@lawpath-tech/openclaw 2026.2.21-31 → 2026.2.21-33

package/dist/plugin-sdk/{reply-C_4ajFUt.js → reply-CrBuiTf0.js}

@@ -30,7 +30,7 @@ import { t as convertMarkdownTables } from "./tables-DAJbUPhT.js";
 import { a as formatIMessageChatTarget, c as parseIMessageTarget, i as DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS, o as isAllowedIMessageSender, r as createIMessageRpcClient, s as normalizeIMessageHandle, t as sendMessageIMessage } from "./send-CiTMY1uN.js";
 import { i as resolveImageSanitizationLimits, n as sanitizeImageBlocks, r as sanitizeToolResultImages } from "./tool-images-D_St2NkT.js";
 import { a as createActionGate, c as jsonResult, d as readReactionParams, f as readStringArrayParam, l as parseAvailableTags, m as readStringParam, n as missingTargetError, o as imageResult, p as readStringOrNumberParam, r as unknownTargetError, s as imageResultFromFile, t as ambiguousTargetError, u as readNumberParam } from "./target-errors-CeKndUCY.js";
-import { a as createSlackWebClient, c as validateSlackBlocksArray, i as buildSlackBlocksFallbackText, o as resolveSlackWebClientOptions, s as parseSlackBlocksInput, t as sendMessageSlack } from "./send-C9Q83PfF.js";
+import { a as buildSlackBlocksFallbackText, c as parseSlackBlocksInput, l as validateSlackBlocksArray, o as createSlackWebClient, r as markdownToSlackMrkdwn, s as resolveSlackWebClientOptions, t as sendMessageSlack } from "./send-DzgvnkSq.js";
 import { $ as parseTelegramTarget, A as hasBotMention, B as resolveSenderAllowMatch, C as buildTelegramGroupPeerId, D as describeReplyTarget, E as buildTypingThreadParams, F as resolveTelegramReplyId, G as readChannelAllowFromStore, H as isSenderIdAllowed, I as resolveTelegramStreamMode, J as upsertChannelPairingRequest, L as resolveTelegramThreadSpec, M as resolveTelegramForumThreadId, N as resolveTelegramGroupAllowFromContext, O as expandTextLinks, P as resolveTelegramMediaPlaceholder, Q as isVoiceCompatibleAudio, R as isSenderAllowed$1, S as buildTelegramGroupFrom, T as buildTelegramThreadParams, U as mergeAllowFromSources, V as firstDefined$1, W as addChannelAllowFromStoreEntry, X as listPairingChannels, Y as getPairingAdapter, Z as withTelegramApiErrorLogging, _ as resolveTelegramFetch, a as reactMessageTelegram, b as buildSenderLabel, c as sendStickerTelegram, d as wasSentByBot, et as resolveTelegramTargetChatType, f as isRecoverableTelegramNetworkError, g as wrapFileReferencesInHtml, h as renderTelegramHtmlText, i as editMessageTelegram, j as normalizeForwardedContext, k as extractTelegramLocation, m as markdownToTelegramHtml, n as createForumTopicTelegram, nt as toLocationContext, o as sendMessageTelegram, p as markdownToTelegramChunks, q as removeChannelAllowFromStoreEntry, r as deleteMessageTelegram, s as sendPollTelegram, t as buildInlineKeyboard, tt as formatLocationText, u as resolveTelegramVoiceSend, v as splitTelegramCaption, w as buildTelegramParentPeer, x as buildSenderName, y as buildGroupLabel, z as normalizeAllowFromWithStore$1 } from "./send-C40m59QO.js";
 import { _ as CLI_OUTPUT_MAX_BUFFER, a as resolveMediaAttachmentLocalRoots, c as loadModelCatalog, d as resolveAttachmentKind, f as registerUnhandledRejectionHandler, g as resolveMediaUnderstandingScope, h as normalizeMediaUnderstandingChatType, i as resolveAutoImageModel, l as modelSupportsVision, m as resolveTimeoutMs$1, n as createMediaAttachmentCache, o as runCapability, p as resolveConcurrency, r as normalizeMediaAttachments, s as findModelInCatalog, t as buildProviderRegistry, v as applyTemplate, y as buildRandomTempFilePath } from "./runner-BkVA5r9t.js";
 import { a as resolveAckReaction, c as resolveHumanDelayConfig, i as resolveResponsePrefixTemplate, n as createReplyPrefixOptions, o as resolveAgentIdentity, s as resolveEffectiveMessagesConfig } from "./reply-prefix-G9ruZ2EI.js";
@@ -58,7 +58,7 @@ import { _ as resolveNativeCommandsEnabled, a as listChatCommandsForConfig, c as
 import { c as signalRpcRequest, l as streamSignalEvents, n as sendReadReceiptSignal, o as resolveSignalRpcContext, r as sendTypingSignal, s as signalCheck, t as sendMessageSignal } from "./send-b1mZbvoC.js";
 import { t as makeProxyFetch } from "./proxy-MquBDehr.js";
 import { n as resolveAgentRoute, t as buildAgentSessionKey } from "./resolve-route-yBLQIeuf.js";
-import { a as createReplyReferencePlanner, i as resolveSlackThreadTs, n as deliverReplies$3, t as createSlackReplyDeliveryPlan } from "./replies-OoosoUz9.js";
+import { a as createReplyReferencePlanner, i as resolveSlackThreadTs, n as deliverReplies$3, t as createSlackReplyDeliveryPlan } from "./replies-CvKNemz4.js";
 import { t as getActiveWebListener } from "./active-listener-n6hyqnXA.js";
 import { n as recordCommandPoll, r as resetCommandPollCount } from "./command-poll-backoff-CBq0jVRw.js";
 import { createRequire } from "node:module";
@@ -26917,7 +26917,7 @@ async function runWithImageModelFallback(params) {
 function createDefaultDeps() {
 	return {
 		sendMessageWhatsApp: async (...args) => {
-			const { sendMessageWhatsApp } = await import("./web-BlY2wNrk.js");
+			const { sendMessageWhatsApp } = await import("./web-DXbKqGiu.js");
 			return await sendMessageWhatsApp(...args);
 		},
 		sendMessageTelegram: async (...args) => {
@@ -26929,7 +26929,7 @@ function createDefaultDeps() {
 			return await sendMessageDiscord(...args);
 		},
 		sendMessageSlack: async (...args) => {
-			const { sendMessageSlack } = await import("./send-C9Q83PfF.js").then((n) => n.n);
+			const { sendMessageSlack } = await import("./send-DzgvnkSq.js").then((n) => n.n);
 			return await sendMessageSlack(...args);
 		},
 		sendMessageSignal: async (...args) => {
@@ -34638,8 +34638,12 @@ function inferSlackChannelType(channelId) {
 }
 function normalizeSlackChannelType(channelType, channelId) {
 	const normalized = channelType?.trim().toLowerCase();
-	if (normalized === "im" || normalized === "mpim" || normalized === "channel" || normalized === "group") return normalized;
-	return inferSlackChannelType(channelId) ?? "channel";
+	const inferred = inferSlackChannelType(channelId);
+	if (normalized === "im" || normalized === "mpim" || normalized === "channel" || normalized === "group") {
+		if (inferred === "im" && normalized !== "im") return "im";
+		return normalized;
+	}
+	return inferred ?? "channel";
 }
 function createSlackMonitorContext(params) {
 	const channelHistories = /* @__PURE__ */ new Map();
@@ -34923,7 +34927,7 @@ function migrateSlackChannelConfig(params) {
 //#endregion
 //#region src/slack/monitor/events/channels.ts
 function registerSlackChannelEvents(params) {
-	const { ctx } = params;
+	const { ctx, trackEvent } = params;
 	const enqueueChannelSystemEvent = (params) => {
 		if (!ctx.isChannelAllowed({
 			channelId: params.channelId,
@@ -34946,6 +34950,7 @@ function registerSlackChannelEvents(params) {
 	ctx.app.event("channel_created", async ({ event, body }) => {
 		try {
 			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			trackEvent?.();
 			const payload = event;
 			const channelId = payload.channel?.id;
 			const channelName = payload.channel?.name;
@@ -34961,6 +34966,7 @@ function registerSlackChannelEvents(params) {
 	ctx.app.event("channel_rename", async ({ event, body }) => {
 		try {
 			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			trackEvent?.();
 			const payload = event;
 			const channelId = payload.channel?.id;
 			enqueueChannelSystemEvent({
@@ -34975,6 +34981,7 @@ function registerSlackChannelEvents(params) {
 	ctx.app.event("channel_id_changed", async ({ event, body }) => {
 		try {
 			if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+			trackEvent?.();
 			const payload = event;
 			const oldChannelId = payload.old_channel_id;
 			const newChannelId = payload.new_channel_id;
@@ -35380,10 +35387,11 @@ function registerSlackInteractionEvents(params) {
 //#endregion
 //#region src/slack/monitor/events/members.ts
 function registerSlackMemberEvents(params) {
-	const { ctx } = params;
+	const { ctx, trackEvent } = params;
 	const handleMemberChannelEvent = async (params) => {
 		try {
 			if (ctx.shouldDropMismatchedSlackEvent(params.body)) return;
+			trackEvent?.();
 			const payload = params.event;
 			const channelId = payload.channel;
 			const channelInfo = channelId ? await ctx.resolveChannelName(channelId) : {};
@@ -35519,9 +35527,10 @@ function registerSlackMessageEvents(params) {
 //#endregion
 //#region src/slack/monitor/events/pins.ts
 async function handleSlackPinEvent(params) {
-	const { ctx, body, event, action, contextKeySuffix, errorLabel } = params;
+	const { ctx, trackEvent, body, event, action, contextKeySuffix, errorLabel } = params;
 	try {
 		if (ctx.shouldDropMismatchedSlackEvent(body)) return;
+		trackEvent?.();
 		const payload = event;
 		const channelId = payload.channel_id;
 		const channelInfo = channelId ? await ctx.resolveChannelName(channelId) : {};
@@ -35550,10 +35559,11 @@ async function handleSlackPinEvent(params) {
 	}
 }
 function registerSlackPinEvents(params) {
-	const { ctx } = params;
+	const { ctx, trackEvent } = params;
 	ctx.app.event("pin_added", async ({ event, body }) => {
 		await handleSlackPinEvent({
 			ctx,
+			trackEvent,
 			body,
 			event,
 			action: "pinned",
@@ -35564,6 +35574,7 @@ function registerSlackPinEvents(params) {
 	ctx.app.event("pin_removed", async ({ event, body }) => {
 		await handleSlackPinEvent({
 			ctx,
+			trackEvent,
 			body,
 			event,
 			action: "unpinned",
@@ -35576,11 +35587,12 @@ function registerSlackPinEvents(params) {
 //#endregion
 //#region src/slack/monitor/events/reactions.ts
 function registerSlackReactionEvents(params) {
-	const { ctx } = params;
+	const { ctx, trackEvent } = params;
 	const handleReactionEvent = async (event, action) => {
 		try {
 			const item = event.item;
 			if (!item || item.type !== "message") return;
+			trackEvent?.();
 			const channelInfo = item.channel ? await ctx.resolveChannelName(item.channel) : {};
 			const channelType = channelInfo?.type;
 			if (!ctx.isChannelAllowed({
@@ -35624,10 +35636,22 @@ function registerSlackMonitorEvents(params) {
 		ctx: params.ctx,
 		handleSlackMessage: params.handleSlackMessage
 	});
-	registerSlackReactionEvents({ ctx: params.ctx });
-	registerSlackMemberEvents({ ctx: params.ctx });
-	registerSlackChannelEvents({ ctx: params.ctx });
-	registerSlackPinEvents({ ctx: params.ctx });
+	registerSlackReactionEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
+	registerSlackMemberEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
+	registerSlackChannelEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
+	registerSlackPinEvents({
+		ctx: params.ctx,
+		trackEvent: params.trackEvent
+	});
 	registerSlackInteractionEvents({ ctx: params.ctx });
 }
 
@@ -35800,7 +35824,7 @@ async function startSlackStream(params) {
 		stopped: false
 	};
 	if (text) {
-		await streamer.append({ markdown_text: text });
+		await streamer.append({ markdown_text: markdownToSlackMrkdwn(text) });
 		logVerbose(`slack-stream: appended initial text (${text.length} chars)`);
 	}
 	return session;
@@ -35815,7 +35839,7 @@ async function appendSlackStream(params) {
 		return;
 	}
 	if (!text) return;
-	await session.streamer.append({ markdown_text: text });
+	await session.streamer.append({ markdown_text: markdownToSlackMrkdwn(text) });
 	logVerbose(`slack-stream: appended ${text.length} chars`);
 }
 /**
@@ -35832,7 +35856,7 @@ async function stopSlackStream(params) {
 	}
 	session.stopped = true;
 	logVerbose(`slack-stream: stopping stream in ${session.channel} thread=${session.threadTs}${text ? ` (final text: ${text.length} chars)` : ""}`);
-	await session.streamer.stop(text ? { markdown_text: text } : void 0);
+	await session.streamer.stop(text ? { markdown_text: markdownToSlackMrkdwn(text) } : void 0);
 	logVerbose("slack-stream: stream stopped");
 }
 
@@ -35851,12 +35875,21 @@ function resolveSlackThreadContext(params) {
 		messageThreadId: isThreadReply ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0
 	};
 }
+/**
+* Resolves Slack thread targeting for replies and status indicators.
+*
+* @returns replyThreadTs - Thread timestamp for reply messages
+* @returns statusThreadTs - Thread timestamp for status indicators (typing, etc.)
+* @returns isThreadReply - true if this is a genuine user reply in a thread,
+*                          false if thread_ts comes from a bot status message
+*/
 function resolveSlackThreadTargets(params) {
-	const { incomingThreadTs, messageTs } = resolveSlackThreadContext(params);
-	const replyThreadTs = incomingThreadTs ?? (params.replyToMode === "all" ? messageTs : void 0);
+	const { incomingThreadTs, messageTs, isThreadReply } = resolveSlackThreadContext(params);
+	const replyThreadTs = isThreadReply ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0;
 	return {
 		replyThreadTs,
-		statusThreadTs: replyThreadTs ?? messageTs
+		statusThreadTs: replyThreadTs ?? messageTs,
+		isThreadReply
 	};
 }
 
@@ -35896,12 +35929,13 @@ async function dispatchPreparedSlackMessage(prepared) {
 			deliveryContext: {
 				channel: "slack",
 				to: `user:${message.user}`,
-				accountId: route.accountId
+				accountId: route.accountId,
+				threadId: prepared.ctxPayload.MessageThreadId
 			},
 			ctx: prepared.ctxPayload
 		});
 	}
-	const { statusThreadTs } = resolveSlackThreadTargets({
+	const { statusThreadTs, isThreadReply } = resolveSlackThreadTargets({
 		message,
 		replyToMode: ctx.replyToMode
 	});
@@ -35913,7 +35947,8 @@ async function dispatchPreparedSlackMessage(prepared) {
 		replyToMode: ctx.replyToMode,
 		incomingThreadTs,
 		messageTs,
-		hasRepliedRef
+		hasRepliedRef,
+		isThreadReply
 	});
 	const typingTarget = statusThreadTs ? `${message.channel}/${statusThreadTs}` : message.channel;
 	const typingCallbacks = createTypingCallbacks({
@@ -35978,7 +36013,8 @@ async function dispatchPreparedSlackMessage(prepared) {
 			accountId: account.accountId,
 			runtime,
 			textLimit: ctx.textLimit,
-			replyThreadTs
+			replyThreadTs,
+			replyToMode: ctx.replyToMode
 		});
 		replyPlan.markSent();
 	};
@@ -36039,7 +36075,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 						token: ctx.botToken,
 						channel: draftChannelId,
 						ts: draftMessageId,
-						text: finalText.trim()
+						text: markdownToSlackMrkdwn(finalText.trim())
 					});
 					return;
 				} catch (err) {
@@ -36069,7 +36105,8 @@ async function dispatchPreparedSlackMessage(prepared) {
 				accountId: account.accountId,
 				runtime,
 				textLimit: ctx.textLimit,
-				replyThreadTs
+				replyThreadTs,
+				replyToMode: ctx.replyToMode
 			});
 			replyPlan.markSent();
 		},
@@ -36078,7 +36115,8 @@ async function dispatchPreparedSlackMessage(prepared) {
 			typingCallbacks.onIdle?.();
 		},
 		onReplyStart: typingCallbacks.onReplyStart,
-		onIdle: typingCallbacks.onIdle
+		onIdle: typingCallbacks.onIdle,
+		onCleanup: typingCallbacks.onCleanup
 	});
 	const draftStream = createSlackDraftStream({
 		target: prepared.replyTarget,
@@ -36719,10 +36757,13 @@ async function prepareSlackMessage(params) {
 	const mergedMedia = [...media ?? [], ...attachmentContent?.media ?? []];
 	const effectiveDirectMedia = mergedMedia.length > 0 ? mergedMedia : null;
 	const mediaPlaceholder = effectiveDirectMedia ? effectiveDirectMedia.map((m) => m.placeholder).join(" ") : void 0;
+	const fileOnlyFallback = !mediaPlaceholder && (message.files?.length ?? 0) > 0 ? message.files.slice(0, 5).map((f) => f.name ?? "file").join(", ") : void 0;
+	const fileOnlyPlaceholder = fileOnlyFallback ? `[Slack file: ${fileOnlyFallback}]` : void 0;
 	const rawBody = [
 		(message.text ?? "").trim(),
 		attachmentContent?.text,
-		mediaPlaceholder
+		mediaPlaceholder,
+		fileOnlyPlaceholder
 	].filter(Boolean).join("\n") || "";
 	if (!rawBody) return null;
 	const ackReaction = resolveAckReaction(cfg, route.agentId, {
@@ -36897,7 +36938,7 @@ async function prepareSlackMessage(params) {
 		ReplyToId: threadContext.replyToId,
 		MessageThreadId: threadContext.messageThreadId,
 		ParentSessionKey: threadKeys.parentSessionKey,
-		ThreadStarterBody: threadStarterBody,
+		ThreadStarterBody: !threadSessionPreviousTimestamp ? threadStarterBody : void 0,
 		ThreadHistoryBody: threadHistoryBody,
 		IsFirstThreadTurn: isThreadReply && threadTs && !threadSessionPreviousTimestamp ? true : void 0,
 		ThreadLabel: threadLabel,
@@ -36921,7 +36962,8 @@ async function prepareSlackMessage(params) {
 			sessionKey: route.mainSessionKey,
 			channel: "slack",
 			to: `user:${message.user}`,
-			accountId: route.accountId
+			accountId: route.accountId,
+			threadId: threadContext.messageThreadId
 		} : void 0,
 		onRecordError: (err) => {
 			ctx.logger.warn({
@@ -37048,7 +37090,7 @@ function buildSeenMessageKey(channelId, ts) {
 	return `${channelId}:${ts}`;
 }
 function createSlackMessageHandler(params) {
-	const { ctx, account } = params;
+	const { ctx, account, trackEvent } = params;
 	const debounceMs = resolveInboundDebounceMs({
 		cfg: ctx.cfg,
 		channel: "slack"
@@ -37138,6 +37180,7 @@ function createSlackMessageHandler(params) {
 		if (seenMessageKey && wasSeen) {
 			if (opts.source !== "app_mention" || !consumeAppMentionRetryKey(seenMessageKey)) return;
 		}
+		trackEvent?.();
 		const resolvedMessage = await threadTsResolver.resolve({
 			message,
 			source: opts.source
@@ -37611,7 +37654,7 @@ async function registerSlackMonitorSlashCommands(params) {
 			});
 			const deliverSlashPayloads = async (replies) => {
 				const [{ deliverSlackSlashReplies }, { resolveChunkMode }, { resolveMarkdownTableMode }] = await Promise.all([
-					import("./replies-OoosoUz9.js").then((n) => n.r),
+					import("./replies-CvKNemz4.js").then((n) => n.r),
 					import("./chunk-D4rztYS_.js").then((n) => n.s),
 					import("./markdown-tables-Bf31F9r6.js").then((n) => n.t)
 				]);
@@ -37791,6 +37834,73 @@ const slackBoltModule = SlackBolt;
 const { App, HTTPReceiver } = (slackBoltModule.App ? slackBoltModule : slackBoltModule.default) ?? slackBoltModule;
 const SLACK_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 const SLACK_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
+const SLACK_SOCKET_RECONNECT_POLICY = {
+	initialMs: 2e3,
+	maxMs: 3e4,
+	factor: 1.8,
+	jitter: .25,
+	maxAttempts: 12
+};
+function getSocketEmitter(app) {
+	const receiver = app.receiver;
+	const client = receiver && typeof receiver === "object" ? receiver.client : void 0;
+	if (!client || typeof client !== "object") return null;
+	const on = client.on;
+	const off = client.off;
+	if (typeof on !== "function" || typeof off !== "function") return null;
+	return {
+		on: (event, listener) => on.call(client, event, listener),
+		off: (event, listener) => off.call(client, event, listener)
+	};
+}
+function waitForSlackSocketDisconnect(app, abortSignal) {
+	return new Promise((resolve) => {
+		const emitter = getSocketEmitter(app);
+		if (!emitter) {
+			abortSignal?.addEventListener("abort", () => resolve({ event: "disconnect" }), { once: true });
+			return;
+		}
+		const disconnectListener = () => resolveOnce({ event: "disconnect" });
+		const startFailListener = () => resolveOnce({ event: "unable_to_socket_mode_start" });
+		const errorListener = (error) => resolveOnce({
+			event: "error",
+			error
+		});
+		const abortListener = () => resolveOnce({ event: "disconnect" });
+		const cleanup = () => {
+			emitter.off("disconnected", disconnectListener);
+			emitter.off("unable_to_socket_mode_start", startFailListener);
+			emitter.off("error", errorListener);
+			abortSignal?.removeEventListener("abort", abortListener);
+		};
+		const resolveOnce = (value) => {
+			cleanup();
+			resolve(value);
+		};
+		emitter.on("disconnected", disconnectListener);
+		emitter.on("unable_to_socket_mode_start", startFailListener);
+		emitter.on("error", errorListener);
+		abortSignal?.addEventListener("abort", abortListener, { once: true });
+	});
+}
+/**
+* Detect non-recoverable Slack API / auth errors that should NOT be retried.
+* These indicate permanent credential problems (revoked bot, deactivated account, etc.)
+* and retrying will never succeed — continuing to retry blocks the entire gateway.
+*/
+function isNonRecoverableSlackAuthError(error) {
+	const msg = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+	return /account_inactive|invalid_auth|token_revoked|token_expired|not_authed|org_login_required|team_access_not_granted|missing_scope|cannot_find_service|invalid_token/i.test(msg);
+}
+function formatUnknownError(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return "unknown error";
+	}
+}
 function parseApiAppIdFromAppToken(raw) {
 	const token = raw?.trim();
 	if (!token) return;
@@ -37914,13 +38024,21 @@ async function monitorSlackProvider(opts = {}) {
 		mediaMaxBytes,
 		removeAckAfterReply
 	});
+	const trackEvent = opts.setStatus ? () => {
+		opts.setStatus({
+			lastEventAt: Date.now(),
+			lastInboundAt: Date.now()
+		});
+	} : void 0;
 	registerSlackMonitorEvents({
 		ctx,
 		account,
 		handleSlackMessage: createSlackMessageHandler({
 			ctx,
-			account
-		})
+			account,
+			trackEvent
+		}),
+		trackEvent
 	});
 	await registerSlackMonitorSlashCommands({
 		ctx,
@@ -38009,13 +38127,52 @@ async function monitorSlackProvider(opts = {}) {
 	opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
 	try {
 		if (slackMode === "socket") {
-			await app.start();
-			runtime.log?.("slack socket mode connected");
-		} else runtime.log?.(`slack http mode listening at ${slackWebhookPath}`);
-		if (opts.abortSignal?.aborted) return;
-		await new Promise((resolve) => {
-			opts.abortSignal?.addEventListener("abort", () => resolve(), { once: true });
-		});
+			let reconnectAttempts = 0;
+			while (!opts.abortSignal?.aborted) {
+				try {
+					await app.start();
+					reconnectAttempts = 0;
+					runtime.log?.("slack socket mode connected");
+				} catch (err) {
+					if (isNonRecoverableSlackAuthError(err)) {
+						runtime.error?.(`slack socket mode failed to start due to non-recoverable auth error — skipping channel (${formatUnknownError(err)})`);
+						throw err;
+					}
+					reconnectAttempts += 1;
+					if (SLACK_SOCKET_RECONNECT_POLICY.maxAttempts > 0 && reconnectAttempts >= SLACK_SOCKET_RECONNECT_POLICY.maxAttempts) throw err;
+					const delayMs = computeBackoff(SLACK_SOCKET_RECONNECT_POLICY, reconnectAttempts);
+					runtime.error?.(`slack socket mode failed to start. retry ${reconnectAttempts}/${SLACK_SOCKET_RECONNECT_POLICY.maxAttempts || "∞"} in ${Math.round(delayMs / 1e3)}s (${formatUnknownError(err)})`);
+					try {
+						await sleepWithAbort(delayMs, opts.abortSignal);
+					} catch {
+						break;
+					}
+					continue;
+				}
+				if (opts.abortSignal?.aborted) break;
+				const disconnect = await waitForSlackSocketDisconnect(app, opts.abortSignal);
+				if (opts.abortSignal?.aborted) break;
+				if (disconnect.error && isNonRecoverableSlackAuthError(disconnect.error)) {
+					runtime.error?.(`slack socket mode disconnected due to non-recoverable auth error — skipping channel (${formatUnknownError(disconnect.error)})`);
+					throw disconnect.error instanceof Error ? disconnect.error : new Error(formatUnknownError(disconnect.error));
+				}
+				reconnectAttempts += 1;
+				if (SLACK_SOCKET_RECONNECT_POLICY.maxAttempts > 0 && reconnectAttempts >= SLACK_SOCKET_RECONNECT_POLICY.maxAttempts) throw new Error(`Slack socket mode reconnect max attempts reached (${reconnectAttempts}/${SLACK_SOCKET_RECONNECT_POLICY.maxAttempts}) after ${disconnect.event}`);
+				const delayMs = computeBackoff(SLACK_SOCKET_RECONNECT_POLICY, reconnectAttempts);
+				runtime.error?.(`slack socket disconnected (${disconnect.event}). retry ${reconnectAttempts}/${SLACK_SOCKET_RECONNECT_POLICY.maxAttempts || "∞"} in ${Math.round(delayMs / 1e3)}s${disconnect.error ? ` (${formatUnknownError(disconnect.error)})` : ""}`);
+				await app.stop().catch(() => void 0);
+				try {
+					await sleepWithAbort(delayMs, opts.abortSignal);
+				} catch {
+					break;
+				}
+			}
+		} else {
+			runtime.log?.(`slack http mode listening at ${slackWebhookPath}`);
+			if (!opts.abortSignal?.aborted) await new Promise((resolve) => {
+				opts.abortSignal?.addEventListener("abort", () => resolve(), { once: true });
+			});
+		}
 	} finally {
 		opts.abortSignal?.removeEventListener("abort", stopOnAbort);
 		unregisterHttpHandler?.();
@@ -44604,7 +44761,7 @@ function loadWebLoginQr() {
 	return webLoginQrPromise;
 }
 function loadWebChannel() {
-	webChannelPromise ??= import("./web-BlY2wNrk.js");
+	webChannelPromise ??= import("./web-DXbKqGiu.js");
 	return webChannelPromise;
 }
 function loadWhatsAppActions() {

package/dist/plugin-sdk/{send-C9Q83PfF.js → send-DzgvnkSq.js}

@@ -6,6 +6,7 @@ import { a as loadWebMedia, n as markdownToIR, t as chunkMarkdownIR } from "./ir
 import { c as resolveChunkMode, i as chunkMarkdownTextWithMode, l as resolveTextChunkLimit } from "./chunk-D4rztYS_.js";
 import { n as resolveMarkdownTableMode } from "./markdown-tables-Bf31F9r6.js";
 import { t as renderMarkdownWithMarkers } from "./render-BiJZ5W4Z.js";
+import { i as isSilentReplyText } from "./tokens-Dag82kdi.js";
 import { WebClient } from "@slack/web-api";
 
 //#region src/slack/blocks-input.ts
@@ -127,6 +128,7 @@ function isAllowedSlackAngleToken(token) {
 	return inner.startsWith("@") || inner.startsWith("#") || inner.startsWith("!") || inner.startsWith("mailto:") || inner.startsWith("tel:") || inner.startsWith("http://") || inner.startsWith("https://") || inner.startsWith("slack://");
 }
 function escapeSlackMrkdwnContent(text) {
+	if (!text) return "";
 	if (!text.includes("&") && !text.includes("<") && !text.includes(">")) return text;
 	SLACK_ANGLE_TOKEN_RE.lastIndex = 0;
 	const out = [];
@@ -142,6 +144,7 @@ function escapeSlackMrkdwnContent(text) {
 	return out.join("");
 }
 function escapeSlackMrkdwnText(text) {
+	if (!text) return "";
 	if (!text.includes("&") && !text.includes("<") && !text.includes(">")) return text;
 	return text.split("\n").map((line) => {
 		if (line.startsWith("> ")) return `> ${escapeSlackMrkdwnContent(line.slice(2))}`;
@@ -190,6 +193,15 @@ function buildSlackRenderOptions() {
 		buildLink: buildSlackLink
 	};
 }
+function markdownToSlackMrkdwn(markdown, options = {}) {
+	return renderMarkdownWithMarkers(markdownToIR(markdown ?? "", {
+		linkify: false,
+		autolink: false,
+		headingStyle: "bold",
+		blockquotePrefix: "> ",
+		tableMode: options.tableMode
+	}), buildSlackRenderOptions());
+}
 function markdownToSlackMrkdwnChunks(markdown, limit, options = {}) {
 	const chunks = chunkMarkdownIR(markdownToIR(markdown ?? "", {
 		linkify: false,
@@ -291,6 +303,13 @@ async function uploadSlackFile(params) {
 }
 async function sendMessageSlack(to, message, opts = {}) {
 	const trimmedMessage = message?.trim() ?? "";
+	if (isSilentReplyText(trimmedMessage) && !opts.mediaUrl && !opts.blocks) {
+		logVerbose("slack send: suppressed NO_REPLY token before API call");
+		return {
+			messageId: "suppressed",
+			channelId: ""
+		};
+	}
 	const blocks = opts.blocks == null ? void 0 : validateSlackBlocksArray(opts.blocks);
 	if (!trimmedMessage && !opts.mediaUrl && !blocks) throw new Error("Slack send requires text, blocks, or media");
 	const cfg = loadConfig();
@@ -364,4 +383,4 @@ async function sendMessageSlack(to, message, opts = {}) {
 }
 
 //#endregion
-export { createSlackWebClient as a, validateSlackBlocksArray as c, buildSlackBlocksFallbackText as i, send_exports as n, resolveSlackWebClientOptions as o, markdownToSlackMrkdwnChunks as r, parseSlackBlocksInput as s, sendMessageSlack as t };
+export { buildSlackBlocksFallbackText as a, parseSlackBlocksInput as c, markdownToSlackMrkdwnChunks as i, validateSlackBlocksArray as l, send_exports as n, createSlackWebClient as o, markdownToSlackMrkdwn as r, resolveSlackWebClientOptions as s, sendMessageSlack as t };

package/dist/plugin-sdk/slack/monitor/events/channels.d.ts

@@ -1,4 +1,5 @@
 import type { SlackMonitorContext } from "../context.js";
 export declare function registerSlackChannelEvents(params: {
     ctx: SlackMonitorContext;
+    trackEvent?: () => void;
 }): void;

package/dist/plugin-sdk/slack/monitor/events/members.d.ts

@@ -1,4 +1,5 @@
 import type { SlackMonitorContext } from "../context.js";
 export declare function registerSlackMemberEvents(params: {
     ctx: SlackMonitorContext;
+    trackEvent?: () => void;
 }): void;

package/dist/plugin-sdk/slack/monitor/events/pins.d.ts

@@ -1,4 +1,5 @@
 import type { SlackMonitorContext } from "../context.js";
 export declare function registerSlackPinEvents(params: {
     ctx: SlackMonitorContext;
+    trackEvent?: () => void;
 }): void;

package/dist/plugin-sdk/slack/monitor/events/reactions.d.ts

@@ -1,4 +1,5 @@
 import type { SlackMonitorContext } from "../context.js";
 export declare function registerSlackReactionEvents(params: {
     ctx: SlackMonitorContext;
+    trackEvent?: () => void;
 }): void;

package/dist/plugin-sdk/slack/monitor/events.d.ts

@@ -5,4 +5,6 @@ export declare function registerSlackMonitorEvents(params: {
     ctx: SlackMonitorContext;
     account: ResolvedSlackAccount;
     handleSlackMessage: SlackMessageHandler;
+    /** Called on each inbound event to update liveness tracking. */
+    trackEvent?: () => void;
 }): void;

package/dist/plugin-sdk/slack/monitor/message-handler.d.ts

@@ -8,4 +8,6 @@ export type SlackMessageHandler = (message: SlackMessageEvent, opts: {
 export declare function createSlackMessageHandler(params: {
     ctx: SlackMonitorContext;
     account: ResolvedSlackAccount;
+    /** Called on each inbound event to update liveness tracking. */
+    trackEvent?: () => void;
 }): SlackMessageHandler;

package/dist/plugin-sdk/slack/monitor/provider.d.ts

@@ -1,2 +1,8 @@
 import type { MonitorSlackOpts } from "./types.js";
+/**
+ * Detect non-recoverable Slack API / auth errors that should NOT be retried.
+ * These indicate permanent credential problems (revoked bot, deactivated account, etc.)
+ * and retrying will never succeed — continuing to retry blocks the entire gateway.
+ */
+export declare function isNonRecoverableSlackAuthError(error: unknown): boolean;
 export declare function monitorSlackProvider(opts?: MonitorSlackOpts): Promise<void>;

package/dist/plugin-sdk/slack/monitor/replies.d.ts

@@ -10,6 +10,7 @@ export declare function deliverReplies(params: {
     runtime: RuntimeEnv;
     textLimit: number;
     replyThreadTs?: string;
+    replyToMode: "off" | "first" | "all";
 }): Promise<void>;
 export type SlackRespondFn = (payload: {
     text: string;
@@ -38,6 +39,7 @@ export declare function createSlackReplyDeliveryPlan(params: {
     hasRepliedRef: {
         value: boolean;
     };
+    isThreadReply?: boolean;
 }): SlackReplyDeliveryPlan;
 export declare function deliverSlackSlashReplies(params: {
     replies: ReplyPayload[];

package/dist/plugin-sdk/slack/monitor/types.d.ts

@@ -11,6 +11,10 @@ export type MonitorSlackOpts = {
     abortSignal?: AbortSignal;
     mediaMaxMb?: number;
     slashCommand?: SlackSlashCommandConfig;
+    /** Callback to update the channel account status snapshot (e.g. lastEventAt). */
+    setStatus?: (next: Record<string, unknown>) => void;
+    /** Callback to read the current channel account status snapshot. */
+    getStatus?: () => Record<string, unknown>;
 };
 export type SlackReactionEvent = {
     type: "reaction_added" | "reaction_removed";