@openclaw/slack 2026.7.2-beta.3 → 2026.7.2-beta.4

package/dist/{config-schema-XjJGfwQC.js → config-schema-B4j4tCOI.js}

@@ -1,8 +1,9 @@
-import { n as buildChannelConfigSchema, t as SlackConfigSchema } from "./config-api-Df9a1B8C.js";
+import { buildSecretInputSchema, hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input";
 import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
-//#endregion
-//#region extensions/slack/src/config-schema.ts
-const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { uiHints: {
+import { ChannelBotLoopProtectionSchema, ChannelDangerouslyAllowNameMatchingSchema, ChannelImplicitMentionsSchema, ChannelPreviewStreamingConfigSchema, ChannelStreamingProgressSchema, GroupPolicySchema, ProviderCommandsSchema, ReplyToModeSchema, buildChannelAllowBotsSchema, buildChannelConfigSchema, buildChannelExecApprovalsSchema, buildChannelReactionShape, buildCommonChannelAccountShape, buildGroupEntrySchema, requireAllowlistAllowFrom, requireOpenAllowFrom } from "openclaw/plugin-sdk/channel-config-schema";
+import { z } from "zod";
+//#region extensions/slack/src/config-ui-hints.ts
+const slackChannelConfigUiHints = {
 	"": {
 		label: "Slack",
 		help: "Slack channel provider configuration for bot/app tokens, streaming behavior, and DM policy controls. Keep token handling and thread behavior explicit to avoid noisy workspace interactions."
@@ -11,16 +12,13 @@ const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { u
 		label: "Slack Enterprise Grid Org Install",
 		help: "Enable only for an Enterprise Grid org-wide bot installation. OpenClaw verifies the token with Slack auth.test at startup; DMs must be disabled or use dmPolicy=\"open\" with allowFrom=[\"*\"]."
 	},
-	identity: {
+	postAs: {
 		label: "Slack Identity",
 		help: "Select \"bot\" (default) for the classic Slack app/bot identity or \"user\" to post as the authorizing human through a user token while the app carries event transport."
 	},
 	...createChannelConfigUiHints({
 		channelLabel: "Slack",
-		dmPolicy: {
-			channelKey: "slack",
-			includeLegacyNestedPolicy: true
-		},
+		dmPolicy: { channelKey: "slack" },
 		configWrites: true,
 		mentionPatterns: {
 			targetDescription: "Slack channel IDs",
@@ -54,22 +52,6 @@ const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { u
 		label: "Slack Bot Loop Cooldown Seconds",
 		help: "How long to suppress the bot pair after it exceeds the budget. Default: 60."
 	},
-	socketMode: {
-		label: "Slack Socket Mode Transport",
-		help: "Slack Socket Mode transport tuning passed to the Slack SDK. Use only when investigating ping/pong timeout or stale websocket behavior."
-	},
-	"socketMode.clientPingTimeout": {
-		label: "Slack Socket Mode Pong Timeout",
-		help: "Milliseconds the Slack SDK waits for a pong after its client ping before treating the websocket as stale (OpenClaw default: 15000). Increase on hosts with event-loop starvation or slow network scheduling."
-	},
-	"socketMode.serverPingTimeout": {
-		label: "Slack Socket Mode Server Ping Timeout",
-		help: "Milliseconds the Slack SDK waits for Slack server pings before treating the websocket as stale."
-	},
-	"socketMode.pingPongLoggingEnabled": {
-		label: "Slack Socket Mode Ping/Pong Logging",
-		help: "Enable Slack SDK ping/pong transport logs while debugging Socket Mode websocket health."
-	},
 	relay: {
 		label: "Slack Relay Mode",
 		help: "Relay-delivered Slack events. Use with mode=\"relay\" when openclaw-slack-router owns the Slack Socket Mode connection."
@@ -218,6 +200,229 @@ const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { u
 		label: "Slack Thread Initial History Limit",
 		help: "Maximum number of existing Slack thread messages to fetch when starting a new thread session (default: 20, set to 0 to disable)."
 	}
-} });
+};
+//#endregion
+//#region extensions/slack/src/config-schema.ts
+const SecretInputSchema = buildSecretInputSchema();
+const SlackStreamingProgressSchema = ChannelStreamingProgressSchema.extend({ nativeTaskCards: z.boolean().optional() }).strict();
+const SlackStreamingConfigSchema = ChannelPreviewStreamingConfigSchema.extend({
+	nativeTransport: z.boolean().optional(),
+	progress: SlackStreamingProgressSchema.optional()
+}).strict();
+const SlackCapabilitiesSchema = z.union([z.array(z.string()), z.object({ interactiveReplies: z.boolean().optional() }).strict()]);
+const SlackDmSchema = z.object({
+	enabled: z.boolean().optional(),
+	groupEnabled: z.boolean().optional(),
+	groupChannels: z.array(z.union([z.string(), z.number()])).optional()
+}).strict();
+const SlackPresenceEventsSchema = z.object({ mode: z.enum([
+	"off",
+	"auto",
+	"on"
+]).optional() }).strict();
+const SlackChannelSchema = buildGroupEntrySchema({
+	ignoreOtherMentions: z.boolean().optional(),
+	replyToMode: ReplyToModeSchema.optional(),
+	allowBots: buildChannelAllowBotsSchema({ allowMentions: true }),
+	botLoopProtection: ChannelBotLoopProtectionSchema.optional(),
+	users: z.array(z.union([z.string(), z.number()])).optional(),
+	presenceEvents: SlackPresenceEventsSchema.optional()
+}, { omit: ["allowFrom"] });
+const SlackThreadSchema = z.object({
+	historyScope: z.enum(["thread", "channel"]).optional(),
+	inheritParent: z.boolean().optional(),
+	initialHistoryLimit: z.number().int().min(0).optional()
+}).strict();
+const ReplyToModeByChatTypeSchema = z.object({
+	direct: ReplyToModeSchema.optional(),
+	group: ReplyToModeSchema.optional(),
+	channel: ReplyToModeSchema.optional()
+}).strict();
+const SlackRelaySchema = z.object({
+	url: z.string().optional(),
+	authToken: SecretInputSchema.optional(),
+	gatewayId: z.string().optional()
+}).strict();
+const SlackIdentitySchema = z.enum(["bot", "user"]);
+const SlackAccountSchema = z.object({
+	...buildCommonChannelAccountShape({
+		omit: ["groupAllowFrom"],
+		capabilities: SlackCapabilitiesSchema.optional(),
+		streaming: SlackStreamingConfigSchema.optional()
+	}),
+	postAs: SlackIdentitySchema.default("bot"),
+	mode: z.enum([
+		"socket",
+		"http",
+		"relay"
+	]).optional(),
+	enterpriseOrgInstall: z.boolean().optional(),
+	relay: SlackRelaySchema.optional(),
+	signingSecret: SecretInputSchema.optional(),
+	webhookPath: z.string().optional(),
+	execApprovals: buildChannelExecApprovalsSchema(z.union([z.string(), z.number()])),
+	commands: ProviderCommandsSchema,
+	botToken: SecretInputSchema.optional(),
+	appToken: SecretInputSchema.optional(),
+	userToken: SecretInputSchema.optional(),
+	userTokenReadOnly: z.boolean().optional().default(true),
+	allowBots: buildChannelAllowBotsSchema({ allowMentions: true }),
+	botLoopProtection: ChannelBotLoopProtectionSchema.optional(),
+	dangerouslyAllowNameMatching: ChannelDangerouslyAllowNameMatchingSchema,
+	requireMention: z.boolean().optional(),
+	implicitMentions: ChannelImplicitMentionsSchema.optional(),
+	unfurlLinks: z.boolean().optional(),
+	unfurlMedia: z.boolean().optional(),
+	...buildChannelReactionShape({
+		notificationModes: [
+			"off",
+			"own",
+			"all",
+			"allowlist"
+		],
+		reactionAllowlist: true,
+		ackReaction: z.string().optional()
+	}),
+	replyToModeByChatType: ReplyToModeByChatTypeSchema.optional(),
+	thread: SlackThreadSchema.optional(),
+	presenceEvents: SlackPresenceEventsSchema.optional(),
+	actions: z.object({
+		reactions: z.boolean().optional(),
+		messages: z.boolean().optional(),
+		pins: z.boolean().optional(),
+		search: z.boolean().optional(),
+		permissions: z.boolean().optional(),
+		memberInfo: z.boolean().optional(),
+		channelInfo: z.boolean().optional(),
+		emojiList: z.boolean().optional()
+	}).strict().optional(),
+	slashCommand: z.object({
+		enabled: z.boolean().optional(),
+		name: z.string().optional(),
+		sessionPrefix: z.string().optional(),
+		ephemeral: z.boolean().optional()
+	}).strict().optional(),
+	dm: SlackDmSchema.optional(),
+	channels: z.record(z.string(), SlackChannelSchema.optional()).optional(),
+	typingReaction: z.string().optional()
+}).strict();
+const SlackAccountEntrySchema = SlackAccountSchema.extend({ postAs: SlackIdentitySchema.optional() });
+function validateSlackSigningSecretRequirements(value, ctx) {
+	const resolveMode = (mode) => mode === "http" || mode === "socket" || mode === "relay" ? mode : void 0;
+	const baseMode = resolveMode(value.mode) ?? "socket";
+	if (baseMode === "http" && !hasConfiguredSecretInput(value.signingSecret)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "channels.slack.mode=\"http\" requires channels.slack.signingSecret",
+		path: ["signingSecret"]
+	});
+	for (const [accountId, account] of Object.entries(value.accounts ?? {})) {
+		if (!account || account.enabled === false) continue;
+		if ((resolveMode(account.mode) ?? baseMode) !== "http") continue;
+		if (!hasConfiguredSecretInput(account.signingSecret ?? value.signingSecret)) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "channels.slack.accounts.*.mode=\"http\" requires channels.slack.signingSecret or channels.slack.accounts.*.signingSecret",
+			path: [
+				"accounts",
+				accountId,
+				"signingSecret"
+			]
+		});
+	}
+}
+const SlackChannelConfigSchema = buildChannelConfigSchema(SlackAccountSchema.safeExtend({
+	mode: z.enum([
+		"socket",
+		"http",
+		"relay"
+	]).optional().default("socket"),
+	signingSecret: SecretInputSchema.optional(),
+	webhookPath: z.string().optional().default("/slack/events"),
+	groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+	accounts: z.record(z.string(), SlackAccountEntrySchema.optional()).optional(),
+	defaultAccount: z.string().optional()
+}).superRefine((value, ctx) => {
+	const dmPolicy = value.dmPolicy ?? "pairing";
+	const allowFrom = value.allowFrom;
+	requireOpenAllowFrom({
+		policy: dmPolicy,
+		allowFrom,
+		ctx,
+		path: ["allowFrom"],
+		message: "channels.slack.dmPolicy=\"open\" requires channels.slack.allowFrom to include \"*\""
+	});
+	requireAllowlistAllowFrom({
+		policy: dmPolicy,
+		allowFrom,
+		ctx,
+		path: ["allowFrom"],
+		message: "channels.slack.dmPolicy=\"allowlist\" requires channels.slack.allowFrom to contain at least one sender ID"
+	});
+	const requireRelayConfig = (relay, path) => {
+		if (typeof relay?.url !== "string" || !relay.url.trim()) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "channels.slack.mode=\"relay\" requires relay.url",
+			path: [...path, "url"]
+		});
+		if (!hasConfiguredSecretInput(relay?.authToken)) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "channels.slack.mode=\"relay\" requires relay.authToken",
+			path: [...path, "authToken"]
+		});
+		if (typeof relay?.gatewayId !== "string" || !relay.gatewayId.trim()) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "channels.slack.mode=\"relay\" requires relay.gatewayId",
+			path: [...path, "gatewayId"]
+		});
+	};
+	const baseMode = value.mode ?? "socket";
+	const accountIds = value.accounts ? Object.keys(value.accounts) : [];
+	if (!value.accounts) {
+		if (baseMode === "relay") requireRelayConfig(value.relay, ["relay"]);
+		validateSlackSigningSecretRequirements(value, ctx);
+		return;
+	}
+	for (const accountId of accountIds) {
+		const account = value.accounts[accountId];
+		if (!account || account.enabled === false) continue;
+		const accountMode = account.mode ?? baseMode;
+		const effectiveRelay = {
+			...value.relay,
+			...account.relay
+		};
+		const effectivePolicy = account.dmPolicy ?? value.dmPolicy ?? "pairing";
+		const effectiveAllowFrom = account.allowFrom ?? value.allowFrom;
+		requireOpenAllowFrom({
+			policy: effectivePolicy,
+			allowFrom: effectiveAllowFrom,
+			ctx,
+			path: [
+				"accounts",
+				accountId,
+				"allowFrom"
+			],
+			message: "channels.slack.accounts.*.dmPolicy=\"open\" requires channels.slack.accounts.*.allowFrom (or channels.slack.allowFrom) to include \"*\""
+		});
+		requireAllowlistAllowFrom({
+			policy: effectivePolicy,
+			allowFrom: effectiveAllowFrom,
+			ctx,
+			path: [
+				"accounts",
+				accountId,
+				"allowFrom"
+			],
+			message: "channels.slack.accounts.*.dmPolicy=\"allowlist\" requires channels.slack.accounts.*.allowFrom (or channels.slack.allowFrom) to contain at least one sender ID"
+		});
+		if (accountMode !== "http") {
+			if (accountMode === "relay") requireRelayConfig(effectiveRelay, [
+				"accounts",
+				accountId,
+				"relay"
+			]);
+			continue;
+		}
+	}
+	validateSlackSigningSecretRequirements(value, ctx);
+}), { uiHints: slackChannelConfigUiHints });
 //#endregion
 export { SlackChannelConfigSchema as t };

package/dist/{directory-config-Bv0lcUlH.js → directory-config-B08pm5ZT.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-DQEbYKh9.js";
+import { i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-BSr252c_.js";
 import { i as parseSlackTarget } from "./target-parsing-N6lHogYZ.js";
 import "./targets-KmjP2E8s.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";

package/dist/directory-contract-api.js

@@ -1,2 +1,2 @@
-import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-Bv0lcUlH.js";
+import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-B08pm5ZT.js";
 export { listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig };

package/dist/{directory-live-CzUIB7th.js → directory-live-DpPKzPrn.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as resolveSlackAccount } from "./accounts-DQEbYKh9.js";
-import { a as createSlackLookupClient } from "./probe-Borhn9PQ.js";
+import { a as resolveSlackAccount } from "./accounts-BSr252c_.js";
+import { a as createSlackLookupClient } from "./probe-CVRuArHA.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/slack/src/directory-live.ts
 var directory_live_exports = /* @__PURE__ */ __exportAll({

package/dist/{doctor-contract-DKpe5VBr.js → doctor-contract-U6oVntbM.js}

@@ -1,5 +1,5 @@
 import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode } from "./streaming-compat-3_X-21wW.js";
-import { asObjectRecord, defineChannelAliasMigration } from "openclaw/plugin-sdk/runtime-doctor";
+import { asObjectRecord, defineChannelAliasMigration, hasLegacyAccountStreamingAliases, normalizeChannelConfigEntries } from "openclaw/plugin-sdk/runtime-doctor";
 //#region extensions/slack/src/doctor-contract.ts
 const streamingAliasMigration = defineChannelAliasMigration({
 	channelId: "slack",
@@ -22,6 +22,21 @@ function hasLegacySlackThreadMentionPolicy(value) {
 	const thread = asObjectRecord(asObjectRecord(value)?.thread);
 	return Boolean(thread && Object.hasOwn(thread, "requireExplicitMention"));
 }
+function hasLegacyDmReplyMode(value) {
+	return Object.hasOwn(asObjectRecord(asObjectRecord(value)?.dm) ?? {}, "replyToMode");
+}
+function migrateDmReplyMode(entry, path, changes) {
+	const dm = asObjectRecord(entry.dm);
+	if (!dm || !Object.hasOwn(dm, "replyToMode")) return false;
+	const byType = asObjectRecord(entry.replyToModeByChatType) ?? {};
+	if (byType.direct === void 0) {
+		byType.direct = dm.replyToMode;
+		entry.replyToModeByChatType = byType;
+		changes.push(`Moved ${path}.dm.replyToMode → ${path}.replyToModeByChatType.direct.`);
+	} else changes.push(`Removed ${path}.dm.replyToMode (replyToModeByChatType.direct already set).`);
+	delete dm.replyToMode;
+	return true;
+}
 function normalizeSlackThreadMentionPolicy(params) {
 	const thread = asObjectRecord(params.value.thread);
 	if (!thread || !Object.hasOwn(thread, "requireExplicitMention")) return {
@@ -69,6 +84,20 @@ function normalizeSlackChannelAllowAliases(params) {
 }
 const legacyConfigRules = [
 	...streamingAliasMigration.legacyConfigRules,
+	{
+		path: ["channels", "slack"],
+		message: "channels.slack.dm.replyToMode moved to replyToModeByChatType.direct. Run \"openclaw doctor --fix\".",
+		match: hasLegacyDmReplyMode
+	},
+	{
+		path: [
+			"channels",
+			"slack",
+			"accounts"
+		],
+		message: "channels.slack.accounts.<id>.dm.replyToMode moved to replyToModeByChatType.direct. Run \"openclaw doctor --fix\".",
+		match: (value) => hasLegacyAccountStreamingAliases(value, hasLegacyDmReplyMode)
+	},
 	{
 		path: ["channels", "slack"],
 		message: "channels.slack.thread.requireExplicitMention is legacy; use channels.slack.implicitMentions.threadParticipation instead. Run \"openclaw doctor --fix\".",
@@ -81,10 +110,7 @@ const legacyConfigRules = [
 			"accounts"
 		],
 		message: "channels.slack.accounts.<id>.thread.requireExplicitMention is legacy; use channels.slack.accounts.<id>.implicitMentions.threadParticipation instead. Run \"openclaw doctor --fix\".",
-		match: (value) => {
-			const accounts = asObjectRecord(value);
-			return Boolean(accounts && Object.values(accounts).some((account) => hasLegacySlackThreadMentionPolicy(account)));
-		}
+		match: (value) => hasLegacyAccountStreamingAliases(value, hasLegacySlackThreadMentionPolicy)
 	},
 	{
 		path: ["channels", "slack"],
@@ -98,105 +124,50 @@ const legacyConfigRules = [
 			"accounts"
 		],
 		message: "channels.slack.accounts.<id>.channels.<id>.allow is legacy; use channels.slack.accounts.<id>.channels.<id>.enabled instead. Run \"openclaw doctor --fix\".",
-		match: (value) => {
-			const accounts = asObjectRecord(value);
-			if (!accounts) return false;
-			return Object.values(accounts).some((account) => hasLegacySlackChannelAllowAlias(account));
-		}
+		match: (value) => hasLegacyAccountStreamingAliases(value, hasLegacySlackChannelAllowAlias)
 	}
 ];
-function normalizeCompatibilityConfig({ cfg }) {
-	const changes = [];
-	const aliases = streamingAliasMigration.normalizeChannelConfig({
-		cfg,
-		changes
+function normalizeSlackEntry(params) {
+	let entry = params.entry;
+	let changed = migrateDmReplyMode(entry, params.pathPrefix, params.changes);
+	const threadPolicy = normalizeSlackThreadMentionPolicy({
+		value: entry,
+		pathPrefix: params.pathPrefix,
+		changes: params.changes
 	});
-	const rawEntry = asObjectRecord(aliases.config.channels?.slack);
-	if (!rawEntry) return {
-		config: cfg,
-		changes: []
-	};
-	let updated = rawEntry;
-	let changed = aliases.config !== cfg;
-	const normalizedThreadPolicy = normalizeSlackThreadMentionPolicy({
-		value: updated,
-		pathPrefix: "channels.slack",
-		changes
-	});
-	if (normalizedThreadPolicy.changed) {
-		updated = normalizedThreadPolicy.value;
-		changed = true;
-	}
-	const channels = asObjectRecord(updated.channels);
+	entry = threadPolicy.value;
+	changed = changed || threadPolicy.changed;
+	const channels = asObjectRecord(entry.channels);
 	if (channels) {
 		const normalized = normalizeSlackChannelAllowAliases({
 			channels,
-			pathPrefix: "channels.slack.channels",
-			changes
+			pathPrefix: `${params.pathPrefix}.channels`,
+			changes: params.changes
 		});
 		if (normalized.changed) {
-			updated = {
-				...updated,
+			entry = {
+				...entry,
 				channels: normalized.channels
 			};
 			changed = true;
 		}
 	}
-	const accounts = asObjectRecord(updated.accounts);
-	if (accounts) {
-		let accountsChanged = false;
-		const nextAccounts = { ...accounts };
-		for (const [accountId, accountValue] of Object.entries(accounts)) {
-			let account = asObjectRecord(accountValue);
-			if (!account) continue;
-			const normalizedAccountThreadPolicy = normalizeSlackThreadMentionPolicy({
-				value: account,
-				pathPrefix: `channels.slack.accounts.${accountId}`,
-				changes
-			});
-			if (normalizedAccountThreadPolicy.changed) {
-				account = normalizedAccountThreadPolicy.value;
-				nextAccounts[accountId] = account;
-				accountsChanged = true;
-			}
-			const channelEntries = asObjectRecord(account.channels);
-			if (channelEntries) {
-				const normalized = normalizeSlackChannelAllowAliases({
-					channels: channelEntries,
-					pathPrefix: `channels.slack.accounts.${accountId}.channels`,
-					changes
-				});
-				if (normalized.changed) {
-					nextAccounts[accountId] = {
-						...account,
-						channels: normalized.channels
-					};
-					accountsChanged = true;
-				}
-			}
-		}
-		if (accountsChanged) {
-			updated = {
-				...updated,
-				accounts: nextAccounts
-			};
-			changed = true;
-		}
-	}
-	if (!changed) return {
-		config: cfg,
-		changes: []
-	};
 	return {
-		config: {
-			...aliases.config,
-			channels: {
-				...aliases.config.channels,
-				slack: updated
-			}
-		},
-		changes
+		entry,
+		changed
 	};
 }
+function normalizeCompatibilityConfig({ cfg }) {
+	const changes = [];
+	return normalizeChannelConfigEntries({
+		cfg: streamingAliasMigration.normalizeChannelConfig({
+			cfg,
+			changes
+		}).config,
+		channelId: "slack",
+		changes,
+		normalizeEntry: normalizeSlackEntry
+	});
+}
 //#endregion
 export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/doctor-contract-api.js

@@ -1,2 +1,2 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-DKpe5VBr.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-U6oVntbM.js";
 export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/{group-policy-Bw-65m3V.js → group-policy-CdnQzQBI.js}

@@ -1,4 +1,4 @@
-import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-DQEbYKh9.js";
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-BSr252c_.js";
 import { i as parseSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-N6lHogYZ.js";
 import { t as isSlackPluginAccountConfigured } from "./account-configured-BwfXBo_F.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
@@ -1512,6 +1512,33 @@ function buildSlackLink(link, text) {
 		close: ">"
 	};
 }
+const SLACK_FORMAT_PROFILE = {
+	mechanism: "markdown",
+	constructs: {
+		bold: "native",
+		italic: "native",
+		underline: "strip",
+		strikethrough: "native",
+		spoiler: "fallback",
+		codeInline: "native",
+		codeBlock: "native",
+		codeLanguage: "fallback",
+		linkLabel: "native",
+		heading: "fallback",
+		bulletList: "fallback",
+		orderedList: "fallback",
+		taskList: "fallback",
+		table: "fallback",
+		blockquote: "native",
+		image: "fallback",
+		mention: "native"
+	},
+	chunk: {
+		limit: 4e3,
+		unit: "chars",
+		hardCap: 4e4
+	}
+};
 const SLACK_ASSISTANT_TRANSCRIPT_PREFIX = "`Assistant:` ";
 function tokenizeSlackMrkdwn(text) {
 	const tokens = [];
@@ -1698,10 +1725,10 @@ function markdownToSlackMrkdwn(markdown, options = {}) {
 		assistantTranscriptRoleHeaders: true,
 		linkify: false,
 		autolink: false,
-		headingStyle: "bold",
+		headingStyle: "rich",
 		blockquotePrefix: "> ",
 		tableMode: options.tableMode
-	}), buildSlackRenderOptions());
+	}), buildSlackRenderOptions(), SLACK_FORMAT_PROFILE);
 }
 function normalizeSlackOutboundText(markdown) {
 	return protectSlackAssistantTranscriptRoleHeaders(markdownToSlackMrkdwn(markdown ?? ""));
@@ -1751,7 +1778,7 @@ function markdownToSlackMrkdwnChunks(markdown, limit, options = {}) {
 		assistantTranscriptRoleHeaders: true,
 		linkify: false,
 		autolink: false,
-		headingStyle: "bold",
+		headingStyle: "rich",
 		blockquotePrefix: "> ",
 		tableMode: options.tableMode
 	});
@@ -1759,7 +1786,7 @@ function markdownToSlackMrkdwnChunks(markdown, limit, options = {}) {
 	return renderMarkdownIRChunksWithinLimit({
 		ir,
 		limit,
-		renderChunk: (chunk) => protectSlackAssistantTranscriptRoleHeaders(renderMarkdownWithMarkers(chunk, renderOptions)),
+		renderChunk: (chunk) => protectSlackAssistantTranscriptRoleHeaders(renderMarkdownWithMarkers(chunk, renderOptions, SLACK_FORMAT_PROFILE)),
 		measureRendered: (rendered) => rendered.length
 	}).map(({ rendered }) => rendered);
 }

package/dist/{interactive-replies-Dm_t2R9S.js → interactive-replies-C3ffk6oN.js}

@@ -1,4 +1,4 @@
-import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId } from "./accounts-DQEbYKh9.js";
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId } from "./accounts-BSr252c_.js";
 import { normalizeLowercaseStringOrEmpty, normalizeStringEntries, normalizeStringEntriesLower } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/slack/src/interactive-replies.ts
 const SLACK_BUTTON_MAX_ITEMS = 5;

package/dist/interactive-replies-api.js

@@ -1,2 +1,2 @@
-import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-Dm_t2R9S.js";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-C3ffk6oN.js";
 export { compileSlackInteractiveReplies, isSlackInteractiveRepliesEnabled };

package/dist/{message-tool-api-C2pcf5du.js → message-tool-api-ByVyIVOh.js}

@@ -1,6 +1,6 @@
-import { a as resolveSlackAccount, t as listEnabledSlackAccounts } from "./accounts-DQEbYKh9.js";
+import { a as resolveSlackAccount, t as listEnabledSlackAccounts } from "./accounts-BSr252c_.js";
 import { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.js";
-import { n as isSlackInteractiveRepliesEnabled } from "./interactive-replies-Dm_t2R9S.js";
+import { n as isSlackInteractiveRepliesEnabled } from "./interactive-replies-C3ffk6oN.js";
 import { createActionGate } from "openclaw/plugin-sdk/channel-actions";
 import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
 import { Type } from "typebox";

package/dist/message-tool-api.js

@@ -1,2 +1,2 @@
-import { t as describeSlackMessageTool } from "./message-tool-api-C2pcf5du.js";
+import { t as describeSlackMessageTool } from "./message-tool-api-ByVyIVOh.js";
 export { describeSlackMessageTool as describeMessageTool };

package/dist/{monitor-CNFeF30h.js → monitor-CnB_WKvF.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { S as buildSlackSlashCommandMatcher, t as monitorSlackProvider } from "./provider-B-HVL5ZE.js";
-import { t as isSlackChannelAllowedByPolicy } from "./policy-b_dOPDCq.js";
-import { o as resolveSlackThreadTs } from "./replies-B4bOdrYb.js";
+import { S as buildSlackSlashCommandMatcher, t as monitorSlackProvider } from "./provider-htuIJGFD.js";
+import { t as isSlackChannelAllowedByPolicy } from "./policy-C31RYSuT.js";
+import { o as resolveSlackThreadTs } from "./replies-Cgr2Gli4.js";
 //#region extensions/slack/src/monitor.ts
 var monitor_exports = /* @__PURE__ */ __exportAll({
 	buildSlackSlashCommandMatcher: () => buildSlackSlashCommandMatcher,

package/dist/{outbound-adapter-CVi2uok0.js → outbound-adapter-DuPz2HHt.js}

@@ -1,6 +1,6 @@
-import { F as SLACK_TEXT_LIMIT, M as resolveSlackAuthoredTextPlacement, Y as escapeSlackMrkdwn, Z as SLACK_PRESENTATION_CAPABILITIES, g as resolveSlackReplyDeliveryMessages, m as resolveSlackReplyBlockResolution, p as parseSlackReplyBlockSegments } from "./group-policy-Bw-65m3V.js";
+import { F as SLACK_TEXT_LIMIT, M as resolveSlackAuthoredTextPlacement, Y as escapeSlackMrkdwn, Z as SLACK_PRESENTATION_CAPABILITIES, g as resolveSlackReplyDeliveryMessages, m as resolveSlackReplyBlockResolution, p as parseSlackReplyBlockSegments } from "./group-policy-CdnQzQBI.js";
 import { n as resolveSlackThreadTsValue } from "./thread-ts-DUGhaYKq.js";
-import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-Dm_t2R9S.js";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-C3ffk6oN.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
@@ -10,7 +10,7 @@ import { resolvePayloadMediaUrls, sendPayloadMediaSequenceAndFinalize, sendTextM
 import { attachChannelToResult, createAttachedChannelResultAdapter } from "openclaw/plugin-sdk/channel-send-result";
 //#region extensions/slack/src/outbound-adapter.ts
 const SLACK_RENDERED_PRESENTATION_PROVENANCE = Object.freeze({});
-const loadSlackSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-CXyxws1D.js"));
+const loadSlackSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-a2pilFor.js"));
 function resolveSlackSendIdentity(identity) {
 	if (!identity) return;
 	const username = normalizeOptionalString(identity.name);