@openclaw/discord 2026.7.2-beta.1 → 2026.7.2-beta.3

package/dist/{provider-DWvDNb4J.js → provider-HW0G-2l6.js}

@@ -1,56 +1,56 @@
-import { C as Client, D as RateLimitError, F as Message, I as User, K as Container, M as Command, N as CommandWithSubcommands, P as Guild, Q as Row, V as Modal, W as Button, Xt as __exportAll, _ as MessageReactionRemoveListener, _t as editChannel, at as BaseMessageInteractiveComponent, bt as getChannelMessage, d as discord_exports, et as Separator, f as GuildCreateListener, g as MessageReactionAddListener, h as MessageCreateListener, m as InteractionCreateListener, mt as createThread, nt as TextDisplay, p as GuildDeleteListener, tt as StringSelectMenu, u as chunkDiscordTextWithMode, v as PresenceUpdateListener, w as Plugin, x as ThreadUpdateListener, y as ReadyListener } from "./send.receipt-aegk69an.js";
-import { c as resolveDiscordAccountAllowFrom, d as resolveDiscordAccountDmPolicy, f as resolveDiscordMaxLinesPerMessage, p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-P19jm1lf.js";
-import { S as encodeCustomIdComponent, _ as parseDiscordComponentCustomId, b as parseDiscordModalCustomIdForInteraction, v as parseDiscordComponentCustomIdForInteraction, x as decodeCustomIdComponent, y as parseDiscordModalCustomId } from "./components-BVrfRS-F.js";
-import { a as resolveDiscordComponentEntryWithPersistence, o as resolveDiscordModalEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-BaXQJKWT.js";
-import { i as setPresence, t as clearPresences } from "./presence-cache-z1N8MbJ3.js";
-import { B as DISCORD_REST_TIMEOUT_MS, D as canViewDiscordGuildChannel, G as registerGateway, H as withValidatedDiscordProxy, I as createDiscordRestClient, K as unregisterGateway, V as validateDiscordProxyUrl } from "./send.shared-Xz7IMVpu.js";
-import { a as isDiscordRateLimitResponseBody, o as summarizeDiscordResponseBody } from "./api--f62GFaS.js";
-import { C as resolveTimestampMs, a as normalizeDiscordSlug, b as formatDiscordReactionEmoji, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordCommandOwnerAllowFrom, f as resolveDiscordGuildEntry, g as resolveDiscordOwnerAllowFrom, h as resolveDiscordOwnerAccess, i as normalizeDiscordDisplaySlug, l as resolveDiscordChannelPolicyCommandAuthorizer, m as resolveDiscordMemberAllowed, n as isDiscordGroupAllowedByPolicy, o as resolveDiscordAllowListMatch, p as resolveDiscordMemberAccessState, r as normalizeDiscordAllowList, v as resolveGroupDmAllow, x as formatDiscordUserTag, y as shouldEmitDiscordReactionNotification } from "./allow-list-B7qOH5xu.js";
-import { s as sendVoiceMessageDiscord } from "./send-BFpa_DHn.js";
-import { a as formatMention, t as sendMessageDiscord } from "./send.outbound-BlA6VzSE.js";
-import { d as withAbortTimeout, l as raceWithTimeout } from "./timeouts-ZRc9Lw4y.js";
-import { r as parseExecApprovalData } from "./approval-custom-id-NYPYj9Po.js";
+import { C as Client, D as RateLimitError, F as Message, I as User, K as Container, M as Command, N as CommandWithSubcommands, P as Guild, Q as Row, V as Modal, W as Button, Yt as __exportAll, _ as MessageReactionRemoveListener, _t as editChannel, at as BaseMessageInteractiveComponent, bt as getChannelMessage, d as discord_exports, et as Separator, f as GuildCreateListener, g as MessageReactionAddListener, h as MessageCreateListener, m as InteractionCreateListener, mt as createThread, nt as TextDisplay, p as GuildDeleteListener, t as chunkDiscordTextWithMode, tt as StringSelectMenu, v as PresenceUpdateListener, w as Plugin, x as ThreadUpdateListener, y as ReadyListener } from "./chunk-CWzmeWf_.js";
+import { c as resolveDiscordAccountAllowFrom, d as resolveDiscordAccountDmPolicy, f as resolveDiscordMaxLinesPerMessage, p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-CMd4nzLB.js";
+import { n as getDiscordActivitiesRuntime } from "./runtime-CD5MRZkD.js";
+import { C as parseDiscordActivityCustomIdForInteraction, D as parseDiscordModalCustomIdForInteraction, E as parseDiscordModalCustomId, O as decodeCustomIdComponent, T as parseDiscordComponentCustomIdForInteraction, k as encodeCustomIdComponent, l as parseExecApprovalData, s as parseDiscordQuestionData, w as parseDiscordComponentCustomId, y as buildDiscordActivityCustomId } from "./outbound-session-route-M2bEY9tI.js";
+import { D as canViewDiscordGuildChannel, F as createDiscordRestClient, H as registerGateway, K as validateDiscordProxyUrl, U as unregisterGateway, q as withValidatedDiscordProxy, z as DISCORD_REST_TIMEOUT_MS } from "./send.shared-Dber6X57.js";
+import { _ as resolveDiscordModalEntryWithPersistence, g as resolveDiscordComponentEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-DLqzOEPJ.js";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
-import { a as isDiscordExecApprovalClientEnabled, r as getDiscordExecApprovalApprovers, t as resolveDiscordConversationIdentity } from "./conversation-identity-BpkAzklg.js";
-import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-BrkWOKdG.js";
-import { t as resolveDiscordUserAllowlist } from "./resolve-users-OjrXXvJP.js";
-import { _ as formatThreadBindingDurationLabel, a as isThreadArchived, d as resolveDiscordChannelNameSafe, f as resolveDiscordChannelParentIdSafe, l as resolveDiscordChannelIdSafe, m as resolveDiscordChannelTopicSafe, p as resolveDiscordChannelParentSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-DJD3qwIN.js";
-import { r as parseApplicationIdFromToken, t as fetchDiscordApplicationId } from "./probe-DxjMBeVG.js";
-import { d as resolveDiscordMessageChannelId, n as resolveDiscordForwardedMessagesTextFromSnapshots, t as resolveDiscordEmbedText, u as resolveDiscordChannelInfo } from "./message-utils-D4j07taS.js";
-import { t as resolveDiscordSenderIdentity } from "./sender-identity-C62lBe18.js";
-import { n as formatDiscordApprovalDisplayValue, t as DISCORD_APPROVAL_ALLOWED_MENTIONS } from "./approval-message-safety-C-8BL6Kv.js";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { a as isDiscordRateLimitResponseBody, o as summarizeDiscordResponseBody } from "./api-C43z8vUm.js";
+import { C as resolveTimestampMs, a as normalizeDiscordSlug, b as formatDiscordReactionEmoji, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordCommandOwnerAllowFrom, f as resolveDiscordGuildEntry, g as resolveDiscordOwnerAllowFrom, h as resolveDiscordOwnerAccess, i as normalizeDiscordDisplaySlug, l as resolveDiscordChannelPolicyCommandAuthorizer, m as resolveDiscordMemberAllowed, n as isDiscordGroupAllowedByPolicy, o as resolveDiscordAllowListMatch, p as resolveDiscordMemberAccessState, r as normalizeDiscordAllowList, t as allowListMatches, v as resolveGroupDmAllow, x as formatDiscordUserTag, y as shouldEmitDiscordReactionNotification } from "./allow-list-DzKrtfah.js";
+import { a as formatMention, t as sendMessageDiscord } from "./send.outbound-C1SfX20w.js";
+import { i as setPresence, t as clearPresences } from "./presence-cache-z1N8MbJ3.js";
+import { n as sendVoiceMessageDiscord } from "./send-CSRxNNgq.js";
+import { c as raceWithTimeout, u as withAbortTimeout } from "./timeouts-B9cy6RvQ.js";
+import { a as getDiscordExecApprovalApprovers, n as formatDiscordApprovalDisplayValue, r as resolveDiscordConversationIdentity, s as isDiscordExecApprovalClientEnabled, t as DISCORD_APPROVAL_ALLOWED_MENTIONS } from "./approval-message-safety-DrLlgIPz.js";
+import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-9KcG3mLg.js";
+import { t as resolveDiscordUserAllowlist } from "./resolve-users-GCGf3oV0.js";
+import { _ as formatThreadBindingDurationLabel, a as isThreadArchived, d as resolveDiscordChannelNameSafe, f as resolveDiscordChannelParentIdSafe, l as resolveDiscordChannelIdSafe, m as resolveDiscordChannelTopicSafe, p as resolveDiscordChannelParentSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-mNCWlgvM.js";
+import { r as parseApplicationIdFromToken, t as fetchDiscordApplicationId } from "./probe-C3SCKyYU.js";
+import { d as resolveDiscordMessageChannelId, n as resolveDiscordForwardedMessagesTextFromSnapshots, t as resolveDiscordEmbedText, u as resolveDiscordChannelInfo } from "./message-utils-Cfe6CZ6N.js";
+import { t as resolveDiscordSenderIdentity } from "./sender-identity-mG_zsdox.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeOptionalStringifiedId, normalizeStringEntries, normalizeStringEntriesLower, summarizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { buildAgentSessionKey, deriveLastRoutePolicy, isAcpSessionKey, isSubagentSessionKey, parseAgentSessionKey, resolveAgentIdFromSessionKey, resolveAgentRoute } from "openclaw/plugin-sdk/routing";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeOptionalStringifiedId, normalizeStringEntries, normalizeStringEntriesLower, summarizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getRuntimeConfig, getRuntimeConfigSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
+import { logDebug, logError } from "openclaw/plugin-sdk/logging-core";
 import { ApplicationCommandOptionType, ButtonStyle, ChannelType, ComponentType, GatewayCloseCodes, GatewayCloseCodes as GatewayCloseCodes$1, GatewayDispatchEvents, GatewayIntentBits, GatewayOpcodes } from "discord-api-types/v10";
-import { MAX_DATE_TIMESTAMP_MS, asDateTimestampMs, parseFiniteNumber, parseStrictFiniteNumber, parseStrictInteger, parseStrictNonNegativeInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { createHash, randomUUID } from "node:crypto";
-import path from "node:path";
-import { resolvePinnedMainDmOwnerFromAllowlist as resolvePinnedMainDmOwnerFromAllowlist$1 } from "openclaw/plugin-sdk/security-runtime";
+import { MAX_DATE_TIMESTAMP_MS, asDateTimestampMs, parseFiniteNumber, parseStrictFiniteNumber, parseStrictInteger, parseStrictNonNegativeInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { Type } from "typebox";
 import { Check, Errors } from "typebox/value";
 import { inspect } from "node:util";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
-import { resolveSendableOutboundReplyParts, resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
-import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
-import { resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
+import { fetchWithSsrFGuard, formatErrorMessage as formatErrorMessage$1 } from "openclaw/plugin-sdk/ssrf-runtime";
 import { createHttp1EnvHttpProxyAgent, createHttp1ProxyAgent, createNodeProxyAgent, resolveEnvHttpProxyAgentOptions, wrapFetchWithAbortSignal } from "openclaw/plugin-sdk/fetch-runtime";
-import { createNonExitingRuntime, createSubsystemLogger, danger, formatDurationSeconds, isVerbose, logVerbose, shouldLogVerbose, warn } from "openclaw/plugin-sdk/runtime-env";
+import { createNonExitingRuntime, createSubsystemLogger, danger, formatDurationSeconds, isVerbose, logVerbose, shouldLogVerbose, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { sliceUtf16Safe, truncateUtf16Safe, withTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
-import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
+import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, canonicalizeAllowlistWithResolvedIds, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
 import { chunkItems, sanitizeAssistantVisibleText, sanitizeAssistantVisibleTextWithProfile } from "openclaw/plugin-sdk/text-chunking";
+import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
 import { buildOutboundSessionContext, createChannelMessageReplyPipeline, resolveChannelStreamingBlockEnabled, sendDurableMessageBatch } from "openclaw/plugin-sdk/channel-outbound";
-import { fetchWithSsrFGuard, formatErrorMessage as formatErrorMessage$1 } from "openclaw/plugin-sdk/ssrf-runtime";
+import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
+import { resolveSendableOutboundReplyParts, resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
+import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
+import { createLazyRuntimeModule, createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
+import { resolvePinnedMainDmOwnerFromAllowlist as resolvePinnedMainDmOwnerFromAllowlist$1 } from "openclaw/plugin-sdk/security-runtime";
 import { GROUP_POLICY_BLOCKED_LABEL, resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
-import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, canonicalizeAllowlistWithResolvedIds, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
+import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 import { buildPairingReply, upsertChannelPairingRequest, upsertChannelPairingRequest as upsertChannelPairingRequest$1 } from "openclaw/plugin-sdk/conversation-runtime";
 import { clearExpiredCooldowns, ensureAuthProfileStore, formatReasoningMessage, isProfileInCooldown, loadModelCatalog, resolveAgentAvatar, resolveDefaultModelForAgent, resolveHumanDelayConfig, resolveProfilesUnavailableReason } from "openclaw/plugin-sdk/agent-runtime";
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
@@ -62,7 +62,7 @@ import { createChannelIngressResolver, defineStableChannelIngressIdentity, readC
 import { ModelSelectionLockedError, applyModelOverrideToSessionEntry, resolveChannelModelOverride } from "openclaw/plugin-sdk/model-session-runtime";
 import { completeWithPreparedSimpleCompletionModel, extractAssistantText, prepareSimpleCompletionModelForAgent } from "openclaw/plugin-sdk/simple-completion-runtime";
 import { getSessionEntry, listSessionEntries, patchSessionEntry, readSessionUpdatedAt as readSessionUpdatedAt$1, resolveStorePath, resolveStorePath as resolveStorePath$1 } from "openclaw/plugin-sdk/session-store-runtime";
-import { formatInboundEnvelope, resolveEnvelopeFormatOptions, runChannelInboundEvent } from "openclaw/plugin-sdk/channel-inbound";
+import { formatInboundEnvelope, resolveEnvelopeFormatOptions, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent } from "openclaw/plugin-sdk/channel-inbound";
 import { buildCommandTextFromArgs, findCommandByNativeName, formatCommandArgMenuTitle, listChatCommands, listNativeCommandSpecsForConfig, listSkillCommandsForAgents, resolveCommandAuthorizedFromAuthorizers, resolveEffectiveAgentRuntime, resolveNativeCommandSessionTargets, resolveStoredModelOverride, serializeCommandArgs } from "openclaw/plugin-sdk/command-auth-native";
 import { buildCommandTextFromArgs as buildCommandTextFromArgs$1, findCommandByNativeName as findCommandByNativeName$1, parseCommandArgs, resolveCommandArgChoices, resolveCommandArgMenu, serializeCommandArgs as serializeCommandArgs$1 } from "openclaw/plugin-sdk/native-command-registry";
 import { resolveDirectStatusReplyForSession } from "openclaw/plugin-sdk/command-status-runtime";
@@ -77,10 +77,8 @@ import { Agent } from "node:https";
 import { captureHttpExchange, captureWsEvent, resolveDebugProxySettings, resolveEffectiveDebugProxyUrl } from "openclaw/plugin-sdk/proxy-capture";
 import * as dns from "node:dns";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
-import { logDebug, logError } from "openclaw/plugin-sdk/logging-core";
 import { stripPlainTextToolCallBlocks } from "openclaw/plugin-sdk/tool-payload";
 import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
-import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
 import { resolveRequestUrl } from "openclaw/plugin-sdk/request-url";
 import { fetchWithRuntimeDispatcher } from "openclaw/plugin-sdk/runtime-fetch";
 import { Agent as Agent$1 } from "undici";
@@ -1259,6 +1257,85 @@ function openDiscordPresenceCooldownStore() {
 	});
 }
 //#endregion
+//#region extensions/discord/src/monitor/presence-emission-gate.ts
+const DISCORD_PRESENCE_RECONNECT_SUPPRESS_MS = 300 * 1e3;
+const DISCORD_PRESENCE_BURST_LIMIT = 8;
+const DISCORD_PRESENCE_BURST_WINDOW_MS = 60 * 1e3;
+function resolveDiscordPresenceGateOptions(config) {
+	return {
+		reconnectSuppressMs: config?.reconnectSuppressSeconds !== void 0 ? config.reconnectSuppressSeconds * 1e3 : DISCORD_PRESENCE_RECONNECT_SUPPRESS_MS,
+		burstLimit: config?.burstLimit ?? DISCORD_PRESENCE_BURST_LIMIT,
+		burstWindowMs: config?.burstWindowSeconds !== void 0 ? config.burstWindowSeconds * 1e3 : DISCORD_PRESENCE_BURST_WINDOW_MS
+	};
+}
+/**
+* Per-account lifecycle gate for online-presence events. Reconnect state belongs to the Gateway
+* session, while burst state follows the guild-owned configuration that supplies its limits.
+*/
+var DiscordPresenceEmissionGate = class {
+	constructor() {
+		this.reconnectLogged = false;
+		this.burstByGuild = /* @__PURE__ */ new Map();
+		this.nextReservationId = 0;
+	}
+	noteGatewaySessionReset(nowMs) {
+		this.lastSessionResetAtMs = nowMs;
+		this.reconnectLogged = false;
+	}
+	evaluateReconnectWindow(nowMs, options) {
+		if (this.lastSessionResetAtMs !== void 0 && options.reconnectSuppressMs > 0 && nowMs - this.lastSessionResetAtMs < options.reconnectSuppressMs) {
+			const shouldLog = !this.reconnectLogged;
+			this.reconnectLogged = true;
+			return {
+				allowed: false,
+				reason: "reconnect-window",
+				shouldLog
+			};
+		}
+		return { allowed: true };
+	}
+	reserveBurst(guildId, nowMs, options) {
+		const state = this.burstByGuild.get(guildId) ?? {
+			reservations: [],
+			logged: false
+		};
+		state.reservations = state.reservations.filter((reservation) => !reservation.committed || nowMs - reservation.atMs < options.burstWindowMs);
+		this.burstByGuild.set(guildId, state);
+		if (state.reservations.length >= options.burstLimit) {
+			const shouldLog = !state.logged;
+			state.logged = true;
+			return {
+				allowed: false,
+				reason: state.reservations.some((reservation) => !reservation.committed) ? "burst-pending" : "burst",
+				shouldLog
+			};
+		}
+		state.logged = false;
+		const reservation = {
+			id: this.nextReservationId++,
+			atMs: nowMs,
+			committed: false
+		};
+		state.reservations.push(reservation);
+		return {
+			allowed: true,
+			reservation: reservation.id
+		};
+	}
+	commitBurst(guildId, reservation, nowMs) {
+		const entry = this.burstByGuild.get(guildId)?.reservations.find((candidate) => candidate.id === reservation);
+		if (!entry) return;
+		entry.atMs = nowMs;
+		entry.committed = true;
+	}
+	releaseBurst(guildId, reservation) {
+		const state = this.burstByGuild.get(guildId);
+		if (!state) return;
+		state.reservations = state.reservations.filter((candidate) => candidate.id !== reservation);
+		if (state.reservations.length === 0 && !state.logged) this.burstByGuild.delete(guildId);
+	}
+};
+//#endregion
 //#region extensions/discord/src/monitor/presence-transition-cache.ts
 const DEFAULT_PRESENCE_BASELINE_MAX_ENTRIES = 75e3;
 var DiscordPresenceBaselineCache = class {
@@ -1362,9 +1439,11 @@ var DiscordMessageListener = class extends MessageCreateListener {
 	}
 	async handle(data, client) {
 		this.onEvent?.();
-		Promise.resolve().then(() => this.handler(data, client)).catch((err) => {
+		try {
+			await this.handler(data, client);
+		} catch (err) {
 			(this.logger ?? discordEventQueueLog).error(danger(`discord handler failed: ${String(err)}`));
-		});
+		}
 	}
 };
 var DiscordInteractionListener = class extends InteractionCreateListener {
@@ -1389,6 +1468,7 @@ var DiscordPresenceListener = class extends PresenceUpdateListener {
 		this.gatewayGeneration = 0;
 		this.cooldownStore = params.cooldownStore ?? openDiscordPresenceCooldownStore();
 		this.presenceBaseline = params.presenceBaseline ?? new DiscordPresenceBaselineCache();
+		this.emissionGate = params.emissionGate ?? new DiscordPresenceEmissionGate();
 	}
 	seedGuildSnapshot(data) {
 		const config = resolveDiscordGuildEntry({
@@ -1436,6 +1516,7 @@ var DiscordPresenceListener = class extends PresenceUpdateListener {
 	}
 	resetGatewaySession() {
 		this.gatewayGeneration += 1;
+		this.emissionGate.noteGatewaySessionReset(this.params.nowMs?.() ?? Date.now());
 		this.presenceBaseline.clear();
 		this.guildPresenceState.clear();
 		this.pendingByGuildUser.clear();
@@ -1477,34 +1558,70 @@ var DiscordPresenceListener = class extends PresenceUpdateListener {
 			else if (isDiscordOnlineStatus(data.status)) this.recordPresenceBaseline(data.guild_id, presenceKey, "online");
 			return;
 		}
-		const fetchedUserIsBot = data.user.bot === void 0 && (await client.fetchUser(userId)).bot === true;
-		if (!this.isCurrentGeneration(data.guild_id, gatewayGeneration, guildGeneration)) return;
-		if (fetchedUserIsBot) {
+		const gateOptions = resolveDiscordPresenceGateOptions(config);
+		const reconnectGate = this.emissionGate.evaluateReconnectWindow(nowMs, gateOptions);
+		if (!reconnectGate.allowed) {
+			if (reconnectGate.shouldLog) (this.params.logger ?? discordEventQueueLog).info("Discord presence events suppressed", {
+				reason: reconnectGate.reason,
+				accountId: this.params.accountId,
+				guildId: data.guild_id
+			});
 			this.recordPresenceBaseline(data.guild_id, presenceKey, "online");
 			return;
 		}
-		const route = resolveAgentRoute({
-			cfg: this.params.cfg,
-			channel: "discord",
-			accountId: this.params.accountId,
-			guildId: data.guild_id,
-			peer: {
-				kind: "channel",
-				id: presenceEvent.channelId
-			}
-		});
+		const burstNowMs = this.params.nowMs?.() ?? Date.now();
+		const burstGate = this.emissionGate.reserveBurst(data.guild_id, burstNowMs, gateOptions);
+		if (!burstGate.allowed) {
+			if (burstGate.shouldLog) (this.params.logger ?? discordEventQueueLog).info("Discord presence events suppressed", {
+				reason: burstGate.reason,
+				accountId: this.params.accountId,
+				guildId: data.guild_id
+			});
+			if (burstGate.reason === "burst-pending") return;
+			this.recordPresenceBaseline(data.guild_id, presenceKey, "online");
+			return;
+		}
+		const burstReservation = burstGate.reservation;
+		let burstCommitted = false;
+		let cooldownReserved = false;
 		try {
-			if (!this.cooldownStore.registerIfAbsent(presenceKey, nowMs, { ttlMs: 288e5 })) {
+			const fetchedUserIsBot = data.user.bot === void 0 && (await client.fetchUser(userId)).bot === true;
+			if (!this.isCurrentGeneration(data.guild_id, gatewayGeneration, guildGeneration)) return;
+			if (fetchedUserIsBot) {
 				this.recordPresenceBaseline(data.guild_id, presenceKey, "online");
 				return;
 			}
-		} catch (err) {
-			(this.params.logger ?? discordEventQueueLog).warn(danger(`discord presence cooldown persistence failed: ${String(err)}`));
-			return;
-		}
-		let queued;
-		try {
-			queued = enqueueSystemEvent(presenceEvent.text, {
+			const canViewTargetChannel = await canViewDiscordGuildChannel(data.guild_id, presenceEvent.channelId, userId, {
+				cfg: this.params.cfg,
+				accountId: this.params.accountId,
+				rest: client.rest
+			});
+			if (!this.isCurrentGeneration(data.guild_id, gatewayGeneration, guildGeneration)) return;
+			if (!canViewTargetChannel) {
+				this.recordPresenceBaseline(data.guild_id, presenceKey, "online");
+				return;
+			}
+			const route = resolveAgentRoute({
+				cfg: this.params.cfg,
+				channel: "discord",
+				accountId: this.params.accountId,
+				guildId: data.guild_id,
+				peer: {
+					kind: "channel",
+					id: presenceEvent.channelId
+				}
+			});
+			try {
+				cooldownReserved = this.cooldownStore.registerIfAbsent(presenceKey, nowMs, { ttlMs: DISCORD_PRESENCE_GREETING_COOLDOWN_MS });
+				if (!cooldownReserved) {
+					this.recordPresenceBaseline(data.guild_id, presenceKey, "online");
+					return;
+				}
+			} catch (err) {
+				(this.params.logger ?? discordEventQueueLog).warn(danger(`discord presence cooldown persistence failed: ${String(err)}`));
+				return;
+			}
+			if (!enqueueSystemEvent(presenceEvent.text, {
 				sessionKey: route.sessionKey,
 				contextKey: `discord:presence-online:${this.params.accountId}:${data.guild_id}:${userId}`,
 				deliveryContext: {
@@ -1512,28 +1629,26 @@ var DiscordPresenceListener = class extends PresenceUpdateListener {
 					to: `channel:${presenceEvent.channelId}`,
 					accountId: this.params.accountId
 				}
+			})) return;
+			this.emissionGate.commitBurst(data.guild_id, burstReservation, this.params.nowMs?.() ?? Date.now());
+			burstCommitted = true;
+			this.recordPresenceBaseline(data.guild_id, presenceKey, "online");
+			requestHeartbeat({
+				source: "notifications-event",
+				intent: "immediate",
+				reason: "wake",
+				agentId: route.agentId,
+				sessionKey: route.sessionKey,
+				heartbeat: {
+					target: "discord",
+					to: `channel:${presenceEvent.channelId}`,
+					accountId: this.params.accountId
+				}
 			});
-		} catch (err) {
-			if (this.cooldownStore.lookup(presenceKey) === nowMs) this.cooldownStore.delete(presenceKey);
-			throw err;
-		}
-		if (!queued) {
-			if (this.cooldownStore.lookup(presenceKey) === nowMs) this.cooldownStore.delete(presenceKey);
-			return;
+		} finally {
+			if (!burstCommitted) this.emissionGate.releaseBurst(data.guild_id, burstReservation);
+			if (cooldownReserved && !burstCommitted && this.cooldownStore.lookup(presenceKey) === nowMs) this.cooldownStore.delete(presenceKey);
 		}
-		this.recordPresenceBaseline(data.guild_id, presenceKey, "online");
-		requestHeartbeat({
-			source: "notifications-event",
-			intent: "immediate",
-			reason: "wake",
-			agentId: route.agentId,
-			sessionKey: route.sessionKey,
-			heartbeat: {
-				target: "discord",
-				to: `channel:${presenceEvent.channelId}`,
-				accountId: this.params.accountId
-			}
-		});
 	}
 	isCurrentGeneration(guildId, gatewayGeneration, guildGeneration) {
 		return gatewayGeneration === this.gatewayGeneration && guildGeneration === (this.guildPresenceState.get(guildId)?.generation ?? 0);
@@ -1606,6 +1721,62 @@ var DiscordThreadUpdateListener = class extends ThreadUpdateListener {
 	}
 };
 //#endregion
+//#region extensions/discord/src/internal/gateway-dispatch.ts
+function dispatchVoiceGatewayEvent(client, type, data) {
+	const guildId = readGuildId(data);
+	if (!guildId) return;
+	const adapter = (client.getPlugin("voice")?.adapters)?.get(guildId);
+	const voiceServerUpdate = GatewayDispatchEvents.VoiceServerUpdate;
+	const voiceStateUpdate = GatewayDispatchEvents.VoiceStateUpdate;
+	if (type === voiceServerUpdate) adapter?.onVoiceServerUpdate?.(data);
+	if (type === voiceStateUpdate) adapter?.onVoiceStateUpdate?.(data);
+}
+function mapGatewayDispatchData(client, type, data) {
+	const messageCreate = GatewayDispatchEvents.MessageCreate;
+	const reactionAdd = GatewayDispatchEvents.MessageReactionAdd;
+	const reactionRemove = GatewayDispatchEvents.MessageReactionRemove;
+	if (type === messageCreate) return createMessageDispatchData(client, data);
+	if (type === reactionAdd || type === reactionRemove) return createReactionDispatchData(client, data);
+	return data;
+}
+function createMessageDispatchData(client, data) {
+	const message = new Message(client, data);
+	return {
+		...data,
+		id: data.id,
+		channel_id: data.channel_id,
+		channelId: data.channel_id,
+		message,
+		author: message.author ?? (data.author ? new User(client, data.author) : null),
+		member: data.member,
+		rawMember: data.member,
+		guild: data.guild_id ? new Guild(client, data.guild_id) : null
+	};
+}
+function createReactionDispatchData(client, data) {
+	const userRaw = data.member?.user && typeof data.member.user === "object" ? {
+		id: data.user_id,
+		username: "",
+		...data.member.user
+	} : {
+		id: data.user_id,
+		username: ""
+	};
+	return {
+		...data,
+		user: new User(client, userRaw),
+		rawMember: data.member,
+		guild: data.guild_id ? new Guild(client, data.guild_id) : null,
+		message: new Message(client, {
+			id: data.message_id,
+			channelId: data.channel_id
+		})
+	};
+}
+function readGuildId(data) {
+	return data && typeof data === "object" && typeof data.guild_id === "string" ? data.guild_id : void 0;
+}
+//#endregion
 //#region extensions/discord/src/monitor/dm-command-decision.ts
 async function handleDiscordDmCommandDecision(params) {
 	if (params.senderAccess.decision === "allow") return true;
@@ -2213,16 +2384,23 @@ function shouldBypassConfiguredAcpGuildGuards(commandName) {
 //#endregion
 //#region extensions/discord/src/monitor/inbound-context.ts
 function createDiscordSupplementalContextAccessChecker(params) {
+	const userAllowList = params.channelConfig?.users ?? params.guildInfo?.users ?? [];
+	const roleAllowList = params.channelConfig?.roles ?? params.guildInfo?.roles ?? [];
+	const allowFrom = [...userAllowList, ...roleAllowList];
 	return (sender) => {
-		if (!params.isGuild) return true;
-		return resolveDiscordMemberAllowed({
-			userAllowList: params.channelConfig?.users ?? params.guildInfo?.users,
-			roleAllowList: params.channelConfig?.roles ?? params.guildInfo?.roles,
-			memberRoleIds: sender.memberRoleIds ?? [],
-			userId: sender.id ?? "",
-			userName: sender.name,
-			userTag: sender.tag,
-			allowNameMatching: params.allowNameMatching
+		return resolveInboundSupplementalSenderAllowed({
+			isGroup: params.isGuild,
+			groupPolicy: allowFrom.length === 0 ? "open" : "allowlist",
+			allowFrom,
+			isSenderAllowed: () => resolveDiscordMemberAllowed({
+				userAllowList,
+				roleAllowList,
+				memberRoleIds: sender.memberRoleIds ?? [],
+				userId: sender.id ?? "",
+				userName: sender.name,
+				userTag: sender.tag,
+				allowNameMatching: params.allowNameMatching
+			})
 		});
 	};
 }
@@ -5127,62 +5305,6 @@ function canResumeAfterGatewayClose(code) {
 	return !nonResumableGatewayCloseCodes.has(code);
 }
 //#endregion
-//#region extensions/discord/src/internal/gateway-dispatch.ts
-function dispatchVoiceGatewayEvent(client, type, data) {
-	const guildId = readGuildId(data);
-	if (!guildId) return;
-	const adapter = (client.getPlugin("voice")?.adapters)?.get(guildId);
-	const voiceServerUpdate = GatewayDispatchEvents.VoiceServerUpdate;
-	const voiceStateUpdate = GatewayDispatchEvents.VoiceStateUpdate;
-	if (type === voiceServerUpdate) adapter?.onVoiceServerUpdate?.(data);
-	if (type === voiceStateUpdate) adapter?.onVoiceStateUpdate?.(data);
-}
-function mapGatewayDispatchData(client, type, data) {
-	const messageCreate = GatewayDispatchEvents.MessageCreate;
-	const reactionAdd = GatewayDispatchEvents.MessageReactionAdd;
-	const reactionRemove = GatewayDispatchEvents.MessageReactionRemove;
-	if (type === messageCreate) return createMessageDispatchData(client, data);
-	if (type === reactionAdd || type === reactionRemove) return createReactionDispatchData(client, data);
-	return data;
-}
-function createMessageDispatchData(client, data) {
-	const message = new Message(client, data);
-	return {
-		...data,
-		id: data.id,
-		channel_id: data.channel_id,
-		channelId: data.channel_id,
-		message,
-		author: message.author ?? (data.author ? new User(client, data.author) : null),
-		member: data.member,
-		rawMember: data.member,
-		guild: data.guild_id ? new Guild(client, data.guild_id) : null
-	};
-}
-function createReactionDispatchData(client, data) {
-	const userRaw = data.member?.user && typeof data.member.user === "object" ? {
-		id: data.user_id,
-		username: "",
-		...data.member.user
-	} : {
-		id: data.user_id,
-		username: ""
-	};
-	return {
-		...data,
-		user: new User(client, userRaw),
-		rawMember: data.member,
-		guild: data.guild_id ? new Guild(client, data.guild_id) : null,
-		message: new Message(client, {
-			id: data.message_id,
-			channelId: data.channel_id
-		})
-	};
-}
-function readGuildId(data) {
-	return data && typeof data === "object" && typeof data.guild_id === "string" ? data.guild_id : void 0;
-}
-//#endregion
 //#region extensions/discord/src/internal/gateway-identify-limiter.ts
 const IDENTIFY_WINDOW_MS = 5e3;
 function normalizeMaxConcurrency(value) {
@@ -5397,10 +5519,15 @@ var DiscordGatewayVoiceStateCache = class {
 				return;
 			}
 			const states = /* @__PURE__ */ new Map();
-			for (const state of guild.voice_states) if (state.channel_id) states.set(state.user_id, {
-				...state,
-				guild_id: guild.id
-			});
+			const membersByUserId = new Map((guild.members ?? []).map((member) => [member.user.id, member]));
+			for (const state of guild.voice_states) if (state.channel_id) {
+				const member = state.member ?? membersByUserId.get(state.user_id);
+				states.set(state.user_id, {
+					...state,
+					...member ? { member } : {},
+					guild_id: guild.id
+				});
+			}
 			this.statesByGuild.set(guild.id, states);
 			return;
 		}
@@ -5412,6 +5539,7 @@ var DiscordGatewayVoiceStateCache = class {
 			const previous = states.get(state.user_id);
 			const current = {
 				...state,
+				...state.member ? {} : previous?.member ? { member: previous.member } : {},
 				guild_id: guildId
 			};
 			this.transitionsByState.set(state, {
@@ -5706,7 +5834,7 @@ var GatewayPlugin = class extends Plugin {
 		}
 		this.voiceStateCache.apply(payload);
 		dispatchVoiceGatewayEvent(this.client, payload.t, payload.d);
-		const data = mapGatewayDispatchData(this.client, payload.t, payload.d);
+		const data = payload.t === GatewayDispatchEvents.MessageCreate ? payload.d : mapGatewayDispatchData(this.client, payload.t, payload.d);
 		await this.client.dispatchGatewayEvent(payload.t, data);
 		if (payload.t === GatewayDispatchEvents.InteractionCreate && this.options.autoInteractions) await this.client.handleInteraction(payload.d);
 	}
@@ -6235,9 +6363,12 @@ function resolveGatewayInfoWithFallback(params) {
 	};
 }
 async function fetchDiscordGatewayMetadataGuarded(input, init, options) {
+	const requestInit = init;
+	const signal = requestInit?.signal ?? void 0;
 	const guarded = await fetchWithSsrFGuard({
 		url: resolveFetchInputUrl(input),
-		init,
+		init: requestInit,
+		...signal ? { signal } : {},
 		policy: { allowedHostnames: [DISCORD_API_HOST] },
 		capture: false,
 		auditContext: "discord.gateway.metadata",
@@ -6652,628 +6783,1134 @@ function createDiscordGatewaySupervisor(params) {
 	};
 }
 //#endregion
-//#region extensions/discord/src/monitor/provider.acp.ts
-const DISCORD_ACP_STATUS_PROBE_TIMEOUT_MS = 8e3;
-const DISCORD_ACP_STALE_RUNNING_ACTIVITY_MS = 120 * 1e3;
-function isLegacyMissingSessionError(message) {
-	return message.includes("Session is not ACP-enabled") || message.includes("ACP session metadata missing");
-}
-function classifyAcpStatusProbeError(params) {
-	if (params.isAcpRuntimeError(params.error) && params.error.code === "ACP_SESSION_INIT_FAILED") return {
-		status: "stale",
-		reason: "session-init-failed"
-	};
-	if (isLegacyMissingSessionError(formatErrorMessage$1(params.error))) return {
-		status: "stale",
-		reason: "session-missing"
+//#region extensions/discord/src/gateway-logging.ts
+const INFO_DEBUG_MARKERS = [
+	"Gateway websocket closed",
+	"Gateway reconnect scheduled in",
+	"Gateway forcing fresh IDENTIFY after"
+];
+const shouldPromoteGatewayDebug = (message) => INFO_DEBUG_MARKERS.some((marker) => message.includes(marker));
+const formatGatewayMetrics = (metrics) => {
+	if (metrics === null || metrics === void 0) return String(metrics);
+	if (typeof metrics === "string") return metrics;
+	if (typeof metrics === "number" || typeof metrics === "boolean" || typeof metrics === "bigint") return String(metrics);
+	try {
+		return JSON.stringify(metrics);
+	} catch {
+		return "[unserializable metrics]";
+	}
+};
+function attachDiscordGatewayLogging(params) {
+	const { emitter, runtime } = params;
+	if (!emitter) return () => {};
+	const onGatewayDebug = (msg) => {
+		const message = String(msg);
+		logVerbose(`discord gateway: ${message}`);
+		if (shouldPromoteGatewayDebug(message)) runtime.log?.(`discord gateway: ${message}`);
 	};
-	return params.isStaleRunning ? {
-		status: "stale",
-		reason: "status-error-running-stale"
-	} : {
-		status: "uncertain",
-		reason: "status-error"
+	const onGatewayWarning = (warning) => {
+		logVerbose(`discord gateway warning: ${String(warning)}`);
 	};
-}
-function resolveRunningActivityAgeMs(params) {
-	if (params.storedState !== "running") return 0;
-	const nowMs = asDateTimestampMs(Date.now());
-	if (nowMs === void 0) return 0;
-	const activityAtMs = asDateTimestampMs(params.lastActivityAt);
-	return Math.max(0, nowMs - (activityAtMs === void 0 ? 0 : Math.max(0, Math.floor(activityAtMs))));
-}
-async function probeDiscordAcpBindingHealth(params) {
-	const { getAcpSessionManager, isAcpRuntimeError } = params.providerSessionRuntime;
-	const manager = getAcpSessionManager();
-	const statusProbeAbortController = new AbortController();
-	const result = await raceWithTimeout({
-		promise: manager.getSessionStatus({
-			cfg: params.cfg,
-			sessionKey: params.sessionKey,
-			signal: statusProbeAbortController.signal
-		}).then((status) => ({
-			kind: "status",
-			status
-		})).catch((error) => ({
-			kind: "error",
-			error
-		})),
-		timeoutMs: DISCORD_ACP_STATUS_PROBE_TIMEOUT_MS,
-		onTimeout: () => ({ kind: "timeout" })
-	});
-	if (result.kind === "timeout") statusProbeAbortController.abort();
-	const runningForMs = resolveRunningActivityAgeMs(params);
-	const isStaleRunning = params.storedState === "running" && runningForMs >= DISCORD_ACP_STALE_RUNNING_ACTIVITY_MS;
-	if (result.kind === "timeout") return isStaleRunning ? {
-		status: "stale",
-		reason: "status-timeout-running-stale"
-	} : {
-		status: "uncertain",
-		reason: "status-timeout"
+	const onGatewayMetrics = (metrics) => {
+		logVerbose(`discord gateway metrics: ${formatGatewayMetrics(metrics)}`);
 	};
-	if (result.kind === "error") return classifyAcpStatusProbeError({
-		error: result.error,
-		isStaleRunning,
-		isAcpRuntimeError
-	});
-	if (result.status.state === "error") return {
-		status: "uncertain",
-		reason: "status-error-state"
+	emitter.on("debug", onGatewayDebug);
+	emitter.on("warning", onGatewayWarning);
+	emitter.on("metrics", onGatewayMetrics);
+	return () => {
+		emitter.removeListener("debug", onGatewayDebug);
+		emitter.removeListener("warning", onGatewayWarning);
+		emitter.removeListener("metrics", onGatewayMetrics);
 	};
-	return { status: "healthy" };
 }
 //#endregion
-//#region extensions/discord/src/monitor/provider.allowlist.ts
-function formatResolutionLogDetails(base, details) {
-	const nonEmpty = details.map((value) => value?.trim()).filter((value) => Boolean(value));
-	return nonEmpty.length > 0 ? `${base} (${nonEmpty.join("; ")})` : base;
-}
-function formatResolvedBase(input, target) {
-	if (!target) return input;
-	return input === target ? input : `${input}→${target}`;
-}
-function formatAliasSummary(aliases) {
-	if (aliases.length === 0) return;
-	const preview = aliases.slice(0, 3).join(", ");
-	if (aliases.length <= 3) return preview;
-	return `${preview}, +${aliases.length - 3} more`;
+//#region extensions/discord/src/monitor.gateway.ts
+async function waitForDiscordGatewayStop(params) {
+	const { gateway, abortSignal } = params;
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => {
+			abortSignal?.removeEventListener("abort", onAbort);
+			params.gatewaySupervisor?.detachLifecycle();
+		};
+		const finishResolve = () => {
+			if (settled) return;
+			settled = true;
+			try {
+				gateway?.disconnect?.();
+			} finally {
+				cleanup();
+				resolve();
+			}
+		};
+		const finishReject = (err) => {
+			if (settled) return;
+			settled = true;
+			try {
+				gateway?.disconnect?.();
+			} finally {
+				cleanup();
+				reject(toLintErrorObject(err, "Non-Error rejection"));
+			}
+		};
+		const onAbort = () => {
+			finishResolve();
+		};
+		const onGatewayEvent = (event) => {
+			if ((params.onGatewayEvent?.(event) ?? "stop") === "stop") finishReject(new DiscordGatewayLifecycleError(event));
+		};
+		const onForceStop = (err) => {
+			finishReject(err);
+		};
+		if (abortSignal?.aborted) {
+			onAbort();
+			return;
+		}
+		abortSignal?.addEventListener("abort", onAbort, { once: true });
+		params.gatewaySupervisor?.attachLifecycle(onGatewayEvent);
+		params.registerForceStop?.(onForceStop);
+	});
 }
-function formatDiscordChannelResolvedGroup(entry) {
-	const aliasSummary = formatAliasSummary(entry.aliases);
-	return formatResolutionLogDetails(entry.target, [
-		entry.guildName ? `guild:${entry.guildName}` : void 0,
-		entry.channelName ? `channel:${entry.channelName}` : void 0,
-		entry.note,
-		aliasSummary ? `aliases:${aliasSummary}` : void 0
-	]);
+function toLintErrorObject(value, fallbackMessage) {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	const error = new Error(fallbackMessage, { cause: value });
+	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
+	return error;
 }
-function formatDiscordChannelUnresolved(entry) {
-	return formatResolutionLogDetails(entry.input, [
-		entry.guildName ? `guild:${entry.guildName}` : entry.guildId ? `guildId:${entry.guildId}` : void 0,
-		entry.channelName ? `channel:${entry.channelName}` : entry.channelId ? `channelId:${entry.channelId}` : void 0,
-		entry.note
-	]);
+//#endregion
+//#region extensions/discord/src/monitor/provider.lifecycle.ts
+const DEFAULT_DISCORD_GATEWAY_READY_TIMEOUT_MS = 15e3;
+const DEFAULT_DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_MS = 3e4;
+const MAX_DISCORD_GATEWAY_READY_TIMEOUT_MS = 12e4;
+const DISCORD_GATEWAY_READY_TIMEOUT_ENV = "OPENCLAW_DISCORD_READY_TIMEOUT_MS";
+const DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_ENV = "OPENCLAW_DISCORD_RUNTIME_READY_TIMEOUT_MS";
+const DISCORD_GATEWAY_READY_POLL_MS = 250;
+const DISCORD_GATEWAY_READY_RETRY_BACKOFF_MS = 2e3;
+const DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS = 5e3;
+const DISCORD_GATEWAY_STARTUP_TERMINATE_CLOSE_TIMEOUT_MS = 1e3;
+const DISCORD_GATEWAY_TRANSPORT_ACTIVITY_STATUS_MIN_INTERVAL_MS = 3e4;
+function normalizeGatewayReadyTimeoutMs(value) {
+	const numeric = parseStrictPositiveInteger(value);
+	if (numeric === void 0) return;
+	return Math.min(numeric, MAX_DISCORD_GATEWAY_READY_TIMEOUT_MS);
 }
-function formatDiscordUserResolved(entry) {
-	const displayName = entry.name?.trim();
-	const target = displayName || entry.id;
-	const formatted = formatResolutionLogDetails(formatResolvedBase(entry.input, target), [
-		displayName && entry.id && entry.id !== entry.input ? `id:${entry.id}` : void 0,
-		entry.guildName ? `guild:${entry.guildName}` : void 0,
-		entry.note
-	]);
-	return formatted === entry.input ? null : formatted;
+function resolveDiscordGatewayReadyTimeoutMs(params) {
+	return normalizeGatewayReadyTimeoutMs(params?.configuredTimeoutMs) ?? normalizeGatewayReadyTimeoutMs(params?.env?.[DISCORD_GATEWAY_READY_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_READY_TIMEOUT_MS;
 }
-function formatDiscordUserUnresolved(entry) {
-	return formatResolutionLogDetails(entry.input, [
-		entry.name ? `name:${entry.name}` : void 0,
-		entry.guildName ? `guild:${entry.guildName}` : void 0,
-		entry.note
-	]);
+function resolveDiscordGatewayRuntimeReadyTimeoutMs(params) {
+	return normalizeGatewayReadyTimeoutMs(params?.configuredTimeoutMs) ?? normalizeGatewayReadyTimeoutMs(params?.env?.[DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_MS;
 }
-function toGuildEntries(value) {
-	if (!value || typeof value !== "object") return {};
-	const out = {};
-	for (const [key, entry] of Object.entries(value)) {
-		if (!entry || typeof entry !== "object") continue;
-		out[key] = entry;
+async function restartGatewayAfterReadyTimeout(params) {
+	if (!params.gateway || params.abortSignal?.aborted) return;
+	const socket = params.gateway.ws;
+	if (!socket) {
+		params.gateway.disconnect();
+		if (!params.abortSignal?.aborted) params.gateway.connect(false);
+		return;
 	}
-	return out;
+	await new Promise((resolve, reject) => {
+		let settled = false;
+		let drainTimeout;
+		let terminateCloseTimeout;
+		const ignoreSocketError = () => {};
+		const clearTimers = () => {
+			if (drainTimeout) {
+				clearTimeout(drainTimeout);
+				drainTimeout = void 0;
+			}
+			if (terminateCloseTimeout) {
+				clearTimeout(terminateCloseTimeout);
+				terminateCloseTimeout = void 0;
+			}
+		};
+		const cleanup = () => {
+			clearTimers();
+			socket.removeListener("close", onClose);
+			socket.removeListener("error", ignoreSocketError);
+		};
+		const finishResolve = () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve();
+		};
+		const finishReject = (error) => {
+			if (params.abortSignal?.aborted) {
+				finishResolve();
+				return;
+			}
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		};
+		const onClose = () => {
+			finishResolve();
+		};
+		socket.on("error", ignoreSocketError);
+		socket.on("close", onClose);
+		params.gateway?.disconnect();
+		drainTimeout = setTimeout(() => {
+			if (settled) return;
+			if (typeof socket.terminate !== "function") {
+				finishReject(/* @__PURE__ */ new Error(`discord gateway socket did not close within ${DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS}ms before restart`));
+				return;
+			}
+			params.runtime.error?.(danger(`discord: startup restart waiting on a stale gateway socket for ${DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS}ms; forcing terminate before reconnect`));
+			try {
+				socket.terminate();
+			} catch {
+				finishReject(/* @__PURE__ */ new Error(`discord gateway socket did not close within ${DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS}ms before restart`));
+				return;
+			}
+			terminateCloseTimeout = setTimeout(() => {
+				finishReject(/* @__PURE__ */ new Error(`discord gateway socket did not close within ${DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS}ms before restart`));
+			}, DISCORD_GATEWAY_STARTUP_TERMINATE_CLOSE_TIMEOUT_MS);
+			terminateCloseTimeout.unref?.();
+		}, DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS);
+		drainTimeout.unref?.();
+	});
+	if (!params.abortSignal?.aborted) params.gateway.connect(false);
 }
-function toAllowlistEntries(value) {
-	if (!Array.isArray(value)) return;
-	return normalizeStringEntries(value);
+function parseGatewayCloseCode(message) {
+	const match = /Gateway websocket closed:\s*(\d{3,5})/.exec(message);
+	if (!match?.[1]) return;
+	const code = Number.parseInt(match[1], 10);
+	return Number.isFinite(code) ? code : void 0;
 }
-function hasGuildEntries(value) {
-	return Object.keys(value).length > 0;
+function resolveTransportActivityAt(event) {
+	const at = event?.at;
+	const timestampMs = asDateTimestampMs(at);
+	return timestampMs !== void 0 && timestampMs >= 0 ? timestampMs : Date.now();
 }
-function collectChannelResolutionInputs(guildEntries) {
-	const entries = [];
-	for (const [guildKey, guildCfg] of Object.entries(guildEntries)) {
-		if (guildKey === "*") continue;
-		const channels = guildCfg?.channels ?? {};
-		const channelKeys = Object.keys(channels).filter((key) => key !== "*");
-		if (channelKeys.length === 0) {
-			const input = /^\d+$/.test(guildKey) ? `guild:${guildKey}` : guildKey;
-			entries.push({
-				input,
-				guildKey
-			});
-			continue;
+function createGatewayStatusObserver(params) {
+	let forceStopHandler;
+	let queuedForceStopError;
+	let readyPollId;
+	let readyTimeoutId;
+	const shouldStop = () => params.abortSignal?.aborted || params.isLifecycleStopping();
+	const clearReadyWatch = () => {
+		if (readyPollId) {
+			clearInterval(readyPollId);
+			readyPollId = void 0;
 		}
-		for (const channelKey of channelKeys) entries.push({
-			input: `${guildKey}/${channelKey}`,
-			guildKey,
-			channelKey
-		});
-	}
-	return entries;
-}
-async function resolveGuildEntriesByChannelAllowlist(params) {
-	const entries = collectChannelResolutionInputs(params.guildEntries);
-	if (entries.length === 0) return params.guildEntries;
-	try {
-		const resolved = await resolveDiscordChannelAllowlist({
-			token: params.token,
-			entries: entries.map((entry) => entry.input),
-			fetcher: params.fetcher
+		if (readyTimeoutId) {
+			clearTimeout(readyTimeoutId);
+			readyTimeoutId = void 0;
+		}
+	};
+	const triggerForceStop = (err) => {
+		if (forceStopHandler) {
+			forceStopHandler(err);
+			return;
+		}
+		queuedForceStopError = err;
+	};
+	const pushConnectedStatus = (at) => {
+		params.pushStatus({
+			...createConnectedChannelStatusPatch(at),
+			lastDisconnect: null,
+			lastError: null
 		});
-		const sourceByInput = new Map(entries.map((entry) => [entry.input, entry]));
-		const nextGuilds = { ...params.guildEntries };
-		const mappingByTarget = /* @__PURE__ */ new Map();
-		const unresolved = [];
-		for (const entry of resolved) {
-			const source = sourceByInput.get(entry.input);
-			if (!source) continue;
-			const sourceGuild = params.guildEntries[source.guildKey] ?? {};
-			if (!entry.resolved || !entry.guildId) {
-				unresolved.push(formatDiscordChannelUnresolved(entry));
-				continue;
+	};
+	const startReadyWatch = () => {
+		clearReadyWatch();
+		const pollConnected = () => {
+			if (shouldStop()) {
+				clearReadyWatch();
+				return;
 			}
-			const target = entry.channelId ? `${entry.guildId}/${entry.channelId}` : entry.guildId;
-			const existingGroup = mappingByTarget.get(target) ?? {
-				target,
-				aliases: [],
-				guildName: entry.guildName,
-				channelName: entry.channelName,
-				note: entry.note
-			};
-			if (entry.input !== target && !existingGroup.aliases.includes(entry.input)) existingGroup.aliases.push(entry.input);
-			if (!existingGroup.guildName && entry.guildName) existingGroup.guildName = entry.guildName;
-			if (!existingGroup.channelName && entry.channelName) existingGroup.channelName = entry.channelName;
-			if (!existingGroup.note && entry.note) existingGroup.note = entry.note;
-			mappingByTarget.set(target, existingGroup);
-			const existing = nextGuilds[entry.guildId] ?? {};
-			const mergedChannels = {
-				...sourceGuild.channels,
-				...existing.channels
-			};
-			const mergedGuild = {
-				...sourceGuild,
-				...existing,
-				channels: mergedChannels
-			};
-			nextGuilds[entry.guildId] = mergedGuild;
-			if (source.channelKey && entry.channelId) {
-				const sourceChannel = sourceGuild.channels?.[source.channelKey];
-				if (sourceChannel) nextGuilds[entry.guildId] = {
-					...mergedGuild,
-					channels: {
-						...mergedChannels,
-						[entry.channelId]: {
-							...sourceChannel,
-							...mergedChannels[entry.channelId]
-						}
-					}
-				};
+			if (!params.gateway?.isConnected) return;
+			clearReadyWatch();
+			pushConnectedStatus(Date.now());
+		};
+		pollConnected();
+		if (!readyTimeoutId) {
+			readyPollId = setInterval(pollConnected, DISCORD_GATEWAY_READY_POLL_MS);
+			readyPollId.unref?.();
+			readyTimeoutId = setTimeout(() => {
+				clearReadyWatch();
+				if (shouldStop() || params.gateway?.isConnected) return;
+				const at = Date.now();
+				const error = /* @__PURE__ */ new Error(`discord gateway opened but did not reach READY within ${params.runtimeReadyTimeoutMs}ms`);
+				params.pushStatus({
+					connected: false,
+					lastEventAt: at,
+					lastDisconnect: {
+						at,
+						error: "runtime-not-ready"
+					},
+					lastError: "runtime-not-ready"
+				});
+				params.runtime.error?.(danger(error.message));
+				triggerForceStop(error);
+			}, params.runtimeReadyTimeoutMs);
+			readyTimeoutId.unref?.();
+		}
+	};
+	const onGatewayDebug = (msg) => {
+		if (shouldStop()) return;
+		const at = Date.now();
+		const message = String(msg);
+		if (message.includes("Gateway websocket opened")) {
+			params.pushStatus({
+				connected: false,
+				lastEventAt: at
+			});
+			startReadyWatch();
+			return;
+		}
+		if (message.includes("Gateway websocket closed")) {
+			clearReadyWatch();
+			const code = parseGatewayCloseCode(message);
+			params.pushStatus({
+				connected: false,
+				lastEventAt: at,
+				lastDisconnect: {
+					at,
+					...code !== void 0 ? { status: code } : {}
+				}
+			});
+			return;
+		}
+		if (message.includes("Gateway reconnect scheduled in")) {
+			clearReadyWatch();
+			params.pushStatus({
+				connected: false,
+				lastEventAt: at,
+				lastError: message
+			});
+		}
+	};
+	return {
+		onGatewayDebug,
+		clearReadyWatch,
+		registerForceStop: (handler) => {
+			forceStopHandler = handler;
+			if (queuedForceStopError !== void 0) {
+				const err = queuedForceStopError;
+				queuedForceStopError = void 0;
+				handler(err);
 			}
+		},
+		dispose: () => {
+			clearReadyWatch();
+			forceStopHandler = void 0;
+			queuedForceStopError = void 0;
 		}
-		summarizeMapping("discord channels", [...mappingByTarget.values()].map((group) => formatDiscordChannelResolvedGroup(group)), unresolved, params.runtime);
-		return nextGuilds;
-	} catch (err) {
-		params.runtime.log?.(`discord channel resolve failed; using config entries. ${formatErrorMessage$1(err)}`);
-		return params.guildEntries;
-	}
+	};
 }
-async function resolveAllowFromByUserAllowlist(params) {
-	const allowEntries = normalizeStringEntries(params.allowFrom).filter((entry) => entry !== "*");
-	if (allowEntries.length === 0) return params.allowFrom;
-	try {
-		const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(await resolveDiscordUserAllowlist({
-			token: params.token,
-			entries: allowEntries,
-			fetcher: params.fetcher
-		}), {
-			formatResolved: formatDiscordUserResolved,
-			formatUnresolved: formatDiscordUserUnresolved
+async function waitForGatewayReady(params) {
+	const waitUntilReady = async () => {
+		const deadlineAt = Date.now() + params.readyTimeoutMs;
+		while (!params.abortSignal?.aborted) {
+			if (await params.beforePoll?.() === "stop") return "stopped";
+			if (params.gateway?.isConnected === true) {
+				const at = Date.now();
+				params.pushStatus?.({
+					...createConnectedChannelStatusPatch(at),
+					lastDisconnect: null,
+					lastError: null
+				});
+				return "ready";
+			}
+			if (Date.now() >= deadlineAt) return "timeout";
+			await new Promise((resolve) => {
+				setTimeout(resolve, DISCORD_GATEWAY_READY_POLL_MS).unref?.();
+			});
+		}
+		return "stopped";
+	};
+	if (!params.gateway) {
+		if (await waitUntilReady() === "timeout") throw new Error(`discord gateway did not reach READY within ${params.readyTimeoutMs}ms`);
+		return;
+	}
+	let attempt = 0;
+	while (!params.abortSignal?.aborted) {
+		if (await waitUntilReady() !== "timeout") return;
+		attempt += 1;
+		const restartAt = Date.now();
+		params.runtime.error?.(danger(`discord: gateway READY wait timed out after ${params.readyTimeoutMs}ms; reconnecting with backoff (attempt ${attempt})`));
+		params.pushStatus?.({
+			connected: false,
+			lastEventAt: restartAt,
+			lastDisconnect: {
+				at: restartAt,
+				error: "startup-not-ready"
+			},
+			lastError: "startup-not-ready"
 		});
-		const allowFrom = canonicalizeAllowlistWithResolvedIds({
-			existing: params.allowFrom,
-			resolvedMap
+		await params.beforeRestart?.();
+		await restartGatewayAfterReadyTimeout({
+			gateway: params.gateway,
+			abortSignal: params.abortSignal,
+			runtime: params.runtime
 		});
-		summarizeMapping("discord users", mapping, unresolved, params.runtime);
-		return allowFrom;
-	} catch (err) {
-		params.runtime.log?.(`discord user resolve failed; using config entries. ${formatErrorMessage$1(err)}`);
-		return params.allowFrom;
-	}
-}
-function collectGuildUserEntries(guildEntries) {
-	const userEntries = /* @__PURE__ */ new Set();
-	for (const guild of Object.values(guildEntries)) {
-		if (!guild || typeof guild !== "object") continue;
-		addAllowlistUserEntriesFromConfigEntry(userEntries, guild);
-		const channels = guild.channels ?? {};
-		for (const channel of Object.values(channels)) addAllowlistUserEntriesFromConfigEntry(userEntries, channel);
-	}
-	return userEntries;
-}
-async function resolveGuildEntriesByUserAllowlist(params) {
-	const userEntries = collectGuildUserEntries(params.guildEntries);
-	if (userEntries.size === 0) return params.guildEntries;
-	try {
-		const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(await resolveDiscordUserAllowlist({
-			token: params.token,
-			entries: Array.from(userEntries),
-			fetcher: params.fetcher
-		}), {
-			formatResolved: formatDiscordUserResolved,
-			formatUnresolved: formatDiscordUserUnresolved
-		});
-		const nextGuilds = { ...params.guildEntries };
-		for (const [guildKey, guildConfig] of Object.entries(params.guildEntries)) {
-			if (!guildConfig || typeof guildConfig !== "object") continue;
-			const nextGuild = { ...guildConfig };
-			const users = guildConfig.users;
-			if (Array.isArray(users) && users.length > 0) nextGuild.users = canonicalizeAllowlistWithResolvedIds({
-				existing: users,
-				resolvedMap
-			});
-			const channels = guildConfig.channels ?? {};
-			if (channels && typeof channels === "object") nextGuild.channels = patchAllowlistUsersInConfigEntries({
-				entries: channels,
-				resolvedMap,
-				strategy: "canonicalize"
-			});
-			nextGuilds[guildKey] = nextGuild;
+		if (params.abortSignal?.aborted) return;
+		try {
+			await sleepWithAbort(DISCORD_GATEWAY_READY_RETRY_BACKOFF_MS, params.abortSignal, { ref: false });
+		} catch {
+			return;
 		}
-		summarizeMapping("discord channel users", mapping, unresolved, params.runtime);
-		return nextGuilds;
-	} catch (err) {
-		params.runtime.log?.(`discord channel user resolve failed; using config entries. ${formatErrorMessage$1(err)}`);
-		return params.guildEntries;
 	}
 }
-async function resolveDiscordAllowlistConfig(params) {
-	let guildEntries = toGuildEntries(params.guildEntries);
-	let allowFrom = toAllowlistEntries(params.allowFrom);
-	if (hasGuildEntries(guildEntries)) guildEntries = await resolveGuildEntriesByChannelAllowlist({
-		token: params.token,
-		guildEntries,
-		fetcher: params.fetcher,
+async function runDiscordGatewayLifecycle(params) {
+	const gateway = params.gateway;
+	const gatewayReadyAtLifecycleStart = gateway?.isConnected === true;
+	if (gateway) registerGateway(params.accountId, gateway);
+	const gatewayEmitter = params.gatewaySupervisor.emitter ?? getDiscordGatewayEmitter(gateway);
+	const stopGatewayLogging = attachDiscordGatewayLogging({
+		emitter: gatewayEmitter,
 		runtime: params.runtime
 	});
-	if (isDangerousNameMatchingEnabled(params.discordConfig)) {
-		allowFrom = await resolveAllowFromByUserAllowlist({
-			token: params.token,
-			allowFrom,
-			fetcher: params.fetcher,
-			runtime: params.runtime
+	let lifecycleStopping = false;
+	const pushStatus = (patch) => {
+		params.statusSink?.(patch);
+	};
+	const gatewayReadyTimeoutMs = resolveDiscordGatewayReadyTimeoutMs({
+		configuredTimeoutMs: params.gatewayReadyTimeoutMs,
+		env: process.env
+	});
+	const gatewayRuntimeReadyTimeoutMs = resolveDiscordGatewayRuntimeReadyTimeoutMs({
+		configuredTimeoutMs: params.gatewayRuntimeReadyTimeoutMs,
+		env: process.env
+	});
+	const statusObserver = createGatewayStatusObserver({
+		gateway,
+		abortSignal: params.abortSignal,
+		runtime: params.runtime,
+		pushStatus,
+		isLifecycleStopping: () => lifecycleStopping,
+		runtimeReadyTimeoutMs: gatewayRuntimeReadyTimeoutMs
+	});
+	gatewayEmitter?.on("debug", statusObserver.onGatewayDebug);
+	let lastTransportActivityStatusAt;
+	const onGatewayTransportActivity = (event) => {
+		if (lifecycleStopping || params.abortSignal?.aborted) return;
+		const at = resolveTransportActivityAt(event);
+		if (lastTransportActivityStatusAt !== void 0 && at - lastTransportActivityStatusAt < DISCORD_GATEWAY_TRANSPORT_ACTIVITY_STATUS_MIN_INTERVAL_MS) return;
+		lastTransportActivityStatusAt = at;
+		pushStatus(createTransportActivityStatusPatch(at));
+	};
+	gatewayEmitter?.on(DISCORD_GATEWAY_TRANSPORT_ACTIVITY_EVENT, onGatewayTransportActivity);
+	let sawDisallowedIntents = false;
+	const handleGatewayEvent = (event) => {
+		if (params.abortSignal?.aborted && event.type === "reconnect-exhausted") {
+			lifecycleStopping = true;
+			params.runtime.log?.(`discord: treating reconnect-exhausted during expected shutdown as clean: ${event.message}`);
+			return "continue";
+		}
+		if (event.type === "disallowed-intents") {
+			lifecycleStopping = true;
+			sawDisallowedIntents = true;
+			params.runtime.error?.(danger("discord: gateway closed with code 4014 (missing privileged gateway intents). Enable the required intents in the Discord Developer Portal or disable them in config."));
+			return "stop";
+		}
+		if (event.shouldStopLifecycle) lifecycleStopping = true;
+		params.runtime.error?.(danger(event.shouldStopLifecycle ? `discord gateway ${event.type}: ${event.message}` : `discord gateway error: ${event.message}`));
+		return event.shouldStopLifecycle ? "stop" : "continue";
+	};
+	const drainPendingGatewayErrors = () => params.gatewaySupervisor.drainPending((event) => {
+		if (handleGatewayEvent(event) !== "stop") return "continue";
+		if (event.type === "disallowed-intents") return "stop";
+		throw new DiscordGatewayLifecycleError(event);
+	});
+	try {
+		if (drainPendingGatewayErrors() === "stop") return;
+		if (gatewayReadyAtLifecycleStart && params.voiceManager) params.voiceManager.autoJoin().catch((err) => params.runtime.error?.(danger(`discord voice: autoJoin failed: ${formatErrorMessage$1(err)}`)));
+		await waitForGatewayReady({
+			gateway,
+			abortSignal: params.abortSignal,
+			beforePoll: drainPendingGatewayErrors,
+			pushStatus,
+			runtime: params.runtime,
+			beforeRestart: statusObserver.clearReadyWatch,
+			readyTimeoutMs: gatewayReadyTimeoutMs
 		});
-		if (hasGuildEntries(guildEntries)) guildEntries = await resolveGuildEntriesByUserAllowlist({
-			token: params.token,
-			guildEntries,
-			fetcher: params.fetcher,
-			runtime: params.runtime
+		if (drainPendingGatewayErrors() === "stop") return;
+		await waitForDiscordGatewayStop({
+			gateway: gateway ? { disconnect: () => gateway.disconnect() } : void 0,
+			abortSignal: params.abortSignal,
+			gatewaySupervisor: params.gatewaySupervisor,
+			onGatewayEvent: handleGatewayEvent,
+			registerForceStop: statusObserver.registerForceStop
 		});
-	}
-	return {
-		guildEntries: hasGuildEntries(guildEntries) ? guildEntries : void 0,
-		allowFrom
-	};
-}
-//#endregion
-//#region extensions/discord/src/monitor/provider.cleanup.ts
-function cleanupDiscordProviderStartup(params) {
-	params.deactivateMessageHandler?.();
-	params.autoPresenceController?.stop();
-	params.setStatus?.({ connected: false });
-	if (params.onEarlyGatewayDebug) params.earlyGatewayEmitter?.removeListener("debug", params.onEarlyGatewayDebug);
-	if (!params.lifecycleStarted) try {
-		params.lifecycleGateway?.disconnect();
 	} catch (err) {
-		params.runtime.error?.(danger(`discord: failed to disconnect gateway during startup cleanup: ${String(err)}`));
+		if (!sawDisallowedIntents && !params.isDisallowedIntentsError(err)) throw err;
+	} finally {
+		lifecycleStopping = true;
+		params.gatewaySupervisor.detachLifecycle();
+		unregisterGateway(params.accountId);
+		stopGatewayLogging();
+		statusObserver.dispose();
+		gatewayEmitter?.removeListener("debug", statusObserver.onGatewayDebug);
+		gatewayEmitter?.removeListener(DISCORD_GATEWAY_TRANSPORT_ACTIVITY_EVENT, onGatewayTransportActivity);
+		if (params.voiceManager) {
+			await params.voiceManager.destroy();
+			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-DjDbt14x.js").then((n) => n.n);
+			setDiscordTranscriptsVoiceManager({
+				accountId: params.accountId,
+				manager: null
+			});
+			params.voiceManagerRef.current = null;
+		}
+		params.threadBindings.stop();
 	}
-	params.gatewaySupervisor?.dispose();
-	if (!params.lifecycleStarted) params.threadBindings.stop();
 }
 //#endregion
-//#region extensions/discord/src/monitor/provider.commands.ts
-let pluginRuntimePromise;
-async function loadPluginRuntime() {
-	const promise = pluginRuntimePromise ?? import("openclaw/plugin-sdk/plugin-runtime");
-	pluginRuntimePromise = promise;
+//#region extensions/discord/src/monitor/provider-runtime.ts
+let discordVoiceRuntimePromise;
+let discordProviderSessionRuntimePromise;
+async function loadDiscordVoiceRuntime() {
+	const promise = discordVoiceRuntimePromise ?? import("./manager.runtime-Cc8vS-M7.js");
+	discordVoiceRuntimePromise = promise;
 	try {
 		return await promise;
 	} catch (error) {
-		if (pluginRuntimePromise === promise) pluginRuntimePromise = void 0;
+		if (discordVoiceRuntimePromise === promise) discordVoiceRuntimePromise = void 0;
 		throw error;
 	}
 }
-async function appendPluginCommandSpecs(params) {
-	const merged = [...params.commandSpecs];
-	const existingNames = new Set(normalizeStringEntriesLower(merged.map((spec) => spec.name)));
-	const getPluginCommandSpecs = params.getPluginCommandSpecs ?? (await loadPluginRuntime()).getPluginCommandSpecs;
-	for (const pluginCommand of getPluginCommandSpecs("discord", { config: params.cfg })) {
-		const normalizedName = normalizeLowercaseStringOrEmpty(pluginCommand.name);
-		if (!normalizedName) continue;
-		if (existingNames.has(normalizedName)) {
-			params.runtime.error?.(danger(`discord: plugin command "/${normalizedName}" duplicates an existing native command. Skipping.`));
-			continue;
-		}
-		existingNames.add(normalizedName);
-		merged.push({
-			name: pluginCommand.name,
-			description: pluginCommand.description,
-			acceptsArgs: pluginCommand.acceptsArgs
-		});
-	}
-	return merged;
-}
-async function resolveDiscordProviderCommandSpecs(params) {
-	const listSkillCommands = params.listSkillCommandsForAgents ?? listSkillCommandsForAgents;
-	const listNativeCommandSpecs = params.listNativeCommandSpecsForConfig ?? listNativeCommandSpecsForConfig;
-	const maxDiscordCommands = params.maxDiscordCommands ?? 100;
-	let skillCommands = params.nativeEnabled && params.nativeSkillsEnabled ? listSkillCommands({ cfg: params.cfg }) : [];
-	let commandSpecs = params.nativeEnabled ? listNativeCommandSpecs(params.cfg, {
-		skillCommands,
-		provider: "discord"
-	}) : [];
-	if (params.nativeEnabled) commandSpecs = await appendPluginCommandSpecs({
-		commandSpecs,
-		runtime: params.runtime,
-		cfg: params.cfg,
-		getPluginCommandSpecs: params.getPluginCommandSpecs
-	});
-	const initialCommandCount = commandSpecs.length;
-	if (params.nativeEnabled && params.nativeSkillsEnabled && commandSpecs.length > maxDiscordCommands) {
-		skillCommands = [];
-		commandSpecs = listNativeCommandSpecs(params.cfg, {
-			skillCommands: [],
-			provider: "discord"
-		});
-		commandSpecs = await appendPluginCommandSpecs({
-			commandSpecs,
-			runtime: params.runtime,
-			cfg: params.cfg,
-			getPluginCommandSpecs: params.getPluginCommandSpecs
-		});
-		params.runtime.log?.(warn(`${initialCommandCount} commands exceed the ${maxDiscordCommands}-command Discord limit; removing per-skill commands and keeping /skill.`));
+async function loadDiscordProviderSessionRuntime() {
+	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-cCfGMsF_.js");
+	discordProviderSessionRuntimePromise = promise;
+	try {
+		return await promise;
+	} catch (error) {
+		if (discordProviderSessionRuntimePromise === promise) discordProviderSessionRuntimePromise = void 0;
+		throw error;
 	}
-	if (params.nativeEnabled && commandSpecs.length > maxDiscordCommands) params.runtime.log?.(warn(`${commandSpecs.length} commands exceed the ${maxDiscordCommands}-command Discord limit; some commands may fail to deploy.`));
-	return {
-		skillCommands,
-		commandSpecs
-	};
 }
+const discordProviderRuntime = {
+	fetchDiscordApplicationId,
+	createDiscordNativeCommand,
+	runDiscordGatewayLifecycle,
+	loadDiscordVoiceRuntime,
+	loadDiscordProviderSessionRuntime,
+	createClient: (...args) => new Client(...args),
+	getPluginCommandSpecs: void 0,
+	resolveDiscordAccount,
+	resolveNativeCommandsEnabled,
+	resolveNativeSkillsEnabled,
+	listNativeCommandSpecsForConfig,
+	listSkillCommandsForAgents,
+	isVerbose,
+	shouldLogVerbose
+};
 //#endregion
-//#region extensions/discord/src/monitor/provider.config-log.ts
-function formatThreadBindingDurationForConfigLabel(durationMs) {
-	const label = formatThreadBindingDurationLabel(durationMs);
-	return label === "disabled" ? "off" : label;
-}
-function logDiscordResolvedConfig(params) {
-	const allowFromSummary = summarizeStringEntries({
-		entries: params.allowFrom ?? [],
-		limit: 4,
-		emptyText: "any"
-	});
-	const groupDmChannelSummary = summarizeStringEntries({
-		entries: params.groupDmChannels ?? [],
-		limit: 4,
-		emptyText: "any"
-	});
-	const guildSummary = summarizeStringEntries({
-		entries: Object.keys(params.guildEntries ?? {}),
-		limit: 4,
-		emptyText: "any"
-	});
-	logVerbose(`discord: config dm=${params.dmEnabled ? "on" : "off"} dmPolicy=${params.dmPolicy} allowFrom=${allowFromSummary} groupDm=${params.groupDmEnabled ? "on" : "off"} groupDmChannels=${groupDmChannelSummary} groupPolicy=${params.groupPolicy} guilds=${guildSummary} historyLimit=${params.historyLimit} mediaMaxMb=${Math.round(params.mediaMaxBytes / (1024 * 1024))} native=${params.nativeEnabled ? "on" : "off"} nativeSkills=${params.nativeSkillsEnabled ? "on" : "off"} accessGroups=${params.useAccessGroups ? "on" : "off"} threadBindings=${params.threadBindingsEnabled ? "on" : "off"} threadIdleTimeout=${formatThreadBindingDurationForConfigLabel(params.threadBindingIdleTimeoutMs)} threadMaxAge=${formatThreadBindingDurationForConfigLabel(params.threadBindingMaxAgeMs)}`);
+//#region extensions/discord/src/monitor/provider.acp.ts
+const DISCORD_ACP_STATUS_PROBE_TIMEOUT_MS = 8e3;
+const DISCORD_ACP_STALE_RUNNING_ACTIVITY_MS = 120 * 1e3;
+function isLegacyMissingSessionError(message) {
+	return message.includes("Session is not ACP-enabled") || message.includes("ACP session metadata missing");
 }
-//#endregion
-//#region extensions/discord/src/monitor/provider.deploy-errors.ts
-const DISCORD_DEPLOY_REJECTED_ENTRY_LIMIT = 3;
-function attachDiscordDeployRequestBody(err, body) {
-	if (!err || typeof err !== "object" || body === void 0) return;
-	const deployErr = err;
-	if (deployErr.deployRequestBody === void 0) deployErr.deployRequestBody = body;
+function classifyAcpStatusProbeError(params) {
+	if (params.isAcpRuntimeError(params.error) && params.error.code === "ACP_SESSION_INIT_FAILED") return {
+		status: "stale",
+		reason: "session-init-failed"
+	};
+	if (isLegacyMissingSessionError(formatErrorMessage$1(params.error))) return {
+		status: "stale",
+		reason: "session-missing"
+	};
+	return params.isStaleRunning ? {
+		status: "stale",
+		reason: "status-error-running-stale"
+	} : {
+		status: "uncertain",
+		reason: "status-error"
+	};
 }
-function attachDiscordDeployRestContext(err, context) {
-	if (!err || typeof err !== "object") return;
-	const deployErr = err;
-	deployErr.deployRestMethod = context.method;
-	deployErr.deployRestPath = context.path;
-	deployErr.deployRequestMs = context.requestMs;
-	if (typeof context.timeoutMs === "number" && Number.isFinite(context.timeoutMs)) deployErr.deployTimeoutMs = context.timeoutMs;
+function resolveRunningActivityAgeMs(params) {
+	if (params.storedState !== "running") return 0;
+	const nowMs = asDateTimestampMs(Date.now());
+	if (nowMs === void 0) return 0;
+	const activityAtMs = asDateTimestampMs(params.lastActivityAt);
+	return Math.max(0, nowMs - (activityAtMs === void 0 ? 0 : Math.max(0, Math.floor(activityAtMs))));
 }
-function stringifyDiscordDeployField(value) {
-	if (typeof value === "string") return JSON.stringify(value);
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return inspect(value, {
-			depth: 2,
-			breakLength: 120
-		});
-	}
+async function probeDiscordAcpBindingHealth(params) {
+	const { getAcpSessionManager, isAcpRuntimeError } = params.providerSessionRuntime;
+	const manager = getAcpSessionManager();
+	const statusProbeAbortController = new AbortController();
+	const result = await raceWithTimeout({
+		promise: manager.getSessionStatus({
+			cfg: params.cfg,
+			sessionKey: params.sessionKey,
+			signal: statusProbeAbortController.signal
+		}).then((status) => ({
+			kind: "status",
+			status
+		})).catch((error) => ({
+			kind: "error",
+			error
+		})),
+		timeoutMs: DISCORD_ACP_STATUS_PROBE_TIMEOUT_MS,
+		onTimeout: () => ({ kind: "timeout" })
+	});
+	if (result.kind === "timeout") statusProbeAbortController.abort();
+	const runningForMs = resolveRunningActivityAgeMs(params);
+	const isStaleRunning = params.storedState === "running" && runningForMs >= DISCORD_ACP_STALE_RUNNING_ACTIVITY_MS;
+	if (result.kind === "timeout") return isStaleRunning ? {
+		status: "stale",
+		reason: "status-timeout-running-stale"
+	} : {
+		status: "uncertain",
+		reason: "status-timeout"
+	};
+	if (result.kind === "error") return classifyAcpStatusProbeError({
+		error: result.error,
+		isStaleRunning,
+		isAcpRuntimeError
+	});
+	if (result.status.state === "error") return {
+		status: "uncertain",
+		reason: "status-error-state"
+	};
+	return { status: "healthy" };
 }
-function readDiscordDeployRejectedFields(value) {
-	if (Array.isArray(value)) return value.filter((entry) => typeof entry === "string").slice(0, 6);
-	if (!value || typeof value !== "object") return [];
-	return Object.keys(value).slice(0, 6);
+//#endregion
+//#region extensions/discord/src/monitor/provider.allowlist.ts
+function formatResolutionLogDetails(base, details) {
+	const nonEmpty = details.map((value) => value?.trim()).filter((value) => Boolean(value));
+	return nonEmpty.length > 0 ? `${base} (${nonEmpty.join("; ")})` : base;
 }
-function resolveDiscordRejectedDeployEntriesSource(rawBody) {
-	if (!rawBody || typeof rawBody !== "object") return null;
-	const payload = rawBody;
-	const source = (payload.errors && typeof payload.errors === "object" ? payload.errors : void 0) ?? rawBody;
-	return source && typeof source === "object" ? source : null;
+function formatResolvedBase(input, target) {
+	if (!target) return input;
+	return input === target ? input : `${input}→${target}`;
 }
-function readDiscordDeployObjectField(value, field) {
-	return value && typeof value === "object" && field in value ? value[field] : void 0;
+function formatAliasSummary(aliases) {
+	if (aliases.length === 0) return;
+	const preview = aliases.slice(0, 3).join(", ");
+	if (aliases.length <= 3) return preview;
+	return `${preview}, +${aliases.length - 3} more`;
 }
-function readFiniteNumber(value) {
-	if (typeof value === "number" && Number.isFinite(value)) return value;
-	if (typeof value === "string" && value.trim().length > 0) return parseStrictFiniteNumber(value);
+function formatDiscordChannelResolvedGroup(entry) {
+	const aliasSummary = formatAliasSummary(entry.aliases);
+	return formatResolutionLogDetails(entry.target, [
+		entry.guildName ? `guild:${entry.guildName}` : void 0,
+		entry.channelName ? `channel:${entry.channelName}` : void 0,
+		entry.note,
+		aliasSummary ? `aliases:${aliasSummary}` : void 0
+	]);
 }
-function readNonNegativeInteger(value) {
-	return parseStrictNonNegativeInteger(value);
+function formatDiscordChannelUnresolved(entry) {
+	return formatResolutionLogDetails(entry.input, [
+		entry.guildName ? `guild:${entry.guildName}` : entry.guildId ? `guildId:${entry.guildId}` : void 0,
+		entry.channelName ? `channel:${entry.channelName}` : entry.channelId ? `channelId:${entry.channelId}` : void 0,
+		entry.note
+	]);
 }
-function isAbortLikeError(err) {
-	if (!err || typeof err !== "object") return false;
-	const name = "name" in err && typeof err.name === "string" ? err.name : void 0;
-	const message = formatErrorMessage$1(err);
-	return name === "AbortError" || message === "This operation was aborted" || message === "The operation was aborted" || /\boperation was aborted\b/i.test(message);
+function formatDiscordUserResolved(entry) {
+	const displayName = entry.name?.trim();
+	const target = displayName || entry.id;
+	const formatted = formatResolutionLogDetails(formatResolvedBase(entry.input, target), [
+		displayName && entry.id && entry.id !== entry.input ? `id:${entry.id}` : void 0,
+		entry.guildName ? `guild:${entry.guildName}` : void 0,
+		entry.note
+	]);
+	return formatted === entry.input ? null : formatted;
 }
-function formatDiscordDeployRestOperation(err) {
-	const method = typeof err.deployRestMethod === "string" && err.deployRestMethod.trim().length > 0 ? err.deployRestMethod.toUpperCase() : void 0;
-	const path = typeof err.deployRestPath === "string" && err.deployRestPath.trim().length > 0 ? err.deployRestPath : void 0;
-	if (method && path) return `${method} ${path}`;
-	if (method) return method;
-	if (path) return path;
-	return "request";
+function formatDiscordUserUnresolved(entry) {
+	return formatResolutionLogDetails(entry.input, [
+		entry.name ? `name:${entry.name}` : void 0,
+		entry.guildName ? `guild:${entry.guildName}` : void 0,
+		entry.note
+	]);
 }
-function formatDiscordDeployErrorMessage(err) {
-	if (!isAbortLikeError(err)) return formatErrorMessage$1(err);
-	const deployErr = err && typeof err === "object" ? err : {};
-	const requestMs = readFiniteNumber(deployErr.deployRequestMs);
-	const timeoutMs = readFiniteNumber(deployErr.deployTimeoutMs);
-	const operation = formatDiscordDeployRestOperation(deployErr);
-	if (!(requestMs !== void 0 || timeoutMs !== void 0 || deployErr.deployRestMethod !== void 0 || deployErr.deployRestPath !== void 0)) return "Discord REST request was aborted";
-	const timing = [];
-	if (timeoutMs !== void 0) timing.push(`timeout=${formatDurationSeconds(timeoutMs, { decimals: timeoutMs >= 1e3 ? 1 : 0 })}`);
-	if (requestMs !== void 0) timing.push(`observed=${formatDurationSeconds(requestMs, { decimals: requestMs >= 1e3 ? 1 : 0 })}`);
-	const timingText = timing.length > 0 ? ` (${timing.join(", ")})` : "";
-	if (timeoutMs !== void 0 && requestMs !== void 0 && requestMs >= timeoutMs) return `Discord REST ${operation} timed out${timingText}`;
-	return `Discord REST ${operation} was aborted${timingText}`;
+function toGuildEntries(value) {
+	if (!value || typeof value !== "object") return {};
+	const out = {};
+	for (const [key, entry] of Object.entries(value)) {
+		if (!entry || typeof entry !== "object") continue;
+		out[key] = entry;
+	}
+	return out;
 }
-function resolveDiscordDeployRateLimitDetails(err) {
-	if (!err || typeof err !== "object") return;
-	const deployErr = err;
-	const status = readNonNegativeInteger(deployErr.status) ?? readNonNegativeInteger(deployErr.statusCode);
-	const retryAfterSeconds = readFiniteNumber(deployErr.retryAfter) ?? readFiniteNumber(readDiscordDeployObjectField(deployErr.rawBody, "retry_after"));
-	if (!(err instanceof RateLimitError || status === 429 || retryAfterSeconds !== void 0)) return;
-	const rawGlobal = readDiscordDeployObjectField(deployErr.rawBody, "global");
-	const scope = typeof deployErr.scope === "string" && deployErr.scope.trim().length > 0 ? deployErr.scope : rawGlobal === true ? "global" : rawGlobal === false ? "route" : void 0;
-	const discordCode = typeof deployErr.discordCode === "number" || typeof deployErr.discordCode === "string" ? deployErr.discordCode : void 0;
-	return {
-		status,
-		retryAfterMs: retryAfterSeconds === void 0 ? void 0 : Math.max(0, retryAfterSeconds * 1e3),
-		scope,
-		discordCode
-	};
+function toAllowlistEntries(value) {
+	if (!Array.isArray(value)) return;
+	return normalizeStringEntries(value);
 }
-function formatDiscordDeployRateLimitDetails(err) {
-	const rateLimit = resolveDiscordDeployRateLimitDetails(err);
-	if (!rateLimit) return "";
-	const details = [];
-	if (typeof rateLimit.status === "number") details.push(`status=${rateLimit.status}`);
-	if (typeof rateLimit.retryAfterMs === "number") details.push(`retryAfter=${formatDurationSeconds(rateLimit.retryAfterMs, { decimals: 1 })}`);
-	if (rateLimit.scope) details.push(`scope=${rateLimit.scope}`);
-	if (typeof rateLimit.discordCode === "number" || typeof rateLimit.discordCode === "string") details.push(`code=${rateLimit.discordCode}`);
-	return details.length > 0 ? ` (${details.join(", ")})` : "";
+function hasGuildEntries(value) {
+	return Object.keys(value).length > 0;
 }
-function formatDiscordDeployRateLimitWarning(err, accountId) {
-	const rateLimit = resolveDiscordDeployRateLimitDetails(err);
-	if (!rateLimit) return;
-	const parts = [`[${accountId}] slash command deploy rate limited`];
-	if (typeof rateLimit.retryAfterMs === "number") parts.push(`retry after ${formatDurationSeconds(rateLimit.retryAfterMs, { decimals: 1 })}`);
-	if (rateLimit.scope) parts.push(`scope=${rateLimit.scope}`);
-	if (typeof rateLimit.discordCode === "number" || typeof rateLimit.discordCode === "string") parts.push(`code=${rateLimit.discordCode}`);
-	return `${parts.join("; ")}. Existing slash commands stay active. Message send/receive is unaffected.`;
+function collectChannelResolutionInputs(guildEntries) {
+	const entries = [];
+	for (const [guildKey, guildCfg] of Object.entries(guildEntries)) {
+		if (guildKey === "*") continue;
+		const channels = guildCfg?.channels ?? {};
+		const channelKeys = Object.keys(channels).filter((key) => key !== "*");
+		if (channelKeys.length === 0) {
+			const input = /^\d+$/.test(guildKey) ? `guild:${guildKey}` : guildKey;
+			entries.push({
+				input,
+				guildKey
+			});
+			continue;
+		}
+		for (const channelKey of channelKeys) entries.push({
+			input: `${guildKey}/${channelKey}`,
+			guildKey,
+			channelKey
+		});
+	}
+	return entries;
 }
-function formatDiscordRejectedDeployEntries(params) {
-	const requestBody = Array.isArray(params.requestBody) ? params.requestBody : null;
-	const rejectedEntriesSource = resolveDiscordRejectedDeployEntriesSource(params.rawBody);
-	if (!rejectedEntriesSource || !requestBody || requestBody.length === 0) return [];
-	return Object.entries(rejectedEntriesSource).filter(([key]) => /^\d+$/.test(key)).slice(0, DISCORD_DEPLOY_REJECTED_ENTRY_LIMIT).flatMap(([key, value]) => {
-		const index = Number.parseInt(key, 10);
-		if (!Number.isFinite(index) || index < 0 || index >= requestBody.length) return [];
-		const command = requestBody[index];
-		if (!command || typeof command !== "object") return [`#${index} fields=${readDiscordDeployRejectedFields(value).join("|") || "unknown"}`];
-		const payload = command;
-		const parts = [`#${index}`, `fields=${readDiscordDeployRejectedFields(value).join("|") || "unknown"}`];
-		if (typeof payload.name === "string" && payload.name.trim().length > 0) parts.push(`name=${payload.name}`);
-		if (payload.description !== void 0) parts.push(`description=${stringifyDiscordDeployField(payload.description)}`);
-		if (Array.isArray(payload.options) && payload.options.length > 0) parts.push(`options=${payload.options.length}`);
-		return [parts.join(" ")];
-	});
+async function resolveGuildEntriesByChannelAllowlist(params) {
+	const entries = collectChannelResolutionInputs(params.guildEntries);
+	if (entries.length === 0) return params.guildEntries;
+	try {
+		const resolved = await resolveDiscordChannelAllowlist({
+			token: params.token,
+			entries: entries.map((entry) => entry.input),
+			fetcher: params.fetcher
+		});
+		const sourceByInput = new Map(entries.map((entry) => [entry.input, entry]));
+		const nextGuilds = { ...params.guildEntries };
+		const mappingByTarget = /* @__PURE__ */ new Map();
+		const unresolved = [];
+		for (const entry of resolved) {
+			const source = sourceByInput.get(entry.input);
+			if (!source) continue;
+			const sourceGuild = params.guildEntries[source.guildKey] ?? {};
+			if (!entry.resolved || !entry.guildId) {
+				unresolved.push(formatDiscordChannelUnresolved(entry));
+				continue;
+			}
+			const target = entry.channelId ? `${entry.guildId}/${entry.channelId}` : entry.guildId;
+			const existingGroup = mappingByTarget.get(target) ?? {
+				target,
+				aliases: [],
+				guildName: entry.guildName,
+				channelName: entry.channelName,
+				note: entry.note
+			};
+			if (entry.input !== target && !existingGroup.aliases.includes(entry.input)) existingGroup.aliases.push(entry.input);
+			if (!existingGroup.guildName && entry.guildName) existingGroup.guildName = entry.guildName;
+			if (!existingGroup.channelName && entry.channelName) existingGroup.channelName = entry.channelName;
+			if (!existingGroup.note && entry.note) existingGroup.note = entry.note;
+			mappingByTarget.set(target, existingGroup);
+			const existing = nextGuilds[entry.guildId] ?? {};
+			const mergedChannels = {
+				...sourceGuild.channels,
+				...existing.channels
+			};
+			const mergedGuild = {
+				...sourceGuild,
+				...existing,
+				channels: mergedChannels
+			};
+			nextGuilds[entry.guildId] = mergedGuild;
+			if (source.channelKey && entry.channelId) {
+				const sourceChannel = sourceGuild.channels?.[source.channelKey];
+				if (sourceChannel) nextGuilds[entry.guildId] = {
+					...mergedGuild,
+					channels: {
+						...mergedChannels,
+						[entry.channelId]: {
+							...sourceChannel,
+							...mergedChannels[entry.channelId]
+						}
+					}
+				};
+			}
+		}
+		summarizeMapping("discord channels", [...mappingByTarget.values()].map((group) => formatDiscordChannelResolvedGroup(group)), unresolved, params.runtime);
+		return nextGuilds;
+	} catch (err) {
+		params.runtime.log?.(`discord channel resolve failed; using config entries. ${formatErrorMessage$1(err)}`);
+		return params.guildEntries;
+	}
 }
-function isRedundantDiscordDeployBody(rawBody) {
-	if (!rawBody || typeof rawBody !== "object" || Array.isArray(rawBody)) return false;
-	const keys = Object.keys(rawBody);
-	return keys.length > 0 && keys.every((key) => key === "message" || key === "code");
+async function resolveAllowFromByUserAllowlist(params) {
+	const allowEntries = normalizeStringEntries(params.allowFrom).filter((entry) => entry !== "*");
+	if (allowEntries.length === 0) return params.allowFrom;
+	try {
+		const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(await resolveDiscordUserAllowlist({
+			token: params.token,
+			entries: allowEntries,
+			fetcher: params.fetcher
+		}), {
+			formatResolved: formatDiscordUserResolved,
+			formatUnresolved: formatDiscordUserUnresolved
+		});
+		const allowFrom = canonicalizeAllowlistWithResolvedIds({
+			existing: params.allowFrom,
+			resolvedMap
+		});
+		summarizeMapping("discord users", mapping, unresolved, params.runtime);
+		return allowFrom;
+	} catch (err) {
+		params.runtime.log?.(`discord user resolve failed; using config entries. ${formatErrorMessage$1(err)}`);
+		return params.allowFrom;
+	}
 }
-function formatDiscordDeployErrorDetails(err) {
-	if (!err || typeof err !== "object") return "";
-	const rateLimitDetails = formatDiscordDeployRateLimitDetails(err);
-	if (rateLimitDetails) return rateLimitDetails;
-	const status = err.status;
-	const discordCode = err.discordCode;
-	const rawBody = err.rawBody;
-	const requestBody = err.deployRequestBody;
-	const details = [];
-	if (typeof status === "number") details.push(`status=${status}`);
-	if (typeof discordCode === "number" || typeof discordCode === "string") details.push(`code=${discordCode}`);
-	if (rawBody !== void 0 && !isRedundantDiscordDeployBody(rawBody)) {
-		let bodyText;
-		try {
-			bodyText = JSON.stringify(rawBody);
-		} catch {
-			bodyText = typeof rawBody === "string" ? rawBody : inspect(rawBody, {
-				depth: 3,
-				breakLength: 120
+function collectGuildUserEntries(guildEntries) {
+	const userEntries = /* @__PURE__ */ new Set();
+	for (const guild of Object.values(guildEntries)) {
+		if (!guild || typeof guild !== "object") continue;
+		addAllowlistUserEntriesFromConfigEntry(userEntries, guild);
+		const channels = guild.channels ?? {};
+		for (const channel of Object.values(channels)) addAllowlistUserEntriesFromConfigEntry(userEntries, channel);
+	}
+	return userEntries;
+}
+async function resolveGuildEntriesByUserAllowlist(params) {
+	const userEntries = collectGuildUserEntries(params.guildEntries);
+	if (userEntries.size === 0) return params.guildEntries;
+	try {
+		const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(await resolveDiscordUserAllowlist({
+			token: params.token,
+			entries: Array.from(userEntries),
+			fetcher: params.fetcher
+		}), {
+			formatResolved: formatDiscordUserResolved,
+			formatUnresolved: formatDiscordUserUnresolved
+		});
+		const nextGuilds = { ...params.guildEntries };
+		for (const [guildKey, guildConfig] of Object.entries(params.guildEntries)) {
+			if (!guildConfig || typeof guildConfig !== "object") continue;
+			const nextGuild = { ...guildConfig };
+			const users = guildConfig.users;
+			if (Array.isArray(users) && users.length > 0) nextGuild.users = canonicalizeAllowlistWithResolvedIds({
+				existing: users,
+				resolvedMap
 			});
+			const channels = guildConfig.channels ?? {};
+			if (channels && typeof channels === "object") nextGuild.channels = patchAllowlistUsersInConfigEntries({
+				entries: channels,
+				resolvedMap,
+				strategy: "canonicalize"
+			});
+			nextGuilds[guildKey] = nextGuild;
 		}
-		if (bodyText) {
-			const maxLen = 800;
-			const trimmed = bodyText.length > maxLen ? `${truncateUtf16Safe(bodyText, maxLen)}...` : bodyText;
-			details.push(`body=${trimmed}`);
-		}
+		summarizeMapping("discord channel users", mapping, unresolved, params.runtime);
+		return nextGuilds;
+	} catch (err) {
+		params.runtime.log?.(`discord channel user resolve failed; using config entries. ${formatErrorMessage$1(err)}`);
+		return params.guildEntries;
 	}
-	const rejectedEntries = formatDiscordRejectedDeployEntries({
-		rawBody,
-		requestBody
-	});
-	if (rejectedEntries.length > 0) details.push(`rejected=${rejectedEntries.join("; ")}`);
-	return details.length > 0 ? ` (${details.join(", ")})` : "";
 }
-function isDiscordDeployDailyCreateLimit(err) {
-	if (!err || typeof err !== "object") return false;
-	const deployErr = err;
-	const discordCode = readNonNegativeInteger(deployErr.discordCode);
-	const rawCode = readNonNegativeInteger(readDiscordDeployObjectField(deployErr.rawBody, "code"));
-	return (discordCode === 30034 || rawCode === 30034) && /daily application command creates/i.test(formatErrorMessage$1(err));
+async function resolveDiscordAllowlistConfig(params) {
+	let guildEntries = toGuildEntries(params.guildEntries);
+	let allowFrom = toAllowlistEntries(params.allowFrom);
+	if (hasGuildEntries(guildEntries)) guildEntries = await resolveGuildEntriesByChannelAllowlist({
+		token: params.token,
+		guildEntries,
+		fetcher: params.fetcher,
+		runtime: params.runtime
+	});
+	if (isDangerousNameMatchingEnabled(params.discordConfig)) {
+		allowFrom = await resolveAllowFromByUserAllowlist({
+			token: params.token,
+			allowFrom,
+			fetcher: params.fetcher,
+			runtime: params.runtime
+		});
+		if (hasGuildEntries(guildEntries)) guildEntries = await resolveGuildEntriesByUserAllowlist({
+			token: params.token,
+			guildEntries,
+			fetcher: params.fetcher,
+			runtime: params.runtime
+		});
+	}
+	return {
+		guildEntries: hasGuildEntries(guildEntries) ? guildEntries : void 0,
+		allowFrom
+	};
 }
 //#endregion
-//#region extensions/discord/src/monitor/provider.startup-log.ts
-function formatDiscordStartupGatewayState(gateway) {
-	if (!gateway) return "gateway=missing";
-	const reconnectAttempts = gateway.reconnectAttempts;
-	return `gatewayConnected=${gateway.isConnected ? "true" : "false"} reconnectAttempts=${typeof reconnectAttempts === "number" ? reconnectAttempts : "na"}`;
-}
-function logDiscordStartupPhase$1(params) {
-	if (!(params.isVerbose ?? isVerbose)()) return;
-	const elapsedMs = Math.max(0, Date.now() - params.startAt);
-	const suffix = [params.details, formatDiscordStartupGatewayState(params.gateway)].filter((value) => Boolean(value)).join(" ");
-	params.runtime.log?.(`discord startup [${params.accountId}] ${params.phase} ${elapsedMs}ms${suffix ? ` ${suffix}` : ""}`);
+//#region extensions/discord/src/monitor/provider.cleanup.ts
+async function cleanupDiscordProviderStartup(params) {
+	await params.deactivateMessageHandler?.();
+	params.autoPresenceController?.stop();
+	params.setStatus?.({ connected: false });
+	if (params.onEarlyGatewayDebug) params.earlyGatewayEmitter?.removeListener("debug", params.onEarlyGatewayDebug);
+	if (!params.lifecycleStarted) try {
+		params.lifecycleGateway?.disconnect();
+	} catch (err) {
+		params.runtime.error?.(danger(`discord: failed to disconnect gateway during startup cleanup: ${String(err)}`));
+	}
+	params.gatewaySupervisor?.dispose();
+	if (!params.lifecycleStarted) params.threadBindings.stop();
 }
 //#endregion
-//#region extensions/discord/src/monitor/provider.deploy.ts
-function readDeployRequestBody(data) {
-	return data && typeof data === "object" && "body" in data ? data.body : void 0;
+//#region extensions/discord/src/monitor/provider.commands.ts
+const loadPluginCommandSpecs = createLazyRuntimeNamedExport(() => import("openclaw/plugin-sdk/plugin-runtime"), "getPluginCommandSpecs");
+async function appendPluginCommandSpecs(params) {
+	const merged = [...params.commandSpecs];
+	const existingNames = new Set(normalizeStringEntriesLower(merged.map((spec) => spec.name)));
+	const getPluginCommandSpecs = params.getPluginCommandSpecs ?? await loadPluginCommandSpecs();
+	for (const pluginCommand of getPluginCommandSpecs("discord", { config: params.cfg })) {
+		const normalizedName = normalizeLowercaseStringOrEmpty(pluginCommand.name);
+		if (!normalizedName) continue;
+		if (existingNames.has(normalizedName)) {
+			params.runtime.error?.(danger(`discord: plugin command "/${normalizedName}" duplicates an existing native command. Skipping.`));
+			continue;
+		}
+		existingNames.add(normalizedName);
+		merged.push({
+			name: pluginCommand.name,
+			description: pluginCommand.description,
+			acceptsArgs: pluginCommand.acceptsArgs
+		});
+	}
+	return merged;
 }
-function isDeployCommandsPath(path) {
-	return path.startsWith("/applications/") && path.includes("/commands");
+async function resolveDiscordProviderCommandSpecs(params) {
+	const listSkillCommands = params.listSkillCommandsForAgents ?? listSkillCommandsForAgents;
+	const listNativeCommandSpecs = params.listNativeCommandSpecsForConfig ?? listNativeCommandSpecsForConfig;
+	const maxDiscordCommands = params.maxDiscordCommands ?? 100;
+	let skillCommands = params.nativeEnabled && params.nativeSkillsEnabled ? listSkillCommands({ cfg: params.cfg }) : [];
+	let commandSpecs = params.nativeEnabled ? listNativeCommandSpecs(params.cfg, {
+		skillCommands,
+		provider: "discord"
+	}) : [];
+	if (params.nativeEnabled) commandSpecs = await appendPluginCommandSpecs({
+		commandSpecs,
+		runtime: params.runtime,
+		cfg: params.cfg,
+		getPluginCommandSpecs: params.getPluginCommandSpecs
+	});
+	const initialCommandCount = commandSpecs.length;
+	if (params.nativeEnabled && params.nativeSkillsEnabled && commandSpecs.length > maxDiscordCommands) {
+		skillCommands = [];
+		commandSpecs = listNativeCommandSpecs(params.cfg, {
+			skillCommands: [],
+			provider: "discord"
+		});
+		commandSpecs = await appendPluginCommandSpecs({
+			commandSpecs,
+			runtime: params.runtime,
+			cfg: params.cfg,
+			getPluginCommandSpecs: params.getPluginCommandSpecs
+		});
+		params.runtime.log?.(warn(`${initialCommandCount} commands exceed the ${maxDiscordCommands}-command Discord limit; removing per-skill commands and keeping /skill.`));
+	}
+	if (params.nativeEnabled && commandSpecs.length > maxDiscordCommands) params.runtime.log?.(warn(`${commandSpecs.length} commands exceed the ${maxDiscordCommands}-command Discord limit; some commands may fail to deploy.`));
+	return {
+		skillCommands,
+		commandSpecs
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/provider.config-log.ts
+function formatThreadBindingDurationForConfigLabel(durationMs) {
+	const label = formatThreadBindingDurationLabel(durationMs);
+	return label === "disabled" ? "off" : label;
+}
+function logDiscordResolvedConfig(params) {
+	const allowFromSummary = summarizeStringEntries({
+		entries: params.allowFrom ?? [],
+		limit: 4,
+		emptyText: "any"
+	});
+	const groupDmChannelSummary = summarizeStringEntries({
+		entries: params.groupDmChannels ?? [],
+		limit: 4,
+		emptyText: "any"
+	});
+	const guildSummary = summarizeStringEntries({
+		entries: Object.keys(params.guildEntries ?? {}),
+		limit: 4,
+		emptyText: "any"
+	});
+	logVerbose(`discord: config dm=${params.dmEnabled ? "on" : "off"} dmPolicy=${params.dmPolicy} allowFrom=${allowFromSummary} groupDm=${params.groupDmEnabled ? "on" : "off"} groupDmChannels=${groupDmChannelSummary} groupPolicy=${params.groupPolicy} guilds=${guildSummary} historyLimit=${params.historyLimit} mediaMaxMb=${Math.round(params.mediaMaxBytes / (1024 * 1024))} native=${params.nativeEnabled ? "on" : "off"} nativeSkills=${params.nativeSkillsEnabled ? "on" : "off"} accessGroups=${params.useAccessGroups ? "on" : "off"} threadBindings=${params.threadBindingsEnabled ? "on" : "off"} threadIdleTimeout=${formatThreadBindingDurationForConfigLabel(params.threadBindingIdleTimeoutMs)} threadMaxAge=${formatThreadBindingDurationForConfigLabel(params.threadBindingMaxAgeMs)}`);
+}
+//#endregion
+//#region extensions/discord/src/monitor/provider.deploy-errors.ts
+const DISCORD_DEPLOY_REJECTED_ENTRY_LIMIT = 3;
+function attachDiscordDeployRequestBody(err, body) {
+	if (!err || typeof err !== "object" || body === void 0) return;
+	const deployErr = err;
+	if (deployErr.deployRequestBody === void 0) deployErr.deployRequestBody = body;
+}
+function attachDiscordDeployRestContext(err, context) {
+	if (!err || typeof err !== "object") return;
+	const deployErr = err;
+	deployErr.deployRestMethod = context.method;
+	deployErr.deployRestPath = context.path;
+	deployErr.deployRequestMs = context.requestMs;
+	if (typeof context.timeoutMs === "number" && Number.isFinite(context.timeoutMs)) deployErr.deployTimeoutMs = context.timeoutMs;
+}
+function stringifyDiscordDeployField(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return inspect(value, {
+			depth: 2,
+			breakLength: 120
+		});
+	}
+}
+function readDiscordDeployRejectedFields(value) {
+	if (Array.isArray(value)) return value.filter((entry) => typeof entry === "string").slice(0, 6);
+	if (!value || typeof value !== "object") return [];
+	return Object.keys(value).slice(0, 6);
+}
+function resolveDiscordRejectedDeployEntriesSource(rawBody) {
+	if (!rawBody || typeof rawBody !== "object") return null;
+	const payload = rawBody;
+	const source = (payload.errors && typeof payload.errors === "object" ? payload.errors : void 0) ?? rawBody;
+	return source && typeof source === "object" ? source : null;
+}
+function readDiscordDeployObjectField(value, field) {
+	return value && typeof value === "object" && field in value ? value[field] : void 0;
+}
+function readFiniteNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim().length > 0) return parseStrictFiniteNumber(value);
+}
+function readNonNegativeInteger(value) {
+	return parseStrictNonNegativeInteger(value);
+}
+function isAbortLikeError(err) {
+	if (!err || typeof err !== "object") return false;
+	const name = "name" in err && typeof err.name === "string" ? err.name : void 0;
+	const message = formatErrorMessage$1(err);
+	return name === "AbortError" || message === "This operation was aborted" || message === "The operation was aborted" || /\boperation was aborted\b/i.test(message);
+}
+function formatDiscordDeployRestOperation(err) {
+	const method = typeof err.deployRestMethod === "string" && err.deployRestMethod.trim().length > 0 ? err.deployRestMethod.toUpperCase() : void 0;
+	const path = typeof err.deployRestPath === "string" && err.deployRestPath.trim().length > 0 ? err.deployRestPath : void 0;
+	if (method && path) return `${method} ${path}`;
+	if (method) return method;
+	if (path) return path;
+	return "request";
+}
+function formatDiscordDeployErrorMessage(err) {
+	if (!isAbortLikeError(err)) return formatErrorMessage$1(err);
+	const deployErr = err && typeof err === "object" ? err : {};
+	const requestMs = readFiniteNumber(deployErr.deployRequestMs);
+	const timeoutMs = readFiniteNumber(deployErr.deployTimeoutMs);
+	const operation = formatDiscordDeployRestOperation(deployErr);
+	if (!(requestMs !== void 0 || timeoutMs !== void 0 || deployErr.deployRestMethod !== void 0 || deployErr.deployRestPath !== void 0)) return "Discord REST request was aborted";
+	const timing = [];
+	if (timeoutMs !== void 0) timing.push(`timeout=${formatDurationSeconds(timeoutMs, { decimals: timeoutMs >= 1e3 ? 1 : 0 })}`);
+	if (requestMs !== void 0) timing.push(`observed=${formatDurationSeconds(requestMs, { decimals: requestMs >= 1e3 ? 1 : 0 })}`);
+	const timingText = timing.length > 0 ? ` (${timing.join(", ")})` : "";
+	if (timeoutMs !== void 0 && requestMs !== void 0 && requestMs >= timeoutMs) return `Discord REST ${operation} timed out${timingText}`;
+	return `Discord REST ${operation} was aborted${timingText}`;
+}
+function resolveDiscordDeployRateLimitDetails(err) {
+	if (!err || typeof err !== "object") return;
+	const deployErr = err;
+	const status = readNonNegativeInteger(deployErr.status) ?? readNonNegativeInteger(deployErr.statusCode);
+	const retryAfterSeconds = readFiniteNumber(deployErr.retryAfter) ?? readFiniteNumber(readDiscordDeployObjectField(deployErr.rawBody, "retry_after"));
+	if (!(err instanceof RateLimitError || status === 429 || retryAfterSeconds !== void 0)) return;
+	const rawGlobal = readDiscordDeployObjectField(deployErr.rawBody, "global");
+	const scope = typeof deployErr.scope === "string" && deployErr.scope.trim().length > 0 ? deployErr.scope : rawGlobal === true ? "global" : rawGlobal === false ? "route" : void 0;
+	const discordCode = typeof deployErr.discordCode === "number" || typeof deployErr.discordCode === "string" ? deployErr.discordCode : void 0;
+	return {
+		status,
+		retryAfterMs: retryAfterSeconds === void 0 ? void 0 : Math.max(0, retryAfterSeconds * 1e3),
+		scope,
+		discordCode
+	};
+}
+function formatDiscordDeployRateLimitDetails(err) {
+	const rateLimit = resolveDiscordDeployRateLimitDetails(err);
+	if (!rateLimit) return "";
+	const details = [];
+	if (typeof rateLimit.status === "number") details.push(`status=${rateLimit.status}`);
+	if (typeof rateLimit.retryAfterMs === "number") details.push(`retryAfter=${formatDurationSeconds(rateLimit.retryAfterMs, { decimals: 1 })}`);
+	if (rateLimit.scope) details.push(`scope=${rateLimit.scope}`);
+	if (typeof rateLimit.discordCode === "number" || typeof rateLimit.discordCode === "string") details.push(`code=${rateLimit.discordCode}`);
+	return details.length > 0 ? ` (${details.join(", ")})` : "";
+}
+function formatDiscordDeployRateLimitWarning(err, accountId) {
+	const rateLimit = resolveDiscordDeployRateLimitDetails(err);
+	if (!rateLimit) return;
+	const parts = [`[${accountId}] slash command deploy rate limited`];
+	if (typeof rateLimit.retryAfterMs === "number") parts.push(`retry after ${formatDurationSeconds(rateLimit.retryAfterMs, { decimals: 1 })}`);
+	if (rateLimit.scope) parts.push(`scope=${rateLimit.scope}`);
+	if (typeof rateLimit.discordCode === "number" || typeof rateLimit.discordCode === "string") parts.push(`code=${rateLimit.discordCode}`);
+	return `${parts.join("; ")}. Existing slash commands stay active. Message send/receive is unaffected.`;
+}
+function formatDiscordRejectedDeployEntries(params) {
+	const requestBody = Array.isArray(params.requestBody) ? params.requestBody : null;
+	const rejectedEntriesSource = resolveDiscordRejectedDeployEntriesSource(params.rawBody);
+	if (!rejectedEntriesSource || !requestBody || requestBody.length === 0) return [];
+	return Object.entries(rejectedEntriesSource).filter(([key]) => /^\d+$/.test(key)).slice(0, DISCORD_DEPLOY_REJECTED_ENTRY_LIMIT).flatMap(([key, value]) => {
+		const index = Number.parseInt(key, 10);
+		if (!Number.isFinite(index) || index < 0 || index >= requestBody.length) return [];
+		const command = requestBody[index];
+		if (!command || typeof command !== "object") return [`#${index} fields=${readDiscordDeployRejectedFields(value).join("|") || "unknown"}`];
+		const payload = command;
+		const parts = [`#${index}`, `fields=${readDiscordDeployRejectedFields(value).join("|") || "unknown"}`];
+		if (typeof payload.name === "string" && payload.name.trim().length > 0) parts.push(`name=${payload.name}`);
+		if (payload.description !== void 0) parts.push(`description=${stringifyDiscordDeployField(payload.description)}`);
+		if (Array.isArray(payload.options) && payload.options.length > 0) parts.push(`options=${payload.options.length}`);
+		return [parts.join(" ")];
+	});
+}
+function isRedundantDiscordDeployBody(rawBody) {
+	if (!rawBody || typeof rawBody !== "object" || Array.isArray(rawBody)) return false;
+	const keys = Object.keys(rawBody);
+	return keys.length > 0 && keys.every((key) => key === "message" || key === "code");
+}
+function formatDiscordDeployErrorDetails(err) {
+	if (!err || typeof err !== "object") return "";
+	const rateLimitDetails = formatDiscordDeployRateLimitDetails(err);
+	if (rateLimitDetails) return rateLimitDetails;
+	const status = err.status;
+	const discordCode = err.discordCode;
+	const rawBody = err.rawBody;
+	const requestBody = err.deployRequestBody;
+	const details = [];
+	if (typeof status === "number") details.push(`status=${status}`);
+	if (typeof discordCode === "number" || typeof discordCode === "string") details.push(`code=${discordCode}`);
+	if (rawBody !== void 0 && !isRedundantDiscordDeployBody(rawBody)) {
+		let bodyText;
+		try {
+			bodyText = JSON.stringify(rawBody);
+		} catch {
+			bodyText = typeof rawBody === "string" ? rawBody : inspect(rawBody, {
+				depth: 3,
+				breakLength: 120
+			});
+		}
+		if (bodyText) {
+			const maxLen = 800;
+			const trimmed = bodyText.length > maxLen ? `${truncateUtf16Safe(bodyText, maxLen)}...` : bodyText;
+			details.push(`body=${trimmed}`);
+		}
+	}
+	const rejectedEntries = formatDiscordRejectedDeployEntries({
+		rawBody,
+		requestBody
+	});
+	if (rejectedEntries.length > 0) details.push(`rejected=${rejectedEntries.join("; ")}`);
+	return details.length > 0 ? ` (${details.join(", ")})` : "";
+}
+function isDiscordDeployDailyCreateLimit(err) {
+	if (!err || typeof err !== "object") return false;
+	const deployErr = err;
+	const discordCode = readNonNegativeInteger(deployErr.discordCode);
+	const rawCode = readNonNegativeInteger(readDiscordDeployObjectField(deployErr.rawBody, "code"));
+	return (discordCode === 30034 || rawCode === 30034) && /daily application command creates/i.test(formatErrorMessage$1(err));
+}
+//#endregion
+//#region extensions/discord/src/monitor/provider.startup-log.ts
+function formatDiscordStartupGatewayState(gateway) {
+	if (!gateway) return "gateway=missing";
+	const reconnectAttempts = gateway.reconnectAttempts;
+	return `gatewayConnected=${gateway.isConnected ? "true" : "false"} reconnectAttempts=${typeof reconnectAttempts === "number" ? reconnectAttempts : "na"}`;
+}
+function logDiscordStartupPhase$1(params) {
+	if (!(params.isVerbose ?? isVerbose)()) return;
+	const elapsedMs = Math.max(0, Date.now() - params.startAt);
+	const suffix = [params.details, formatDiscordStartupGatewayState(params.gateway)].filter((value) => Boolean(value)).join(" ");
+	params.runtime.log?.(`discord startup [${params.accountId}] ${params.phase} ${elapsedMs}ms${suffix ? ` ${suffix}` : ""}`);
+}
+//#endregion
+//#region extensions/discord/src/monitor/provider.deploy.ts
+function readDeployRequestBody(data) {
+	return data && typeof data === "object" && "body" in data ? data.body : void 0;
+}
+function isDeployCommandsPath(path) {
+	return path.startsWith("/applications/") && path.includes("/commands");
 }
 function wrapDeployRestMethod(params) {
 	return async (path, data, query) => {
@@ -7391,8 +8028,75 @@ function runDiscordCommandDeployInBackground(params) {
 	});
 }
 //#endregion
-//#region extensions/discord/src/voice/access.ts
-async function authorizeDiscordVoiceIngress(params) {
+//#region extensions/discord/src/monitor/agent-components-reply.ts
+async function replySilently(interaction, params) {
+	try {
+		await interaction.reply(params);
+	} catch {}
+}
+//#endregion
+//#region extensions/discord/src/activities/interaction.ts
+const REGISTRATION_WIDGET_ID = "AAAAAAAAAAAAAAAAAAAAAA";
+const PENDING_LAUNCH_WRITE_BUDGET_MS = 250;
+var DiscordActivityButton = class extends Button {
+	constructor(ctx, deps) {
+		super();
+		this.ctx = ctx;
+		this.deps = deps;
+		this.label = "Open widget";
+		this.customId = buildDiscordActivityCustomId(REGISTRATION_WIDGET_ID);
+		this.customIdParser = parseDiscordActivityCustomIdForInteraction;
+		this.pendingLaunchFailureLogged = false;
+	}
+	logPendingLaunchFailure(error) {
+		if (this.pendingLaunchFailureLogged) return;
+		this.pendingLaunchFailureLogged = true;
+		this.deps.logError(`discord activity: failed to record pending launch: ${String(error)}`);
+	}
+	async run(interaction, data) {
+		if (typeof data.widgetId !== "string") {
+			await this.deps.reply(interaction, {
+				content: "This widget is no longer valid.",
+				ephemeral: true
+			});
+			return;
+		}
+		const runtime = getDiscordActivitiesRuntime();
+		const channelId = interaction.rawData.channel_id;
+		const discordUserId = interaction.userId;
+		if (!runtime || !channelId || !discordUserId) this.logPendingLaunchFailure(/* @__PURE__ */ new Error("missing activity runtime or interaction identity"));
+		else {
+			const write = runtime.store.recordPendingLaunch({
+				accountId: this.ctx.accountId,
+				channelId,
+				discordUserId,
+				widgetId: data.widgetId,
+				createdAt: Date.now()
+			}).then(() => "written").catch((error) => {
+				this.logPendingLaunchFailure(error);
+				return "failed";
+			});
+			const timeout = new Promise((resolve) => {
+				setTimeout(() => resolve("timeout"), PENDING_LAUNCH_WRITE_BUDGET_MS).unref?.();
+			});
+			if (await Promise.race([write, timeout]) === "timeout") this.logPendingLaunchFailure(/* @__PURE__ */ new Error(`pending launch write exceeded ${PENDING_LAUNCH_WRITE_BUDGET_MS}ms`));
+		}
+		await interaction.launchActivity();
+	}
+};
+function createDiscordActivityButton(ctx, applicationId, deps = {}) {
+	const runtime = getDiscordActivitiesRuntime();
+	if (!runtime || !runtime.isAccountEnabled(ctx.accountId, ctx.cfg)) return null;
+	if (applicationId) runtime.registerApplicationId(ctx.accountId, applicationId);
+	if (!runtime.resolveAccount(ctx.accountId, ctx.cfg)) return null;
+	return new DiscordActivityButton(ctx, {
+		reply: deps.reply ?? replySilently,
+		logError: deps.logError ?? logError
+	});
+}
+//#endregion
+//#region extensions/discord/src/voice/access.ts
+async function authorizeDiscordVoiceIngress(params) {
 	const groupPolicy = params.groupPolicy ?? resolveOpenProviderRuntimeGroupPolicy({
 		providerConfigPresent: params.cfg.channels?.discord !== void 0,
 		groupPolicy: params.discordConfig.groupPolicy,
@@ -7442,17 +8146,18 @@ async function authorizeDiscordVoiceIngress(params) {
 		sender: params.sender,
 		allowNameMatching: false
 	});
-	const { ownerAllowList, ownerAllowed } = resolveDiscordOwnerAccess({
-		allowFrom: params.ownerAllowFrom ?? params.discordConfig.allowFrom ?? params.discordConfig.dm?.allowFrom,
-		sender: params.sender,
-		allowNameMatching: false
-	});
+	const admissionAllowList = normalizeDiscordAllowList(params.admissionAllowFrom ?? params.discordConfig.allowFrom ?? params.discordConfig.dm?.allowFrom, [
+		"discord:",
+		"user:",
+		"pk:"
+	]);
+	const admissionAllowed = admissionAllowList ? allowListMatches(admissionAllowList, params.sender, { allowNameMatching: false }) : false;
 	const useAccessGroups = params.useAccessGroups ?? params.cfg.commands?.useAccessGroups !== false;
 	return resolveCommandAuthorizedFromAuthorizers({
 		useAccessGroups,
 		authorizers: useAccessGroups ? [{
-			configured: params.ownerAllowAll === true || ownerAllowList != null,
-			allowed: params.ownerAllowAll === true || ownerAllowed
+			configured: admissionAllowList != null,
+			allowed: admissionAllowed
 		}, {
 			configured: hasAccessRestrictions,
 			allowed: memberAllowed
@@ -7471,17 +8176,19 @@ async function authorizeDiscordVoiceIngress(params) {
 }
 //#endregion
 //#region extensions/discord/src/voice/owner-access.ts
-function resolveDiscordVoiceOwnerAccess(params) {
+function resolveDiscordVoiceAccess(params) {
 	const commandOwnerAllowFrom = resolveDiscordCommandOwnerAllowFrom(params.cfg);
 	if (commandOwnerAllowFrom) return {
+		admissionAllowFrom: commandOwnerAllowFrom,
 		ownerAllowFrom: commandOwnerAllowFrom,
 		ownerAllowAll: commandOwnerAllowFrom.includes("*")
 	};
 	return {
-		ownerAllowFrom: resolveDiscordAccountAllowFrom({
+		admissionAllowFrom: resolveDiscordAccountAllowFrom({
 			cfg: params.cfg,
 			accountId: params.accountId
 		}) ?? params.discordConfig.allowFrom ?? params.discordConfig.dm?.allowFrom ?? [],
+		ownerAllowFrom: [],
 		ownerAllowAll: false
 	};
 }
@@ -7512,7 +8219,7 @@ async function authorizeVoiceCommand(interaction, params, options) {
 		author: user,
 		member: interaction.rawData.member
 	});
-	const ownerAccess = resolveDiscordVoiceOwnerAccess(params);
+	const voiceAccess = resolveDiscordVoiceAccess(params);
 	const access = await authorizeDiscordVoiceIngress({
 		cfg: params.cfg,
 		discordConfig: params.discordConfig,
@@ -7530,8 +8237,7 @@ async function authorizeVoiceCommand(interaction, params, options) {
 		scope: channelContext.isThreadChannel ? "thread" : "channel",
 		channelLabel: channelId ? formatMention({ channelId }) : "This channel",
 		memberRoleIds,
-		ownerAllowFrom: ownerAccess.ownerAllowFrom,
-		ownerAllowAll: ownerAccess.ownerAllowAll,
+		admissionAllowFrom: voiceAccess.admissionAllowFrom,
 		sender: {
 			id: sender.id,
 			name: sender.name,
@@ -7822,13 +8528,6 @@ async function resolveComponentInteractionContext(params) {
 	};
 }
 //#endregion
-//#region extensions/discord/src/monitor/agent-components-reply.ts
-async function replySilently(interaction, params) {
-	try {
-		await interaction.reply(params);
-	} catch {}
-}
-//#endregion
 //#region extensions/discord/src/monitor/agent-components-dm-auth.ts
 async function ensureDmComponentAuthorized(params) {
 	const { ctx, interaction, user, componentLabel, replyOpts } = params;
@@ -8467,7 +9166,7 @@ async function deliverDiscordReply(params) {
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.dispatch.ts
 const loadConversationRuntime$1 = createLazyRuntimeModule(() => import("./agent-components.runtime-CEPrf2SY.js"));
-const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing-BnYT7Szq.js").then((n) => n.n));
+const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing-wxtm1NlF.js").then((n) => n.n));
 function buildDiscordComponentConversationLabel(params) {
 	if (params.interactionCtx.isDirectMessage) return buildDirectLabel(params.interactionCtx.user);
 	if (params.interactionCtx.isGroupDm) return `Group DM #${params.channelCtx.channelName ?? params.interactionCtx.channelId} channel id:${params.interactionCtx.channelId}`;
@@ -8576,7 +9275,7 @@ async function dispatchDiscordComponentEvent(params) {
 		previousTimestamp,
 		envelope: envelopeOptions
 	});
-	const { createReplyReferencePlanner, dispatchReplyWithBufferedBlockDispatcher, finalizeInboundContext, resolveChunkMode, resolveTextChunkLimit, recordInboundSession } = await (async () => {
+	const { createReplyReferencePlanner, finalizeInboundContext, resolveChunkMode, resolveTextChunkLimit } = await (async () => {
 		return { ...await loadConversationRuntime$1() };
 	})();
 	const ctxPayload = finalizeInboundContext({
@@ -8652,12 +9351,11 @@ async function dispatchDiscordComponentEvent(params) {
 				cfg: ctx.cfg,
 				channel: "discord",
 				accountId,
-				agentId,
-				routeSessionKey: sessionKey,
-				storePath,
+				route: {
+					agentId,
+					sessionKey
+				},
 				ctxPayload,
-				recordInboundSession,
-				dispatchReplyWithBufferedBlockDispatcher,
 				record: {
 					updateLastRoute: interactionCtx.isDirectMessage ? {
 						sessionKey: inboundLastRouteSessionKey,
@@ -8880,7 +9578,7 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.handlers.ts
-const loadComponentsRuntime = createLazyRuntimeModule(() => import("./components-BVrfRS-F.js").then((n) => n.t));
+const loadComponentsRuntime = createLazyRuntimeModule(() => import("./outbound-session-route-M2bEY9tI.js").then((n) => n.n));
 async function handleDiscordComponentEvent(params) {
 	const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
 	if (!parsed) {
@@ -9372,769 +10070,388 @@ var DiscordComponentSelectControl = class extends BaseMessageInteractiveComponen
 		await this.handlers.handleComponentEvent({
 			ctx: this.ctx,
 			interaction,
-			data,
-			componentLabel: this.spec.componentLabel,
-			label: this.spec.label,
-			values: interaction.values ?? []
-		});
-	}
-};
-var DiscordComponentButton = class extends Button {
-	constructor(ctx, handlers) {
-		super();
-		this.ctx = ctx;
-		this.handlers = handlers;
-		this.label = "component";
-		this.customId = "__openclaw_discord_component_button_wildcard__";
-		this.style = ButtonStyle.Primary;
-		this.customIdParser = parseDiscordComponentCustomIdForInteraction;
-	}
-	async run(interaction, data) {
-		if (parseDiscordComponentData(data, resolveInteractionCustomId(interaction))?.modalId) {
-			await this.handlers.handleModalTrigger({
-				ctx: this.ctx,
-				interaction,
-				data,
-				label: "discord component modal"
-			});
-			return;
-		}
-		await this.handlers.handleComponentEvent({
-			ctx: this.ctx,
-			interaction,
-			data,
-			componentLabel: "button",
-			label: "discord component button"
-		});
-	}
-};
-function createSelectControl(spec, ctx, handlers) {
-	return new DiscordComponentSelectControl(spec, ctx, handlers);
-}
-function bindSelectControl(spec) {
-	return (ctx, handlers) => createSelectControl(spec, ctx, handlers);
-}
-function createDiscordComponentButtonControl(ctx, handlers) {
-	return new DiscordComponentButton(ctx, handlers);
-}
-const createDiscordComponentStringSelectControl = bindSelectControl(SELECT_CONTROLS.string);
-const createDiscordComponentUserSelectControl = bindSelectControl(SELECT_CONTROLS.user);
-const createDiscordComponentRoleSelectControl = bindSelectControl(SELECT_CONTROLS.role);
-const createDiscordComponentMentionableSelectControl = bindSelectControl(SELECT_CONTROLS.mentionable);
-const createDiscordComponentChannelSelectControl = bindSelectControl(SELECT_CONTROLS.channel);
-//#endregion
-//#region extensions/discord/src/monitor/agent-components.ts
-function bindDiscordComponentControl(createControl) {
-	return (ctx) => createControl(ctx, discordComponentControlHandlers);
-}
-const createDiscordComponentButton = bindDiscordComponentControl(createDiscordComponentButtonControl);
-const createDiscordComponentStringSelect = bindDiscordComponentControl(createDiscordComponentStringSelectControl);
-const createDiscordComponentUserSelect = bindDiscordComponentControl(createDiscordComponentUserSelectControl);
-const createDiscordComponentRoleSelect = bindDiscordComponentControl(createDiscordComponentRoleSelectControl);
-const createDiscordComponentMentionableSelect = bindDiscordComponentControl(createDiscordComponentMentionableSelectControl);
-const createDiscordComponentChannelSelect = bindDiscordComponentControl(createDiscordComponentChannelSelectControl);
-const createAgentComponentControls = [createAgentComponentButton, createAgentSelectMenu];
-const createDiscordComponentControls = [
-	createDiscordComponentButton,
-	createDiscordComponentStringSelect,
-	createDiscordComponentUserSelect,
-	createDiscordComponentRoleSelect,
-	createDiscordComponentMentionableSelect,
-	createDiscordComponentChannelSelect
-];
-function createDiscordComponentModal(ctx) {
-	return new DiscordComponentModal(ctx);
-}
-//#endregion
-//#region extensions/discord/src/monitor/exec-approvals.ts
-function resolveTerminalLabel(approval) {
-	if (approval.status === "allowed") return approval.decision === "allow-always" ? "Allowed always" : "Allowed once";
-	if (approval.status === "denied") return "Denied";
-	return approval.status === "expired" ? "Expired" : "Cancelled";
-}
-function buildTerminalPayload(params) {
-	const { approval } = params;
-	const label = resolveTerminalLabel(approval);
-	const accentColor = approval.status === "denied" ? "#ED4245" : approval.status === "allowed" ? "#57F287" : "#99AAB5";
-	return {
-		allowed_mentions: DISCORD_APPROVAL_ALLOWED_MENTIONS,
-		components: [new Container([
-			new TextDisplay(params.applied ? "## Approval resolved" : "## Approval already resolved"),
-			new TextDisplay(`Canonical result: **${label}**`),
-			new Separator({
-				divider: false,
-				spacing: "small"
-			}),
-			new TextDisplay(`-# ID: ${formatDiscordApprovalDisplayValue(approval.id)}`)
-		], { accentColor })]
-	};
-}
-function isStructuredApprovalNotFoundError(err) {
-	if (!err || typeof err !== "object") return false;
-	const record = err;
-	if (record.gatewayCode === "APPROVAL_NOT_FOUND") return true;
-	return record.gatewayCode === "INVALID_REQUEST" && record.details?.reason === "APPROVAL_NOT_FOUND";
-}
-var ExecApprovalButton = class extends Button {
-	constructor(ctx) {
-		super();
-		this.ctx = ctx;
-		this.label = "execapproval";
-		this.customId = "execapproval:seed=1";
-		this.style = ButtonStyle.Primary;
-	}
-	async run(interaction, data) {
-		const parsed = parseExecApprovalData(data);
-		if (!parsed) {
-			try {
-				await interaction.reply({
-					content: "This approval is no longer valid.",
-					ephemeral: true
-				});
-			} catch {}
-			return;
-		}
-		const approvers = this.ctx.getApprovers();
-		const userId = interaction.userId;
-		if (!approvers.some((id) => id === userId)) {
-			try {
-				await interaction.reply({
-					content: "⛔ You are not authorized to approve requests.",
-					ephemeral: true
-				});
-			} catch {}
-			return;
-		}
-		const decisionLabel = parsed.action === "allow-once" ? "Allowed (once)" : parsed.action === "allow-always" ? "Allowed (always)" : "Denied";
-		try {
-			await interaction.acknowledge();
-		} catch {}
-		const result = await this.ctx.resolveApproval(parsed.approvalId, parsed.approvalKind, parsed.action);
-		if (!result.ok) {
-			try {
-				await interaction.followUp({
-					content: result.reason === "not-found" ? `That approval request is no longer pending. It may have expired or already been resolved.` : `Failed to submit approval decision for **${decisionLabel}**. The request may have expired or already been resolved.`,
-					ephemeral: true
-				});
-			} catch {}
-			return;
-		}
-		const terminalLabel = resolveTerminalLabel(result.resolution.approval);
-		let terminalized = false;
-		try {
-			await interaction.editReply(buildTerminalPayload({
-				approval: result.resolution.approval,
-				applied: result.resolution.applied
-			}));
-			terminalized = true;
-		} catch {}
-		if (!terminalized || !result.resolution.applied) try {
-			await interaction.followUp({
-				content: result.resolution.applied ? `Approval resolved: ${terminalLabel}.` : `This approval was already resolved: ${terminalLabel}.`,
-				ephemeral: true
-			});
-		} catch {}
-	}
-};
-function createExecApprovalButton(ctx) {
-	return new ExecApprovalButton(ctx);
-}
-function createDiscordExecApprovalButtonContext(params) {
-	return {
-		getApprovers: () => getDiscordExecApprovalApprovers({
-			cfg: params.cfg,
-			accountId: params.accountId,
-			configOverride: params.config
-		}),
-		resolveApproval: async (approvalId, approvalKind, decision) => {
-			try {
-				return {
-					ok: true,
-					resolution: await resolveApprovalOverGateway({
-						cfg: params.cfg,
-						approvalId,
-						approvalKind,
-						decision,
-						gatewayUrl: params.gatewayUrl,
-						clientDisplayName: `Discord approval (${params.accountId})`
-					})
-				};
-			} catch (err) {
-				return {
-					ok: false,
-					reason: isStructuredApprovalNotFoundError(err) ? "not-found" : "error"
-				};
-			}
-		}
-	};
-}
-//#endregion
-//#region extensions/discord/src/monitor/provider.interactions.ts
-function createDiscordProviderInteractionSurface(params) {
-	const createNativeCommand = params.createNativeCommand ?? createDiscordNativeCommand;
-	const commands = params.commandSpecs.map((spec) => createNativeCommand({
-		command: spec,
-		cfg: params.cfg,
-		discordConfig: params.discordConfig,
-		accountId: params.accountId,
-		sessionPrefix: params.sessionPrefix,
-		ephemeralDefault: params.ephemeralDefault,
-		threadBindings: params.threadBindings
-	}));
-	if (params.nativeEnabled && params.voiceEnabled) commands.push(createDiscordVoiceCommand({
-		cfg: params.cfg,
-		discordConfig: params.discordConfig,
-		accountId: params.accountId,
-		groupPolicy: params.groupPolicy,
-		useAccessGroups: params.useAccessGroups,
-		getManager: () => params.voiceManagerRef.current,
-		ephemeralDefault: params.ephemeralDefault
-	}));
-	const execApprovalsConfig = params.discordConfig.execApprovals ?? {};
-	const execApprovalsEnabled = isDiscordExecApprovalClientEnabled({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		configOverride: execApprovalsConfig
-	});
-	const approvalActionsEnabled = getDiscordExecApprovalApprovers({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		configOverride: execApprovalsConfig
-	}).length > 0;
-	if (execApprovalsEnabled) registerChannelRuntimeContext({
-		channelRuntime: params.channelRuntime,
-		channelId: "discord",
-		accountId: params.accountId,
-		capability: CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY,
-		context: {
-			token: params.token,
-			config: execApprovalsConfig
-		},
-		abortSignal: params.abortSignal
-	});
-	const components = [
-		createDiscordCommandArgFallbackButton({
-			cfg: params.cfg,
-			discordConfig: params.discordConfig,
-			accountId: params.accountId,
-			sessionPrefix: params.sessionPrefix,
-			threadBindings: params.threadBindings
-		}),
-		createDiscordModelPickerFallbackButton({
-			cfg: params.cfg,
-			discordConfig: params.discordConfig,
-			accountId: params.accountId,
-			sessionPrefix: params.sessionPrefix,
-			threadBindings: params.threadBindings
-		}),
-		createDiscordModelPickerFallbackSelect({
-			cfg: params.cfg,
-			discordConfig: params.discordConfig,
-			accountId: params.accountId,
-			sessionPrefix: params.sessionPrefix,
-			threadBindings: params.threadBindings
-		})
-	];
-	const modals = [];
-	if (approvalActionsEnabled) components.push(createExecApprovalButton(createDiscordExecApprovalButtonContext({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		config: execApprovalsConfig
-	})));
-	if ((params.discordConfig.agentComponents ?? {}).enabled ?? true) {
-		const componentContext = {
-			cfg: params.cfg,
-			discordConfig: params.discordConfig,
-			accountId: params.accountId,
-			guildEntries: params.guildEntries,
-			allowFrom: params.allowFrom,
-			dmPolicy: params.dmPolicy,
-			runtime: params.runtime,
-			token: params.token
-		};
-		components.push(...createAgentComponentControls.map((create) => create(componentContext)));
-		components.push(...createDiscordComponentControls.map((create) => create(componentContext)));
-		modals.push(createDiscordComponentModal(componentContext));
-	}
-	return {
-		commands,
-		components,
-		modals
-	};
-}
-//#endregion
-//#region extensions/discord/src/gateway-logging.ts
-const INFO_DEBUG_MARKERS = [
-	"Gateway websocket closed",
-	"Gateway reconnect scheduled in",
-	"Gateway forcing fresh IDENTIFY after"
-];
-const shouldPromoteGatewayDebug = (message) => INFO_DEBUG_MARKERS.some((marker) => message.includes(marker));
-const formatGatewayMetrics = (metrics) => {
-	if (metrics === null || metrics === void 0) return String(metrics);
-	if (typeof metrics === "string") return metrics;
-	if (typeof metrics === "number" || typeof metrics === "boolean" || typeof metrics === "bigint") return String(metrics);
-	try {
-		return JSON.stringify(metrics);
-	} catch {
-		return "[unserializable metrics]";
+			data,
+			componentLabel: this.spec.componentLabel,
+			label: this.spec.label,
+			values: interaction.values ?? []
+		});
 	}
 };
-function attachDiscordGatewayLogging(params) {
-	const { emitter, runtime } = params;
-	if (!emitter) return () => {};
-	const onGatewayDebug = (msg) => {
-		const message = String(msg);
-		logVerbose(`discord gateway: ${message}`);
-		if (shouldPromoteGatewayDebug(message)) runtime.log?.(`discord gateway: ${message}`);
-	};
-	const onGatewayWarning = (warning) => {
-		logVerbose(`discord gateway warning: ${String(warning)}`);
-	};
-	const onGatewayMetrics = (metrics) => {
-		logVerbose(`discord gateway metrics: ${formatGatewayMetrics(metrics)}`);
-	};
-	emitter.on("debug", onGatewayDebug);
-	emitter.on("warning", onGatewayWarning);
-	emitter.on("metrics", onGatewayMetrics);
-	return () => {
-		emitter.removeListener("debug", onGatewayDebug);
-		emitter.removeListener("warning", onGatewayWarning);
-		emitter.removeListener("metrics", onGatewayMetrics);
-	};
-}
-//#endregion
-//#region extensions/discord/src/monitor.gateway.ts
-async function waitForDiscordGatewayStop(params) {
-	const { gateway, abortSignal } = params;
-	return await new Promise((resolve, reject) => {
-		let settled = false;
-		const cleanup = () => {
-			abortSignal?.removeEventListener("abort", onAbort);
-			params.gatewaySupervisor?.detachLifecycle();
-		};
-		const finishResolve = () => {
-			if (settled) return;
-			settled = true;
-			try {
-				gateway?.disconnect?.();
-			} finally {
-				cleanup();
-				resolve();
-			}
-		};
-		const finishReject = (err) => {
-			if (settled) return;
-			settled = true;
-			try {
-				gateway?.disconnect?.();
-			} finally {
-				cleanup();
-				reject(toLintErrorObject(err, "Non-Error rejection"));
-			}
-		};
-		const onAbort = () => {
-			finishResolve();
-		};
-		const onGatewayEvent = (event) => {
-			if ((params.onGatewayEvent?.(event) ?? "stop") === "stop") finishReject(new DiscordGatewayLifecycleError(event));
-		};
-		const onForceStop = (err) => {
-			finishReject(err);
-		};
-		if (abortSignal?.aborted) {
-			onAbort();
+var DiscordComponentButton = class extends Button {
+	constructor(ctx, handlers) {
+		super();
+		this.ctx = ctx;
+		this.handlers = handlers;
+		this.label = "component";
+		this.customId = "__openclaw_discord_component_button_wildcard__";
+		this.style = ButtonStyle.Primary;
+		this.customIdParser = parseDiscordComponentCustomIdForInteraction;
+	}
+	async run(interaction, data) {
+		if (parseDiscordComponentData(data, resolveInteractionCustomId(interaction))?.modalId) {
+			await this.handlers.handleModalTrigger({
+				ctx: this.ctx,
+				interaction,
+				data,
+				label: "discord component modal"
+			});
 			return;
 		}
-		abortSignal?.addEventListener("abort", onAbort, { once: true });
-		params.gatewaySupervisor?.attachLifecycle(onGatewayEvent);
-		params.registerForceStop?.(onForceStop);
-	});
+		await this.handlers.handleComponentEvent({
+			ctx: this.ctx,
+			interaction,
+			data,
+			componentLabel: "button",
+			label: "discord component button"
+		});
+	}
+};
+function createSelectControl(spec, ctx, handlers) {
+	return new DiscordComponentSelectControl(spec, ctx, handlers);
 }
-function toLintErrorObject(value, fallbackMessage) {
-	if (value instanceof Error) return value;
-	if (typeof value === "string") return new Error(value);
-	const error = new Error(fallbackMessage, { cause: value });
-	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
-	return error;
+function bindSelectControl(spec) {
+	return (ctx, handlers) => createSelectControl(spec, ctx, handlers);
 }
-//#endregion
-//#region extensions/discord/src/monitor/provider.lifecycle.ts
-const DEFAULT_DISCORD_GATEWAY_READY_TIMEOUT_MS = 15e3;
-const DEFAULT_DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_MS = 3e4;
-const MAX_DISCORD_GATEWAY_READY_TIMEOUT_MS = 12e4;
-const DISCORD_GATEWAY_READY_TIMEOUT_ENV = "OPENCLAW_DISCORD_READY_TIMEOUT_MS";
-const DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_ENV = "OPENCLAW_DISCORD_RUNTIME_READY_TIMEOUT_MS";
-const DISCORD_GATEWAY_READY_POLL_MS = 250;
-const DISCORD_GATEWAY_READY_RETRY_BACKOFF_MS = 2e3;
-const DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS = 5e3;
-const DISCORD_GATEWAY_STARTUP_TERMINATE_CLOSE_TIMEOUT_MS = 1e3;
-const DISCORD_GATEWAY_TRANSPORT_ACTIVITY_STATUS_MIN_INTERVAL_MS = 3e4;
-function normalizeGatewayReadyTimeoutMs(value) {
-	const numeric = parseStrictPositiveInteger(value);
-	if (numeric === void 0) return;
-	return Math.min(numeric, MAX_DISCORD_GATEWAY_READY_TIMEOUT_MS);
+function createDiscordComponentButtonControl(ctx, handlers) {
+	return new DiscordComponentButton(ctx, handlers);
 }
-function resolveDiscordGatewayReadyTimeoutMs(params) {
-	return normalizeGatewayReadyTimeoutMs(params?.configuredTimeoutMs) ?? normalizeGatewayReadyTimeoutMs(params?.env?.[DISCORD_GATEWAY_READY_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_READY_TIMEOUT_MS;
+const createDiscordComponentStringSelectControl = bindSelectControl(SELECT_CONTROLS.string);
+const createDiscordComponentUserSelectControl = bindSelectControl(SELECT_CONTROLS.user);
+const createDiscordComponentRoleSelectControl = bindSelectControl(SELECT_CONTROLS.role);
+const createDiscordComponentMentionableSelectControl = bindSelectControl(SELECT_CONTROLS.mentionable);
+const createDiscordComponentChannelSelectControl = bindSelectControl(SELECT_CONTROLS.channel);
+//#endregion
+//#region extensions/discord/src/monitor/agent-components.ts
+function bindDiscordComponentControl(createControl) {
+	return (ctx) => createControl(ctx, discordComponentControlHandlers);
 }
-function resolveDiscordGatewayRuntimeReadyTimeoutMs(params) {
-	return normalizeGatewayReadyTimeoutMs(params?.configuredTimeoutMs) ?? normalizeGatewayReadyTimeoutMs(params?.env?.[DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_MS;
+const createDiscordComponentButton = bindDiscordComponentControl(createDiscordComponentButtonControl);
+const createDiscordComponentStringSelect = bindDiscordComponentControl(createDiscordComponentStringSelectControl);
+const createDiscordComponentUserSelect = bindDiscordComponentControl(createDiscordComponentUserSelectControl);
+const createDiscordComponentRoleSelect = bindDiscordComponentControl(createDiscordComponentRoleSelectControl);
+const createDiscordComponentMentionableSelect = bindDiscordComponentControl(createDiscordComponentMentionableSelectControl);
+const createDiscordComponentChannelSelect = bindDiscordComponentControl(createDiscordComponentChannelSelectControl);
+const createAgentComponentControls = [createAgentComponentButton, createAgentSelectMenu];
+const createDiscordComponentControls = [
+	createDiscordComponentButton,
+	createDiscordComponentStringSelect,
+	createDiscordComponentUserSelect,
+	createDiscordComponentRoleSelect,
+	createDiscordComponentMentionableSelect,
+	createDiscordComponentChannelSelect
+];
+function createDiscordComponentModal(ctx) {
+	return new DiscordComponentModal(ctx);
 }
-async function restartGatewayAfterReadyTimeout(params) {
-	if (!params.gateway || params.abortSignal?.aborted) return;
-	const socket = params.gateway.ws;
-	if (!socket) {
-		params.gateway.disconnect();
-		if (!params.abortSignal?.aborted) params.gateway.connect(false);
-		return;
-	}
-	await new Promise((resolve, reject) => {
-		let settled = false;
-		let drainTimeout;
-		let terminateCloseTimeout;
-		const ignoreSocketError = () => {};
-		const clearTimers = () => {
-			if (drainTimeout) {
-				clearTimeout(drainTimeout);
-				drainTimeout = void 0;
-			}
-			if (terminateCloseTimeout) {
-				clearTimeout(terminateCloseTimeout);
-				terminateCloseTimeout = void 0;
-			}
-		};
-		const cleanup = () => {
-			clearTimers();
-			socket.removeListener("close", onClose);
-			socket.removeListener("error", ignoreSocketError);
-		};
-		const finishResolve = () => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			resolve();
-		};
-		const finishReject = (error) => {
-			if (params.abortSignal?.aborted) {
-				finishResolve();
-				return;
-			}
-			if (settled) return;
-			settled = true;
-			cleanup();
-			reject(error);
-		};
-		const onClose = () => {
-			finishResolve();
-		};
-		socket.on("error", ignoreSocketError);
-		socket.on("close", onClose);
-		params.gateway?.disconnect();
-		drainTimeout = setTimeout(() => {
-			if (settled) return;
-			if (typeof socket.terminate !== "function") {
-				finishReject(/* @__PURE__ */ new Error(`discord gateway socket did not close within ${DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS}ms before restart`));
-				return;
-			}
-			params.runtime.error?.(danger(`discord: startup restart waiting on a stale gateway socket for ${DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS}ms; forcing terminate before reconnect`));
-			try {
-				socket.terminate();
-			} catch {
-				finishReject(/* @__PURE__ */ new Error(`discord gateway socket did not close within ${DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS}ms before restart`));
-				return;
-			}
-			terminateCloseTimeout = setTimeout(() => {
-				finishReject(/* @__PURE__ */ new Error(`discord gateway socket did not close within ${DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS}ms before restart`));
-			}, DISCORD_GATEWAY_STARTUP_TERMINATE_CLOSE_TIMEOUT_MS);
-			terminateCloseTimeout.unref?.();
-		}, DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS);
-		drainTimeout.unref?.();
-	});
-	if (!params.abortSignal?.aborted) params.gateway.connect(false);
+//#endregion
+//#region extensions/discord/src/monitor/exec-approvals.ts
+function resolveTerminalLabel(approval) {
+	if (approval.status === "allowed") return approval.decision === "allow-always" ? "Allowed always" : "Allowed once";
+	if (approval.status === "denied") return "Denied";
+	return approval.status === "expired" ? "Expired" : "Cancelled";
 }
-function parseGatewayCloseCode(message) {
-	const match = /Gateway websocket closed:\s*(\d{3,5})/.exec(message);
-	if (!match?.[1]) return;
-	const code = Number.parseInt(match[1], 10);
-	return Number.isFinite(code) ? code : void 0;
+function buildTerminalPayload(params) {
+	const { approval } = params;
+	const label = resolveTerminalLabel(approval);
+	const accentColor = approval.status === "denied" ? "#ED4245" : approval.status === "allowed" ? "#57F287" : "#99AAB5";
+	return {
+		allowed_mentions: DISCORD_APPROVAL_ALLOWED_MENTIONS,
+		components: [new Container([
+			new TextDisplay(params.applied ? "## Approval resolved" : "## Approval already resolved"),
+			new TextDisplay(`Canonical result: **${label}**`),
+			new Separator({
+				divider: false,
+				spacing: "small"
+			}),
+			new TextDisplay(`-# ID: ${formatDiscordApprovalDisplayValue(approval.id)}`)
+		], { accentColor })]
+	};
 }
-function resolveTransportActivityAt(event) {
-	const at = event?.at;
-	const timestampMs = asDateTimestampMs(at);
-	return timestampMs !== void 0 && timestampMs >= 0 ? timestampMs : Date.now();
+function isStructuredApprovalNotFoundError(err) {
+	if (!err || typeof err !== "object") return false;
+	const record = err;
+	if (record.gatewayCode === "APPROVAL_NOT_FOUND") return true;
+	return record.gatewayCode === "INVALID_REQUEST" && record.details?.reason === "APPROVAL_NOT_FOUND";
 }
-function createGatewayStatusObserver(params) {
-	let forceStopHandler;
-	let queuedForceStopError;
-	let readyPollId;
-	let readyTimeoutId;
-	const shouldStop = () => params.abortSignal?.aborted || params.isLifecycleStopping();
-	const clearReadyWatch = () => {
-		if (readyPollId) {
-			clearInterval(readyPollId);
-			readyPollId = void 0;
-		}
-		if (readyTimeoutId) {
-			clearTimeout(readyTimeoutId);
-			readyTimeoutId = void 0;
-		}
-	};
-	const triggerForceStop = (err) => {
-		if (forceStopHandler) {
-			forceStopHandler(err);
-			return;
-		}
-		queuedForceStopError = err;
-	};
-	const pushConnectedStatus = (at) => {
-		params.pushStatus({
-			...createConnectedChannelStatusPatch(at),
-			lastDisconnect: null,
-			lastError: null
-		});
-	};
-	const startReadyWatch = () => {
-		clearReadyWatch();
-		const pollConnected = () => {
-			if (shouldStop()) {
-				clearReadyWatch();
-				return;
-			}
-			if (!params.gateway?.isConnected) return;
-			clearReadyWatch();
-			pushConnectedStatus(Date.now());
-		};
-		pollConnected();
-		if (!readyTimeoutId) {
-			readyPollId = setInterval(pollConnected, DISCORD_GATEWAY_READY_POLL_MS);
-			readyPollId.unref?.();
-			readyTimeoutId = setTimeout(() => {
-				clearReadyWatch();
-				if (shouldStop() || params.gateway?.isConnected) return;
-				const at = Date.now();
-				const error = /* @__PURE__ */ new Error(`discord gateway opened but did not reach READY within ${params.runtimeReadyTimeoutMs}ms`);
-				params.pushStatus({
-					connected: false,
-					lastEventAt: at,
-					lastDisconnect: {
-						at,
-						error: "runtime-not-ready"
-					},
-					lastError: "runtime-not-ready"
+var ExecApprovalButton = class extends Button {
+	constructor(ctx) {
+		super();
+		this.ctx = ctx;
+		this.label = "execapproval";
+		this.customId = "execapproval:seed=1";
+		this.style = ButtonStyle.Primary;
+	}
+	async run(interaction, data) {
+		const parsed = parseExecApprovalData(data);
+		if (!parsed) {
+			try {
+				await interaction.reply({
+					content: "This approval is no longer valid.",
+					ephemeral: true
 				});
-				params.runtime.error?.(danger(error.message));
-				triggerForceStop(error);
-			}, params.runtimeReadyTimeoutMs);
-			readyTimeoutId.unref?.();
-		}
-	};
-	const onGatewayDebug = (msg) => {
-		if (shouldStop()) return;
-		const at = Date.now();
-		const message = String(msg);
-		if (message.includes("Gateway websocket opened")) {
-			params.pushStatus({
-				connected: false,
-				lastEventAt: at
-			});
-			startReadyWatch();
+			} catch {}
 			return;
 		}
-		if (message.includes("Gateway websocket closed")) {
-			clearReadyWatch();
-			const code = parseGatewayCloseCode(message);
-			params.pushStatus({
-				connected: false,
-				lastEventAt: at,
-				lastDisconnect: {
-					at,
-					...code !== void 0 ? { status: code } : {}
-				}
-			});
+		const approvers = this.ctx.getApprovers();
+		const userId = interaction.userId;
+		if (!approvers.some((id) => id === userId)) {
+			try {
+				await interaction.reply({
+					content: "⛔ You are not authorized to approve requests.",
+					ephemeral: true
+				});
+			} catch {}
 			return;
 		}
-		if (message.includes("Gateway reconnect scheduled in")) {
-			clearReadyWatch();
-			params.pushStatus({
-				connected: false,
-				lastEventAt: at,
-				lastError: message
-			});
-		}
-	};
-	return {
-		onGatewayDebug,
-		clearReadyWatch,
-		registerForceStop: (handler) => {
-			forceStopHandler = handler;
-			if (queuedForceStopError !== void 0) {
-				const err = queuedForceStopError;
-				queuedForceStopError = void 0;
-				handler(err);
-			}
-		},
-		dispose: () => {
-			clearReadyWatch();
-			forceStopHandler = void 0;
-			queuedForceStopError = void 0;
-		}
-	};
-}
-async function waitForGatewayReady(params) {
-	const waitUntilReady = async () => {
-		const deadlineAt = Date.now() + params.readyTimeoutMs;
-		while (!params.abortSignal?.aborted) {
-			if (await params.beforePoll?.() === "stop") return "stopped";
-			if (params.gateway?.isConnected === true) {
-				const at = Date.now();
-				params.pushStatus?.({
-					...createConnectedChannelStatusPatch(at),
-					lastDisconnect: null,
-					lastError: null
+		const decisionLabel = parsed.action === "allow-once" ? "Allowed (once)" : parsed.action === "allow-always" ? "Allowed (always)" : "Denied";
+		try {
+			await interaction.acknowledge();
+		} catch {}
+		const result = await this.ctx.resolveApproval(parsed.approvalId, parsed.approvalKind, parsed.action);
+		if (!result.ok) {
+			try {
+				await interaction.followUp({
+					content: result.reason === "not-found" ? `That approval request is no longer pending. It may have expired or already been resolved.` : `Failed to submit approval decision for **${decisionLabel}**. The request may have expired or already been resolved.`,
+					ephemeral: true
 				});
-				return "ready";
-			}
-			if (Date.now() >= deadlineAt) return "timeout";
-			await new Promise((resolve) => {
-				setTimeout(resolve, DISCORD_GATEWAY_READY_POLL_MS).unref?.();
-			});
+			} catch {}
+			return;
+		}
+		const terminalLabel = resolveTerminalLabel(result.resolution.approval);
+		let terminalized = false;
+		try {
+			await interaction.editReply(buildTerminalPayload({
+				approval: result.resolution.approval,
+				applied: result.resolution.applied
+			}));
+			terminalized = true;
+		} catch {}
+		if (!terminalized || !result.resolution.applied) try {
+			await interaction.followUp({
+				content: result.resolution.applied ? `Approval resolved: ${terminalLabel}.` : `This approval was already resolved: ${terminalLabel}.`,
+				ephemeral: true
+			});
+		} catch {}
+	}
+};
+function createExecApprovalButton(ctx) {
+	return new ExecApprovalButton(ctx);
+}
+function createDiscordExecApprovalButtonContext(params) {
+	return {
+		getApprovers: () => getDiscordExecApprovalApprovers({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			configOverride: params.config
+		}),
+		resolveApproval: async (approvalId, approvalKind, decision) => {
+			try {
+				return {
+					ok: true,
+					resolution: await resolveApprovalOverGateway({
+						cfg: params.cfg,
+						approvalId,
+						approvalKind,
+						decision,
+						gatewayUrl: params.gatewayUrl,
+						clientDisplayName: `Discord approval (${params.accountId})`
+					})
+				};
+			} catch (err) {
+				return {
+					ok: false,
+					reason: isStructuredApprovalNotFoundError(err) ? "not-found" : "error"
+				};
+			}
 		}
-		return "stopped";
-	};
-	if (!params.gateway) {
-		if (await waitUntilReady() === "timeout") throw new Error(`discord gateway did not reach READY within ${params.readyTimeoutMs}ms`);
-		return;
-	}
-	let attempt = 0;
-	while (!params.abortSignal?.aborted) {
-		if (await waitUntilReady() !== "timeout") return;
-		attempt += 1;
-		const restartAt = Date.now();
-		params.runtime.error?.(danger(`discord: gateway READY wait timed out after ${params.readyTimeoutMs}ms; reconnecting with backoff (attempt ${attempt})`));
-		params.pushStatus?.({
-			connected: false,
-			lastEventAt: restartAt,
-			lastDisconnect: {
-				at: restartAt,
-				error: "startup-not-ready"
-			},
-			lastError: "startup-not-ready"
-		});
-		await params.beforeRestart?.();
-		await restartGatewayAfterReadyTimeout({
-			gateway: params.gateway,
-			abortSignal: params.abortSignal,
-			runtime: params.runtime
-		});
-		if (params.abortSignal?.aborted) return;
-		await new Promise((resolve) => {
-			setTimeout(resolve, DISCORD_GATEWAY_READY_RETRY_BACKOFF_MS).unref?.();
-		});
-	}
-}
-async function runDiscordGatewayLifecycle(params) {
-	const gateway = params.gateway;
-	const gatewayReadyAtLifecycleStart = gateway?.isConnected === true;
-	if (gateway) registerGateway(params.accountId, gateway);
-	const gatewayEmitter = params.gatewaySupervisor.emitter ?? getDiscordGatewayEmitter(gateway);
-	const stopGatewayLogging = attachDiscordGatewayLogging({
-		emitter: gatewayEmitter,
-		runtime: params.runtime
-	});
-	let lifecycleStopping = false;
-	const pushStatus = (patch) => {
-		params.statusSink?.(patch);
-	};
-	const gatewayReadyTimeoutMs = resolveDiscordGatewayReadyTimeoutMs({
-		configuredTimeoutMs: params.gatewayReadyTimeoutMs,
-		env: process.env
-	});
-	const gatewayRuntimeReadyTimeoutMs = resolveDiscordGatewayRuntimeReadyTimeoutMs({
-		configuredTimeoutMs: params.gatewayRuntimeReadyTimeoutMs,
-		env: process.env
-	});
-	const statusObserver = createGatewayStatusObserver({
-		gateway,
-		abortSignal: params.abortSignal,
-		runtime: params.runtime,
-		pushStatus,
-		isLifecycleStopping: () => lifecycleStopping,
-		runtimeReadyTimeoutMs: gatewayRuntimeReadyTimeoutMs
-	});
-	gatewayEmitter?.on("debug", statusObserver.onGatewayDebug);
-	let lastTransportActivityStatusAt;
-	const onGatewayTransportActivity = (event) => {
-		if (lifecycleStopping || params.abortSignal?.aborted) return;
-		const at = resolveTransportActivityAt(event);
-		if (lastTransportActivityStatusAt !== void 0 && at - lastTransportActivityStatusAt < DISCORD_GATEWAY_TRANSPORT_ACTIVITY_STATUS_MIN_INTERVAL_MS) return;
-		lastTransportActivityStatusAt = at;
-		pushStatus(createTransportActivityStatusPatch(at));
 	};
-	gatewayEmitter?.on(DISCORD_GATEWAY_TRANSPORT_ACTIVITY_EVENT, onGatewayTransportActivity);
-	let sawDisallowedIntents = false;
-	const handleGatewayEvent = (event) => {
-		if (params.abortSignal?.aborted && event.type === "reconnect-exhausted") {
-			lifecycleStopping = true;
-			params.runtime.log?.(`discord: treating reconnect-exhausted during expected shutdown as clean: ${event.message}`);
-			return "continue";
+}
+//#endregion
+//#region extensions/discord/src/monitor/questions.ts
+var QuestionButton = class extends Button {
+	constructor(ctx) {
+		super();
+		this.ctx = ctx;
+		this.label = "question";
+		this.customId = "ocq:id=seed;i=0";
+		this.style = ButtonStyle.Primary;
+	}
+	async run(interaction, data) {
+		const callback = parseDiscordQuestionData(data);
+		if (!callback) {
+			await interaction.reply({
+				content: "This question is no longer valid.",
+				ephemeral: true
+			});
+			return;
 		}
-		if (event.type === "disallowed-intents") {
-			lifecycleStopping = true;
-			sawDisallowedIntents = true;
-			params.runtime.error?.(danger("discord: gateway closed with code 4014 (missing privileged gateway intents). Enable the required intents in the Discord Developer Portal or disable them in config."));
-			return "stop";
+		if (!await this.ctx.authorizeQuestion(interaction)) return;
+		try {
+			await interaction.acknowledge();
+		} catch {}
+		let result;
+		try {
+			result = await this.ctx.resolveQuestion({
+				cfg: this.ctx.cfg,
+				questionId: callback.questionId,
+				optionIndex: callback.optionIndex,
+				senderId: interaction.userId,
+				clientDisplayName: `Discord question (${this.ctx.accountId})`
+			});
+		} catch {
+			try {
+				await interaction.followUp({
+					content: "Could not submit this answer.",
+					ephemeral: true
+				});
+			} catch {}
+			return;
 		}
-		if (event.shouldStopLifecycle) lifecycleStopping = true;
-		params.runtime.error?.(danger(event.shouldStopLifecycle ? `discord gateway ${event.type}: ${event.message}` : `discord gateway error: ${event.message}`));
-		return event.shouldStopLifecycle ? "stop" : "continue";
+		try {
+			await interaction.followUp({
+				content: result.status === "answered" ? "Answer submitted." : "This question was already answered.",
+				ephemeral: true
+			});
+		} catch {}
+	}
+};
+function createDiscordQuestionButton(params) {
+	const authContext = params.authContext ?? {
+		cfg: params.cfg,
+		accountId: params.accountId
 	};
-	const drainPendingGatewayErrors = () => params.gatewaySupervisor.drainPending((event) => {
-		if (handleGatewayEvent(event) !== "stop") return "continue";
-		if (event.type === "disallowed-intents") return "stop";
-		throw new DiscordGatewayLifecycleError(event);
+	return new QuestionButton({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		resolveQuestion: params.resolveQuestion ?? questionGatewayRuntime.resolveOption,
+		authorizeQuestion: params.authorizeQuestion ?? (async (interaction) => Boolean(await resolveAuthorizedComponentInteraction({
+			ctx: authContext,
+			interaction,
+			label: "discord question",
+			componentLabel: "button",
+			unauthorizedReply: "You are not authorized to answer this question.",
+			defer: false
+		})))
 	});
-	try {
-		if (drainPendingGatewayErrors() === "stop") return;
-		if (gatewayReadyAtLifecycleStart && params.voiceManager) params.voiceManager.autoJoin().catch((err) => params.runtime.error?.(danger(`discord voice: autoJoin failed: ${formatErrorMessage$1(err)}`)));
-		await waitForGatewayReady({
-			gateway,
-			abortSignal: params.abortSignal,
-			beforePoll: drainPendingGatewayErrors,
-			pushStatus,
-			runtime: params.runtime,
-			beforeRestart: statusObserver.clearReadyWatch,
-			readyTimeoutMs: gatewayReadyTimeoutMs
-		});
-		if (drainPendingGatewayErrors() === "stop") return;
-		await waitForDiscordGatewayStop({
-			gateway: gateway ? { disconnect: () => gateway.disconnect() } : void 0,
-			abortSignal: params.abortSignal,
-			gatewaySupervisor: params.gatewaySupervisor,
-			onGatewayEvent: handleGatewayEvent,
-			registerForceStop: statusObserver.registerForceStop
-		});
-	} catch (err) {
-		if (!sawDisallowedIntents && !params.isDisallowedIntentsError(err)) throw err;
-	} finally {
-		lifecycleStopping = true;
-		params.gatewaySupervisor.detachLifecycle();
-		unregisterGateway(params.accountId);
-		stopGatewayLogging();
-		statusObserver.dispose();
-		gatewayEmitter?.removeListener("debug", statusObserver.onGatewayDebug);
-		gatewayEmitter?.removeListener(DISCORD_GATEWAY_TRANSPORT_ACTIVITY_EVENT, onGatewayTransportActivity);
-		if (params.voiceManager) {
-			await params.voiceManager.destroy();
-			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-CLZ5X8fh.js").then((n) => n.n);
-			setDiscordTranscriptsVoiceManager({
+}
+//#endregion
+//#region extensions/discord/src/monitor/provider.interactions.ts
+function createDiscordProviderInteractionSurface(params) {
+	const createNativeCommand = params.createNativeCommand ?? createDiscordNativeCommand;
+	const commands = params.commandSpecs.map((spec) => createNativeCommand({
+		command: spec,
+		cfg: params.cfg,
+		discordConfig: params.discordConfig,
+		accountId: params.accountId,
+		sessionPrefix: params.sessionPrefix,
+		ephemeralDefault: params.ephemeralDefault,
+		threadBindings: params.threadBindings
+	}));
+	if (params.nativeEnabled && params.voiceEnabled) commands.push(createDiscordVoiceCommand({
+		cfg: params.cfg,
+		discordConfig: params.discordConfig,
+		accountId: params.accountId,
+		groupPolicy: params.groupPolicy,
+		useAccessGroups: params.useAccessGroups,
+		getManager: () => params.voiceManagerRef.current,
+		ephemeralDefault: params.ephemeralDefault
+	}));
+	const execApprovalsConfig = params.discordConfig.execApprovals ?? {};
+	const execApprovalsEnabled = isDiscordExecApprovalClientEnabled({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		configOverride: execApprovalsConfig
+	});
+	const approvalActionsEnabled = getDiscordExecApprovalApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		configOverride: execApprovalsConfig
+	}).length > 0;
+	if (execApprovalsEnabled) registerChannelRuntimeContext({
+		channelRuntime: params.channelRuntime,
+		channelId: "discord",
+		accountId: params.accountId,
+		capability: CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY,
+		context: {
+			token: params.token,
+			config: execApprovalsConfig
+		},
+		abortSignal: params.abortSignal
+	});
+	const components = [
+		createDiscordQuestionButton({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			authContext: {
+				cfg: params.cfg,
 				accountId: params.accountId,
-				manager: null
-			});
-			params.voiceManagerRef.current = null;
-		}
-		params.threadBindings.stop();
+				discordConfig: params.discordConfig,
+				runtime: params.runtime,
+				token: params.token,
+				guildEntries: params.guildEntries,
+				allowFrom: params.allowFrom,
+				dmPolicy: params.dmPolicy
+			}
+		}),
+		createDiscordCommandArgFallbackButton({
+			cfg: params.cfg,
+			discordConfig: params.discordConfig,
+			accountId: params.accountId,
+			sessionPrefix: params.sessionPrefix,
+			threadBindings: params.threadBindings
+		}),
+		createDiscordModelPickerFallbackButton({
+			cfg: params.cfg,
+			discordConfig: params.discordConfig,
+			accountId: params.accountId,
+			sessionPrefix: params.sessionPrefix,
+			threadBindings: params.threadBindings
+		}),
+		createDiscordModelPickerFallbackSelect({
+			cfg: params.cfg,
+			discordConfig: params.discordConfig,
+			accountId: params.accountId,
+			sessionPrefix: params.sessionPrefix,
+			threadBindings: params.threadBindings
+		})
+	];
+	const activityButton = createDiscordActivityButton({
+		cfg: params.cfg,
+		discordConfig: params.discordConfig,
+		accountId: params.accountId,
+		guildEntries: params.guildEntries,
+		allowFrom: params.allowFrom,
+		dmPolicy: params.dmPolicy,
+		runtime: params.runtime,
+		token: params.token
+	}, params.applicationId);
+	if (activityButton) components.push(activityButton);
+	const modals = [];
+	if (approvalActionsEnabled) components.push(createExecApprovalButton(createDiscordExecApprovalButtonContext({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		config: execApprovalsConfig
+	})));
+	if ((params.discordConfig.agentComponents ?? {}).enabled ?? true) {
+		const componentContext = {
+			cfg: params.cfg,
+			discordConfig: params.discordConfig,
+			accountId: params.accountId,
+			guildEntries: params.guildEntries,
+			allowFrom: params.allowFrom,
+			dmPolicy: params.dmPolicy,
+			runtime: params.runtime,
+			token: params.token
+		};
+		components.push(...createAgentComponentControls.map((create) => create(componentContext)));
+		components.push(...createDiscordComponentControls.map((create) => create(componentContext)));
+		modals.push(createDiscordComponentModal(componentContext));
 	}
+	return {
+		commands,
+		components,
+		modals
+	};
 }
 //#endregion
 //#region extensions/discord/src/internal/voice.ts
@@ -10224,7 +10541,7 @@ async function createDiscordMonitorClient(params) {
 		publicKey: "a",
 		token: params.token,
 		autoDeploy: false,
-		commandDeployHashStorePath: path.join(resolveStateDir(process.env), "discord", "command-deploy-cache.json"),
+		commandDeployHashStore: params.commandDeployHashStore,
 		requestOptions: {
 			timeout: DISCORD_REST_TIMEOUT_MS,
 			runtimeProfile: "persistent",
@@ -10401,35 +10718,12 @@ function formatDiscordStartupStatusMessage(params) {
 //#endregion
 //#region extensions/discord/src/monitor/provider.ts
 const DEFAULT_DISCORD_MEDIA_MAX_MB = 100;
-let discordVoiceRuntimePromise;
-let discordProviderSessionRuntimePromise;
-let getPluginCommandSpecsForTesting;
 function logDiscordStartupPhase(params) {
 	logDiscordStartupPhase$1({
 		...params,
-		isVerbose
+		isVerbose: discordProviderRuntime.isVerbose
 	});
 }
-async function loadDiscordVoiceRuntime() {
-	const promise = discordVoiceRuntimePromise ?? import("./manager.runtime-3RVMVkyx.js");
-	discordVoiceRuntimePromise = promise;
-	try {
-		return await promise;
-	} catch (error) {
-		if (discordVoiceRuntimePromise === promise) discordVoiceRuntimePromise = void 0;
-		throw error;
-	}
-}
-async function loadDiscordProviderSessionRuntime() {
-	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-D5pCGibh.js");
-	discordProviderSessionRuntimePromise = promise;
-	try {
-		return await promise;
-	} catch (error) {
-		if (discordProviderSessionRuntimePromise === promise) discordProviderSessionRuntimePromise = void 0;
-		throw error;
-	}
-}
 const DISCORD_DISALLOWED_INTENTS_CODE = GatewayCloseCodes$1.DisallowedIntents;
 function isDiscordDisallowedIntentsError(err) {
 	if (!err) return false;
@@ -10438,7 +10732,7 @@ function isDiscordDisallowedIntentsError(err) {
 async function monitorDiscordProvider(opts = {}) {
 	const startupStartedAt = Date.now();
 	const cfg = opts.config ?? getRuntimeConfig();
-	const account = resolveDiscordAccount({
+	const account = discordProviderRuntime.resolveDiscordAccount({
 		cfg,
 		accountId: opts.accountId
 	});
@@ -10482,7 +10776,7 @@ async function monitorDiscordProvider(opts = {}) {
 		cfg,
 		accountId: account.accountId
 	}) ?? "pairing";
-	const discordProviderSessionRuntime = await loadDiscordProviderSessionRuntime();
+	const discordProviderSessionRuntime = await discordProviderRuntime.loadDiscordProviderSessionRuntime();
 	const threadBindingIdleTimeoutMs = discordProviderSessionRuntime.resolveThreadBindingIdleTimeoutMs({
 		channelIdleHoursRaw: discordAccountThreadBindings?.idleHours ?? discordRootThreadBindings?.idleHours,
 		sessionIdleHoursRaw: cfg.session?.threadBindings?.idleHours
@@ -10497,12 +10791,12 @@ async function monitorDiscordProvider(opts = {}) {
 	});
 	const groupDmEnabled = dmConfig?.groupEnabled ?? false;
 	const groupDmChannels = dmConfig?.groupChannels;
-	const nativeEnabled = resolveNativeCommandsEnabled({
+	const nativeEnabled = discordProviderRuntime.resolveNativeCommandsEnabled({
 		providerId: "discord",
 		providerSetting: discordCfg.commands?.native,
 		globalSetting: cfg.commands?.native
 	});
-	const nativeSkillsEnabled = resolveNativeSkillsEnabled({
+	const nativeSkillsEnabled = discordProviderRuntime.resolveNativeSkillsEnabled({
 		providerId: "discord",
 		providerSetting: discordCfg.commands?.nativeSkills,
 		globalSetting: cfg.commands?.nativeSkills
@@ -10522,7 +10816,7 @@ async function monitorDiscordProvider(opts = {}) {
 	});
 	guildEntries = allowlistResolved.guildEntries;
 	allowFrom = allowlistResolved.allowFrom ?? [];
-	if (shouldLogVerbose()) logDiscordResolvedConfig({
+	if (discordProviderRuntime.shouldLogVerbose()) logDiscordResolvedConfig({
 		dmEnabled,
 		dmPolicy,
 		allowFrom,
@@ -10545,7 +10839,7 @@ async function monitorDiscordProvider(opts = {}) {
 		phase: "fetch-application-id:start",
 		startAt: startupStartedAt
 	});
-	const applicationId = (typeof discordCfg.applicationId === "string" && discordCfg.applicationId.trim() ? discordCfg.applicationId.trim() : void 0) ?? parseApplicationIdFromToken(token) ?? await fetchDiscordApplicationId(token, 4e3, discordRestFetch);
+	const applicationId = (typeof discordCfg.applicationId === "string" && discordCfg.applicationId.trim() ? discordCfg.applicationId.trim() : void 0) ?? parseApplicationIdFromToken(token) ?? await discordProviderRuntime.fetchDiscordApplicationId(token, 4e3, discordRestFetch);
 	if (!applicationId) throw new Error("Failed to resolve Discord application id");
 	logDiscordStartupPhase({
 		runtime,
@@ -10559,9 +10853,9 @@ async function monitorDiscordProvider(opts = {}) {
 		runtime,
 		nativeEnabled,
 		nativeSkillsEnabled,
-		listSkillCommandsForAgents,
-		listNativeCommandSpecsForConfig,
-		getPluginCommandSpecs: getPluginCommandSpecsForTesting
+		listSkillCommandsForAgents: discordProviderRuntime.listSkillCommandsForAgents,
+		listNativeCommandSpecsForConfig: discordProviderRuntime.listNativeCommandSpecsForConfig,
+		getPluginCommandSpecs: discordProviderRuntime.getPluginCommandSpecs
 	});
 	const voiceManagerRef = { current: null };
 	const threadBindings = threadBindingsEnabled ? discordProviderSessionRuntime.createThreadBindingManager({
@@ -10605,6 +10899,7 @@ async function monitorDiscordProvider(opts = {}) {
 			cfg,
 			discordConfig: discordCfg,
 			accountId: account.accountId,
+			applicationId,
 			token,
 			commandSpecs,
 			nativeEnabled,
@@ -10621,7 +10916,7 @@ async function monitorDiscordProvider(opts = {}) {
 			runtime,
 			channelRuntime: opts.channelRuntime,
 			abortSignal: opts.abortSignal,
-			createNativeCommand: createDiscordNativeCommand
+			createNativeCommand: discordProviderRuntime.createDiscordNativeCommand
 		});
 		const { client, gateway, gatewaySupervisor: createdGatewaySupervisor, autoPresenceController: createdAutoPresenceController } = await createDiscordMonitorClient({
 			accountId: account.accountId,
@@ -10634,7 +10929,8 @@ async function monitorDiscordProvider(opts = {}) {
 			voiceEnabled,
 			discordConfig: discordCfg,
 			runtime,
-			createClient: ((...args) => new Client(...args)),
+			commandDeployHashStore: opts.commandDeployHashStore,
+			createClient: discordProviderRuntime.createClient,
 			createGatewayPlugin: createDiscordGatewayPlugin,
 			createGatewaySupervisor: createDiscordGatewaySupervisor,
 			createAutoPresenceController: createDiscordAutoPresenceController,
@@ -10645,7 +10941,7 @@ async function monitorDiscordProvider(opts = {}) {
 		autoPresenceController = createdAutoPresenceController;
 		earlyGatewayEmitter = gatewaySupervisor.emitter;
 		onEarlyGatewayDebug = (msg) => {
-			if (!isVerbose()) return;
+			if (!discordProviderRuntime.isVerbose()) return;
 			runtime.log?.(`discord startup [${account.accountId}] gateway-debug ${Math.max(0, Date.now() - startupStartedAt)}ms ${String(msg)}`);
 		};
 		earlyGatewayEmitter?.on("debug", onEarlyGatewayDebug);
@@ -10663,8 +10959,8 @@ async function monitorDiscordProvider(opts = {}) {
 			enabled: nativeEnabled,
 			accountId: account.accountId,
 			startupStartedAt,
-			shouldLogVerbose,
-			isVerbose
+			shouldLogVerbose: discordProviderRuntime.shouldLogVerbose,
+			isVerbose: discordProviderRuntime.isVerbose
 		});
 		const logger = createSubsystemLogger("discord/monitor");
 		const guildHistories = /* @__PURE__ */ new Map();
@@ -10683,7 +10979,7 @@ async function monitorDiscordProvider(opts = {}) {
 		});
 		let voiceManager = null;
 		if (voiceEnabled) {
-			const { DiscordVoiceGuildCreateListener, DiscordVoiceManager, DiscordVoiceReadyListener, DiscordVoiceResumedListener, DiscordVoiceStateUpdateListener } = await loadDiscordVoiceRuntime();
+			const { DiscordVoiceGuildCreateListener, DiscordVoiceManager, DiscordVoiceReadyListener, DiscordVoiceResumedListener, DiscordVoiceStateUpdateListener } = await discordProviderRuntime.loadDiscordVoiceRuntime();
 			voiceManager = new DiscordVoiceManager({
 				client,
 				cfg,
@@ -10692,7 +10988,7 @@ async function monitorDiscordProvider(opts = {}) {
 				runtime,
 				botUserId
 			});
-			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-CLZ5X8fh.js").then((n) => n.n);
+			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-DjDbt14x.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: account.accountId,
 				manager: voiceManager
@@ -10704,6 +11000,7 @@ async function monitorDiscordProvider(opts = {}) {
 			registerDiscordListener(client.listeners, new DiscordVoiceStateUpdateListener(voiceManager));
 		}
 		const messageHandler = discordProviderSessionRuntime.createDiscordMessageHandler({
+			client,
 			cfg,
 			discordConfig: discordCfg,
 			accountId: account.accountId,
@@ -10768,7 +11065,7 @@ async function monitorDiscordProvider(opts = {}) {
 		lifecycleStarted = true;
 		earlyGatewayEmitter?.removeListener("debug", onEarlyGatewayDebug);
 		onEarlyGatewayDebug = void 0;
-		await runDiscordGatewayLifecycle({
+		await discordProviderRuntime.runDiscordGatewayLifecycle({
 			accountId: account.accountId,
 			gateway: lifecycleGateway,
 			runtime,
@@ -10783,7 +11080,7 @@ async function monitorDiscordProvider(opts = {}) {
 			gatewayRuntimeReadyTimeoutMs: account.config.gatewayRuntimeReadyTimeoutMs
 		});
 	} finally {
-		cleanupDiscordProviderStartup({
+		await cleanupDiscordProviderStartup({
 			deactivateMessageHandler,
 			autoPresenceController,
 			setStatus: opts.setStatus,
@@ -10798,4 +11095,4 @@ async function monitorDiscordProvider(opts = {}) {
 	}
 }
 //#endregion
-export { resolveDiscordTextCommandAccess as A, registerDiscordListener as C, resolveDiscordThreadStarter as D, resolveDiscordReplyTarget as E, sanitizeDiscordThreadName as O, handleDiscordDmCommandDecision as S, resolveDiscordAutoThreadReplyPlan as T, createDiscordSupplementalContextAccessChecker as _, buildDirectLabel as a, resolveDiscordEffectiveRoute as b, resolveDiscordVoiceOwnerAccess as c, resolveDiscordGatewayIntents as d, waitForDiscordGatewayPluginRegistration as f, buildDiscordInboundAccessContext as g, buildDiscordGroupSystemPrompt as h, sanitizeDiscordFrontChannelReplyPayloads as i, resolveDiscordDmCommandAccess as k, authorizeDiscordVoiceIngress as l, createDiscordNativeCommand as m, deliverDiscordReply as n, buildGuildLabel as o, resolveDiscordVoiceEnabled as p, formatDiscordReplyDeliveryFailure as r, resolveReplyContext as s, monitorDiscordProvider as t, createDiscordGatewayPlugin as u, buildDiscordRoutePeer as v, threading_exports as w, shouldIgnoreStaleDiscordRouteBinding as x, resolveDiscordConversationRoute as y };
+export { resolveDiscordDmCommandAccess as A, mapGatewayDispatchData as C, resolveDiscordReplyTarget as D, resolveDiscordAutoThreadReplyPlan as E, resolveDiscordThreadStarter as O, handleDiscordDmCommandDecision as S, threading_exports as T, createDiscordSupplementalContextAccessChecker as _, buildDirectLabel as a, resolveDiscordEffectiveRoute as b, resolveDiscordVoiceAccess as c, resolveDiscordGatewayIntents as d, waitForDiscordGatewayPluginRegistration as f, buildDiscordInboundAccessContext as g, buildDiscordGroupSystemPrompt as h, sanitizeDiscordFrontChannelReplyPayloads as i, resolveDiscordTextCommandAccess as j, sanitizeDiscordThreadName as k, authorizeDiscordVoiceIngress as l, createDiscordNativeCommand as m, deliverDiscordReply as n, buildGuildLabel as o, resolveDiscordVoiceEnabled as p, formatDiscordReplyDeliveryFailure as r, resolveReplyContext as s, monitorDiscordProvider as t, createDiscordGatewayPlugin as u, buildDiscordRoutePeer as v, registerDiscordListener as w, shouldIgnoreStaleDiscordRouteBinding as x, resolveDiscordConversationRoute as y };