@openclaw/slack 2026.6.6 → 2026.6.8-beta.2

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-BxD37X5Y.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-BxD37X5Y.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";
@@ -345,6 +345,15 @@ async function handleSlackMessageAction(params) {
 //#endregion
 //#region extensions/slack/src/channel-actions.ts
 let slackActionRuntimePromise$1;
+const SLACK_TOOL_DELIVERY_ACTIONS = new Set([
+	"deleteMessage",
+	"editMessage",
+	"pinMessage",
+	"react",
+	"sendMessage",
+	"unpinMessage",
+	"uploadFile"
+]);
 async function loadSlackActionRuntime$1() {
 	slackActionRuntimePromise$1 ??= import("./action-runtime.runtime-D05xDf1s.js");
 	return await slackActionRuntimePromise$1;
@@ -361,6 +370,7 @@ function createSlackActions(providerId, options) {
 	return {
 		describeMessageTool: describeSlackMessageTool,
 		extractToolSend: ({ args }) => extractSlackToolSend(args),
+		isToolDeliveryAction: ({ args }) => typeof args.action === "string" && SLACK_TOOL_DELIVERY_ACTIONS.has(args.action),
 		prepareSendPayload: ({ ctx, payload }) => ctx.action === "send" ? payload : null,
 		handleAction: async (ctx) => {
 			return await handleSlackMessageAction({
@@ -476,7 +486,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 +524,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-BxD37X5Y.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,