@openclaw/discord 2026.9.5 → 2026.9.7

package/dist/.setup/{provider-72zIvN-i.mjs → provider-B_G5hASF.mjs}

@@ -1,38 +1,39 @@
-import { D as Message, E as Guild, G as Row, J as StringSelectMenu, L as Button, O as User, P as Modal, Q as BaseMessageInteractiveComponent, T as CommandWithSubcommands, Y as TextDisplay, a as MessageCreateListener, c as PresenceUpdateListener, d as ThreadDeleteListener, f as ThreadUpdateListener, h as Plugin, i as InteractionCreateListener, k as hasDiscordV2Components, l as ReadyListener, m as Client, n as GuildCreateListener, o as MessageReactionAddListener, q as Separator, r as GuildDeleteListener, s as MessageReactionRemoveListener, t as discord_exports, v as RateLimitError, w as Command, z as Container } from "./discord-BXpHW-cu.mjs";
-import { C as parseDiscordActivityCustomIdForInteraction, D as parseDiscordModalCustomIdForInteraction, E as parseDiscordModalCustomId, O as decodeCustomIdComponent, T as parseDiscordComponentCustomIdForInteraction, c as parseExecApprovalData, d as buildDiscordComponentMessage, k as encodeCustomIdComponent, o as parseDiscordQuestionData, w as parseDiscordComponentCustomId, y as buildDiscordActivityCustomId } from "./components-MqMWUWnE.mjs";
-import { C as resolveTimestampMs, E as getDiscordEndpointRuntime, T as assertDiscordEndpointGatewayUrl, a as normalizeDiscordDisplaySlug, b as formatDiscordReactionEmoji, c as resolveDiscordChannelConfig, f as resolveDiscordGuildEntry, g as resolveDiscordOwnerAllowFrom, h as resolveDiscordOwnerAccess, i as normalizeDiscordAllowList, l as resolveDiscordChannelConfigWithFallback, m as resolveDiscordMemberAllowed, o as normalizeDiscordSlug, p as resolveDiscordMemberAccessState, r as isDiscordGroupAllowedByPolicy, s as resolveDiscordAllowListMatch, t as isDiscordThreadChannelType, u as resolveDiscordChannelPolicyCommandAuthorizer, v as resolveGroupDmAllow, x as formatDiscordUserTag, y as shouldEmitDiscordReactionNotification } from "./channel-type-DKnjV1XW.mjs";
-import { c as resolveDiscordAccount, f as resolveDiscordAccountDmPolicy, h as resolveDiscordToken, l as resolveDiscordAccountAllowFrom, m as normalizeDiscordToken, o as mergeDiscordAccountConfig, p as resolveDiscordMaxLinesPerMessage } from "./accounts-CwJQoLjM.mjs";
-import { a as registerDiscordComponentEntries, o as resolveDiscordComponentEntryWithPersistence, s as resolveDiscordModalEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-DWQjXhPV.mjs";
+import { C as parseDiscordActivityCustomIdForInteraction, D as parseDiscordModalCustomIdForInteraction, E as parseDiscordModalCustomId, O as decodeCustomIdComponent, T as parseDiscordComponentCustomIdForInteraction, c as parseExecApprovalData, d as buildDiscordComponentMessage, k as encodeCustomIdComponent, o as parseDiscordQuestionData, w as parseDiscordComponentCustomId, y as buildDiscordActivityCustomId } from "./components-Cq1PvIpN.mjs";
+import { $ as BaseMessageInteractiveComponent, B as Container, D as Message, E as Guild, J as Separator, K as Row, O as User, P as Modal, R as Button, T as CommandWithSubcommands, X as TextDisplay, Y as StringSelectMenu, a as MessageCreateListener, c as PresenceUpdateListener, d as ThreadDeleteListener, f as ThreadUpdateListener, h as Plugin, i as InteractionCreateListener, k as hasDiscordV2Components, l as ReadyListener, m as Client, n as GuildCreateListener, o as MessageReactionAddListener, r as GuildDeleteListener, s as MessageReactionRemoveListener, t as discord_exports, v as RateLimitError, w as Command } from "./discord-0xJYfdDD.mjs";
+import { D as getDiscordEndpointRuntime, E as assertDiscordEndpointGatewayUrl, S as formatDiscordUserTag, _ as resolveDiscordOwnerAllowFrom, a as normalizeDiscordDisplaySlug, b as shouldEmitDiscordReactionNotification, c as resolveDiscordChannelConfig, f as resolveDiscordGuildEntry, g as resolveDiscordOwnerAccess, i as normalizeDiscordAllowList, l as resolveDiscordChannelConfigWithFallback, m as resolveDiscordMemberAllowed, o as normalizeDiscordSlug, p as resolveDiscordMemberAccessState, r as isDiscordGroupAllowedByPolicy, s as resolveDiscordAllowListMatch, t as isDiscordThreadChannelType, u as resolveDiscordChannelPolicyCommandAuthorizer, w as resolveTimestampMs, x as formatDiscordReactionEmoji, y as resolveGroupDmAllow } from "./channel-type-DRCrEMss.mjs";
+import { c as resolveDiscordAccount, f as resolveDiscordAccountDmPolicy, h as resolveDiscordToken, l as resolveDiscordAccountAllowFrom, m as normalizeDiscordToken, o as mergeDiscordAccountConfig, p as resolveDiscordMaxLinesPerMessage } from "./accounts-ChaMcixG.mjs";
+import { a as registerDiscordComponentEntries, o as resolveDiscordComponentEntryWithPersistence, s as resolveDiscordModalEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-DxQAMfES.mjs";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.mjs";
-import { a as isDiscordRateLimitResponseBody, o as summarizeDiscordResponseBody } from "./api-CBK9zcq5.mjs";
-import { o as chunkDiscordTextWithMode } from "./retry-DBfcEgmO.mjs";
-import { B as validateDiscordProxyUrl, G as unregisterGateway, P as createDiscordRestClient, R as DISCORD_REST_TIMEOUT_MS, V as withValidatedDiscordProxy, W as registerGateway, b as canViewDiscordGuildChannel, w as hasAnyChannelPermissionDiscord } from "./send.shared-Zwx6BxQ5.mjs";
-import { o as formatMention, t as sendMessageDiscord } from "./send.outbound-D0hQ7s50.mjs";
-import { n as getDiscordActivitiesRuntime } from "./runtime-BVoa7hhx.mjs";
+import { a as isDiscordRateLimitResponseBody, s as summarizeDiscordResponseBody } from "./api-DVbJwZVt.mjs";
+import { o as chunkDiscordTextWithMode } from "./retry-pz_cSha2.mjs";
+import { B as withValidatedDiscordProxy, C as hasAnyChannelPermissionDiscord, L as DISCORD_REST_TIMEOUT_MS, N as createDiscordRestClient, U as registerGateway, W as unregisterGateway, y as canViewDiscordGuildChannel, z as validateDiscordProxyUrl } from "./send.shared-DGFkbkQR.mjs";
+import { o as formatMention, t as sendMessageDiscord } from "./send.outbound-BISKnb-a.mjs";
+import { n as getDiscordActivitiesRuntime } from "./runtime-sUksZ--Q.mjs";
 import { t as resolveDiscordCommandOwnerAllowFrom } from "./command-owners-D78sAoOz.mjs";
 import { n as resolveDiscordChannelInfoSafe, o as resolveDiscordChannelTopicSafe, r as resolveDiscordChannelNameSafe } from "./channel-access-C12aDZ0p.mjs";
-import { D as resolveDiscordMessageStickers, c as resolveDiscordVoiceAccess, d as resolveFetchedDiscordThreadLikeChannelContext, o as resolveDiscordVoiceEnabled, r as setDiscordTranscriptsVoiceManager, s as authorizeDiscordVoiceIngress, u as resolveDiscordThreadLikeChannelContext } from "./transcripts-source-CuWYgayu.mjs";
-import { i as setPresence, t as clearPresences } from "./presence-cache-dYSHPWMx.mjs";
-import { _ as readMessagesDiscord, s as sendVoiceMessageDiscord } from "./send-CKDczUNL.mjs";
+import { D as resolveDiscordReferencedReplyMessage, O as resolveDiscordReferencedReplyMessageId, a as resolveDiscordVoiceEnabled, i as setDiscordTranscriptsVoiceManager, l as resolveDiscordThreadLikeChannelContext, o as authorizeDiscordVoiceIngress, s as resolveDiscordVoiceAccess, u as resolveFetchedDiscordThreadLikeChannelContext } from "./transcripts-source-p8EV179h.mjs";
+import { i as setPresence, t as clearPresences } from "./presence-cache-Di3H3DIU.mjs";
+import { _ as readMessagesDiscord, s as sendVoiceMessageDiscord } from "./send-CrfEI6Bs.mjs";
 import { c as raceWithTimeout, u as withAbortTimeout } from "./timeouts-D86uWLt_.mjs";
-import { D as isDiscordExecApprovalClientEnabled, T as getDiscordExecApprovalApprovers, a as resolveDiscordComponentSpec, c as formatDiscordApprovalDisplayValue, d as resolveDiscordBoundConversationRoute, h as resolveDiscordConversationIdentity, l as buildDiscordConversationRouteContext, n as DISCORD_PRESENTATION_CAPABILITIES, p as resolveDiscordEffectiveRoute, r as buildDiscordPresentationPayload, s as DISCORD_APPROVAL_ALLOWED_MENTIONS } from "./outbound-session-route-CqWbuMOm.mjs";
-import { n as discordIngressIdentity, t as selectDiscordLivePolicyConfig } from "./live-policy-config-eKQ-PLdy.mjs";
-import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-BbvsLQOZ.mjs";
-import { t as resolveDiscordUserAllowlist } from "./resolve-users-ByFlR7LQ.mjs";
-import { i as getThreadBindingManager, o as isThreadArchived, u as formatThreadBindingDurationLabel } from "./thread-bindings.manager-eexkKyrG.mjs";
-import { a as probeDiscordApplicationId, r as parseApplicationIdFromToken } from "./probe-CupW4we4.mjs";
+import { D as isDiscordExecApprovalClientEnabled, T as getDiscordExecApprovalApprovers, a as resolveDiscordComponentSpec, c as formatDiscordApprovalDisplayValue, d as resolveDiscordBoundConversationRoute, h as resolveDiscordConversationIdentity, l as buildDiscordConversationRouteContext, n as DISCORD_PRESENTATION_CAPABILITIES, p as resolveDiscordEffectiveRoute, r as buildDiscordPresentationPayload, s as DISCORD_APPROVAL_ALLOWED_MENTIONS, u as buildDiscordRoutePeer } from "./outbound-session-route-zVGxxceg.mjs";
+import { n as discordIngressIdentity, t as selectDiscordLivePolicyConfig } from "./live-policy-config-8Pv20CHc.mjs";
+import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-BFPNRmVv.mjs";
+import { t as resolveDiscordUserAllowlist } from "./resolve-users-0-aBuCy3.mjs";
+import { a as isThreadArchived, n as getThreadBindingManager } from "./thread-bindings.manager-DN-NissX.mjs";
+import { a as probeDiscordApplicationId, r as parseApplicationIdFromToken } from "./probe-LYrIHlBF.mjs";
 import { i as sanitizeRecentModels, n as normalizeModelRef, r as preferenceTimestampMs, t as buildPreferenceModelKey } from "./model-picker-preference-primitives-BHT1LkR_.mjs";
-import { t as resolveDiscordSenderIdentity } from "./sender-identity-0Ymgvmaj.mjs";
-import { n as hasDiscordApprovalControl, t as discordApprovalMessageUpdates } from "./approval-message-updates-BN7JtScm.mjs";
+import { t as resolveDiscordSenderIdentity } from "./sender-identity-B9X5Vb9R.mjs";
+import { n as hasDiscordApprovalControl, t as discordApprovalMessageUpdates } from "./approval-message-updates-BKFqavHZ.mjs";
 import { createRequire } from "node:module";
 import { logDebug, logError } from "openclaw/plugin-sdk/logging-core";
 import { ApplicationCommandOptionType, ButtonStyle, ChannelType, ComponentType, GatewayCloseCodes, GatewayCloseCodes as GatewayCloseCodes$1, GatewayDispatchEvents, GatewayIntentBits, GatewayOpcodes, PermissionFlagsBits } from "discord-api-types/v10";
 import { Type } from "typebox";
 import { Check, Errors } from "typebox/value";
 import { createHash, randomUUID } from "node:crypto";
-import { MAX_DATE_TIMESTAMP_MS, MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, asSafeIntegerInRange, parseFiniteNumber, parseStrictInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { MAX_DATE_TIMESTAMP_MS, MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, asSafeIntegerInRange, parseFiniteNumber, parseStrictInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolvePromptHistoryLimit, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { inspect } from "node:util";
+import * as fetchRuntimeSdk from "openclaw/plugin-sdk/fetch-runtime";
 import { createHttp1EnvHttpProxyAgent, createHttp1ProxyAgent, createNodeProxyAgent, resolveEnvHttpProxyAgentOptions, wrapFetchWithAbortSignal } from "openclaw/plugin-sdk/fetch-runtime";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 import { fetchWithSsrFGuard, formatErrorMessage, resolvePinnedHostnameWithPolicy } from "openclaw/plugin-sdk/ssrf-runtime";
@@ -53,29 +54,28 @@ import { buildOutboundSessionContext, listMessageReceiptPlatformIds, resolveChan
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
 import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { buildCommandTextFromArgs, findCommandByNativeName, formatCommandArgMenuTitle, listChatCommands, listNativeCommandSpecsForConfig, listSkillCommandsForAgents, resolveCommandAuthorizedFromAuthorizers, resolveEffectiveAgentRuntime, resolveNativeCommandSessionTargets, resolveStoredModelOverride, serializeCommandArgs } from "openclaw/plugin-sdk/command-auth-native";
+import { buildCommandTextFromArgs, findCommandByNativeName, formatCommandArgMenuTitle, listChatCommands, listNativeCommandSpecsForConfig, listSkillCommandsForAgents, resolveCommandAuthorization, resolveCommandAuthorizedFromAuthorizers, resolveEffectiveAgentRuntime, resolveNativeCommandSessionTargets, resolveStoredModelOverride, serializeCommandArgs } from "openclaw/plugin-sdk/command-auth-native";
 import { GROUP_POLICY_BLOCKED_LABEL, resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
-import { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-runtime";
-import { createChannelPartialDeliveryError, createCommandTurnContext, dispatchChannelInboundTurn, formatInboundEnvelope, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, resolveEnvelopeFormatOptions, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent } from "openclaw/plugin-sdk/channel-inbound";
+import { buildChannelInboundEventContext, createChannelPartialDeliveryError, createCommandTurnContext, dispatchChannelInboundTurn, formatInboundEnvelope, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, resolveEnvelopeFormatOptions, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent } from "openclaw/plugin-sdk/channel-inbound";
 import path from "node:path";
-import { resolvePinnedMainDmOwnerFromAllowlist as resolvePinnedMainDmOwnerFromAllowlist$1 } from "openclaw/plugin-sdk/security-runtime";
+import { resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
-import { buildPairingReply, upsertChannelPairingRequest, upsertChannelPairingRequest as upsertChannelPairingRequest$1 } from "openclaw/plugin-sdk/conversation-runtime";
-import * as conversationRuntime from "openclaw/plugin-sdk/conversation-binding-runtime";
+import { buildPairingReply, formatThreadBindingDurationLabel, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
+import { ensureConfiguredBindingRouteReady, resolveConfiguredBindingRoute } from "openclaw/plugin-sdk/conversation-binding-runtime";
 import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
-import { createChannelIngressResolver, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
-import { clearExpiredCooldowns, ensureAuthProfileStore, formatReasoningMessage, getPreparedModelCatalogSnapshot, isProfileInCooldown, listAgentIds, loadPreparedModelCatalog, resolveAgentAvatar, resolveAgentDir, resolveDefaultModelForAgent, resolveHumanDelayConfig, resolveProfilesUnavailableReason } from "openclaw/plugin-sdk/agent-runtime";
+import { readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { resolveNativeCommandsEnabled, resolveNativeSkillsEnabled } from "openclaw/plugin-sdk/native-command-config-runtime";
 import { requestHeartbeat } from "openclaw/plugin-sdk/heartbeat-runtime";
-import { enqueueRoutedSystemEvent, enqueueRoutedSystemEvent as enqueueRoutedSystemEvent$1 } from "openclaw/plugin-sdk/system-event-runtime";
-import { deleteSessionEntry, getSessionEntry, listSessionEntries, readSessionUpdatedAt as readSessionUpdatedAt$1, resolveStorePath, resolveStorePath as resolveStorePath$1 } from "openclaw/plugin-sdk/session-store-runtime";
-import { captureHttpExchange, captureWsEvent, resolveDebugProxySettings, resolveEffectiveDebugProxyUrl } from "openclaw/plugin-sdk/proxy-capture";
+import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
+import { clearExpiredCooldowns, ensureAuthProfileStore, formatReasoningMessage, getPreparedModelCatalogSnapshot, isProfileInCooldown, listAgentIds, loadPreparedModelCatalog, resolveAgentAvatar, resolveAgentDir, resolveDefaultModelForAgent, resolveHumanDelayConfig, resolveProfilesUnavailableReason } from "openclaw/plugin-sdk/agent-runtime";
+import { deleteSessionEntry, getSessionEntry, listSessionEntries, readSessionUpdatedAt, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import * as proxyCaptureSdk from "openclaw/plugin-sdk/proxy-capture";
+import { resolveDebugProxySettings, resolveEffectiveDebugProxyUrl } from "openclaw/plugin-sdk/proxy-capture";
 import { resolveRequestUrl } from "openclaw/plugin-sdk/request-url";
 import { fetchWithRuntimeDispatcher } from "openclaw/plugin-sdk/runtime-fetch";
-import { Agent } from "undici";
 import * as dns from "node:dns";
 import { buildCommandTextFromArgs as buildCommandTextFromArgs$1, findCommandByNativeName as findCommandByNativeName$1, mergeNativeCommandSpecs, parseCommandArgs, resolveCommandArgChoices, resolveCommandArgMenu, serializeCommandArgs as serializeCommandArgs$1 } from "openclaw/plugin-sdk/native-command-registry";
 import { PLUGIN_COMMAND_DISPATCH } from "openclaw/plugin-sdk/plugin-command-runtime";
@@ -83,7 +83,7 @@ import { resolveDirectStatusReplyForSession } from "openclaw/plugin-sdk/command-
 import * as modelsProviderRuntime from "openclaw/plugin-sdk/models-provider-runtime";
 import { normalizeProviderId } from "openclaw/plugin-sdk/provider-model-shared";
 import { EventEmitter } from "node:events";
-import { Agent as Agent$1 } from "node:https";
+import { Agent } from "node:https";
 import { channelReadyPatch, createTransportActivityStatusPatch } from "openclaw/plugin-sdk/gateway-runtime";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
 import { stripPlainTextToolCallBlocks } from "openclaw/plugin-sdk/tool-payload";
@@ -382,7 +382,7 @@ function createDiscordDynamicAccessGroupResolver(params) {
 	};
 }
 function createDiscordIngressResolver(params) {
-	return createChannelIngressResolver({
+	return getDiscordRuntime().channel.inbound.ingress.createResolver({
 		channelId: DISCORD_CHANNEL_ID,
 		accountId: params.accountId,
 		identity: discordIngressIdentity,
@@ -529,22 +529,10 @@ async function runDiscordReactionHandler(initialParams) {
 		listener: params.listener,
 		event: params.event,
 		run: async () => handleDiscordReactionEvent({
+			...params.handlerParams,
 			data: params.data,
 			client: params.client,
-			action: params.action,
-			cfg: params.handlerParams.cfg,
-			isPolicyCurrent: params.handlerParams.isPolicyCurrent,
-			accountId: params.handlerParams.accountId,
-			botUserId: params.handlerParams.botUserId,
-			dmEnabled: params.handlerParams.dmEnabled,
-			groupDmEnabled: params.handlerParams.groupDmEnabled,
-			groupDmChannels: params.handlerParams.groupDmChannels,
-			dmPolicy: params.handlerParams.dmPolicy,
-			allowFrom: params.handlerParams.allowFrom,
-			groupPolicy: params.handlerParams.groupPolicy,
-			allowNameMatching: params.handlerParams.allowNameMatching,
-			guildEntries: params.handlerParams.guildEntries,
-			logger: params.handlerParams.logger
+			action: params.action
 		})
 	});
 }
@@ -626,51 +614,6 @@ async function authorizeDiscordReactionIngress(params) {
 	};
 	return { allowed: true };
 }
-async function handleDiscordThreadReactionNotification(params) {
-	if (params.reactionMode === "off") return;
-	if (params.reactionMode === "all" || params.reactionMode === "allowlist") {
-		const { access, channelConfig } = await params.resolveThreadChannelAccess();
-		if (!access.allowed || !params.shouldNotifyReaction({
-			mode: params.reactionMode,
-			channelConfig
-		})) return;
-		const { baseText } = params.resolveReactionBase();
-		params.emitReaction(baseText, params.parentId);
-		return;
-	}
-	const message = await params.message.fetch().catch(() => null);
-	const { access, channelConfig } = await params.resolveThreadChannelAccess();
-	const messageAuthorId = message?.author?.id ?? void 0;
-	if (!access.allowed || !params.shouldNotifyReaction({
-		mode: params.reactionMode,
-		messageAuthorId,
-		channelConfig
-	})) return;
-	params.emitReactionWithAuthor(message);
-}
-async function handleDiscordChannelReactionNotification(params) {
-	if (params.isGuildMessage) {
-		if (!(await params.authorizeReactionIngressForChannel(params.channelConfig)).allowed) return;
-	}
-	if (params.reactionMode === "off") return;
-	if (params.reactionMode === "all" || params.reactionMode === "allowlist") {
-		if (!params.shouldNotifyReaction({
-			mode: params.reactionMode,
-			channelConfig: params.channelConfig
-		})) return;
-		const { baseText } = params.resolveReactionBase();
-		params.emitReaction(baseText, params.parentId);
-		return;
-	}
-	const message = await params.message.fetch().catch(() => null);
-	const messageAuthorId = message?.author?.id ?? void 0;
-	if (!params.shouldNotifyReaction({
-		mode: params.reactionMode,
-		messageAuthorId,
-		channelConfig: params.channelConfig
-	})) return;
-	params.emitReactionWithAuthor(message);
-}
 function hasDiscordGuildChannelOverrides(guildInfo) {
 	return Boolean(guildInfo?.channels && Object.keys(guildInfo.channels).length > 0);
 }
@@ -758,57 +701,10 @@ async function handleDiscordReactionEvent(params) {
 		const parentId = isThreadChannel ? channelContext.threadParentId : channelContext.parentId;
 		const parentName = isThreadChannel ? channelContext.threadParentName : void 0;
 		const parentSlug = isThreadChannel ? channelContext.threadParentSlug : "";
-		let reactionBase = null;
-		const resolveReactionBase = () => {
-			if (reactionBase) return reactionBase;
-			const emojiLabel = formatDiscordReactionEmoji(data.emoji);
-			const actorLabel = formatDiscordUserTag(user) || user.id;
-			const guildSlug = guildInfo?.slug || (data.guild?.name ? normalizeDiscordSlug(data.guild.name) : data.guild_id ?? (isGroupDm ? "group-dm" : "dm"));
-			const channelLabel = channelSlug ? `#${channelSlug}` : channelName ? `#${normalizeDiscordSlug(channelName)}` : `#${data.channel_id}`;
-			reactionBase = {
-				baseText: `Discord ${data.burst ? "super " : ""}reaction ${action}: ${emojiLabel} by ${actorLabel} on ${guildSlug} ${channelLabel} msg ${data.message_id}`,
-				contextKey: `discord:reaction:${action}:${data.message_id}:${user.id}:${emojiLabel}${data.burst ? ":burst" : ""}`
-			};
-			return reactionBase;
-		};
-		const emitReaction = (text, parentPeerId) => {
-			const { contextKey } = resolveReactionBase();
-			const route = resolveAgentRoute({
-				cfg: params.cfg,
-				channel: "discord",
-				accountId: params.accountId,
-				guildId: data.guild_id ?? void 0,
-				memberRoleIds,
-				peer: {
-					kind: isDirectMessage ? "direct" : isGroupDm ? "group" : "channel",
-					id: isDirectMessage ? user.id : data.channel_id
-				},
-				parentPeer: parentPeerId ? {
-					kind: "channel",
-					id: parentPeerId
-				} : void 0
-			});
-			enqueueRoutedSystemEvent(text, route, { contextKey });
-		};
-		const shouldNotifyReaction = (options) => shouldEmitDiscordReactionNotification({
-			mode: options.mode,
-			botId: botUserId,
-			messageAuthorId: options.messageAuthorId,
-			userId: user.id,
-			userName: user.username,
-			userTag: formatDiscordUserTag(user),
-			channelConfig: options.channelConfig,
-			guildInfo,
-			memberRoleIds,
-			allowNameMatching: params.allowNameMatching
-		});
-		const emitReactionWithAuthor = (message) => {
-			const { baseText } = resolveReactionBase();
-			const authorLabel = message?.author ? formatDiscordUserTag(message.author) : void 0;
-			const text = authorLabel ? `${baseText} from ${authorLabel}` : baseText;
-			emitReaction(text, parentId);
-		};
-		const resolveThreadChannelConfig = () => resolveDiscordChannelConfigWithFallback({
+		if (isThreadChannel && reactionMode === "off") return;
+		let message = null;
+		if (isThreadChannel && reactionMode === "own") message = await data.message.fetch().catch(() => null);
+		const channelConfig = resolveDiscordChannelConfigWithFallback({
 			guildInfo,
 			channelId: data.channel_id,
 			channelName,
@@ -816,54 +712,51 @@ async function handleDiscordReactionEvent(params) {
 			parentId,
 			parentName,
 			parentSlug,
-			scope: "thread"
-		});
-		const authorizeReactionIngressForChannel = async (channelConfig) => await authorizeDiscordReactionIngress({
-			...reactionIngressBase,
-			channelConfig
+			scope: isThreadChannel ? "thread" : "channel"
 		});
-		const resolveThreadChannelAccess = async () => {
-			const channelConfig = resolveThreadChannelConfig();
-			return {
-				access: await authorizeReactionIngressForChannel(channelConfig),
+		if (isGuildMessage || isThreadChannel) {
+			if (!(await authorizeDiscordReactionIngress({
+				...reactionIngressBase,
 				channelConfig
-			};
-		};
-		if (isThreadChannel) {
-			await handleDiscordThreadReactionNotification({
-				reactionMode,
-				message: data.message,
-				parentId,
-				resolveThreadChannelAccess,
-				shouldNotifyReaction,
-				resolveReactionBase,
-				emitReaction,
-				emitReactionWithAuthor
-			});
-			return;
+			})).allowed) return;
 		}
-		const channelConfig = resolveDiscordChannelConfigWithFallback({
-			guildInfo,
-			channelId: data.channel_id,
-			channelName,
-			channelSlug,
-			parentId,
-			parentName,
-			parentSlug,
-			scope: "channel"
-		});
-		await handleDiscordChannelReactionNotification({
-			isGuildMessage,
-			reactionMode,
-			message: data.message,
+		if (!isThreadChannel && reactionMode === "own") message = await data.message.fetch().catch(() => null);
+		if (!shouldEmitDiscordReactionNotification({
+			mode: reactionMode,
+			botId: botUserId,
+			messageAuthorId: message?.author?.id,
+			userId: user.id,
+			userName: user.username,
+			userTag: formatDiscordUserTag(user),
 			channelConfig,
-			parentId,
-			authorizeReactionIngressForChannel,
-			shouldNotifyReaction,
-			resolveReactionBase,
-			emitReaction,
-			emitReactionWithAuthor
+			guildInfo,
+			memberRoleIds,
+			allowNameMatching: params.allowNameMatching
+		})) return;
+		const emojiLabel = formatDiscordReactionEmoji(data.emoji);
+		const actorLabel = formatDiscordUserTag(user) || user.id;
+		const guildSlug = guildInfo?.slug || (data.guild?.name ? normalizeDiscordSlug(data.guild.name) : data.guild_id ?? (isGroupDm ? "group-dm" : "dm"));
+		const channelLabel = channelSlug ? `#${channelSlug}` : channelName ? `#${normalizeDiscordSlug(channelName)}` : `#${data.channel_id}`;
+		const baseText = `Discord ${data.burst ? "super " : ""}reaction ${action}: ${emojiLabel} by ${actorLabel} on ${guildSlug} ${channelLabel} msg ${data.message_id}`;
+		const authorLabel = message?.author ? formatDiscordUserTag(message.author) : void 0;
+		const text = authorLabel ? `${baseText} from ${authorLabel}` : baseText;
+		const contextKey = `discord:reaction:${action}:${data.message_id}:${user.id}:${emojiLabel}${data.burst ? ":burst" : ""}`;
+		const route = resolveAgentRoute({
+			cfg: params.cfg,
+			channel: "discord",
+			accountId: params.accountId,
+			guildId: data.guild_id ?? void 0,
+			memberRoleIds,
+			peer: {
+				kind: isDirectMessage ? "direct" : isGroupDm ? "group" : "channel",
+				id: isDirectMessage ? user.id : data.channel_id
+			},
+			parentPeer: parentId ? {
+				kind: "channel",
+				id: parentId
+			} : void 0
 		});
+		enqueueRoutedSystemEvent(text, route, { contextKey });
 	} catch (err) {
 		params.logger.error(danger(`discord reaction handler failed: ${String(err)}`));
 	}
@@ -899,7 +792,7 @@ var DiscordInteractionListener = class extends InteractionCreateListener {
 	}
 	async handle(data, client) {
 		this.onEvent?.();
-		Promise.resolve().then(() => client.handleInteraction(data, {})).catch((err) => {
+		Promise.resolve().then(() => client.handleInteraction(data)).catch((err) => {
 			(this.logger ?? discordEventQueueLog).error(danger(`discord interaction handler failed: ${String(err)}`));
 		});
 	}
@@ -1254,7 +1147,7 @@ var DiscordThreadDeleteListener = class extends ThreadDeleteListener {
 			event: this.type,
 			run: async () => {
 				const threadId = data.id;
-				getThreadBindingManager(this.accountId)?.unbindThread({
+				await getThreadBindingManager(this.accountId)?.unbindThread({
 					threadId,
 					reason: "thread-delete",
 					sendFarewell: false
@@ -1276,14 +1169,12 @@ var DiscordThreadDeleteListener = class extends ThreadDeleteListener {
 };
 //#endregion
 //#region extensions/discord/src/internal/gateway-dispatch.ts
-function dispatchVoiceGatewayEvent(client, type, data) {
-	const guildId = readGuildId(data);
+function dispatchVoiceGatewayEvent(client, payload) {
+	const guildId = readGuildId(payload.d);
 	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);
+	if (payload.t === GatewayDispatchEvents.VoiceServerUpdate) adapter?.onVoiceServerUpdate?.(payload.d);
+	if (payload.t === GatewayDispatchEvents.VoiceStateUpdate) adapter?.onVoiceStateUpdate?.(payload.d);
 }
 function mapGatewayDispatchData(client, type, data) {
 	const messageCreate = GatewayDispatchEvents.MessageCreate;
@@ -1514,10 +1405,8 @@ async function resolveAllowFromByUserAllowlist(params) {
 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);
+		for (const channel of Object.values(guild.channels ?? {})) addAllowlistUserEntriesFromConfigEntry(userEntries, channel);
 	}
 	return userEntries;
 }
@@ -1534,15 +1423,13 @@ async function resolveGuildEntriesByUserAllowlist(params) {
 			formatResolved: formatDiscordUserResolved,
 			formatUnresolved: formatDiscordUserUnresolved
 		});
-		const nextGuilds = { ...params.guildEntries };
-		for (const [guildKey, guildConfig] of Object.entries(params.guildEntries)) {
-			if (!guildConfig || typeof guildConfig !== "object") continue;
+		const nextGuilds = patchAllowlistUsersInConfigEntries({
+			entries: params.guildEntries,
+			resolvedMap,
+			strategy: "canonicalize"
+		});
+		for (const [guildKey, guildConfig] of Object.entries(nextGuilds)) {
 			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,
@@ -1602,7 +1489,7 @@ function isDiscordTransportHostname(hostname) {
 	return DISCORD_DNS_HOSTS.some((target) => normalized === target || normalized.endsWith(`.${target}`));
 }
 function reorderLookupAddresses(addresses) {
-	if (!Array.isArray(addresses) || addresses.length < 2) return addresses;
+	if (addresses.length < 2) return addresses;
 	const ipv4 = addresses.filter((entry) => entry.family === 4);
 	const ipv6 = addresses.filter((entry) => entry.family === 6);
 	if (ipv4.length === 0) return ipv6;
@@ -1655,13 +1542,9 @@ function createDiscordEndpointDnsLookup(endpointHostname) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/rest-fetch.ts
+const captureSdk$2 = proxyCaptureSdk;
+const fetchSdk = fetchRuntimeSdk;
 const discordDnsLookup$1 = createDiscordDnsLookup();
-function createDirectDiscordRestDispatcher() {
-	return new Agent({
-		allowH2: false,
-		connect: { lookup: discordDnsLookup$1 }
-	});
-}
 function createEnvProxyDiscordRestDispatcher(runtime) {
 	const envProxyOptions = resolveEnvHttpProxyAgentOptions();
 	if (!envProxyOptions) return;
@@ -1680,7 +1563,7 @@ function createDiscordRestFetchWithDispatcher(dispatcher) {
 		...init,
 		dispatcher
 	}).then((response) => {
-		captureHttpExchange({
+		captureSdk$2.captureHttpExchangeAsync?.({
 			url: resolveRequestUrl(input),
 			method: init?.method ?? "GET",
 			requestHeaders: init?.headers,
@@ -1688,7 +1571,7 @@ function createDiscordRestFetchWithDispatcher(dispatcher) {
 			response,
 			flowId: randomUUID(),
 			meta: { subsystem: "discord-rest" }
-		});
+		}).catch(() => {});
 		return response;
 	})));
 }
@@ -1700,7 +1583,12 @@ function resolveDiscordRestFetch(proxyUrl, runtime) {
 		runtime.log?.("discord: rest proxy enabled");
 		return fetcher;
 	}
-	return createDiscordRestFetchWithDispatcher(createEnvProxyDiscordRestDispatcher(runtime) ?? createDirectDiscordRestDispatcher());
+	return createDiscordRestFetchWithDispatcher(createEnvProxyDiscordRestDispatcher(runtime) ?? fetchSdk.createHttp1Agent?.({ connect: { lookup: discordDnsLookup$1 } }) ?? createHttp1EnvHttpProxyAgent({
+		httpProxy: "",
+		httpsProxy: "",
+		noProxy: "*",
+		connect: { lookup: discordDnsLookup$1 }
+	}));
 }
 //#endregion
 //#region extensions/discord/src/monitor/live-policy.ts
@@ -1848,6 +1736,13 @@ async function readDiscordInteractionPolicy(readPolicy) {
 //#endregion
 //#region extensions/discord/src/monitor/native-command-reply.ts
 const DISCORD_EMPTY_VISIBLE_REPLY_WARNING = "⚠️ Command produced no visible reply.";
+function resolveDiscordInteractionReplyOptions(params) {
+	return {
+		textLimit: resolveTextChunkLimit(params.cfg, "discord", params.accountId, { fallbackLimit: 2e3 }),
+		maxLinesPerMessage: resolveDiscordMaxLinesPerMessage(params),
+		chunkMode: resolveChunkMode(params.cfg, "discord", params.accountId)
+	};
+}
 function isDiscordUnknownInteraction(error) {
 	if (!error || typeof error !== "object") return false;
 	const err = error;
@@ -1937,55 +1832,33 @@ async function deliverDiscordInteractionReply(params) {
 		if (!payloadDelivered) throw expiry;
 		throw createChannelPartialDeliveryError(expiry, { visibleReplySent: true });
 	};
-	if (reply.hasMedia) {
-		const media = await Promise.all(reply.mediaUrls.map(async (url) => {
-			const loaded = await loadWebMedia(url, { localRoots: params.mediaLocalRoots });
-			return {
-				name: loaded.fileName ?? "upload",
-				data: loaded.buffer,
-				contentType: loaded.contentType
-			};
-		}));
-		const chunks = resolveTextChunksWithFallback(reply.text, chunkDiscordTextWithMode(reply.text, {
-			maxChars: textLimit,
-			maxLines: maxLinesPerMessage,
-			chunkMode
-		}));
-		await sendMessage(chunks[0] ?? "", media, firstMessageComponents, firstMessageEmbeds);
-		for (const chunk of chunks.slice(1)) {
-			if (!chunk.trim()) continue;
-			await sendMessage(chunk);
-		}
-		return payloadDelivered;
-	}
-	if (!reply.hasText && !firstMessageComponents && !firstMessageEmbeds) return false;
+	const files = reply.hasMedia ? await Promise.all(reply.mediaUrls.map(async (url) => {
+		const loaded = await loadWebMedia(url, { localRoots: params.mediaLocalRoots });
+		return {
+			name: loaded.fileName ?? "upload",
+			data: loaded.buffer,
+			contentType: loaded.contentType
+		};
+	})) : void 0;
+	if (!files && !reply.hasText && !firstMessageComponents && !firstMessageEmbeds) return false;
 	const chunks = resolveTextChunksWithFallback(reply.text, chunkDiscordTextWithMode(reply.text, {
 		maxChars: textLimit,
 		maxLines: maxLinesPerMessage,
 		chunkMode
 	}));
 	if (chunks.length === 0) chunks.push("");
-	for (const chunk of chunks) {
-		if (!chunk.trim() && !firstMessageComponents && !firstMessageEmbeds) continue;
-		await sendMessage(chunk, void 0, firstMessageComponents, firstMessageEmbeds);
+	for (const [index, chunk] of chunks.entries()) {
+		const chunkFiles = index === 0 ? files : void 0;
+		if (!chunk.trim() && !chunkFiles && !firstMessageComponents && !firstMessageEmbeds) continue;
+		await sendMessage(chunk, chunkFiles, firstMessageComponents, firstMessageEmbeds);
 	}
 	return payloadDelivered;
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-command-route.ts
-async function resolveDiscordNativeInteractionRouteState(params) {
-	const route = resolveDiscordBoundConversationRoute({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		guildId: params.guildId,
-		memberRoleIds: params.memberRoleIds,
-		isDirectMessage: params.isDirectMessage,
-		isGroupDm: params.isGroupDm,
-		directUserId: params.directUserId,
-		conversationId: params.conversationId,
-		parentConversationId: params.parentConversationId
-	});
-	const configuredRoute = params.threadBinding == null ? conversationRuntime.resolveConfiguredBindingRoute({
+function resolveDiscordNativeInteractionRouteState(params) {
+	const route = resolveDiscordBoundConversationRoute(params);
+	const configuredRoute = params.threadBinding == null ? resolveConfiguredBindingRoute({
 		cfg: params.cfg,
 		route,
 		conversation: {
@@ -2008,17 +1881,14 @@ async function resolveDiscordNativeInteractionRouteState(params) {
 		}),
 		boundSessionKey,
 		configuredRoute,
-		configuredBinding,
-		bindingReadiness: params.enforceConfiguredBindingReadiness && configuredBinding ? await conversationRuntime.ensureConfiguredBindingRouteReady({
-			cfg: params.cfg,
-			bindingResolution: configuredBinding
-		}) : null
+		configuredBinding
 	};
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-command.runtime.ts
 const nativeCommandRuntime = {
 	dispatchChannelInboundTurn,
+	ensureConfiguredBindingRouteReady,
 	resolveDirectStatusReplyForSession,
 	resolveDiscordNativeInteractionRouteState,
 	getSessionEntry
@@ -2055,15 +1925,9 @@ async function dispatchDiscordNativeAgentReply(params) {
 						sessionKey: params.ctxPayload.CommandTargetSessionKey ?? params.effectiveRoute.sessionKey
 					},
 					mediaLocalRoots: params.mediaLocalRoots,
-					textLimit: resolveTextChunkLimit(params.cfg, "discord", params.accountId, { fallbackLimit: 2e3 }),
-					maxLinesPerMessage: resolveDiscordMaxLinesPerMessage({
-						cfg: params.cfg,
-						discordConfig: params.discordConfig,
-						accountId: params.accountId
-					}),
+					...resolveDiscordInteractionReplyOptions(params),
 					preferFollowUp: params.preferFollowUp || didReply,
-					responseEphemeral: params.responseEphemeral,
-					chunkMode: resolveChunkMode(params.cfg, "discord", params.accountId)
+					responseEphemeral: params.responseEphemeral
 				});
 				didReply ||= payloadDelivered;
 				return payloadDelivered ? { visibleReplySent: true } : {
@@ -2109,11 +1973,7 @@ async function dispatchDiscordNativeAgentReply(params) {
 			content: DISCORD_EMPTY_VISIBLE_REPLY_WARNING,
 			ephemeral: true
 		};
-		if (params.preferFollowUp) {
-			await params.interaction.followUp(payload);
-			return;
-		}
-		await params.interaction.reply(payload);
+		await params.interaction[params.preferFollowUp ? "followUp" : "reply"](payload);
 	});
 	return dispatchResult;
 }
@@ -2125,9 +1985,6 @@ function resolveDiscordSlashCommandConfig(raw) {
 //#endregion
 //#region extensions/discord/src/monitor/native-command-arg-ui.ts
 const DISCORD_COMMAND_ARG_CUSTOM_ID_KEY = "cmdarg";
-function createCommandArgsWithValue(params) {
-	return { values: { [params.argName]: params.value } };
-}
 function buildDiscordCommandArgCustomId(params) {
 	return [
 		`${DISCORD_COMMAND_ARG_CUSTOM_ID_KEY}:command=${encodeCustomIdComponent(params.command)}`,
@@ -2172,45 +2029,33 @@ async function handleDiscordCommandArgInteraction(params) {
 		return;
 	}
 	if (await clearWithMessage(`⏳ Applying ${parsed.value}...`) === null) return;
-	const commandArgs = createCommandArgsWithValue({
-		argName: parsed.arg,
-		value: parsed.value
-	});
+	const commandArgs = { values: { [parsed.arg]: parsed.value } };
 	const commandArgsWithRaw = {
 		...commandArgs,
 		raw: serializeCommandArgs(commandDefinition, commandArgs)
 	};
 	const prompt = buildCommandTextFromArgs(commandDefinition, commandArgsWithRaw);
 	await params.dispatchCommandInteraction({
-		readPolicy: ctx.readPolicy,
+		...ctx,
 		interaction,
 		prompt,
 		command: commandDefinition,
 		commandArgs: commandArgsWithRaw,
-		cfg: ctx.cfg,
-		discordConfig: ctx.discordConfig,
-		accountId: ctx.accountId,
-		sessionPrefix: ctx.sessionPrefix,
 		preferFollowUp: true,
-		threadBindings: ctx.threadBindings,
 		responseEphemeral: resolveDiscordSlashCommandConfig(ctx.discordConfig?.slashCommand).ephemeral,
-		dispatchReplyFromConfig: ctx.dispatchReplyFromConfig,
 		pluginCommandDispatch: { kind: "non-plugin" }
 	});
 }
-async function runDiscordCommandArgButton(params) {
-	await handleDiscordCommandArgInteraction(params);
-}
 var DiscordCommandArgButton = class extends Button {
 	constructor(params) {
 		super();
-		this.style = ButtonStyle.Secondary;
+		this.params = params;
 		this.label = params.label;
 		this.customId = params.customId;
-		this.params = params;
+		this.style = params.style ?? ButtonStyle.Secondary;
 	}
 	async run(interaction, data) {
-		await runDiscordCommandArgButton({
+		await handleDiscordCommandArgInteraction({
 			...this.params,
 			interaction,
 			data
@@ -2244,23 +2089,205 @@ function buildDiscordCommandArgMenu(params) {
 		components: rows
 	};
 }
-var DiscordCommandArgFallbackButton = class extends Button {
-	constructor(params) {
-		super();
-		this.params = params;
-		this.label = "cmdarg";
-		this.customId = "cmdarg:seed=1";
-	}
-	async run(interaction, data) {
-		await runDiscordCommandArgButton({
-			...this.params,
-			interaction,
-			data
-		});
-	}
-};
 function createDiscordCommandArgFallbackButton$1(params) {
-	return new DiscordCommandArgFallbackButton(params);
+	return new DiscordCommandArgButton({
+		...params,
+		label: "cmdarg",
+		customId: "cmdarg:seed=1",
+		style: ButtonStyle.Primary
+	});
+}
+//#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) => {
+		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
+			})
+		});
+	};
+}
+function buildDiscordGroupSystemPrompt(channelConfig) {
+	return channelConfig?.systemPrompt?.trim() || void 0;
+}
+function buildDiscordChannelStructuredContext(params) {
+	if (!params.isGuild || typeof params.channelTopic !== "string" || !params.channelTopic.trim()) return;
+	return [{
+		label: "Discord channel metadata",
+		source: "discord",
+		type: "channel_metadata",
+		payload: { topic: params.channelTopic.trim() }
+	}];
+}
+function buildDiscordInboundAccessContext(params) {
+	return {
+		groupSystemPrompt: params.isGuild ? buildDiscordGroupSystemPrompt(params.channelConfig) : void 0,
+		channelStructuredContext: buildDiscordChannelStructuredContext({
+			isGuild: params.isGuild,
+			channelTopic: params.channelTopic
+		}),
+		ownerAllowFrom: resolveDiscordOwnerAllowFrom({
+			channelConfig: params.channelConfig,
+			guildInfo: params.guildInfo,
+			sender: params.sender,
+			allowNameMatching: params.allowNameMatching
+		})
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/native-command-context.ts
+async function buildDiscordNativeCommandContext(params) {
+	const conversationLabel = params.isDirectMessage ? params.user.globalName ?? params.user.username : params.channelId;
+	const { groupSystemPrompt, ownerAllowFrom, channelStructuredContext } = buildDiscordInboundAccessContext({
+		channelConfig: params.channelConfig,
+		guildInfo: params.guildInfo,
+		sender: params.sender,
+		allowNameMatching: params.allowNameMatching,
+		isGuild: params.isGuild,
+		channelTopic: params.channelTopic
+	});
+	const conversation = {
+		kind: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
+		id: params.channelId,
+		parentId: params.isThreadChannel ? params.threadParentId : void 0,
+		threadId: params.isThreadChannel ? params.channelId : void 0
+	};
+	const allowFrom = params.commandAuthorized ? [`user:${params.user.id}`] : [];
+	const channelIngress = await getDiscordRuntime().channel.inbound.ingress.createResolver({
+		channelId: "discord",
+		accountId: params.accountId,
+		identity: discordIngressIdentity,
+		useDefaultPairingStore: false
+	}).command({
+		subject: {
+			stableId: params.user.id,
+			aliases: { participantKind: "user" }
+		},
+		conversation,
+		contextBinding: {
+			agentId: params.agentId,
+			sessionKey: params.sessionKey,
+			nativeChannelId: params.channelId,
+			messageId: params.interactionId,
+			inboundEventKind: "user_request"
+		},
+		event: {
+			kind: "native-command",
+			mayPair: false
+		},
+		dmPolicy: "allowlist",
+		groupPolicy: "allowlist",
+		allowFrom,
+		groupAllowFrom: allowFrom,
+		command: { modeWhenAccessGroupsOff: "configured" }
+	});
+	return await (params.buildContext ?? buildChannelInboundEventContext)({
+		channel: "discord",
+		channelIngress,
+		accountId: params.accountId,
+		messageId: params.interactionId,
+		timestamp: params.timestampMs ?? Date.now(),
+		from: params.isDirectMessage ? `discord:${params.user.id}` : params.isGroupDm ? `discord:group:${params.channelId}` : `discord:channel:${params.channelId}`,
+		sender: {
+			id: params.user.id,
+			name: params.user.globalName ?? params.user.username,
+			username: params.user.username,
+			tag: params.sender.tag,
+			roles: params.memberRoleIds
+		},
+		conversation: {
+			...conversation,
+			nativeChannelId: params.channelId,
+			routePeer: buildDiscordRoutePeer({
+				isDirectMessage: params.isDirectMessage,
+				isGroupDm: params.isGroupDm,
+				directUserId: params.user.id,
+				conversationId: params.channelId
+			}),
+			label: conversationLabel,
+			spaceId: params.isGuild ? params.guildInfo?.id ?? params.guildInfo?.slug ?? params.guildId : void 0
+		},
+		route: {
+			agentId: params.agentId,
+			accountId: params.accountId,
+			routeSessionKey: params.commandTargetSessionKey,
+			dispatchSessionKey: params.sessionKey
+		},
+		reply: {
+			to: `slash:${params.user.id}`,
+			originatingTo: resolveDiscordConversationIdentity({
+				isDirectMessage: params.isDirectMessage,
+				userId: params.user.id,
+				channelId: params.channelId
+			}) ?? (params.isDirectMessage ? `user:${params.user.id}` : `channel:${params.channelId}`)
+		},
+		message: { rawBody: params.prompt },
+		access: {
+			mentions: {
+				canDetectMention: true,
+				wasMentioned: true
+			},
+			commands: { authorized: params.commandAuthorized }
+		},
+		commandTurn: {
+			kind: "native",
+			source: "native",
+			authorized: params.commandAuthorized,
+			body: params.prompt
+		},
+		supplemental: { groupSystemPrompt },
+		extra: {
+			CommandArgs: params.commandArgs,
+			CommandTargetSessionKey: params.commandTargetSessionKey,
+			CommandSource: "native",
+			GroupSubject: params.isGuild ? params.guildName : void 0,
+			ChannelStructuredContext: channelStructuredContext,
+			OwnerAllowFrom: ownerAllowFrom
+		}
+	});
+}
+async function buildDiscordNativeInteractionContext(params) {
+	const { interaction, route, boundSessionKey, sessionPrefix, channelContext, ...context } = params;
+	const targets = resolveNativeCommandSessionTargets({
+		agentId: route.agentId,
+		sessionPrefix,
+		userId: context.user.id,
+		targetSessionKey: route.sessionKey,
+		boundSessionKey
+	});
+	return {
+		ctxPayload: await buildDiscordNativeCommandContext({
+			...context,
+			...targets,
+			agentId: route.agentId,
+			accountId: route.accountId,
+			interactionId: interaction.rawData.id,
+			channelId: channelContext.rawChannelId || "unknown",
+			threadParentId: channelContext.threadParentId,
+			memberRoleIds: Array.isArray(interaction.rawData.member?.roles) ? interaction.rawData.member.roles : [],
+			guildId: interaction.guild?.id,
+			guildName: interaction.guild?.name,
+			channelTopic: resolveDiscordChannelTopicSafe(interaction.channel),
+			isGuild: Boolean(interaction.guild),
+			isDirectMessage: channelContext.isDirectMessage,
+			isGroupDm: channelContext.isGroupDm,
+			isThreadChannel: channelContext.isThreadChannel
+		}),
+		...targets
+	};
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-interaction-channel-context.ts
@@ -2286,6 +2313,60 @@ async function resolveDiscordNativeInteractionChannelContext(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-command-auth.ts
+function resolveDiscordNativePolicyReader(params) {
+	return params.readPolicy ?? createDiscordLivePolicyReader({
+		...params,
+		readConfig: () => getRuntimeConfigSnapshot() ?? params.cfg,
+		resolvedAllowlist: {
+			guildEntries: params.discordConfig?.guilds,
+			allowFrom: params.discordConfig?.allowFrom ?? resolveDiscordAccountAllowFrom(params)
+		}
+	});
+}
+function createDiscordNativeCommandAuthority(params) {
+	const assertAdmittedOwner = resolveCommandAuthorization(params).assertOwnerCurrent;
+	const readAuthorization = () => {
+		const cfg = getRuntimeConfigSnapshot() ?? params.cfg;
+		const owners = resolveDiscordCommandOwnerAllowFrom(cfg);
+		const senderIsOwner = params.isPolicyCurrent?.() !== false && (resolveDiscordOwnerAccess({
+			allowFrom: owners,
+			sender: params.sender,
+			allowNameMatching: params.allowNameMatching
+		}).ownerAllowed || resolveCommandAuthorization({
+			...params,
+			cfg
+		}).senderIsOwner);
+		const commands = resolveDiscordNativeCommandAllowlistAccess({
+			cfg,
+			sender: params.sender,
+			guildId: params.guildId
+		});
+		return {
+			senderIsOwner,
+			allowed: (!commands.configured || commands.allowed) && (!owners || owners.includes("*") || senderIsOwner || commands.allowed || params.commandName === "status" || params.pluginCommand)
+		};
+	};
+	const assertActive = () => {
+		assertAdmittedOwner?.();
+		if (params.isPolicyCurrent?.() === false || !readAuthorization().allowed) throw new Error("Discord command authority changed; send a new request.");
+	};
+	return {
+		assertActive,
+		assertOwnerCurrent: () => {
+			assertActive();
+			if (!readAuthorization().senderIsOwner) throw new Error("Discord owner authority changed; send a new request.");
+		},
+		senderIsOwner: () => readAuthorization().senderIsOwner,
+		isAllowed: () => {
+			try {
+				assertActive();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+	};
+}
 function resolveDiscordNativeCommandAllowlistAccess(params) {
 	const commandsAllowFrom = params.cfg.commands?.allowFrom;
 	if (!commandsAllowFrom || typeof commandsAllowFrom !== "object") return {
@@ -2327,10 +2408,7 @@ function resolveDiscordNativeCommandChannelAccessContext(params) {
 	const guild = params.guild ?? null;
 	const commandsAllowFromAccess = resolveDiscordNativeCommandAllowlistAccess({
 		cfg: params.cfg,
-		accountId: params.accountId,
 		sender: params.sender,
-		chatType: params.isDirectMessage ? "direct" : params.isThreadChannel ? "thread" : guild ? "channel" : "group",
-		conversationId: params.rawChannelId || void 0,
 		guildId: guild?.id
 	});
 	const guildInfo = resolveDiscordGuildEntry({
@@ -2372,10 +2450,6 @@ async function resolveDiscordGuildNativeCommandAuthorized(params) {
 		sender: params.sender,
 		allowNameMatching: params.allowNameMatching
 	});
-	const commandAllowlistAuthorizer = {
-		configured: params.commandsAllowFromAccess.configured,
-		allowed: params.commandsAllowFromAccess.allowed
-	};
 	const ownerAuthorizer = {
 		configured: params.ownerAllowListConfigured,
 		allowed: params.ownerAllowed
@@ -2393,9 +2467,9 @@ async function resolveDiscordGuildNativeCommandAuthorized(params) {
 		ownerAuthorizer,
 		memberAuthorizer
 	];
-	const authorizers = params.commandsAllowFromAccess.configured ? [commandAllowlistAuthorizer] : fallbackAuthorizers;
+	const authorizers = params.commandsAllowFromAccess.configured ? [params.commandsAllowFromAccess] : fallbackAuthorizers;
 	return resolveCommandAuthorizedFromAuthorizers({
-		useAccessGroups: params.useAccessGroups,
+		useAccessGroups: true,
 		authorizers,
 		modeWhenAccessGroupsOff: "configured"
 	});
@@ -2425,43 +2499,31 @@ async function resolveDiscordNativeAutocompleteAuthorized(params) {
 		author: user,
 		pluralkitInfo: null
 	});
-	const { isDirectMessage, isGroupDm, isThreadChannel, channelName, channelSlug, rawChannelId, threadParentId, threadParentName, threadParentSlug } = await resolveDiscordNativeInteractionChannelContext({
+	const channelContext = await resolveDiscordNativeInteractionChannelContext({
 		channel: interaction.channel,
 		client: interaction.client,
 		hasGuild: Boolean(interaction.guild),
 		channelIdFallback: interaction.rawData.channel_id ?? ""
 	});
+	const { isDirectMessage, isGroupDm, isThreadChannel, channelName, channelSlug, rawChannelId, threadParentId } = channelContext;
 	if (params.isPolicyCurrent?.() === false) return false;
 	const memberRoleIds = Array.isArray(interaction.rawData.member?.roles) ? interaction.rawData.member.roles.map((roleId) => roleId) : [];
 	const allowNameMatching = isDangerousNameMatchingEnabled(discordConfig);
-	const useAccessGroups = true;
 	const configuredDmAllowFrom = resolveDiscordAccountAllowFrom({
 		cfg,
 		accountId
 	}) ?? [];
 	const { ownerAllowList, ownerAllowed: ownerOk } = resolveDiscordOwnerAccess({
 		allowFrom: configuredDmAllowFrom,
-		sender: {
-			id: sender.id,
-			name: sender.name,
-			tag: sender.tag
-		},
+		sender,
 		allowNameMatching
 	});
 	const { commandsAllowFromAccess, guildInfo, channelConfig } = resolveDiscordNativeCommandChannelAccessContext({
 		cfg,
 		discordConfig,
-		accountId,
 		sender,
-		isDirectMessage,
-		isThreadChannel,
-		guild: interaction.guild ?? null,
-		rawChannelId,
-		channelName,
-		channelSlug,
-		threadParentId,
-		threadParentName,
-		threadParentSlug
+		...channelContext,
+		guild: interaction.guild ?? null
 	});
 	if (channelConfig?.enabled === false) return false;
 	if (interaction.guild && channelConfig?.allowed === false) return false;
@@ -2488,11 +2550,7 @@ async function resolveDiscordNativeAutocompleteAuthorized(params) {
 			accountId,
 			dmPolicy,
 			configuredAllowFrom: configuredDmAllowFrom,
-			sender: {
-				id: sender.id,
-				name: sender.name,
-				tag: sender.tag
-			},
+			sender,
 			allowNameMatching,
 			cfg,
 			rest: interaction.client.rest
@@ -2507,162 +2565,73 @@ async function resolveDiscordNativeAutocompleteAuthorized(params) {
 		channelName,
 		channelSlug
 	}).allowed) return false;
-	if (params.skipCommandOwnerAllowFrom !== true) {
-		const commandOwnerAllowFrom = resolveDiscordCommandOwnerAllowFrom(cfg);
-		const { ownerAllowed: commandOwnerOk } = resolveDiscordOwnerAccess({
-			allowFrom: commandOwnerAllowFrom,
-			sender: {
-				id: sender.id,
-				name: sender.name,
-				tag: sender.tag
-			},
-			allowNameMatching
-		});
-		const commandOwnerAllowAll = commandOwnerAllowFrom?.includes("*") === true;
-		if (commandOwnerAllowFrom && !(commandOwnerOk || commandOwnerAllowAll) && !commandsAllowFromAccess.allowed) return false;
+	if (!isDirectMessage) {
+		if (!await resolveDiscordGuildNativeCommandAuthorized({
+			cfg,
+			discordConfig,
+			commandsAllowFromAccess,
+			guildInfo,
+			channelConfig,
+			memberRoleIds,
+			sender,
+			allowNameMatching,
+			ownerAllowListConfigured: ownerAllowList != null,
+			ownerAllowed: ownerOk
+		})) return false;
 	}
-	if (!isDirectMessage) return await resolveDiscordGuildNativeCommandAuthorized({
-		cfg,
-		accountId,
-		discordConfig,
-		useAccessGroups,
-		commandsAllowFromAccess,
-		guildInfo,
-		channelConfig,
-		memberRoleIds,
+	const commandOwnerAllowFrom = resolveDiscordCommandOwnerAllowFrom(cfg);
+	if (params.skipCommandOwnerAllowFrom !== true && commandOwnerAllowFrom && !commandOwnerAllowFrom.includes("*") && !commandsAllowFromAccess.allowed && !resolveDiscordOwnerAccess({
+		allowFrom: commandOwnerAllowFrom,
 		sender,
-		allowNameMatching,
-		ownerAllowListConfigured: ownerAllowList != null,
-		ownerAllowed: ownerOk
-	}) && params.isPolicyCurrent?.() !== false;
+		allowNameMatching
+	}).ownerAllowed) {
+		const routeState = resolveDiscordNativeInteractionRouteState({
+			cfg,
+			accountId,
+			guildId: interaction.guild?.id,
+			memberRoleIds,
+			isDirectMessage,
+			isGroupDm,
+			directUserId: user.id,
+			conversationId: rawChannelId,
+			parentConversationId: threadParentId,
+			threadBinding: isThreadChannel ? params.threadBindings?.getByThreadId(rawChannelId) : void 0
+		});
+		const { ctxPayload } = await buildDiscordNativeInteractionContext({
+			buildContext: params.buildContext,
+			interaction,
+			channelContext,
+			route: routeState.effectiveRoute,
+			boundSessionKey: routeState.boundSessionKey,
+			sessionPrefix: params.sessionPrefix ?? "discord:slash",
+			channelConfig,
+			guildInfo,
+			allowNameMatching,
+			commandAuthorized: true,
+			user,
+			sender,
+			prompt: "",
+			commandArgs: {}
+		});
+		if (!resolveCommandAuthorization({
+			ctx: ctxPayload,
+			cfg,
+			commandAuthorized: true
+		}).senderIsOwner) return false;
+	}
 	return params.isPolicyCurrent?.() !== false;
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-command-bypass.ts
 function shouldBypassConfiguredAcpEnsure(commandName) {
-	return commandName.trim().toLowerCase() === "acp";
+	const command = commandName.trim().toLowerCase();
+	return command === "acp" || command === "status";
 }
 function shouldBypassConfiguredAcpGuildGuards(commandName) {
 	const command = commandName.trim().toLowerCase();
 	return command === "new" || command === "reset";
 }
 //#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) => {
-		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
-			})
-		});
-	};
-}
-function buildDiscordGroupSystemPrompt(channelConfig) {
-	return channelConfig?.systemPrompt?.trim() || void 0;
-}
-function buildDiscordChannelStructuredContext(params) {
-	if (!params.isGuild) return;
-	const entries = [];
-	if (typeof params.channelTopic === "string" && params.channelTopic.trim().length > 0) entries.push({
-		label: "Discord channel metadata",
-		source: "discord",
-		type: "channel_metadata",
-		payload: { topic: params.channelTopic.trim() }
-	});
-	return entries.length > 0 ? entries : void 0;
-}
-function buildDiscordInboundAccessContext(params) {
-	return {
-		groupSystemPrompt: params.isGuild ? buildDiscordGroupSystemPrompt(params.channelConfig) : void 0,
-		channelStructuredContext: buildDiscordChannelStructuredContext({
-			isGuild: params.isGuild,
-			channelTopic: params.channelTopic
-		}),
-		ownerAllowFrom: resolveDiscordOwnerAllowFrom({
-			channelConfig: params.channelConfig,
-			guildInfo: params.guildInfo,
-			sender: params.sender,
-			allowNameMatching: params.allowNameMatching
-		})
-	};
-}
-//#endregion
-//#region extensions/discord/src/monitor/native-command-context.ts
-function buildDiscordNativeCommandContext(params) {
-	const conversationLabel = params.isDirectMessage ? params.user.globalName ?? params.user.username : params.channelId;
-	const { groupSystemPrompt, ownerAllowFrom, channelStructuredContext } = buildDiscordInboundAccessContext({
-		channelConfig: params.channelConfig,
-		guildInfo: params.guildInfo,
-		sender: params.sender,
-		allowNameMatching: params.allowNameMatching,
-		isGuild: params.isGuild,
-		channelTopic: params.channelTopic
-	});
-	return finalizeInboundContext({
-		Body: params.prompt,
-		BodyForAgent: params.prompt,
-		RawBody: params.prompt,
-		CommandBody: params.prompt,
-		CommandArgs: params.commandArgs,
-		From: params.isDirectMessage ? `discord:${params.user.id}` : params.isGroupDm ? `discord:group:${params.channelId}` : `discord:channel:${params.channelId}`,
-		To: `slash:${params.user.id}`,
-		SessionKey: params.sessionKey,
-		CommandTargetSessionKey: params.commandTargetSessionKey,
-		AccountId: params.accountId ?? void 0,
-		ChatType: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
-		...buildDiscordConversationRouteContext({
-			isDirectMessage: params.isDirectMessage,
-			isGroupDm: params.isGroupDm,
-			directUserId: params.user.id,
-			conversationId: params.channelId,
-			isThread: params.isThreadChannel,
-			parentConversationId: params.threadParentId
-		}),
-		ConversationLabel: conversationLabel,
-		GroupSubject: params.isGuild ? params.guildName : void 0,
-		GroupSpace: params.isGuild ? params.guildInfo?.id ?? params.guildInfo?.slug ?? params.guildId : void 0,
-		MemberRoleIds: params.memberRoleIds,
-		GroupSystemPrompt: groupSystemPrompt,
-		ChannelStructuredContext: channelStructuredContext,
-		OwnerAllowFrom: ownerAllowFrom,
-		SenderName: params.user.globalName ?? params.user.username,
-		SenderId: params.user.id,
-		SenderUsername: params.user.username,
-		SenderTag: params.sender.tag,
-		Provider: "discord",
-		Surface: "discord",
-		WasMentioned: true,
-		MessageSid: params.interactionId,
-		Timestamp: params.timestampMs ?? Date.now(),
-		CommandAuthorized: params.commandAuthorized,
-		CommandTurn: {
-			kind: "native",
-			source: "native",
-			authorized: params.commandAuthorized,
-			body: params.prompt
-		},
-		CommandSource: "native",
-		OriginatingChannel: "discord",
-		OriginatingTo: resolveDiscordConversationIdentity({
-			isDirectMessage: params.isDirectMessage,
-			userId: params.user.id,
-			channelId: params.channelId
-		}) ?? (params.isDirectMessage ? `user:${params.user.id}` : `channel:${params.channelId}`)
-	});
-}
-//#endregion
 //#region extensions/discord/src/monitor/model-picker-preferences.ts
 const DEFAULT_RECENT_LIMIT = 5;
 const PREFERENCE_MAX_ENTRIES = 2e3;
@@ -2675,14 +2644,11 @@ function openPreferenceStore(env) {
 		...env ? { env } : {}
 	});
 }
-function normalizeId(value) {
-	return normalizeOptionalString(value) ?? "";
-}
 function buildDiscordModelPickerPreferenceKey(scope) {
-	const userId = normalizeId(scope.userId);
+	const userId = normalizeOptionalString(scope.userId);
 	if (!userId) return null;
 	const accountId = normalizeAccountId(scope.accountId);
-	const guildId = normalizeId(scope.guildId);
+	const guildId = normalizeOptionalString(scope.guildId);
 	if (guildId) return `discord:${accountId}:guild:${guildId}:user:${userId}`;
 	return `discord:${accountId}:dm:user:${userId}`;
 }
@@ -2702,6 +2668,12 @@ function sanitizeStoredPreferenceEntry(value) {
 function timestampOrder(value) {
 	return value !== void 0 && value >= 0 ? value : 0;
 }
+function scopedPreferenceEntries(entries, scopeKey) {
+	return entries.map((entry) => ({
+		key: entry.key,
+		value: sanitizeStoredPreferenceEntry(entry.value)
+	})).filter((entry) => entry.value?.scopeKey === scopeKey);
+}
 function comparePreferenceEntries(left, right) {
 	return preferenceTimestampMs(right.value.updatedAt) - preferenceTimestampMs(left.value.updatedAt) || timestampOrder(right.value.updatedOrder) - timestampOrder(left.value.updatedOrder) || left.key.localeCompare(right.key);
 }
@@ -2720,10 +2692,7 @@ async function readDiscordModelPickerRecentModels(params) {
 	if (!key) return [];
 	const limit = Math.max(1, Math.min(params.limit ?? DEFAULT_RECENT_LIMIT, 10));
 	try {
-		const recent = (await openPreferenceStore(params.env).entries()).map((entry) => ({
-			key: entry.key,
-			value: sanitizeStoredPreferenceEntry(entry.value)
-		})).filter((entry) => entry.value?.scopeKey === key).toSorted(comparePreferenceEntries).map((entry) => entry.value.modelRef);
+		const recent = scopedPreferenceEntries(await openPreferenceStore(params.env).entries(), key).toSorted(comparePreferenceEntries).map((entry) => entry.value.modelRef);
 		if (!params.allowedModelRefs || params.allowedModelRefs.size === 0) return sanitizeRecentModels(recent, limit);
 		return sanitizeRecentModels(recent.filter((modelRef) => params.allowedModelRefs?.has(modelRef)), limit);
 	} catch {
@@ -2736,17 +2705,14 @@ async function recordDiscordModelPickerRecentModel(params) {
 	if (!key || !normalizedModelRef) return;
 	try {
 		const store = openPreferenceStore(params.env);
-		const timestamp = nextPreferenceTimestamp((await store.entries()).map((entry) => sanitizeStoredPreferenceEntry(entry.value)).filter((entry) => entry?.scopeKey === key));
+		const timestamp = nextPreferenceTimestamp(scopedPreferenceEntries(await store.entries(), key).map((entry) => entry.value));
 		await store.register(buildPreferenceModelKey(key, normalizedModelRef), {
 			scopeKey: key,
 			modelRef: normalizedModelRef,
 			...timestamp
 		});
 		const limit = Math.max(1, Math.min(params.limit ?? DEFAULT_RECENT_LIMIT, 10));
-		const scopedEntries = (await store.entries()).map((entry) => ({
-			key: entry.key,
-			value: sanitizeStoredPreferenceEntry(entry.value)
-		})).filter((entry) => entry.value?.scopeKey === key).toSorted(comparePreferenceEntries);
+		const scopedEntries = scopedPreferenceEntries(await store.entries(), key).toSorted(comparePreferenceEntries);
 		await Promise.all(scopedEntries.slice(limit).map((entry) => store.delete(entry.key)));
 	} catch {}
 }
@@ -2789,11 +2755,6 @@ const PICKER_VIEWS = [
 	"models",
 	"recents"
 ];
-/**
-* Alpha buckets engage only when the sorted item list exceeds the single-page
-* select cap. Below this threshold the user gets the existing flat list +
-* prev/next behavior unchanged.
-*/
 const DISCORD_MODEL_PICKER_BUCKET_THRESHOLD = DISCORD_COMPONENT_MAX_SELECT_OPTIONS;
 /** Target items per alpha bucket. Discord caps selects at 25 options. */
 const DISCORD_MODEL_PICKER_BUCKET_TARGET_SIZE = 20;
@@ -2815,9 +2776,7 @@ function isValidPickerView(value) {
 	return PICKER_VIEWS.includes(value);
 }
 function normalizeModelPickerPage(value) {
-	const numeric = typeof value === "number" ? value : NaN;
-	if (!Number.isFinite(numeric)) return 1;
-	return Math.max(1, Math.floor(numeric));
+	return normalizeOptionalModelPickerIndex(value) ?? 1;
 }
 function parseRawPage(value) {
 	if (typeof value === "number") return normalizeModelPickerPage(value);
@@ -2948,17 +2907,6 @@ function parseDiscordModelPickerData(data) {
 		...modelBucketRaw ? { modelBucket: modelBucketRaw } : {}
 	};
 }
-/**
-* Split a sorted item list into letter-range buckets when its length exceeds
-* {@link DISCORD_MODEL_PICKER_BUCKET_THRESHOLD}. Items below the threshold
-* return a single "All" bucket so callers can render the same code path.
-*
-* The boundary extender keeps items sharing the same starting letter inside
-* the same bucket — selecting "A–G" never strands a stray "g" item in the
-* next bucket. If every item shares a first letter (e.g. all `qwen3-*`),
-* the function falls back to count-based numeric chunks so the user still
-* gets a finite-cardinality picker.
-*/
 function computeAlphaBuckets(sortedItems) {
 	if (sortedItems.length === 0) return [];
 	if (sortedItems.length <= DISCORD_MODEL_PICKER_BUCKET_THRESHOLD) return [{
@@ -2993,16 +2941,8 @@ function computeAlphaBuckets(sortedItems) {
 	}
 	return buckets;
 }
-/**
-* Pick the per-bucket target size such that the resulting bucket count never
-* exceeds {@link DISCORD_COMPONENT_MAX_SELECT_OPTIONS} (Discord's hard select
-* cap). Stays at the default {@link DISCORD_MODEL_PICKER_BUCKET_TARGET_SIZE}
-* for typical inputs and grows linearly for very large lists.
-*/
 function computeBucketTargetSize(totalItems) {
-	const minTarget = DISCORD_MODEL_PICKER_BUCKET_TARGET_SIZE;
-	const capByBucketCount = Math.ceil(totalItems / DISCORD_COMPONENT_MAX_SELECT_OPTIONS);
-	return Math.max(minTarget, capByBucketCount);
+	return Math.max(DISCORD_MODEL_PICKER_BUCKET_TARGET_SIZE, Math.ceil(totalItems / DISCORD_COMPONENT_MAX_SELECT_OPTIONS));
 }
 function chunkBucketsByCount(sortedItems) {
 	const buckets = [];
@@ -3018,37 +2958,15 @@ function chunkBucketsByCount(sortedItems) {
 	}
 	return buckets;
 }
-/**
-* Resolve a bucket from a list given a (possibly user-supplied) bucket id.
-* Falls back to the first bucket when the id does not match — mirrors the
-* "bad customId → reset to defaults" semantics already used for other
-* state fields.
-*/
 function resolveBucket(buckets, id) {
-	if (buckets.length === 0) return null;
-	if (!id) return expectDefined(buckets.at(0), "non-empty model picker buckets");
-	return buckets.find((bucket) => bucket.id === id) ?? expectDefined(buckets.at(0), "non-empty model picker buckets");
+	return buckets.find((bucket) => bucket.id === id) ?? buckets[0] ?? null;
 }
-/**
-* Derive the alpha-bucket id that contains a given provider id. Returns
-* `undefined` when bucketing is inactive (all providers fit in one bucket)
-* or the provider is unknown. Used by the interaction handler to recompute
-* `providerBucket` at re-render time without forcing every customId to
-* carry the bucket field — the bucket is a pure function of the provider
-* list + provider id.
-*/
 function findProviderBucketId(data, provider) {
 	return findProviderBucketLocation(data, provider)?.bucket;
 }
 function findProviderBucketLocation(data, provider) {
 	return findModelPickerBucketLocation([...data.providers].toSorted(), normalizeProviderId(provider));
 }
-/**
-* Derive the alpha-bucket id that contains a given model id within the
-* named provider. Same rationale as {@link findProviderBucketId} — saves
-* customId budget by recomputing the bucket from the durable state
-* (provider + model) rather than carrying it as a parameter.
-*/
 function findModelBucketId(data, provider, model) {
 	const modelSet = data.byProvider.get(normalizeProviderId(provider));
 	return modelSet ? findModelPickerBucketLocation([...modelSet].toSorted(compareBucketItems), model)?.bucket : void 0;
@@ -3156,14 +3074,6 @@ function createModelSelect(params) {
 	}
 	return new DiscordModelPickerSelect();
 }
-/**
-* Build the alpha-bucket select row that appears above the provider/model
-* surface when the list exceeds {@link DISCORD_MODEL_PICKER_BUCKET_THRESHOLD}.
-*
-* Selecting a bucket emits action=bucket. The chosen bucket travels in the
-* select value, while the custom_id carries only the stable context needed to
-* rebuild the picker under Discord's 100-character custom_id limit.
-*/
 function buildBucketSelectRow(params) {
 	if (params.buckets.length <= 1) return null;
 	const options = params.buckets.map((bucket) => ({
@@ -3197,11 +3107,6 @@ function resolveExplicitRuntimeState(params) {
 	const runtime = params.pendingRuntime?.trim() || params.currentRuntime?.trim();
 	return runtime && runtime !== "auto" && runtime !== "default" ? runtime : void 0;
 }
-function resolveSelectedRuntime(params) {
-	const choices = getRuntimeChoices(params);
-	const explicit = resolveExplicitRuntimeState(params);
-	return explicit ? choices?.find((choice) => choice.id === explicit)?.id : choices?.[0]?.id;
-}
 function getActiveBucketId(bucket) {
 	return bucket && bucket.id !== "all" ? bucket.id : void 0;
 }
@@ -3237,18 +3142,18 @@ function buildRenderedShell(params) {
 	return { components: [new Container(containerComponents)] };
 }
 function buildProviderSelectRow(params) {
-	if (params.page.items.length === 0) return null;
 	const options = params.page.items.map((provider) => ({
 		label: provider.id,
 		value: provider.id,
 		default: provider.id === params.currentProvider,
-		description: `${provider.count} ${provider.count === 1 ? "model" : "models"}`
+		...params.showModelCounts ? { description: `${provider.count} ${provider.count === 1 ? "model" : "models"}` } : {}
 	}));
 	return new Row([createModelSelect({
 		customId: buildDiscordModelPickerCustomId({
 			command: params.command,
 			action: "provider",
 			view: "models",
+			provider: params.provider,
 			page: params.page.page,
 			providerPage: params.page.page,
 			providerBucket: params.providerBucket,
@@ -3292,40 +3197,27 @@ function buildModelRows(params) {
 		page: params.providerPage,
 		bucket: params.providerBucket
 	});
-	const providerOptions = providerPage.items.map((provider) => ({
-		label: provider.id,
-		value: provider.id,
-		default: provider.id === params.modelPage.provider
-	}));
 	const activeProviderBucket = getActiveBucketId(providerPage.bucket);
 	const activeModelBucket = getActiveBucketId(params.modelPage.bucket);
-	if (!((params.modelPage.buckets?.length ?? 0) > 1)) rows.push(new Row([createModelSelect({
-		customId: buildDiscordModelPickerCustomId({
-			command: params.command,
-			action: "provider",
-			view: "models",
-			provider: params.modelPage.provider,
-			page: providerPage.page,
-			providerPage: providerPage.page,
-			providerBucket: activeProviderBucket,
-			userId: params.userId
-		}),
-		options: providerOptions,
-		placeholder: "Select provider"
-	})]));
+	if (!((params.modelPage.buckets?.length ?? 0) > 1)) rows.push(buildProviderSelectRow({
+		command: params.command,
+		userId: params.userId,
+		page: providerPage,
+		provider: params.modelPage.provider,
+		currentProvider: params.modelPage.provider,
+		providerBucket: activeProviderBucket
+	}));
 	const runtimeChoices = getRuntimeChoices({
 		data: params.data,
 		provider: params.modelPage.provider,
 		modelRef: params.pendingModel ?? params.currentModel
 	});
 	const currentRuntime = parsedCurrentModel?.provider === params.modelPage.provider ? params.currentRuntime : void 0;
-	const selectedRuntime = resolveSelectedRuntime({
-		data: params.data,
-		provider: params.modelPage.provider,
-		modelRef: params.pendingModel ?? params.currentModel,
+	const explicitRuntime = resolveExplicitRuntimeState({
 		currentRuntime,
 		pendingRuntime: params.pendingRuntime
 	});
+	const selectedRuntime = explicitRuntime ? runtimeChoices?.find((choice) => choice.id === explicitRuntime)?.id : runtimeChoices?.[0]?.id;
 	const compactRuntime = resolveCompactRuntimeState({
 		currentRuntime,
 		pendingRuntime: params.pendingRuntime
@@ -3387,7 +3279,7 @@ function buildModelRows(params) {
 		providerPage: providerPage.page,
 		modelIndex: params.pendingModelIndex,
 		modelToken: pendingModelToken,
-		modelBucket: params.modelPage.bucket && params.modelPage.bucket.id !== "all" ? params.modelPage.bucket.id : void 0
+		modelBucket: activeModelBucket
 	});
 	if (modelNavRow) rows.push(modelNavRow);
 	const resolvedDefault = params.data.resolvedDefault;
@@ -3454,7 +3346,9 @@ function buildModelRows(params) {
 	}));
 	return {
 		rows,
-		buttonRow: new Row(buttonRowItems)
+		buttonRow: new Row(buttonRowItems),
+		runtimeChoices,
+		selectedRuntime
 	};
 }
 function renderDiscordModelPickerProvidersView(params) {
@@ -3473,15 +3367,15 @@ function renderDiscordModelPickerProvidersView(params) {
 		currentBucketId: page.bucket?.id
 	});
 	if (bucketRow) rows.push(bucketRow);
-	const activeProviderBucket = page.bucket && page.bucket.id !== "all" ? page.bucket.id : void 0;
-	const providerRow = buildProviderSelectRow({
+	const activeProviderBucket = getActiveBucketId(page.bucket);
+	if (page.items.length > 0) rows.push(buildProviderSelectRow({
 		command: params.command,
 		userId: params.userId,
 		page,
 		currentProvider: parsedCurrent?.provider,
-		providerBucket: activeProviderBucket
-	});
-	if (providerRow) rows.push(providerRow);
+		providerBucket: activeProviderBucket,
+		showModelCounts: true
+	}));
 	const navRow = buildPaginationRow({
 		command: params.command,
 		userId: params.userId,
@@ -3531,19 +3425,10 @@ function renderDiscordModelPickerModelsView(params) {
 			footer: "Choose a different provider."
 		});
 	}
-	const { rows: modelRows, buttonRow } = buildModelRows({
-		command: params.command,
-		userId: params.userId,
-		data: params.data,
+	const { rows: modelRows, buttonRow, runtimeChoices: choices, selectedRuntime } = buildModelRows({
+		...params,
 		providerPage,
-		modelPage,
-		currentModel: params.currentModel,
-		currentRuntime: params.currentRuntime,
-		pendingModel: params.pendingModel,
-		pendingModelIndex: params.pendingModelIndex,
-		pendingRuntime: params.pendingRuntime,
-		quickModels: params.quickModels,
-		providerBucket: params.providerBucket
+		modelPage
 	});
 	const pendingRuntime = params.pendingRuntime?.trim();
 	const rows = [];
@@ -3555,24 +3440,11 @@ function renderDiscordModelPickerModelsView(params) {
 		currentBucketId: modelPage.bucket?.id,
 		provider: modelPage.provider,
 		runtimeToken: pendingRuntime ? createDiscordModelPickerRuntimeToken(pendingRuntime) : void 0,
-		providerPage,
-		providerBucket: params.providerBucket
+		providerPage
 	});
 	if (bucketRow) rows.push(bucketRow);
 	rows.push(...modelRows);
 	const defaultModel = `${params.data.resolvedDefault.provider}/${params.data.resolvedDefault.model}`;
-	const choices = getRuntimeChoices({
-		data: params.data,
-		provider: modelPage.provider,
-		modelRef: params.pendingModel ?? params.currentModel
-	});
-	const selectedRuntime = resolveSelectedRuntime({
-		data: params.data,
-		provider: modelPage.provider,
-		modelRef: params.pendingModel ?? params.currentModel,
-		currentRuntime: parseCurrentModelRef(params.currentModel)?.provider === modelPage.provider ? params.currentRuntime : void 0,
-		pendingRuntime: params.pendingRuntime
-	});
 	const selectedRuntimeLabel = choices?.find((choice) => choice.id === selectedRuntime)?.label;
 	const pendingLine = !params.pendingModel ? "Select a model, then press Submit." : !supportsDiscordModelPickerRuntimeChoices() ? `Selected: ${params.pendingModel} (press Submit)` : choices === void 0 ? "Could not confirm how to run this model. Open /models to try again." : choices.length === 0 ? "This model cannot run with your current connections. Choose another model." : selectedRuntimeLabel ? `Selected: ${params.pendingModel} · ${selectedRuntimeLabel} (press Submit)` : "Choose how to run this model, then press Submit.";
 	const detailLines = [formatCurrentModelLine(params.currentModel), `Default: ${defaultModel}`];
@@ -3662,6 +3534,7 @@ async function applyDiscordModelPickerSelection(params) {
 			preferFollowUp: true,
 			threadBindings: params.threadBindings,
 			suppressReplies: true,
+			buildContext: params.buildContext,
 			dispatchReplyFromConfig: params.dispatchReplyFromConfig,
 			pluginCommandDispatch: { kind: "non-plugin" }
 		}), 12e3);
@@ -3710,21 +3583,11 @@ async function applyDiscordModelPickerSelection(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-command-model-picker-ui.ts
-function resolveDiscordModelPickerCommandContext(command) {
-	const normalized = normalizeLowercaseStringOrEmpty(command.nativeName ?? command.key);
-	if (normalized === "model" || normalized === "models") return normalized;
-	return null;
-}
-function resolveCommandArgStringValue(args, key) {
-	const value = args?.values?.[key];
-	if (typeof value !== "string") return "";
-	return value.trim();
-}
 function shouldOpenDiscordModelPickerFromCommand(params) {
-	const context = resolveDiscordModelPickerCommandContext(params.command);
-	if (!context) return null;
+	const context = normalizeLowercaseStringOrEmpty(params.command.nativeName ?? params.command.key);
+	if (context !== "model" && context !== "models") return null;
 	const serializedArgs = normalizeOptionalString(serializeCommandArgs(params.command, params.commandArgs)) ?? "";
-	if (context === "model") return !resolveCommandArgStringValue(params.commandArgs, "model") && !serializedArgs ? context : null;
+	if (context === "model") return !normalizeOptionalString(params.commandArgs?.values?.model) && !serializedArgs ? context : null;
 	return serializedArgs ? null : context;
 }
 function buildDiscordModelPickerAllowedModelRefs(data) {
@@ -3746,7 +3609,7 @@ function resolveDiscordModelPickerPreferenceScope(params) {
 function buildDiscordModelPickerNoticePayload(message) {
 	return { components: [new Container([new TextDisplay(message)])] };
 }
-async function resolveDiscordModelPickerRouteState(params) {
+async function resolveDiscordModelPickerRoute(params) {
 	const { interaction, cfg, accountId } = params;
 	const { isDirectMessage, isGroupDm, isThreadChannel, rawChannelId, threadParentId } = await resolveDiscordNativeInteractionChannelContext({
 		channel: interaction.channel,
@@ -3756,7 +3619,7 @@ async function resolveDiscordModelPickerRouteState(params) {
 	});
 	const memberRoleIds = Array.isArray(interaction.rawData.member?.roles) ? interaction.rawData.member.roles.map((roleId) => roleId) : [];
 	const threadBinding = isThreadChannel ? params.threadBindings.getByThreadId(rawChannelId) : void 0;
-	return await resolveDiscordNativeInteractionRouteState({
+	return resolveDiscordNativeInteractionRouteState({
 		cfg,
 		accountId,
 		guildId: interaction.guild?.id ?? void 0,
@@ -3766,24 +3629,12 @@ async function resolveDiscordModelPickerRouteState(params) {
 		directUserId: interaction.user?.id ?? rawChannelId,
 		conversationId: rawChannelId,
 		parentConversationId: threadParentId,
-		threadBinding,
-		enforceConfiguredBindingReadiness: params.enforceConfiguredBindingReadiness
-	});
-}
-async function resolveDiscordModelPickerRoute(params) {
-	return (await resolveDiscordModelPickerRouteState(params)).effectiveRoute;
+		threadBinding
+	}).effectiveRoute;
 }
 async function resolveDiscordNativeChoiceContext(params) {
 	try {
-		const resolved = await resolveDiscordModelPickerRouteState({
-			interaction: params.interaction,
-			cfg: params.cfg,
-			accountId: params.accountId,
-			threadBindings: params.threadBindings,
-			enforceConfiguredBindingReadiness: true
-		});
-		if (resolved.bindingReadiness && !resolved.bindingReadiness.ok) return null;
-		const route = resolved.effectiveRoute;
+		const route = params.route ?? await resolveDiscordModelPickerRoute(params);
 		const fallback = resolveDefaultModelForAgent({
 			cfg: params.cfg,
 			agentId: route.agentId
@@ -3898,8 +3749,6 @@ async function replyWithDiscordModelPickerProviders(params) {
 		provider: initialProvider,
 		model: parsedCurrentRef.model
 	}) : { page: 1 };
-	const initialPage = initialResolved.page;
-	const initialModelBucket = initialResolved.bucket;
 	const initialProviderLocation = findProviderBucketLocation(data, initialProvider);
 	const payload = {
 		...renderDiscordModelPickerModelsView({
@@ -3907,10 +3756,10 @@ async function replyWithDiscordModelPickerProviders(params) {
 			userId: params.userId,
 			data,
 			provider: initialProvider,
-			page: initialPage,
+			page: initialResolved.page,
 			providerPage: initialProviderLocation?.page ?? 1,
 			providerBucket: initialProviderLocation?.bucket,
-			modelBucket: initialModelBucket,
+			modelBucket: initialResolved.bucket,
 			currentModel,
 			currentRuntime,
 			quickModels
@@ -3918,11 +3767,7 @@ async function replyWithDiscordModelPickerProviders(params) {
 		ephemeral: true
 	};
 	await params.safeInteractionCall("model picker reply", async () => {
-		if (params.preferFollowUp) {
-			await params.interaction.followUp(payload);
-			return;
-		}
-		await params.interaction.reply(payload);
+		await params.interaction[params.preferFollowUp ? "followUp" : "reply"](payload);
 	});
 }
 function splitDiscordModelRef(modelRef) {
@@ -3940,11 +3785,7 @@ function splitDiscordModelRef(modelRef) {
 //#endregion
 //#region extensions/discord/src/monitor/native-command-model-picker-interaction.ts
 function resolveModelPickerSelectionValue(interaction) {
-	const rawValues = interaction.values;
-	if (!Array.isArray(rawValues) || rawValues.length === 0) return null;
-	const first = rawValues[0];
-	if (typeof first !== "string") return null;
-	return first.trim() || null;
+	return normalizeOptionalString(interaction.values?.[0]) ?? null;
 }
 function resolveRuntimeToken(choices, token) {
 	if (!token) return;
@@ -4011,15 +3852,11 @@ function resolveDiscordModelPickerModelRefByToken(data, modelToken) {
 	return matchingRefs.length === 1 ? matchingRefs[0] ?? null : null;
 }
 function resolveDiscordModelPickerModelIndex(params) {
-	const models = listDiscordModelPickerProviderModels(params.data, params.provider);
-	if (!models.length) return null;
-	const index = models.indexOf(params.model);
-	if (index < 0) return null;
-	return index + 1;
+	const index = listDiscordModelPickerProviderModels(params.data, params.provider).indexOf(params.model);
+	return index < 0 ? null : index + 1;
 }
 function resolveDiscordModelPickerModelSelection(params) {
 	const models = listDiscordModelPickerProviderModels(params.data, params.provider);
-	if (!models.length) return null;
 	if (params.modelToken) {
 		const matchingModels = models.filter((model) => createDiscordModelPickerModelToken(params.provider, model) === params.modelToken);
 		return matchingModels.length === 1 ? matchingModels[0] ?? null : null;
@@ -4038,10 +3875,8 @@ async function handleDiscordModelPickerInteraction(params) {
 		await params.safeInteractionCall("model picker ack", () => interaction.acknowledge());
 		return;
 	}
-	let deferredUpdate = interaction.acknowledged;
-	if (!deferredUpdate) {
+	if (!interaction.acknowledged) {
 		if (await params.safeInteractionCall("model picker defer", () => interaction.acknowledge()) === null) return;
-		deferredUpdate = true;
 	}
 	const cfg = getRuntimeConfigSnapshot() ?? ctx.cfg;
 	const requireModelToken = cfg !== ctx.cfg;
@@ -4079,7 +3914,7 @@ async function handleDiscordModelPickerInteraction(params) {
 		allowedModelRefs,
 		limit: 5
 	});
-	const updatePicker = async (payload) => await params.safeInteractionCall("model picker update", () => deferredUpdate ? interaction.editReply(payload) : interaction.update(payload));
+	const updatePicker = async (payload) => await params.safeInteractionCall("model picker update", () => interaction.editReply(payload));
 	const showNotice = async (message) => await updatePicker(buildDiscordModelPickerNoticePayload(message));
 	const updateModelsView = async (provider, state = {}) => {
 		const rendered = renderDiscordModelPickerModelsView({
@@ -4146,15 +3981,16 @@ async function handleDiscordModelPickerInteraction(params) {
 		}));
 		return;
 	}
-	if (parsed.action === "bucket" && parsed.view === "models") {
+	if (parsed.view === "models" && (parsed.action === "bucket" || parsed.action === "back")) {
 		const provider = resolveModelPickerProvider({
 			parsedProvider,
 			currentModelRef,
 			data: pickerData
 		});
+		const selectingBucket = parsed.action === "bucket";
 		await updateModelsView(provider, {
-			page: 1,
-			modelBucket: resolveSelectedBucket(interaction),
+			page: selectingBucket ? 1 : parsed.page,
+			modelBucket: selectingBucket ? resolveSelectedBucket(interaction) : parsed.modelBucket,
 			pendingRuntime: resolvePendingRuntime({
 				data: pickerData,
 				provider,
@@ -4197,22 +4033,6 @@ async function handleDiscordModelPickerInteraction(params) {
 		});
 		return;
 	}
-	if (parsed.action === "back" && parsed.view === "models") {
-		const provider = resolveModelPickerProvider({
-			parsedProvider,
-			currentModelRef,
-			data: pickerData
-		});
-		await updateModelsView(provider, {
-			modelBucket: parsed.modelBucket,
-			pendingRuntime: resolvePendingRuntime({
-				data: pickerData,
-				provider,
-				parsed
-			})
-		});
-		return;
-	}
 	if (parsed.action === "provider") {
 		const selectedProvider = resolveModelPickerSelectionValue(interaction) ?? parsed.provider;
 		if (!selectedProvider || !pickerData.byProvider.has(selectedProvider)) {
@@ -4284,9 +4104,8 @@ async function handleDiscordModelPickerInteraction(params) {
 			provider,
 			model: selectedModel
 		}) : void 0;
-		const currentModelOnly = splitDiscordModelRef(currentModelRef ?? "");
 		await updateModelsView(provider, {
-			modelBucket: parsed.modelBucket ?? (selectedModel ? findModelBucketId(pickerData, provider, selectedModel) : currentModelOnly && currentModelOnly.provider === provider ? findModelBucketId(pickerData, provider, currentModelOnly.model) : void 0),
+			modelBucket: parsed.modelBucket ?? (selectedModel ? findModelBucketId(pickerData, provider, selectedModel) : currentModel && currentModel.provider === provider ? findModelBucketId(pickerData, provider, currentModel.model) : void 0),
 			...pendingModel ? { pendingModel } : {},
 			pendingModelIndex: pendingModelIndex ?? void 0,
 			pendingRuntime: selectedRuntime
@@ -4364,16 +4183,11 @@ async function handleDiscordModelPickerInteraction(params) {
 			return;
 		}
 		const applyResult = await applyDiscordModelPickerSelection({
+			...ctx,
 			interaction,
 			selectionCommand,
 			dispatchCommandInteraction: params.dispatchCommandInteraction,
 			cfg,
-			discordConfig: ctx.discordConfig,
-			readPolicy: ctx.readPolicy,
-			accountId: ctx.accountId,
-			sessionPrefix: ctx.sessionPrefix,
-			threadBindings: ctx.threadBindings,
-			dispatchReplyFromConfig: ctx.dispatchReplyFromConfig,
 			route,
 			resolvedModelRef,
 			selectedRuntime,
@@ -4397,44 +4211,37 @@ async function handleDiscordModelPickerInteraction(params) {
 	}
 	if (parsed.action === "cancel") await showNotice(`ℹ️ Model kept as ${currentModelRef ?? "default"}.`);
 }
-async function runDiscordModelPickerFallback(params) {
-	await handleDiscordModelPickerInteraction(params);
-}
-var DiscordModelPickerFallbackButton = class extends Button {
-	constructor(params) {
-		super();
-		this.params = params;
-		this.label = "modelpick";
-		this.customId = `${DISCORD_MODEL_PICKER_CUSTOM_ID_KEY}:seed=btn`;
-	}
-	async run(interaction, data) {
-		await runDiscordModelPickerFallback({
-			...this.params,
-			interaction,
-			data
-		});
-	}
-};
-var DiscordModelPickerFallbackSelect = class extends StringSelectMenu {
-	constructor(params) {
-		super();
-		this.params = params;
-		this.customId = `${DISCORD_MODEL_PICKER_CUSTOM_ID_KEY}:seed=sel`;
-		this.options = [];
-	}
-	async run(interaction, data) {
-		await runDiscordModelPickerFallback({
-			...this.params,
-			interaction,
-			data
-		});
-	}
-};
 function createDiscordModelPickerFallbackButton$1(params) {
-	return new DiscordModelPickerFallbackButton(params);
+	return new class extends Button {
+		constructor(..._args) {
+			super(..._args);
+			this.label = "modelpick";
+			this.customId = `${DISCORD_MODEL_PICKER_CUSTOM_ID_KEY}:seed=btn`;
+		}
+		async run(interaction, data) {
+			await handleDiscordModelPickerInteraction({
+				...params,
+				interaction,
+				data
+			});
+		}
+	}();
 }
 function createDiscordModelPickerFallbackSelect$1(params) {
-	return new DiscordModelPickerFallbackSelect(params);
+	return new class extends StringSelectMenu {
+		constructor(..._args2) {
+			super(..._args2);
+			this.customId = `${DISCORD_MODEL_PICKER_CUSTOM_ID_KEY}:seed=sel`;
+			this.options = [];
+		}
+		async run(interaction, data) {
+			await handleDiscordModelPickerInteraction({
+				...params,
+				interaction,
+				data
+			});
+		}
+	}();
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-command-status.ts
@@ -4455,15 +4262,9 @@ async function maybeDeliverDiscordDirectStatus(params) {
 			interaction: params.interaction,
 			payload: statusReply,
 			mediaLocalRoots: params.mediaLocalRoots,
-			textLimit: resolveTextChunkLimit(params.cfg, "discord", params.accountId, { fallbackLimit: 2e3 }),
-			maxLinesPerMessage: resolveDiscordMaxLinesPerMessage({
-				cfg: params.cfg,
-				discordConfig: params.discordConfig,
-				accountId: params.accountId
-			}),
+			...resolveDiscordInteractionReplyOptions(params),
 			preferFollowUp: params.preferFollowUp,
-			responseEphemeral: params.responseEphemeral,
-			chunkMode: resolveChunkMode(params.cfg, "discord", params.accountId)
+			responseEphemeral: params.responseEphemeral
 		});
 		return {
 			accepted: true,
@@ -4483,9 +4284,9 @@ function readDiscordCommandArgs(interaction, definitions) {
 	const values = {};
 	for (const definition of definitions) {
 		let value;
-		if (definition.type === "number") value = interaction.options.getNumber(definition.name) ?? null;
-		else if (definition.type === "boolean") value = interaction.options.getBoolean(definition.name) ?? null;
-		else value = interaction.options.getString(definition.name) ?? null;
+		if (definition.type === "number") value = interaction.options.getNumber(definition.name);
+		else if (definition.type === "boolean") value = interaction.options.getBoolean(definition.name);
+		else value = interaction.options.getString(definition.name);
 		if (value != null) values[definition.name] = value;
 	}
 	return Object.keys(values).length > 0 ? { values } : void 0;
@@ -4520,26 +4321,21 @@ function truncateDiscordCommandDescriptionLocalizations(params) {
 		label: `${params.label} locale:${locale}`
 	})]));
 }
-function resolveDiscordCommandLogLabel(command) {
-	if (typeof command.nativeName === "string" && command.nativeName.trim().length > 0) return command.nativeName;
-	return command.key;
-}
 function buildDiscordCommandOptions(params) {
 	const { command, cfg, resolveConfig, authorizeChoiceContext, resolveChoiceContext } = params;
-	const commandLabel = resolveDiscordCommandLogLabel(command);
+	const commandLabel = command.nativeName?.trim() ? command.nativeName : command.key;
 	const args = command.args;
 	if (!args || args.length === 0) return;
 	return args.map((arg) => {
-		const required = arg.required ?? false;
-		if (arg.type === "number" || arg.type === "boolean") return {
+		const base = {
 			name: arg.name,
 			description: truncateDiscordCommandDescription({
 				value: arg.description,
 				label: `command:${commandLabel} arg:${arg.name}`
 			}),
-			type: arg.type === "number" ? ApplicationCommandOptionType.Number : ApplicationCommandOptionType.Boolean,
-			required
+			required: arg.required ?? false
 		};
+		if (arg.type === "number" || arg.type === "boolean") return Object.assign(base, { type: arg.type === "number" ? ApplicationCommandOptionType.Number : ApplicationCommandOptionType.Boolean });
 		const resolvedChoices = resolveCommandArgChoices({
 			command,
 			arg,
@@ -4580,35 +4376,19 @@ function buildDiscordCommandOptions(params) {
 			name: choice.label,
 			value: choice.value
 		})) : void 0;
-		return {
-			name: arg.name,
-			description: truncateDiscordCommandDescription({
-				value: arg.description,
-				label: `command:${commandLabel} arg:${arg.name}`
-			}),
+		return Object.assign(base, {
 			type: ApplicationCommandOptionType.String,
-			required,
 			choices,
 			autocomplete
-		};
+		});
 	});
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-command.ts
 const log = createSubsystemLogger("discord/native-command");
 const NON_PLUGIN_COMMAND_DISPATCH = Object.freeze({ kind: "non-plugin" });
-function resolveDiscordNativePolicyReader(params) {
-	return params.readPolicy ?? createDiscordLivePolicyReader({
-		...params,
-		readConfig: () => getRuntimeConfigSnapshot() ?? params.cfg,
-		resolvedAllowlist: {
-			guildEntries: params.discordConfig?.guilds,
-			allowFrom: params.discordConfig?.allowFrom ?? resolveDiscordAccountAllowFrom(params)
-		}
-	});
-}
 function createDiscordNativeCommand(params) {
-	const { command, cfg, discordConfig, accountId, sessionPrefix, ephemeralDefault, threadBindings, dispatchReplyFromConfig } = params;
+	const { command, cfg, discordConfig, accountId, sessionPrefix, ephemeralDefault, threadBindings, buildContext, dispatchReplyFromConfig } = params;
 	const fallbackCommandDefinition = createNativeCommandDefinition(command);
 	const pluginCommandCandidate = "prepareDispatch" in command ? command : void 0;
 	const commandDefinition = pluginCommandCandidate ? fallbackCommandDefinition : findCommandByNativeName$1(command.name, "discord", { includeBundledChannelFallback: false }) ?? fallbackCommandDefinition;
@@ -4627,6 +4407,9 @@ function createDiscordNativeCommand(params) {
 				...policy,
 				isPolicyCurrent: policy.isCurrent,
 				accountId,
+				sessionPrefix,
+				threadBindings,
+				buildContext,
 				skipCommandOwnerAllowFrom: pluginCommandCandidate !== void 0
 			});
 		},
@@ -4681,6 +4464,7 @@ function createDiscordNativeCommand(params) {
 				preferFollowUp: true,
 				threadBindings,
 				responseEphemeral: ephemeralDefault,
+				buildContext,
 				dispatchReplyFromConfig,
 				pluginCommandDispatch: preparedPluginCommand ?? NON_PLUGIN_COMMAND_DISPATCH
 			});
@@ -4688,7 +4472,7 @@ function createDiscordNativeCommand(params) {
 	}();
 }
 async function dispatchDiscordCommandInteraction(params) {
-	const { interaction, prompt, command, commandArgs, cfg: inputConfig, discordConfig: inputDiscordConfig, accountId, sessionPrefix, preferFollowUp, threadBindings, responseEphemeral, suppressReplies, dispatchReplyFromConfig } = params;
+	const { interaction, prompt, command, commandArgs, cfg: inputConfig, discordConfig: inputDiscordConfig, accountId, sessionPrefix, preferFollowUp, threadBindings, responseEphemeral, suppressReplies, buildContext, dispatchReplyFromConfig } = params;
 	const policy = await params.readPolicy?.();
 	const cfg = policy?.cfg ?? getRuntimeConfigSnapshot() ?? inputConfig;
 	const discordConfig = policy?.discordConfig ?? inputDiscordConfig;
@@ -4700,14 +4484,9 @@ async function dispatchDiscordCommandInteraction(params) {
 			...ephemeral !== void 0 ? { ephemeral } : {}
 		};
 		await safeDiscordInteractionCall("interaction reply", async () => {
-			if (preferFollowUp) {
-				await interaction.followUp(payload);
-				return;
-			}
-			await interaction.reply(payload);
+			await interaction[preferFollowUp ? "followUp" : "reply"](payload);
 		});
 	};
-	const useAccessGroups = true;
 	const user = interaction.user;
 	if (!user) return { accepted: false };
 	const sender = resolveDiscordSenderIdentity({
@@ -4715,12 +4494,13 @@ async function dispatchDiscordCommandInteraction(params) {
 		pluralkitInfo: null
 	});
 	const channel = interaction.channel;
-	const { isDirectMessage, isGroupDm, isThreadChannel, channelName, channelSlug, rawChannelId, threadParentId, threadParentName, threadParentSlug } = await resolveDiscordNativeInteractionChannelContext({
+	const channelContext = await resolveDiscordNativeInteractionChannelContext({
 		channel,
 		client: interaction.client,
 		hasGuild: Boolean(interaction.guild),
 		channelIdFallback: interaction.rawData.channel_id ?? ""
 	});
+	const { isDirectMessage, isGroupDm, isThreadChannel, channelName, channelSlug, rawChannelId, threadParentId } = channelContext;
 	if (policy?.isCurrent() === false) {
 		await respond("Access policy changed. Try this interaction again.", { ephemeral: true });
 		return { accepted: false };
@@ -4731,47 +4511,20 @@ async function dispatchDiscordCommandInteraction(params) {
 		cfg,
 		accountId
 	}) ?? [];
-	const commandOwnerAllowFrom = resolveDiscordCommandOwnerAllowFrom(cfg);
-	const { ownerAllowList: discordOwnerAllowList, ownerAllowed: discordOwnerOk } = resolveDiscordOwnerAccess({
+	const { ownerAllowList, ownerAllowed } = resolveDiscordOwnerAccess({
 		allowFrom: configuredDmAllowFrom,
-		sender: {
-			id: sender.id,
-			name: sender.name,
-			tag: sender.tag
-		},
-		allowNameMatching
-	});
-	const { ownerAllowed: commandOwnerOk } = resolveDiscordOwnerAccess({
-		allowFrom: commandOwnerAllowFrom,
-		sender: {
-			id: sender.id,
-			name: sender.name,
-			tag: sender.tag
-		},
+		sender,
 		allowNameMatching
 	});
-	const commandOwnerAllowAll = commandOwnerAllowFrom?.includes("*") === true;
-	const senderIsCommandOwner = commandOwnerOk;
-	const commandOwnerAccessAllowed = senderIsCommandOwner || commandOwnerAllowAll;
-	const ownerAllowListConfigured = discordOwnerAllowList != null;
-	const ownerOk = discordOwnerOk;
 	const { commandsAllowFromAccess, guildInfo, channelConfig } = resolveDiscordNativeCommandChannelAccessContext({
 		cfg,
 		discordConfig,
-		accountId,
 		sender,
-		isDirectMessage,
-		isThreadChannel,
-		guild: interaction.guild ?? null,
-		rawChannelId,
-		channelName,
-		channelSlug,
-		threadParentId,
-		threadParentName,
-		threadParentSlug
+		...channelContext,
+		guild: interaction.guild ?? null
 	});
-	let nativeRouteStatePromise;
-	const getNativeRouteState = () => nativeRouteStatePromise ??= nativeCommandRuntime.resolveDiscordNativeInteractionRouteState({
+	let nativeRouteState;
+	const getNativeRouteState = () => nativeRouteState ??= nativeCommandRuntime.resolveDiscordNativeInteractionRouteState({
 		cfg,
 		accountId,
 		guildId: interaction.guild?.id ?? void 0,
@@ -4781,19 +4534,18 @@ async function dispatchDiscordCommandInteraction(params) {
 		directUserId: user.id,
 		conversationId: rawChannelId || "unknown",
 		parentConversationId: threadParentId,
-		threadBinding: isThreadChannel ? threadBindings.getByThreadId(rawChannelId) : void 0,
-		enforceConfiguredBindingReadiness: !shouldBypassConfiguredAcpEnsure(commandName)
+		threadBinding: isThreadChannel ? threadBindings.getByThreadId(rawChannelId) : void 0
 	});
-	const canBypassConfiguredAcpGuildGuards = async () => {
+	const canBypassConfiguredAcpGuildGuards = () => {
 		if (!interaction.guild || !shouldBypassConfiguredAcpGuildGuards(commandName)) return false;
-		const routeState = await getNativeRouteState();
-		return routeState.effectiveRoute.matchedBy === "binding.channel" || routeState.boundSessionKey != null || routeState.configuredBinding != null || routeState.configuredRoute != null;
+		const routeState = getNativeRouteState();
+		return routeState.effectiveRoute.matchedBy === "binding.channel" || routeState.boundSessionKey != null || routeState.configuredBinding != null;
 	};
-	if (channelConfig?.enabled === false && !await canBypassConfiguredAcpGuildGuards()) {
+	if (channelConfig?.enabled === false && !canBypassConfiguredAcpGuildGuards()) {
 		await respond("This channel is disabled.");
 		return { accepted: false };
 	}
-	if (interaction.guild && channelConfig?.allowed === false && !await canBypassConfiguredAcpGuildGuards()) {
+	if (interaction.guild && channelConfig?.allowed === false && !canBypassConfiguredAcpGuildGuards()) {
 		await respond("This channel is not allowed.");
 		return { accepted: false };
 	}
@@ -4807,7 +4559,7 @@ async function dispatchDiscordCommandInteraction(params) {
 			groupPolicy,
 			guildInfo,
 			channelConfig
-		}).allowed && !await canBypassConfiguredAcpGuildGuards()) {
+		}).allowed && !canBypassConfiguredAcpGuildGuards()) {
 			await respond("This channel is not allowed.");
 			return { accepted: false };
 		}
@@ -4831,11 +4583,7 @@ async function dispatchDiscordCommandInteraction(params) {
 			accountId,
 			dmPolicy,
 			configuredAllowFrom: configuredDmAllowFrom,
-			sender: {
-				id: sender.id,
-				name: sender.name,
-				tag: sender.tag
-			},
+			sender,
 			allowNameMatching,
 			cfg,
 			rest: interaction.client.rest
@@ -4883,19 +4631,17 @@ async function dispatchDiscordCommandInteraction(params) {
 	if (!isDirectMessage) {
 		commandAuthorized = await resolveDiscordGuildNativeCommandAuthorized({
 			cfg,
-			accountId,
 			discordConfig,
-			useAccessGroups,
 			commandsAllowFromAccess,
 			guildInfo,
 			channelConfig,
 			memberRoleIds,
 			sender,
 			allowNameMatching,
-			ownerAllowListConfigured,
-			ownerAllowed: ownerOk
+			ownerAllowListConfigured: ownerAllowList != null,
+			ownerAllowed
 		});
-		if (!commandAuthorized && !await canBypassConfiguredAcpGuildGuards()) {
+		if (!commandAuthorized && !canBypassConfiguredAcpGuildGuards()) {
 			await respond("You are not authorized to use this command.", { ephemeral: true });
 			return { accepted: false };
 		}
@@ -4904,18 +4650,63 @@ async function dispatchDiscordCommandInteraction(params) {
 		await respond("Access policy changed. Try this interaction again.", { ephemeral: true });
 		return { accepted: false };
 	}
-	if (commandOwnerAllowFrom && !commandOwnerAccessAllowed && !commandsAllowFromAccess.allowed && commandName !== "status" && params.pluginCommandDispatch.kind !== "plugin") {
+	const routeState = getNativeRouteState();
+	const effectiveRoute = routeState.effectiveRoute;
+	const { ctxPayload, sessionKey, commandTargetSessionKey } = await buildDiscordNativeInteractionContext({
+		buildContext,
+		interaction,
+		channelContext,
+		route: effectiveRoute,
+		boundSessionKey: routeState.boundSessionKey,
+		sessionPrefix,
+		prompt,
+		commandArgs: commandArgs ?? {},
+		channelConfig,
+		guildInfo,
+		allowNameMatching,
+		commandAuthorized,
+		user,
+		sender
+	});
+	const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, effectiveRoute.agentId);
+	if (policy?.isCurrent() === false) {
+		await respond("Access policy changed. Try this interaction again.", { ephemeral: true });
+		return { accepted: false };
+	}
+	const authority = createDiscordNativeCommandAuthority({
+		cfg,
+		ctx: ctxPayload,
+		commandAuthorized,
+		sender,
+		allowNameMatching,
+		isPolicyCurrent: policy?.isCurrent,
+		accountId,
+		guildId: interaction.guild?.id,
+		commandName,
+		pluginCommand: params.pluginCommandDispatch.kind === "plugin"
+	});
+	if (!authority.isAllowed()) {
+		await respond("You are not authorized to use this command.", { ephemeral: true });
+		return { accepted: false };
+	}
+	const bindingReadiness = routeState.configuredBinding && !shouldBypassConfiguredAcpEnsure(commandName) ? await nativeCommandRuntime.ensureConfiguredBindingRouteReady({
+		cfg,
+		bindingResolution: routeState.configuredBinding,
+		assertActive: authority.assertActive
+	}) : null;
+	if (!authority.isAllowed()) {
 		await respond("You are not authorized to use this command.", { ephemeral: true });
 		return { accepted: false };
 	}
 	const isGuild = Boolean(interaction.guild);
 	const channelId = rawChannelId || "unknown";
 	const menuNeedsModelContext = !(commandArgs?.raw && !commandArgs.values) && command.args?.some((arg) => typeof arg.choices === "function" && commandArgs?.values?.[arg.name] == null);
-	const menuModelContext = menuNeedsModelContext ? await resolveDiscordNativeChoiceContext({
+	const menuModelContext = menuNeedsModelContext && bindingReadiness?.ok !== false ? await resolveDiscordNativeChoiceContext({
 		interaction,
 		cfg,
 		accountId,
-		threadBindings
+		threadBindings,
+		route: effectiveRoute
 	}) : null;
 	const menuModelCatalog = command.key === "think" && menuNeedsModelContext ? await loadPreparedModelCatalog({
 		config: cfg,
@@ -4925,17 +4716,20 @@ async function dispatchDiscordCommandInteraction(params) {
 		} : {},
 		readOnly: true
 	}) : void 0;
-	const menuRouteState = command.key === "verbose" ? await getNativeRouteState() : void 0;
-	const menu = menuRouteState?.bindingReadiness?.ok === false ? null : resolveCommandArgMenu({
+	const menu = command.key === "verbose" && bindingReadiness?.ok === false ? null : resolveCommandArgMenu({
 		command,
 		args: commandArgs,
 		cfg,
-		session: menuRouteState?.effectiveRoute,
+		session: command.key === "verbose" ? effectiveRoute : void 0,
 		provider: menuModelContext?.provider,
 		model: menuModelContext?.model,
 		agentRuntime: menuModelContext?.agentRuntime,
 		catalog: menuModelCatalog
 	});
+	if (policy?.isCurrent() === false) {
+		await respond("Access policy changed. Try this interaction again.", { ephemeral: true });
+		return { accepted: false };
+	}
 	if (menu) {
 		const menuPayload = buildDiscordCommandArgMenu({
 			command,
@@ -4947,20 +4741,13 @@ async function dispatchDiscordCommandInteraction(params) {
 				accountId,
 				sessionPrefix,
 				threadBindings,
+				buildContext,
 				dispatchReplyFromConfig
 			},
 			safeInteractionCall: safeDiscordInteractionCall,
 			dispatchCommandInteraction: dispatchDiscordCommandInteraction
 		});
-		if (preferFollowUp) {
-			await safeDiscordInteractionCall("interaction follow-up", () => interaction.followUp({
-				content: menuPayload.content,
-				components: menuPayload.components,
-				ephemeral: true
-			}));
-			return { accepted: true };
-		}
-		await safeDiscordInteractionCall("interaction reply", () => interaction.reply({
+		await safeDiscordInteractionCall(preferFollowUp ? "interaction follow-up" : "interaction reply", () => interaction[preferFollowUp ? "followUp" : "reply"]({
 			content: menuPayload.content,
 			components: menuPayload.components,
 			ephemeral: true
@@ -4974,19 +4761,20 @@ async function dispatchDiscordCommandInteraction(params) {
 		}
 		const messageThreadId = !isDirectMessage && isThreadChannel ? channelId : void 0;
 		const pluginThreadParentId = !isDirectMessage && isThreadChannel ? threadParentId : void 0;
-		const routeState = await getNativeRouteState();
-		const { effectiveRoute } = routeState;
 		const pluginCommandAgentId = (isThreadChannel ? threadBindings.getByThreadId(rawChannelId)?.agentId : void 0) || routeState.configuredBinding?.statefulTarget.agentId || effectiveRoute.agentId;
 		const targetSessionEntry = nativeCommandRuntime.getSessionEntry({
 			agentId: pluginCommandAgentId,
 			sessionKey: effectiveRoute.sessionKey
 		});
+		authority.assertActive();
+		const senderIsOwner = authority.senderIsOwner();
 		const pluginReply = await params.pluginCommandDispatch.execute({
 			senderId: sender.id,
 			channel: "discord",
 			channelId,
 			isAuthorizedSender: commandAuthorized,
-			senderIsOwner: senderIsCommandOwner,
+			senderIsOwner,
+			...senderIsOwner ? { assertOwnerCurrent: authority.assertOwnerCurrent } : {},
 			agentId: pluginCommandAgentId,
 			sessionKey: effectiveRoute.sessionKey,
 			authProfileId: targetSessionEntry?.authProfileOverride,
@@ -5015,15 +4803,13 @@ async function dispatchDiscordCommandInteraction(params) {
 		await deliverDiscordInteractionReply({
 			interaction,
 			payload: pluginReply,
-			textLimit: resolveTextChunkLimit(cfg, "discord", accountId, { fallbackLimit: 2e3 }),
-			maxLinesPerMessage: resolveDiscordMaxLinesPerMessage({
+			...resolveDiscordInteractionReplyOptions({
 				cfg,
 				discordConfig,
 				accountId
 			}),
 			preferFollowUp,
-			responseEphemeral,
-			chunkMode: resolveChunkMode(cfg, "discord", accountId)
+			responseEphemeral
 		});
 		return {
 			accepted: true,
@@ -5047,58 +4833,14 @@ async function dispatchDiscordCommandInteraction(params) {
 		});
 		return { accepted: true };
 	}
-	const interactionId = interaction.rawData.id;
-	const routeState = await getNativeRouteState();
-	if (routeState.bindingReadiness && !routeState.bindingReadiness.ok) {
+	if (bindingReadiness && !bindingReadiness.ok) {
 		const configuredBinding = routeState.configuredBinding;
 		if (configuredBinding) {
-			logVerbose(`discord native command: configured ACP binding unavailable for channel ${configuredBinding.record.conversation.conversationId}: ${routeState.bindingReadiness.error}`);
+			logVerbose(`discord native command: configured ACP binding unavailable for channel ${configuredBinding.record.conversation.conversationId}: ${bindingReadiness.error}`);
 			await respond("Configured ACP binding is unavailable right now. Please try again.");
 			return { accepted: false };
 		}
 	}
-	const boundSessionKey = routeState.boundSessionKey;
-	const effectiveRoute = routeState.effectiveRoute;
-	const { sessionKey, commandTargetSessionKey } = resolveNativeCommandSessionTargets({
-		agentId: effectiveRoute.agentId,
-		sessionPrefix,
-		userId: user.id,
-		targetSessionKey: effectiveRoute.sessionKey,
-		boundSessionKey
-	});
-	const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, effectiveRoute.agentId);
-	const ctxPayload = buildDiscordNativeCommandContext({
-		prompt,
-		commandArgs: commandArgs ?? {},
-		sessionKey,
-		commandTargetSessionKey,
-		accountId: effectiveRoute.accountId,
-		interactionId,
-		channelId,
-		threadParentId,
-		memberRoleIds,
-		guildId: interaction.guild?.id,
-		guildName: interaction.guild?.name,
-		channelTopic: resolveDiscordChannelTopicSafe(channel),
-		channelConfig,
-		guildInfo,
-		allowNameMatching,
-		commandAuthorized,
-		isDirectMessage,
-		isGroupDm,
-		isGuild,
-		isThreadChannel,
-		user: {
-			id: user.id,
-			username: user.username,
-			globalName: user.globalName
-		},
-		sender: {
-			id: sender.id,
-			name: sender.name,
-			tag: sender.tag
-		}
-	});
 	const directStatusResult = await maybeDeliverDiscordDirectStatus({
 		commandName,
 		suppressReplies,
@@ -5110,7 +4852,7 @@ async function dispatchDiscordCommandInteraction(params) {
 		commandTargetSessionKey,
 		channel: "discord",
 		senderId: sender.id,
-		senderIsOwner: senderIsCommandOwner,
+		senderIsOwner: authority.senderIsOwner(),
 		isAuthorizedSender: commandAuthorized,
 		isGroup: isGuild || isGroupDm,
 		defaultGroupActivation: () => !isGuild ? "always" : channelConfig?.requireMention === false ? "always" : "mention",
@@ -5325,7 +5067,7 @@ var GatewaySendLimiter = class {
 				shouldEmitOverflowWarning = true;
 			}
 		}
-		this.outboundQueue.push({ payload: serialized });
+		this.outboundQueue.push(serialized);
 		if (shouldEmitOverflowWarning) this.emitOverflowWarning({
 			droppedEvents: this.droppedEvents,
 			maxQueuedEvents: GATEWAY_SEND_QUEUE_LIMIT,
@@ -5382,9 +5124,9 @@ var GatewaySendLimiter = class {
 	flush() {
 		while (this.outboundQueue.length > 0 && this.canSend(Date.now())) {
 			const queued = this.outboundQueue.shift();
-			if (!queued) continue;
+			if (queued === void 0) continue;
 			try {
-				this.sendSerialized(queued.payload);
+				this.sendSerialized(queued);
 			} catch (error) {
 				this.emitError(error instanceof Error ? error : new Error(String(error), { cause: error }));
 				this.clear();
@@ -5519,9 +5261,6 @@ var GatewayPlugin = class extends Plugin {
 		};
 		this.gatewayInfo = gatewayInfo;
 	}
-	get ping() {
-		return null;
-	}
 	listVoiceChannelStates(guildId, channelId) {
 		return this.voiceStateCache.listVoiceChannelStates(guildId, channelId);
 	}
@@ -5555,8 +5294,8 @@ var GatewayPlugin = class extends Plugin {
 		this.connect(false);
 	}
 	connect(resume = false) {
-		this.stopReconnectTimer();
-		this.stopHeartbeat();
+		this.reconnectTimer.stop();
+		this.heartbeatTimers.stop();
 		if (this.isConnecting) return;
 		this.shouldReconnect = true;
 		this.lastHeartbeatAck = true;
@@ -5569,8 +5308,8 @@ var GatewayPlugin = class extends Plugin {
 	}
 	disconnect() {
 		this.shouldReconnect = false;
-		this.stopReconnectTimer();
-		this.stopHeartbeat();
+		this.reconnectTimer.stop();
+		this.heartbeatTimers.stop();
 		this.outboundLimiter.clear();
 		this.ws?.close(1e3, "Client disconnect");
 		this.ws = null;
@@ -5603,7 +5342,7 @@ var GatewayPlugin = class extends Plugin {
 		socket.on("close", (code) => {
 			if (socket !== this.ws) return;
 			const closeCode = code;
-			this.stopHeartbeat();
+			this.heartbeatTimers.stop();
 			this.outboundLimiter.clear();
 			this.isConnecting = false;
 			this.isConnected = false;
@@ -5688,12 +5427,6 @@ var GatewayPlugin = class extends Plugin {
 			}
 		});
 	}
-	stopHeartbeat() {
-		this.heartbeatTimers.stop();
-	}
-	stopReconnectTimer() {
-		this.reconnectTimer.stop();
-	}
 	sendHeartbeat() {
 		if (!this.ws || this.ws.readyState !== READY_STATE_OPEN) return;
 		this.lastHeartbeatAck = false;
@@ -5759,7 +5492,7 @@ var GatewayPlugin = class extends Plugin {
 			this.isConnected = true;
 		}
 		this.voiceStateCache.apply(payload);
-		dispatchVoiceGatewayEvent(this.client, payload.t, payload.d);
+		dispatchVoiceGatewayEvent(this.client, payload);
 		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);
@@ -5779,8 +5512,8 @@ var GatewayPlugin = class extends Plugin {
 	}
 	scheduleReconnect(options) {
 		if (!this.shouldReconnect) return;
-		this.stopHeartbeat();
-		this.stopReconnectTimer();
+		this.heartbeatTimers.stop();
+		this.reconnectTimer.stop();
 		this.ws?.close();
 		this.ws = null;
 		this.isConnecting = false;
@@ -5818,43 +5551,24 @@ var GatewayPlugin = class extends Plugin {
 			d: data
 		}, true);
 	}
-	requestGuildMembers(data) {
-		if (!this.hasIntent(GatewayIntentBits.GuildMembers)) throw new Error("GUILD_MEMBERS intent is required for requestGuildMembers");
-		if (data.presences && !this.hasIntent(GatewayIntentBits.GuildPresences)) throw new Error("GUILD_PRESENCES intent is required when requesting presences");
-		if (!data.query && data.query !== "" && !data.user_ids) throw new Error("Either query or user_ids is required for requestGuildMembers");
-		this.send({
-			op: GatewayOpcodes.RequestGuildMembers,
-			d: data
-		});
-	}
 	getRateLimitStatus() {
 		return this.outboundLimiter.getStatus();
 	}
-	hasIntent(intent) {
-		return Boolean((this.options.intents ?? 0) & intent);
-	}
 };
 //#endregion
 //#region extensions/discord/src/monitor/presence.ts
-const DEFAULT_CUSTOM_ACTIVITY_TYPE$1 = 4;
-const CUSTOM_STATUS_NAME$1 = "Custom Status";
+const DEFAULT_CUSTOM_ACTIVITY_TYPE = 4;
+const CUSTOM_STATUS_NAME = "Custom Status";
 function resolveDiscordPresenceUpdate(config) {
 	const activityText = normalizeOptionalString(config.activity) ?? "";
 	const status = normalizeOptionalString(config.status) ?? "";
 	const activityType = config.activityType;
 	const activityUrl = normalizeOptionalString(config.activityUrl) ?? "";
-	const hasActivity = Boolean(activityText);
-	if (!hasActivity && !Boolean(status)) return {
-		since: null,
-		activities: [],
-		status: "online",
-		afk: false
-	};
 	const activities = [];
-	if (hasActivity) {
-		const resolvedType = activityType ?? DEFAULT_CUSTOM_ACTIVITY_TYPE$1;
-		const activity = resolvedType === DEFAULT_CUSTOM_ACTIVITY_TYPE$1 ? {
-			name: CUSTOM_STATUS_NAME$1,
+	if (activityText) {
+		const resolvedType = activityType ?? DEFAULT_CUSTOM_ACTIVITY_TYPE;
+		const activity = resolvedType === DEFAULT_CUSTOM_ACTIVITY_TYPE ? {
+			name: CUSTOM_STATUS_NAME,
 			type: resolvedType,
 			state: activityText
 		} : {
@@ -5873,8 +5587,6 @@ function resolveDiscordPresenceUpdate(config) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/auto-presence.ts
-const DEFAULT_CUSTOM_ACTIVITY_TYPE = 4;
-const CUSTOM_STATUS_NAME = "Custom Status";
 const DEFAULT_INTERVAL_MS = 3e4;
 const DEFAULT_MIN_UPDATE_INTERVAL_MS = 15e3;
 const MIN_INTERVAL_MS = 5e3;
@@ -5894,13 +5606,6 @@ function resolveAutoPresenceConfig(config) {
 		minUpdateIntervalMs
 	};
 }
-function buildCustomStatusActivity(text) {
-	return {
-		name: CUSTOM_STATUS_NAME,
-		type: DEFAULT_CUSTOM_ACTIVITY_TYPE,
-		state: text
-	};
-}
 function isExhaustedUnavailableReason(reason) {
 	if (!reason) return false;
 	return reason === "rate_limit" || reason === "overloaded" || reason === "billing" || reason === "auth" || reason === "auth_permanent";
@@ -5916,15 +5621,6 @@ function resolveAuthAvailability(params) {
 		now: params.now
 	})) ? "exhausted" : "degraded";
 }
-function resolvePresenceActivities(params) {
-	if (params.state === "healthy") return params.basePresence?.activities ?? [];
-	return [buildCustomStatusActivity(params.state === "degraded" ? "runtime degraded" : "token exhausted")];
-}
-function resolvePresenceStatus(state) {
-	if (state === "healthy") return "online";
-	if (state === "exhausted") return "dnd";
-	return "idle";
-}
 function resolveDiscordAutoPresenceUpdate(params) {
 	if (!resolveAutoPresenceConfig(params.discordConfig.autoPresence).enabled) return null;
 	const now = params.now ?? Date.now();
@@ -5934,15 +5630,15 @@ function resolveDiscordAutoPresenceUpdate(params) {
 		now
 	});
 	const state = params.gatewayConnected ? availability : "degraded";
-	return {
+	return state === "healthy" ? {
 		since: null,
-		activities: resolvePresenceActivities({
-			state,
-			basePresence
-		}),
-		status: resolvePresenceStatus(state),
+		activities: basePresence.activities,
+		status: "online",
 		afk: false
-	};
+	} : resolveDiscordPresenceUpdate({
+		activity: state === "degraded" ? "runtime degraded" : "token exhausted",
+		status: state === "degraded" ? "idle" : "dnd"
+	});
 }
 function stablePresenceSignature(payload) {
 	return JSON.stringify({
@@ -6015,6 +5711,7 @@ function createDiscordAutoPresenceController(params) {
 const DISCORD_GATEWAY_TRANSPORT_ACTIVITY_EVENT = "openclaw:discord-gateway-transport-activity";
 //#endregion
 //#region extensions/discord/src/monitor/gateway-metadata.ts
+const captureSdk$1 = proxyCaptureSdk;
 const DISCORD_GATEWAY_BOT_URL = "https://discord.com/api/v10/gateway/bot";
 const DISCORD_API_HOST = "discord.com";
 const DEFAULT_DISCORD_GATEWAY_URL = "wss://gateway.discord.gg/";
@@ -6034,11 +5731,6 @@ const discordGatewayBotInfoSchema = Type.Object({
 	})
 });
 const gatewayMetadataFallbackLogLastAt = /* @__PURE__ */ new WeakMap();
-function resolveFetchInputUrl(input) {
-	if (typeof input === "string") return input;
-	if (input instanceof URL) return input.toString();
-	return input.url;
-}
 async function materializeGuardedResponse(response) {
 	const body = new Uint8Array(await readResponseWithLimit(response, DISCORD_GATEWAY_METADATA_MAX_BYTES, { onOverflow: ({ size, maxBytes }) => /* @__PURE__ */ new Error(`Discord gateway metadata response body too large: ${size} bytes (limit: ${maxBytes} bytes)`) }));
 	return new Response(body, {
@@ -6102,6 +5794,7 @@ function parseDiscordGatewayInfoBody(body) {
 }
 async function fetchDiscordGatewayInfo(params) {
 	let response;
+	let body;
 	try {
 		response = await params.fetchImpl(params.gatewayBotUrl ?? DISCORD_GATEWAY_BOT_URL, {
 			...params.fetchInit,
@@ -6110,15 +5803,6 @@ async function fetchDiscordGatewayInfo(params) {
 				Authorization: `Bot ${params.token}`
 			}
 		});
-	} catch (error) {
-		throw createGatewayMetadataError({
-			detail: formatErrorMessage$1(error),
-			transient: true,
-			cause: error
-		});
-	}
-	let body;
-	try {
 		body = await response.text();
 	} catch (error) {
 		throw createGatewayMetadataError({
@@ -6183,7 +5867,7 @@ async function fetchDiscordGatewayMetadataGuarded(input, init, options) {
 	const requestInit = init;
 	const signal = requestInit?.signal ?? void 0;
 	const guarded = await fetchWithSsrFGuard({
-		url: resolveFetchInputUrl(input),
+		url: input,
 		init: requestInit,
 		...signal ? { signal } : {},
 		policy: { allowedHostnames: [DISCORD_API_HOST] },
@@ -6204,7 +5888,7 @@ async function fetchDiscordGatewayMetadataGuarded(input, init, options) {
 	} finally {
 		await guarded.release();
 	}
-	if (options?.capture) captureHttpExchange({
+	if (options?.capture) captureSdk$1.captureHttpExchangeAsync?.({
 		url: input,
 		method: init?.method ?? "GET",
 		requestHeaders: init?.headers,
@@ -6212,23 +5896,17 @@ async function fetchDiscordGatewayMetadataGuarded(input, init, options) {
 		response,
 		flowId: options.capture.flowId,
 		meta: options.capture.meta
-	});
+	}).catch(() => {});
 	return response;
 }
 //#endregion
 //#region extensions/discord/src/monitor/gateway-plugin.ts
+const captureSdk = proxyCaptureSdk;
 const DISCORD_GATEWAY_POLICY_VIOLATION_CLOSE_CODE = 1008;
 const DISCORD_GATEWAY_WS_RECEIVER_LIMIT_CODE = "WS_ERR_TOO_MANY_BUFFERED_PARTS";
 const DISCORD_GATEWAY_CLOSE_REASON_LOG_MAX_CHARS = 240;
 const discordDnsLookup = createDiscordDnsLookup();
 const registrationPromises = /* @__PURE__ */ new WeakMap();
-function assignGatewayClient(plugin, client) {
-	plugin.client = client;
-}
-function hasGatewaySocketStarted(plugin) {
-	const state = plugin;
-	return state.ws != null || state.isConnecting === true;
-}
 function readStringProperty(value, key) {
 	const property = value[key];
 	return typeof property === "string" && property ? property : void 0;
@@ -6304,7 +5982,7 @@ function createGatewayPlugin(params) {
 			return registration;
 		}
 		async registerClientInternal(client) {
-			assignGatewayClient(this, client);
+			this.client = client;
 			if (!this.gatewayInfo || this.gatewayInfoUsedFallback) {
 				const resolved = await fetchDiscordGatewayInfoWithTimeout({
 					token: client.options.token,
@@ -6329,7 +6007,7 @@ function createGatewayPlugin(params) {
 				await params.testing.registerClient(this, client);
 				return;
 			}
-			if (hasGatewaySocketStarted(this)) return;
+			if (this.ws != null || this.isConnecting) return;
 			return super.registerClient(client);
 		}
 		createWebSocket(url) {
@@ -6345,35 +6023,34 @@ function createGatewayPlugin(params) {
 				if (this.ws !== socket) return;
 				this.emitter.emit(DISCORD_GATEWAY_TRANSPORT_ACTIVITY_EVENT, { at: Date.now() });
 			};
-			captureWsEvent({
-				url,
+			const captureEvent = (event) => {
+				captureSdk.captureWsEventAsync?.({
+					url,
+					...event(),
+					flowId: wsFlowId,
+					meta: { subsystem: "discord-gateway" }
+				}).catch(() => {});
+			};
+			captureEvent(() => ({
 				direction: "local",
-				kind: "ws-open",
-				flowId: wsFlowId,
-				meta: { subsystem: "discord-gateway" }
-			});
+				kind: "ws-open"
+			}));
 			socket.on?.("message", (data) => {
 				emitTransportActivity();
-				captureWsEvent({
-					url,
+				captureEvent(() => ({
 					direction: "inbound",
 					kind: "ws-frame",
-					flowId: wsFlowId,
-					payload: Buffer.isBuffer(data) ? data : Buffer.from(String(data)),
-					meta: { subsystem: "discord-gateway" }
-				});
+					payload: Buffer.isBuffer(data) ? data : Buffer.from(String(data))
+				}));
 			});
 			socket.on?.("close", (code, reason) => {
 				const closeReason = Buffer.isBuffer(reason) ? reason : Buffer.from(String(reason ?? ""));
-				captureWsEvent({
-					url,
+				captureEvent(() => ({
 					direction: "local",
 					kind: "ws-close",
-					flowId: wsFlowId,
 					closeCode: code,
-					payload: closeReason,
-					meta: { subsystem: "discord-gateway" }
-				});
+					payload: closeReason
+				}));
 				if (shouldLogDiscordGatewayTransportClose({
 					code,
 					reason: closeReason,
@@ -6387,14 +6064,11 @@ function createGatewayPlugin(params) {
 			});
 			socket.on?.("error", (error) => {
 				lastTransportError = describeDiscordGatewayTransportError(error);
-				captureWsEvent({
-					url,
+				captureEvent(() => ({
 					direction: "local",
 					kind: "error",
-					flowId: wsFlowId,
-					errorText: error.message,
-					meta: { subsystem: "discord-gateway" }
-				});
+					errorText: error.message
+				}));
 				params.runtime?.log?.(warn(formatDiscordGatewayTransportErrorLog({
 					flowId: wsFlowId,
 					error: lastTransportError
@@ -6445,7 +6119,7 @@ function createDiscordGatewayPlugin(params) {
 	} : void 0;
 	const endpointGatewayUrl = endpoint ? new URL(endpoint.gatewayOrigin) : void 0;
 	let fetchImpl = createDiscordGatewayMetadataFetch(debugProxySettings.enabled, endpoint ? { endpoint } : void 0);
-	let wsAgent = endpointGatewayUrl?.protocol === "ws:" ? void 0 : new Agent$1({ lookup: endpointGatewayUrl ? createDiscordEndpointDnsLookup(endpointGatewayUrl.hostname) : discordDnsLookup });
+	let wsAgent = endpointGatewayUrl?.protocol === "ws:" ? void 0 : new Agent({ lookup: endpointGatewayUrl ? createDiscordEndpointDnsLookup(endpointGatewayUrl.hostname) : discordDnsLookup });
 	if (proxy && !endpoint) try {
 		validateDiscordProxyUrl(proxy);
 		wsAgent = params.testing?.createProxyAgent?.(proxy) ?? createNodeProxyAgent({
@@ -6524,29 +6198,16 @@ function formatDiscordGatewayErrorMessage(err) {
 }
 function classifyDiscordGatewayEvent(params) {
 	const message = formatDiscordGatewayErrorMessage(params.err);
-	if (params.isDisallowedIntentsError(params.err)) return {
-		type: "disallowed-intents",
-		err: params.err,
-		message,
-		shouldStopLifecycle: true
-	};
-	if (message.includes("Max reconnect attempts")) return {
-		type: "reconnect-exhausted",
-		err: params.err,
-		message,
-		shouldStopLifecycle: true
-	};
-	if (params.err instanceof TypeError || message.includes("Fatal Gateway error") || message.includes("Fatal gateway close code") || message.includes("Gateway HELLO missing heartbeat") || message.includes("Invalid gateway payload") || message.includes("Gateway socket emitted an unknown error")) return {
-		type: "fatal",
-		err: params.err,
-		message,
-		shouldStopLifecycle: true
-	};
+	let type;
+	if (params.isDisallowedIntentsError(params.err)) type = "disallowed-intents";
+	else if (message.includes("Max reconnect attempts")) type = "reconnect-exhausted";
+	else if (params.err instanceof TypeError || message.includes("Fatal Gateway error") || message.includes("Fatal gateway close code") || message.includes("Gateway HELLO missing heartbeat") || message.includes("Invalid gateway payload") || message.includes("Gateway socket emitted an unknown error")) type = "fatal";
+	else type = "other";
 	return {
-		type: "other",
+		type,
 		err: params.err,
 		message,
-		shouldStopLifecycle: false
+		shouldStopLifecycle: type !== "other"
 	};
 }
 function createDiscordGatewaySupervisor(params) {
@@ -6562,7 +6223,7 @@ function createDiscordGatewaySupervisor(params) {
 	let lifecycleHandler;
 	let phase = "buffering";
 	const seenLateEventKeys = /* @__PURE__ */ new Set();
-	const logLateEvent = (state) => (event) => {
+	const logLateEvent = (state, event) => {
 		const key = `${state}:${event.type}:${event.message}`;
 		if (seenLateEventKeys.has(key)) return;
 		seenLateEventKeys.add(key);
@@ -6575,13 +6236,13 @@ function createDiscordGatewaySupervisor(params) {
 		});
 		switch (phase) {
 			case "disposed":
-				logLateEvent("disposed")(event);
+				logLateEvent("disposed", event);
 				return;
 			case "active":
 				lifecycleHandler?.(event);
 				return;
 			case "teardown":
-				logLateEvent("teardown")(event);
+				logLateEvent("teardown", event);
 				return;
 			case "buffering": pending.push(event);
 		}
@@ -6733,12 +6394,6 @@ function normalizeGatewayReadyTimeoutMs(value) {
 	if (numeric === void 0) return;
 	return Math.min(numeric, MAX_DISCORD_GATEWAY_READY_TIMEOUT_MS);
 }
-function resolveDiscordGatewayReadyTimeoutMs(params) {
-	return normalizeGatewayReadyTimeoutMs(params?.env?.[DISCORD_GATEWAY_READY_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_READY_TIMEOUT_MS;
-}
-function resolveDiscordGatewayRuntimeReadyTimeoutMs(params) {
-	return normalizeGatewayReadyTimeoutMs(params?.env?.[DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_MS;
-}
 async function restartGatewayAfterReadyTimeout(params) {
 	if (!params.gateway || params.abortSignal?.aborted) return;
 	const socket = params.gateway.ws;
@@ -6767,44 +6422,32 @@ async function restartGatewayAfterReadyTimeout(params) {
 			socket.removeListener("close", onClose);
 			socket.removeListener("error", ignoreSocketError);
 		};
-		const finishResolve = () => {
+		const finish = (error) => {
 			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();
+			if (error && !params.abortSignal?.aborted) reject(error);
+			else resolve();
 		};
+		const onClose = () => finish();
+		const failClose = () => finish(/* @__PURE__ */ new Error(`discord gateway socket did not close within ${DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS}ms before restart`));
 		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`));
+				failClose();
 				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`));
+				failClose();
 				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 = setTimeout(failClose, DISCORD_GATEWAY_STARTUP_TERMINATE_CLOSE_TIMEOUT_MS);
 			terminateCloseTimeout.unref?.();
 		}, DISCORD_GATEWAY_STARTUP_DISCONNECT_DRAIN_TIMEOUT_MS);
 		drainTimeout.unref?.();
@@ -6845,9 +6488,6 @@ function createGatewayStatusObserver(params) {
 		}
 		queuedForceStopError = err;
 	};
-	const pushConnectedStatus = (at) => {
-		params.pushStatus(createDiscordReadyStatusPatch(at));
-	};
 	const startReadyWatch = () => {
 		clearReadyWatch();
 		const pollConnected = () => {
@@ -6857,7 +6497,7 @@ function createGatewayStatusObserver(params) {
 			}
 			if (!params.gateway?.isConnected) return;
 			clearReadyWatch();
-			pushConnectedStatus(Date.now());
+			params.pushStatus(createDiscordReadyStatusPatch(Date.now()));
 		};
 		pollConnected();
 		if (!readyTimeoutId) {
@@ -7007,8 +6647,8 @@ async function runDiscordGatewayLifecycle(params) {
 	const pushStatus = (patch) => {
 		params.statusSink?.(patch);
 	};
-	const gatewayReadyTimeoutMs = resolveDiscordGatewayReadyTimeoutMs({ env: process.env });
-	const gatewayRuntimeReadyTimeoutMs = resolveDiscordGatewayRuntimeReadyTimeoutMs({ env: process.env });
+	const gatewayReadyTimeoutMs = normalizeGatewayReadyTimeoutMs(process.env[DISCORD_GATEWAY_READY_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_READY_TIMEOUT_MS;
+	const gatewayRuntimeReadyTimeoutMs = normalizeGatewayReadyTimeoutMs(process.env[DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_MS;
 	const statusObserver = createGatewayStatusObserver({
 		gateway,
 		abortSignal: params.abortSignal,
@@ -7072,23 +6712,26 @@ async function runDiscordGatewayLifecycle(params) {
 	} 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();
-			setDiscordTranscriptsVoiceManager({
-				accountId: params.accountId,
-				manager: null,
-				expectedManager: params.voiceManager
-			});
-			params.voiceManagerRef.current = null;
+		try {
+			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();
+				setDiscordTranscriptsVoiceManager({
+					accountId: params.accountId,
+					manager: null,
+					expectedManager: params.voiceManager
+				});
+				params.voiceManagerRef.current = null;
+			}
+		} finally {
+			await params.threadBindings.stop();
 		}
-		params.threadBindings.stop();
 	}
 }
 //#endregion
@@ -7096,7 +6739,7 @@ async function runDiscordGatewayLifecycle(params) {
 let discordVoiceRuntimePromise;
 let discordProviderSessionRuntimePromise;
 async function loadDiscordVoiceRuntime() {
-	const promise = discordVoiceRuntimePromise ?? import("./voice-runtime-DHVQ2mFz.mjs").then((n) => n.t);
+	const promise = discordVoiceRuntimePromise ?? import("./voice-runtime-B46rcwrG.mjs").then((n) => n.t);
 	discordVoiceRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7106,7 +6749,7 @@ async function loadDiscordVoiceRuntime() {
 	}
 }
 async function loadDiscordProviderSessionRuntime() {
-	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-BW7QrF5C.mjs");
+	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-BYlTBFD2.mjs");
 	discordProviderSessionRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7210,22 +6853,49 @@ async function probeDiscordAcpBindingHealth(params) {
 //#endregion
 //#region extensions/discord/src/monitor/provider.cleanup.ts
 async function cleanupDiscordProviderStartup(params) {
-	const listenersStopped = params.stopMonitorListeners?.();
 	try {
-		await params.deactivateMessageHandler?.();
+		const listenersStopped = params.stopMonitorListeners?.();
+		try {
+			await params.deactivateMessageHandler?.();
+		} finally {
+			await listenersStopped;
+		}
+		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();
 	} finally {
-		await listenersStopped;
-	}
-	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 (!params.lifecycleStarted) await params.threadBindings.stop();
 	}
-	params.gatewaySupervisor?.dispose();
-	if (!params.lifecycleStarted) params.threadBindings.stop();
+}
+//#endregion
+//#region extensions/discord/src/voice/session.ts
+const MIN_SEGMENT_SECONDS = .35;
+const CAPTURE_FINALIZE_GRACE_MS = 2e3;
+const VOICE_CONNECT_READY_TIMEOUT_MS = 3e4;
+const VOICE_RECONNECT_GRACE_MS = 15e3;
+function resolveVoiceTimeoutMs(value, fallbackMs) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return fallbackMs;
+	return Math.floor(value);
+}
+function resolveDiscordVoiceMode(voice) {
+	const mode = voice?.mode;
+	if (mode === "stt-tts" || mode === "bidi") return mode;
+	return "agent-proxy";
+}
+function isDiscordRealtimeVoiceMode(mode) {
+	return mode === "agent-proxy" || mode === "bidi";
+}
+function logVoiceVerbose(message) {
+	logVerbose(`discord voice: ${message}`);
+}
+function isVoiceChannel(type) {
+	return type === discord_exports.ChannelType.GuildVoice || type === discord_exports.ChannelType.GuildStageVoice;
 }
 //#endregion
 //#region extensions/discord/src/voice/command.ts
@@ -7302,37 +6972,6 @@ async function authorizeVoiceCommand(interaction, params, options) {
 		guildId: interaction.guild.id
 	};
 }
-async function resolveVoiceCommandRuntimeContext(interaction, params) {
-	const guildId = interaction.guild?.id;
-	if (!guildId) {
-		await interaction.reply({
-			content: "Unable to resolve guild for this command.",
-			ephemeral: true
-		});
-		return null;
-	}
-	const manager = params.getManager();
-	if (!manager) {
-		await interaction.reply({
-			content: "Voice manager is not available yet.",
-			ephemeral: true
-		});
-		return null;
-	}
-	return {
-		guildId,
-		manager
-	};
-}
-async function ensureVoiceCommandAccess(params) {
-	const access = await authorizeVoiceCommand(params.interaction, params.context, { channelOverride: params.channelOverride });
-	if (access.ok) return true;
-	await params.interaction.reply({
-		content: access.message ?? "Not authorized.",
-		ephemeral: true
-	});
-	return false;
-}
 function createDiscordVoiceCommand(startupParams) {
 	const params = {
 		...startupParams,
@@ -7348,7 +6987,6 @@ function createDiscordVoiceCommand(startupParams) {
 			}
 		})
 	};
-	const resolveSessionChannelId = (manager, guildId) => manager.status().find((entry) => entry.guildId === guildId)?.channelId;
 	class JoinCommand extends Command {
 		constructor(..._args) {
 			super(..._args);
@@ -7384,7 +7022,7 @@ function createDiscordVoiceCommand(startupParams) {
 				});
 				return;
 			}
-			if (!isVoiceChannelType(channel.type)) {
+			if (!isVoiceChannel(channel.type)) {
 				await interaction.reply({
 					content: "That is not a voice channel.",
 					ephemeral: true
@@ -7417,48 +7055,49 @@ function createDiscordVoiceCommand(startupParams) {
 			});
 		}
 	}
-	class LeaveCommand extends Command {
-		constructor(..._args2) {
-			super(..._args2);
-			this.name = "leave";
-			this.description = "Leave the current voice channel";
-			this.defer = true;
-			this.ephemeral = params.ephemeralDefault;
-		}
-		async run(interaction) {
-			const runtimeContext = await resolveVoiceCommandRuntimeContext(interaction, params);
-			if (!runtimeContext) return;
-			const sessionChannelId = resolveSessionChannelId(runtimeContext.manager, runtimeContext.guildId);
-			if (!await ensureVoiceCommandAccess({
-				interaction,
-				context: params,
-				channelOverride: sessionChannelId ? { id: sessionChannelId } : void 0
-			})) return;
-			const result = await runtimeContext.manager.leave({ guildId: runtimeContext.guildId });
-			await interaction.reply({
-				content: result.message,
-				ephemeral: true
-			});
-		}
-	}
-	class StatusCommand extends Command {
-		constructor(..._args3) {
-			super(..._args3);
-			this.name = "status";
-			this.description = "Show active voice sessions";
+	class SessionCommand extends Command {
+		constructor(name) {
+			super();
+			this.name = name;
 			this.defer = true;
 			this.ephemeral = params.ephemeralDefault;
+			this.description = name === "leave" ? "Leave the current voice channel" : "Show active voice sessions";
 		}
 		async run(interaction) {
-			const runtimeContext = await resolveVoiceCommandRuntimeContext(interaction, params);
-			if (!runtimeContext) return;
-			const sessions = runtimeContext.manager.status().filter((entry) => entry.guildId === runtimeContext.guildId);
+			const guildId = interaction.guild?.id;
+			if (!guildId) {
+				await interaction.reply({
+					content: "Unable to resolve guild for this command.",
+					ephemeral: true
+				});
+				return;
+			}
+			const manager = params.getManager();
+			if (!manager) {
+				await interaction.reply({
+					content: "Voice manager is not available yet.",
+					ephemeral: true
+				});
+				return;
+			}
+			const sessions = manager.status().filter((entry) => entry.guildId === guildId);
 			const sessionChannelId = sessions[0]?.channelId;
-			if (!await ensureVoiceCommandAccess({
-				interaction,
-				context: params,
-				channelOverride: sessionChannelId ? { id: sessionChannelId } : void 0
-			})) return;
+			const access = await authorizeVoiceCommand(interaction, params, { channelOverride: sessionChannelId ? { id: sessionChannelId } : void 0 });
+			if (!access.ok) {
+				await interaction.reply({
+					content: access.message ?? "Not authorized.",
+					ephemeral: true
+				});
+				return;
+			}
+			if (this.name === "leave") {
+				const result = await manager.leave({ guildId });
+				await interaction.reply({
+					content: result.message,
+					ephemeral: true
+				});
+				return;
+			}
 			if (sessions.length === 0) {
 				await interaction.reply({
 					content: "No active voice sessions.",
@@ -7474,21 +7113,18 @@ function createDiscordVoiceCommand(startupParams) {
 		}
 	}
 	return new class extends CommandWithSubcommands {
-		constructor(..._args4) {
-			super(..._args4);
+		constructor(..._args2) {
+			super(..._args2);
 			this.name = DISCORD_VOICE_COMMAND_SPEC.name;
 			this.description = DISCORD_VOICE_COMMAND_SPEC.description;
 			this.subcommands = [
 				new JoinCommand(),
-				new LeaveCommand(),
-				new StatusCommand()
+				new SessionCommand("leave"),
+				new SessionCommand("status")
 			];
 		}
 	}();
 }
-function isVoiceChannelType(type) {
-	return type === ChannelType.GuildVoice || type === ChannelType.GuildStageVoice;
-}
 //#endregion
 //#region extensions/discord/src/monitor/provider.commands.ts
 const loadPluginCommandRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/plugin-command-runtime"));
@@ -7570,7 +7206,6 @@ function attachDiscordDeployRestContext(err, context) {
 	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 {
@@ -7588,8 +7223,7 @@ function readDiscordDeployRejectedFields(value) {
 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;
+	return (payload.errors && typeof payload.errors === "object" ? payload.errors : void 0) ?? rawBody;
 }
 function readDiscordDeployObjectField(value, field) {
 	return value && typeof value === "object" && field in value ? value[field] : void 0;
@@ -7604,9 +7238,7 @@ 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";
+	return method ?? path ?? "request";
 }
 function formatDiscordDeployErrorMessage(err) {
 	if (!isAbortLikeError(err)) return formatErrorMessage(err);
@@ -7642,19 +7274,19 @@ 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.status !== void 0) details.push(`status=${rateLimit.status}`);
+	if (rateLimit.retryAfterMs !== void 0) 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}`);
+	if (rateLimit.discordCode !== void 0) 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.retryAfterMs !== void 0) 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}`);
+	if (rateLimit.discordCode !== void 0) parts.push(`code=${rateLimit.discordCode}`);
 	return `${parts.join("; ")}. Existing slash commands stay active. Message send/receive is unaffected.`;
 }
 function formatDiscordRejectedDeployEntries(params) {
@@ -7683,10 +7315,7 @@ 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 { status, discordCode, rawBody, deployRequestBody: requestBody } = err;
 	const details = [];
 	if (typeof status === "number") details.push(`status=${status}`);
 	if (typeof discordCode === "number" || typeof discordCode === "string") details.push(`code=${discordCode}`);
@@ -7727,7 +7356,7 @@ function formatDiscordStartupGatewayState(gateway) {
 	const reconnectAttempts = gateway.reconnectAttempts;
 	return `gatewayConnected=${gateway.isConnected ? "true" : "false"} reconnectAttempts=${typeof reconnectAttempts === "number" ? reconnectAttempts : "na"}`;
 }
-function logDiscordStartupPhase$1(params) {
+function logDiscordStartupPhase(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(" ");
@@ -7835,7 +7464,7 @@ async function deployDiscordCommands(params) {
 }
 function runDiscordCommandDeployInBackground(params) {
 	if (!params.enabled) return;
-	logDiscordStartupPhase$1({
+	logDiscordStartupPhase({
 		runtime: params.runtime,
 		accountId: params.accountId,
 		phase: "deploy-commands:scheduled",
@@ -7844,7 +7473,7 @@ function runDiscordCommandDeployInBackground(params) {
 		isVerbose: params.isVerbose
 	});
 	deployDiscordCommands(params).then(() => {
-		logDiscordStartupPhase$1({
+		logDiscordStartupPhase({
 			runtime: params.runtime,
 			accountId: params.accountId,
 			phase: "deploy-commands:done",
@@ -7921,7 +7550,7 @@ var DiscordActivityButton = class extends Button {
 };
 function createDiscordActivityButton(ctx, applicationId, deps = {}) {
 	const runtime = getDiscordActivitiesRuntime();
-	if (!runtime || !runtime.isAccountEnabled(ctx.accountId, ctx.cfg)) return null;
+	if (!runtime) return null;
 	if (applicationId) runtime.registerApplicationId(ctx.accountId, applicationId);
 	if (!runtime.resolveAccount(ctx.accountId, ctx.cfg)) return null;
 	return new DiscordActivityButton(ctx, {
@@ -8036,6 +7665,104 @@ async function resolveComponentInteractionContext(params) {
 	};
 }
 //#endregion
+//#region extensions/discord/src/monitor/agent-components-data.ts
+function readParsedComponentId(data) {
+	if (!data || typeof data !== "object") return;
+	return "cid" in data ? data.cid : data.componentId;
+}
+function normalizeComponentId(value) {
+	if (typeof value === "string") return normalizeOptionalString(value);
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+}
+function mapOptionLabels(options, values) {
+	if (!options || options.length === 0) return values;
+	const map = new Map(options.map((option) => [option.value, option.label]));
+	return values.map((value) => map.get(value) ?? value);
+}
+function parseAgentComponentData(data) {
+	const raw = readParsedComponentId(data);
+	const componentId = typeof raw === "string" ? decodeCustomIdComponent(raw) : typeof raw === "number" ? String(raw) : null;
+	if (!componentId) return null;
+	return { componentId };
+}
+function parseDiscordComponentData(data, customId) {
+	if (!data || typeof data !== "object") return null;
+	const rawComponentId = readParsedComponentId(data);
+	const rawModalId = "mid" in data ? data.mid : data.modalId;
+	let componentId = normalizeComponentId(rawComponentId);
+	let modalId = normalizeComponentId(rawModalId);
+	if (!componentId && customId) {
+		const parsed = parseDiscordComponentCustomId(customId);
+		if (parsed) {
+			componentId = parsed.componentId;
+			modalId = parsed.modalId;
+		}
+	}
+	if (!componentId) return null;
+	return {
+		componentId,
+		modalId
+	};
+}
+function parseDiscordModalId(data, customId) {
+	if (data && typeof data === "object") {
+		const modalId = normalizeComponentId("mid" in data ? data.mid : data.modalId);
+		if (modalId) return modalId;
+	}
+	if (customId) return parseDiscordModalCustomId(customId);
+	return null;
+}
+function resolveInteractionCustomId(interaction) {
+	if (!interaction?.rawData || typeof interaction.rawData !== "object") return;
+	if (!("data" in interaction.rawData)) return;
+	return normalizeOptionalString(interaction.rawData.data?.custom_id);
+}
+function mapSelectValues(entry, values) {
+	switch (entry.selectType) {
+		case "string": return mapOptionLabels(entry.options, values);
+		case "user":
+		case "role":
+		case "mentionable":
+		case "channel": return values.map((value) => `${entry.selectType}:${value}`);
+		default: return values;
+	}
+}
+function resolveModalFieldValues(field, interaction) {
+	const fields = interaction.fields;
+	const required = field.required === true;
+	try {
+		switch (field.type) {
+			case "text": {
+				const value = fields.getText(field.id, required);
+				return value ? [value] : [];
+			}
+			case "select":
+			case "checkbox":
+			case "radio": return mapOptionLabels(field.options, fields.getStringSelect(field.id, required));
+			case "role-select": try {
+				return fields.getRoleSelect(field.id, required).map((role) => role.name ?? role.id);
+			} catch {
+				return fields.getStringSelect(field.id, required);
+			}
+			case "user-select": return fields.getUserSelect(field.id, required).map((user) => formatDiscordUserTag(user));
+			default: return [];
+		}
+	} catch (err) {
+		logError(`agent modal: failed to read field ${field.id}: ${String(err)}`);
+		return [];
+	}
+}
+function formatModalSubmissionText(entry, interaction) {
+	const lines = [`Form "${entry.title}" submitted.`];
+	for (const field of entry.fields) {
+		const values = resolveModalFieldValues(field, interaction);
+		if (values.length === 0) continue;
+		lines.push(`- ${field.label}: ${values.join(", ")}`);
+	}
+	if (lines.length === 1) lines.push("- (no values)");
+	return lines.join("\n");
+}
+//#endregion
 //#region extensions/discord/src/monitor/agent-components-live-policy.ts
 async function resolveAgentComponentPolicyContext(params) {
 	if (!params.ctx.readPolicy) return params.ctx;
@@ -8108,7 +7835,7 @@ async function ensureDmComponentAuthorized(params) {
 		channel: "discord",
 		accountId: ctx.accountId,
 		upsertPairingRequest: async ({ id, meta }) => {
-			return await upsertChannelPairingRequest$1({
+			return await upsertChannelPairingRequest({
 				channel: "discord",
 				id,
 				accountId: ctx.accountId,
@@ -8258,7 +7985,7 @@ async function ensureGuildComponentMemberAllowed(params) {
 	return false;
 }
 async function ensureComponentUserAllowed(params) {
-	const allowList = normalizeDiscordAllowList(params.entry.allowedUsers, [
+	const allowList = normalizeDiscordAllowList(params.allowedUsers, [
 		"discord:",
 		"user:",
 		"pk:"
@@ -8369,6 +8096,13 @@ async function resolveAuthorizedComponentInteraction(params) {
 		});
 		return null;
 	}
+	if (params.allowedUsers !== void 0 && !await ensureComponentUserAllowed({
+		...params,
+		allowedUsers: params.allowedUsers,
+		user,
+		replyOpts,
+		allowNameMatching
+	})) return null;
 	return {
 		ctx,
 		interactionCtx,
@@ -8388,159 +8122,50 @@ async function resolveComponentCommandAuthorized(params) {
 		allowFrom: ctx.allowFrom,
 		sender: {
 			id: interactionCtx.user.id,
-			name: interactionCtx.user.username,
-			tag: formatDiscordUserTag(interactionCtx.user)
-		},
-		allowNameMatching: params.allowNameMatching
-	});
-	const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
-		channelConfig,
-		guildInfo,
-		memberRoleIds: interactionCtx.memberRoleIds,
-		sender: {
-			id: interactionCtx.user.id,
-			name: interactionCtx.user.username,
-			tag: formatDiscordUserTag(interactionCtx.user)
-		},
-		allowNameMatching: params.allowNameMatching
-	});
-	return resolveCommandAuthorizedFromAuthorizers({
-		useAccessGroups: true,
-		authorizers: [{
-			configured: ownerAllowList != null,
-			allowed: ownerOk
-		}, {
-			configured: hasAccessRestrictions,
-			allowed: memberAllowed
-		}],
-		modeWhenAccessGroupsOff: "configured"
-	});
-}
-//#endregion
-//#region extensions/discord/src/monitor/agent-components-data.ts
-function readParsedComponentId(data) {
-	if (!data || typeof data !== "object") return;
-	return "cid" in data ? data.cid : data.componentId;
-}
-function normalizeComponentId(value) {
-	if (typeof value === "string") {
-		const trimmed = value.trim();
-		return trimmed ? trimmed : void 0;
-	}
-	if (typeof value === "number" && Number.isFinite(value)) return String(value);
-}
-function mapOptionLabels(options, values) {
-	if (!options || options.length === 0) return values;
-	const map = new Map(options.map((option) => [option.value, option.label]));
-	return values.map((value) => map.get(value) ?? value);
-}
-function parseAgentComponentData(data) {
-	const raw = readParsedComponentId(data);
-	const componentId = typeof raw === "string" ? decodeCustomIdComponent(raw) : typeof raw === "number" ? String(raw) : null;
-	if (!componentId) return null;
-	return { componentId };
-}
-function parseDiscordComponentData(data, customId) {
-	if (!data || typeof data !== "object") return null;
-	const rawComponentId = readParsedComponentId(data);
-	const rawModalId = "mid" in data ? data.mid : data.modalId;
-	let componentId = normalizeComponentId(rawComponentId);
-	let modalId = normalizeComponentId(rawModalId);
-	if (!componentId && customId) {
-		const parsed = parseDiscordComponentCustomId(customId);
-		if (parsed) {
-			componentId = parsed.componentId;
-			modalId = parsed.modalId;
-		}
-	}
-	if (!componentId) return null;
-	return {
-		componentId,
-		modalId
-	};
-}
-function parseDiscordModalId(data, customId) {
-	if (data && typeof data === "object") {
-		const modalId = normalizeComponentId("mid" in data ? data.mid : data.modalId);
-		if (modalId) return modalId;
-	}
-	if (customId) return parseDiscordModalCustomId(customId);
-	return null;
-}
-function resolveInteractionCustomId(interaction) {
-	if (!interaction?.rawData || typeof interaction.rawData !== "object") return;
-	if (!("data" in interaction.rawData)) return;
-	const customId = interaction.rawData.data?.custom_id;
-	if (typeof customId !== "string") return;
-	const trimmed = customId.trim();
-	return trimmed ? trimmed : void 0;
-}
-function mapSelectValues(entry, values) {
-	if (entry.selectType === "string") return mapOptionLabels(entry.options, values);
-	if (entry.selectType === "user") return values.map((value) => `user:${value}`);
-	if (entry.selectType === "role") return values.map((value) => `role:${value}`);
-	if (entry.selectType === "mentionable") return values.map((value) => `mentionable:${value}`);
-	if (entry.selectType === "channel") return values.map((value) => `channel:${value}`);
-	return values;
-}
-function resolveModalFieldValues(field, interaction) {
-	const fields = interaction.fields;
-	const optionLabels = field.options?.map((option) => ({
-		value: option.value,
-		label: option.label
-	}));
-	const required = field.required === true;
-	try {
-		switch (field.type) {
-			case "text": {
-				const value = required ? fields.getText(field.id, true) : fields.getText(field.id);
-				return value ? [value] : [];
-			}
-			case "select":
-			case "checkbox":
-			case "radio": return mapOptionLabels(optionLabels, required ? fields.getStringSelect(field.id, true) : fields.getStringSelect(field.id) ?? []);
-			case "role-select": try {
-				return (required ? fields.getRoleSelect(field.id, true) : fields.getRoleSelect(field.id) ?? []).map((role) => role.name ?? role.id);
-			} catch {
-				return required ? fields.getStringSelect(field.id, true) : fields.getStringSelect(field.id) ?? [];
-			}
-			case "user-select": return (required ? fields.getUserSelect(field.id, true) : fields.getUserSelect(field.id) ?? []).map((user) => formatDiscordUserTag(user));
-			default: return [];
-		}
-	} catch (err) {
-		logError(`agent modal: failed to read field ${field.id}: ${String(err)}`);
-		return [];
-	}
-}
-function formatModalSubmissionText(entry, interaction) {
-	const lines = [`Form "${entry.title}" submitted.`];
-	for (const field of entry.fields) {
-		const values = resolveModalFieldValues(field, interaction);
-		if (values.length === 0) continue;
-		lines.push(`- ${field.label}: ${values.join(", ")}`);
-	}
-	if (lines.length === 1) lines.push("- (no values)");
-	return lines.join("\n");
+			name: interactionCtx.user.username,
+			tag: formatDiscordUserTag(interactionCtx.user)
+		},
+		allowNameMatching: params.allowNameMatching
+	});
+	const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
+		channelConfig,
+		guildInfo,
+		memberRoleIds: interactionCtx.memberRoleIds,
+		sender: {
+			id: interactionCtx.user.id,
+			name: interactionCtx.user.username,
+			tag: formatDiscordUserTag(interactionCtx.user)
+		},
+		allowNameMatching: params.allowNameMatching
+	});
+	return resolveCommandAuthorizedFromAuthorizers({
+		useAccessGroups: true,
+		authorizers: [{
+			configured: ownerAllowList != null,
+			allowed: ownerOk
+		}, {
+			configured: hasAccessRestrictions,
+			allowed: memberAllowed
+		}],
+		modeWhenAccessGroupsOff: "configured"
+	});
 }
 //#endregion
-//#region extensions/discord/src/monitor/agent-components-helpers.ts
-const AGENT_BUTTON_KEY = "agent";
-const AGENT_SELECT_KEY = "agentsel";
-//#endregion
 //#region extensions/discord/src/monitor/reply-context.ts
 function resolveReplyContext(message, resolveDiscordMessageText) {
-	const referenced = message.referencedMessage;
-	if (!referenced?.author) return null;
+	const id = resolveDiscordReferencedReplyMessageId(message);
+	if (!id) return null;
+	const referenced = resolveDiscordReferencedReplyMessage(message);
+	const channelId = message.messageReference?.channel_id ?? message.channelId;
+	if (!referenced?.author || referenced.id !== id) return null;
 	const referencedText = resolveDiscordMessageText(referenced, { includeForwarded: true });
-	const hasVisibleMedia = referenced.attachments.length > 0 || !referencedText && resolveDiscordMessageStickers(referenced).length > 0;
-	if (!referencedText && !hasVisibleMedia) return null;
 	const sender = resolveDiscordSenderIdentity({
 		author: referenced.author,
 		pluralkitInfo: null
 	});
 	return {
-		id: referenced.id,
-		channelId: referenced.channelId,
+		id,
+		channelId,
 		sender: sender.tag ?? sender.label ?? "unknown",
 		senderId: referenced.author.id,
 		senderName: referenced.author.username ?? void 0,
@@ -8624,14 +8249,10 @@ function formatDiscordReplySkip(params) {
 	const context = [`target=${params.target}`, params.sessionKey ? `session=${params.sessionKey}` : void 0].filter(Boolean).join(" ");
 	return `discord ${params.kind} reply skipped (${params.reason}): ${context}`;
 }
-function resolveTargetChannelId(target) {
-	if (!target.startsWith("channel:")) return;
-	return target.slice(8).trim() || void 0;
-}
 function resolveBoundThreadBinding(params) {
 	const sessionKey = params.sessionKey?.trim();
 	if (!params.threadBindings || !sessionKey) return;
-	const targetChannelId = resolveTargetChannelId(params.target);
+	const targetChannelId = params.target.startsWith("channel:") ? params.target.slice(8).trim() : void 0;
 	if (!targetChannelId) return;
 	return params.threadBindings.listBySessionKey(sessionKey).find((entry) => entry.threadId === targetChannelId);
 }
@@ -8662,27 +8283,6 @@ function createDiscordDeliveryDeps(params) {
 		})
 	};
 }
-function resolveDiscordDeliveryOptions(params) {
-	const binding = resolveBoundThreadBinding({
-		threadBindings: params.threadBindings,
-		sessionKey: params.sessionKey,
-		target: params.target
-	});
-	return {
-		to: binding ? `channel:${binding.channelId}` : params.target,
-		threadId: binding?.threadId,
-		agentId: binding?.agentId,
-		identity: resolveBindingIdentity(params.cfg, binding),
-		mediaAccess: params.mediaLocalRoots?.length ? { localRoots: params.mediaLocalRoots } : void 0,
-		replyToMode: params.replyToMode ?? "all",
-		formatting: {
-			textLimit: params.textLimit,
-			maxLinesPerMessage: params.maxLinesPerMessage,
-			tableMode: params.tableMode,
-			chunkMode: params.chunkMode
-		}
-	};
-}
 function formatDiscordReasoningPayload(payload) {
 	if (payload.isReasoning !== true) return payload;
 	const text = typeof payload.text === "string" ? payload.text.trim() : "";
@@ -8694,8 +8294,8 @@ function formatDiscordReasoningPayload(payload) {
 	return nextPayload;
 }
 async function deliverDiscordReply(params) {
-	params.runtime;
-	const delivery = resolveDiscordDeliveryOptions(params);
+	const binding = resolveBoundThreadBinding(params);
+	const to = binding ? `channel:${binding.channelId}` : params.target;
 	const payloads = sanitizeDiscordFrontChannelReplyPayloads(params.replies, { kind: params.kind }).map(formatDiscordReasoningPayload).map((payload) => params.bindPendingFinalDelivery?.(payload) ?? payload);
 	if (payloads.length === 0) return {
 		visibleReplySent: false,
@@ -8704,14 +8304,19 @@ async function deliverDiscordReply(params) {
 	const send = await sendDurableMessageBatch({
 		cfg: params.cfg,
 		channel: "discord",
-		to: delivery.to,
+		to,
 		accountId: params.accountId,
 		payloads,
 		replyToId: normalizeOptionalString(params.replyToId),
-		replyToMode: delivery.replyToMode,
-		formatting: delivery.formatting,
-		threadId: delivery.threadId,
-		identity: delivery.identity,
+		replyToMode: params.replyToMode ?? "all",
+		formatting: {
+			textLimit: params.textLimit,
+			maxLinesPerMessage: params.maxLinesPerMessage,
+			tableMode: params.tableMode,
+			chunkMode: params.chunkMode
+		},
+		threadId: binding?.threadId,
+		identity: resolveBindingIdentity(params.cfg, binding),
 		onPlatformSendDispatch: params.onPlatformSendDispatch,
 		assertDirectAdapterHandoff: params.assertPlatformSendAuthorized,
 		deps: createDiscordDeliveryDeps({
@@ -8720,11 +8325,11 @@ async function deliverDiscordReply(params) {
 			rest: params.rest,
 			allowedMentions: params.allowedMentions
 		}),
-		mediaAccess: delivery.mediaAccess,
+		mediaAccess: params.mediaLocalRoots?.length ? { localRoots: params.mediaLocalRoots } : void 0,
 		session: buildOutboundSessionContext({
 			cfg: params.cfg,
 			sessionKey: params.sessionKey,
-			agentId: delivery.agentId,
+			agentId: binding?.agentId,
 			requesterAccountId: params.accountId
 		})
 	});
@@ -8740,7 +8345,7 @@ async function deliverDiscordReply(params) {
 			}
 		};
 	}
-	if (send.results.length === 0) throw new Error(`discord final reply produced no delivered message for ${delivery.to}`);
+	if (send.results.length === 0) throw new Error(`discord final reply produced no delivered message for ${to}`);
 	const deliveryResult = {
 		messageIds: listMessageReceiptPlatformIds(send.receipt),
 		receipt: send.receipt,
@@ -8751,8 +8356,8 @@ async function deliverDiscordReply(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.dispatch.ts
-const loadConversationRuntime$1 = createLazyRuntimeModule(() => import("./agent-components.runtime-CEPrf2SY.mjs"));
-const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing-BKZL5fGj.mjs").then((n) => n.n));
+const loadReplyRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/reply-runtime"));
+const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing-BiHCzBRu.mjs").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}`;
@@ -8767,16 +8372,8 @@ function resolveDiscordComponentChatType(interactionCtx) {
 	if (interactionCtx.isGroupDm) return "group";
 	return "channel";
 }
-function resolveDiscordComponentOriginatingTo(interactionCtx) {
-	return resolveDiscordConversationIdentity({
-		isDirectMessage: interactionCtx.isDirectMessage,
-		userId: interactionCtx.userId,
-		channelId: interactionCtx.channelId
-	});
-}
 async function dispatchDiscordComponentEvent(params) {
 	const { ctx, interaction, interactionCtx, channelCtx, guildInfo, eventText } = params;
-	const runtime = ctx.runtime ?? createNonExitingRuntime();
 	const route = resolveAgentComponentRoute({
 		ctx,
 		rawGuildId: interactionCtx.rawGuildId,
@@ -8790,7 +8387,6 @@ async function dispatchDiscordComponentEvent(params) {
 	const sessionKey = params.routeOverrides?.sessionKey ?? route.sessionKey;
 	const agentId = params.routeOverrides?.agentId ?? route.agentId;
 	const accountId = params.routeOverrides?.accountId ?? route.accountId;
-	const inboundLastRouteSessionKey = sessionKey;
 	const fromLabel = buildDiscordComponentConversationLabel({
 		interactionCtx,
 		interaction,
@@ -8825,7 +8421,7 @@ async function dispatchDiscordComponentEvent(params) {
 		isGuild: !interactionCtx.isDirectMessage
 	});
 	const groupSystemPrompt = buildDiscordGroupSystemPrompt(channelConfig);
-	const pinnedMainDmOwner = interactionCtx.isDirectMessage ? resolvePinnedMainDmOwnerFromAllowlist$1({
+	const pinnedMainDmOwner = interactionCtx.isDirectMessage ? resolvePinnedMainDmOwnerFromAllowlist({
 		dmScope: ctx.cfg.session?.dmScope,
 		allowFrom: channelConfig?.users ?? guildInfo?.users,
 		normalizeEntry: (entry) => {
@@ -8844,12 +8440,17 @@ async function dispatchDiscordComponentEvent(params) {
 		guildInfo,
 		allowNameMatching
 	});
-	const storePath = resolveStorePath$1(ctx.cfg.session?.store, { agentId });
+	const storePath = resolveStorePath(ctx.cfg.session?.store, { agentId });
 	const envelopeOptions = resolveEnvelopeFormatOptions(ctx.cfg);
-	const previousTimestamp = readSessionUpdatedAt$1({
+	const previousTimestamp = readSessionUpdatedAt({
 		storePath,
 		sessionKey
 	});
+	const originatingTo = resolveDiscordConversationIdentity({
+		isDirectMessage: interactionCtx.isDirectMessage,
+		userId: interactionCtx.userId,
+		channelId: interactionCtx.channelId
+	});
 	const timestamp = Date.now();
 	const combinedBody = formatInboundEnvelope({
 		channel: "Discord",
@@ -8861,9 +8462,7 @@ async function dispatchDiscordComponentEvent(params) {
 		previousTimestamp,
 		envelope: envelopeOptions
 	});
-	const { createReplyReferencePlanner, finalizeInboundContext, resolveChunkMode, resolveTextChunkLimit } = await (async () => {
-		return { ...await loadConversationRuntime$1() };
-	})();
+	const { createReplyReferencePlanner, finalizeInboundContext, resolveChunkMode, resolveTextChunkLimit } = await loadReplyRuntime();
 	const ctxPayload = finalizeInboundContext({
 		Body: combinedBody,
 		BodyForAgent: eventText,
@@ -8905,7 +8504,7 @@ async function dispatchDiscordComponentEvent(params) {
 		MessageSid: interaction.rawData.id,
 		Timestamp: timestamp,
 		OriginatingChannel: "discord",
-		OriginatingTo: resolveDiscordComponentOriginatingTo(interactionCtx) ?? `channel:${interactionCtx.channelId}`
+		OriginatingTo: originatingTo ?? `channel:${interactionCtx.channelId}`
 	});
 	const deliverTarget = `channel:${interactionCtx.channelId}`;
 	const typingChannelId = interactionCtx.channelId;
@@ -8951,11 +8550,11 @@ async function dispatchDiscordComponentEvent(params) {
 				dispatchReplyFromConfig: ctx.channelRuntime?.reply?.dispatchReplyFromConfig,
 				record: {
 					updateLastRoute: interactionCtx.isDirectMessage ? {
-						sessionKey: inboundLastRouteSessionKey,
+						sessionKey,
 						channel: "discord",
-						to: resolveDiscordComponentOriginatingTo(interactionCtx) ?? `user:${interactionCtx.userId}`,
+						to: originatingTo ?? `user:${interactionCtx.userId}`,
 						accountId,
-						mainDmOwnerPin: inboundLastRouteSessionKey === route.mainSessionKey && pinnedMainDmOwner ? {
+						mainDmOwnerPin: sessionKey === route.mainSessionKey && pinnedMainDmOwner ? {
 							ownerRecipient: pinnedMainDmOwner,
 							senderRecipient: interactionCtx.userId,
 							onSkip: ({ ownerRecipient, senderRecipient }) => {
@@ -8977,7 +8576,6 @@ async function dispatchDiscordComponentEvent(params) {
 							token,
 							accountId,
 							rest: interaction.client.rest,
-							runtime,
 							replyToId,
 							replyToMode,
 							textLimit,
@@ -9034,7 +8632,7 @@ async function dispatchDiscordPluginInteractiveHandler(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.plugin-interactive.ts
-const loadConversationRuntime = createLazyRuntimeModule(() => import("./agent-components.runtime-CEPrf2SY.mjs"));
+const loadConversationRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/conversation-runtime"));
 async function dispatchPluginDiscordInteractiveEvent(params) {
 	const normalizedConversationId = params.interactionCtx.rawGuildId || params.channelCtx.channelType === ChannelType.GroupDM ? `channel:${params.interactionCtx.channelId}` : `user:${params.interactionCtx.userId}`;
 	let responded = false;
@@ -9089,13 +8687,16 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 			});
 		}
 	};
+	const acknowledgeSilently = async () => {
+		try {
+			await respond.acknowledge();
+		} catch {}
+	};
 	const conversationRuntime = await loadConversationRuntime();
 	const pluginBindingApproval = conversationRuntime.parsePluginBindingApprovalCustomId(params.data);
 	if (pluginBindingApproval) {
 		const { buildPluginBindingResolvedText, resolvePluginConversationBindingApproval } = conversationRuntime;
-		try {
-			await respond.acknowledge();
-		} catch {}
+		await acknowledgeSilently();
 		const resolved = await resolvePluginConversationBindingApproval({
 			approvalId: pluginBindingApproval.approvalId,
 			decision: pluginBindingApproval.decision,
@@ -9140,24 +8741,18 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 			}
 		},
 		respond,
-		onMatched: async () => {
-			try {
-				await respond.acknowledge();
-			} catch {}
-		}
+		onMatched: acknowledgeSilently
 	});
 	if (!dispatched.matched) return "unmatched";
 	if (dispatched.handled) {
-		if (!responded) try {
-			await respond.acknowledge();
-		} catch {}
+		if (!responded) await acknowledgeSilently();
 		return "handled";
 	}
 	return "unmatched";
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.handlers.ts
-const loadComponentsRuntime = createLazyRuntimeModule(() => import("./components-MqMWUWnE.mjs").then((n) => n.t));
+const loadComponentsRuntime = createLazyRuntimeModule(() => import("./components-Cq1PvIpN.mjs").then((n) => n.t));
 async function handleDiscordComponentEvent(params) {
 	const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
 	if (!parsed) {
@@ -9180,19 +8775,11 @@ async function handleDiscordComponentEvent(params) {
 		label: params.label,
 		componentLabel: params.componentLabel,
 		unauthorizedReply,
+		allowedUsers: entry.allowedUsers,
 		defer: false
 	});
 	if (!authorized) return;
-	const { ctx, interactionCtx, channelCtx, guildInfo, allowNameMatching, commandAuthorized, user, replyOpts } = authorized;
-	if (!await ensureComponentUserAllowed({
-		entry,
-		interaction: params.interaction,
-		user,
-		replyOpts,
-		componentLabel: params.componentLabel,
-		unauthorizedReply,
-		allowNameMatching
-	})) return;
+	const { ctx, interactionCtx, channelCtx, guildInfo, commandAuthorized, replyOpts } = authorized;
 	const consumed = await resolveDiscordComponentEntryWithPersistence({
 		id: parsed.componentId,
 		consume: !entry.reusable
@@ -9228,14 +8815,11 @@ async function handleDiscordComponentEvent(params) {
 		label: consumed.label,
 		values
 	});
-	try {
-		await params.interaction.reply({
-			content: "✓",
-			...replyOpts
-		});
-	} catch (err) {
-		logError(`${params.label}: failed to acknowledge interaction: ${String(err)}`);
-	}
+	await ackComponentInteraction({
+		interaction: params.interaction,
+		replyOpts,
+		label: params.label
+	});
 	await dispatchDiscordComponentEvent({
 		ctx,
 		interaction: params.interaction,
@@ -9272,25 +8856,14 @@ async function handleDiscordModalTrigger(params) {
 		await replyUnavailableComponentInteraction(params.interaction, "This form is no longer available.");
 		return;
 	}
-	const unauthorizedReply = "You are not authorized to use this form.";
-	const authorized = await resolveAuthorizedComponentInteraction({
+	if (!await resolveAuthorizedComponentInteraction({
 		ctx: params.ctx,
 		interaction: params.interaction,
 		label: params.label,
 		componentLabel: "form",
-		unauthorizedReply,
+		unauthorizedReply: "You are not authorized to use this form.",
+		allowedUsers: entry.allowedUsers,
 		defer: false
-	});
-	if (!authorized) return;
-	const { user, replyOpts, allowNameMatching } = authorized;
-	if (!await ensureComponentUserAllowed({
-		entry,
-		interaction: params.interaction,
-		user,
-		replyOpts,
-		componentLabel: "form",
-		unauthorizedReply,
-		allowNameMatching
 	})) return;
 	const consumed = await resolveDiscordComponentEntryWithPersistence({
 		id: parsed.componentId,
@@ -9325,11 +8898,11 @@ const discordComponentControlHandlers = {
 var DiscordComponentModal = class extends Modal {
 	constructor(ctx) {
 		super();
+		this.ctx = ctx;
 		this.title = "OpenClaw form";
 		this.customId = "__openclaw_discord_component_modal_wildcard__";
 		this.components = [];
 		this.customIdParser = parseDiscordModalCustomIdForInteraction;
-		this.ctx = ctx;
 	}
 	async run(interaction, data) {
 		const modalId = parseDiscordModalId(data, resolveInteractionCustomId(interaction));
@@ -9346,32 +8919,18 @@ var DiscordComponentModal = class extends Modal {
 			await replyUnavailableComponentInteraction(interaction, "This form has expired.");
 			return;
 		}
-		const unauthorizedReply = "You are not authorized to use this form.";
 		const authorized = await resolveAuthorizedComponentInteraction({
 			ctx: this.ctx,
 			interaction,
 			label: "discord component modal",
 			componentLabel: "form",
-			unauthorizedReply,
+			unauthorizedReply: "You are not authorized to use this form.",
+			allowedUsers: modalEntry.allowedUsers,
 			defer: false
 		});
 		if (!authorized) return;
 		const ctx = authorized.ctx;
-		const { interactionCtx, channelCtx, guildInfo, allowNameMatching, commandAuthorized, user, replyOpts } = authorized;
-		if (!await ensureComponentUserAllowed({
-			entry: {
-				id: modalEntry.id,
-				kind: "button",
-				label: modalEntry.title,
-				allowedUsers: modalEntry.allowedUsers
-			},
-			interaction,
-			user,
-			replyOpts,
-			componentLabel: "form",
-			unauthorizedReply,
-			allowNameMatching
-		})) return;
+		const { interactionCtx, channelCtx, guildInfo, commandAuthorized } = authorized;
 		const consumed = await resolveDiscordModalEntryWithPersistence({
 			id: modalId,
 			consume: !modalEntry.reusable
@@ -9421,6 +8980,8 @@ var DiscordComponentModal = class extends Modal {
 };
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.system-controls.ts
+const AGENT_BUTTON_KEY = "agent";
+const AGENT_SELECT_KEY = "agentsel";
 async function runAgentSystemControlInteraction(params) {
 	const parsed = parseAgentComponentData(params.data);
 	if (!parsed) {
@@ -9468,7 +9029,7 @@ async function runAgentSystemControlInteraction(params) {
 		userId
 	});
 	logDebug(`${params.label}: enqueuing event for channel ${channelId}: ${eventText}`);
-	enqueueRoutedSystemEvent$1(eventText, route, { contextKey: `${params.contextKeyPrefix}:${channelId}:${componentId}:${userId}:${params.interaction.id}` });
+	enqueueRoutedSystemEvent(eventText, route, { contextKey: `${params.contextKeyPrefix}:${channelId}:${componentId}:${userId}:${params.interaction.id}` });
 	await ackComponentInteraction({
 		interaction: params.interaction,
 		replyOpts,
@@ -9478,10 +9039,10 @@ async function runAgentSystemControlInteraction(params) {
 var AgentComponentButton = class extends Button {
 	constructor(ctx) {
 		super();
+		this.ctx = ctx;
 		this.label = AGENT_BUTTON_KEY;
 		this.customId = `${AGENT_BUTTON_KEY}:seed=1`;
 		this.style = ButtonStyle.Primary;
-		this.ctx = ctx;
 	}
 	async run(interaction, data) {
 		await runAgentSystemControlInteraction({
@@ -9501,9 +9062,9 @@ var AgentComponentButton = class extends Button {
 var AgentSelectMenu = class extends StringSelectMenu {
 	constructor(ctx) {
 		super();
+		this.ctx = ctx;
 		this.customId = `${AGENT_SELECT_KEY}:seed=1`;
 		this.options = [];
-		this.ctx = ctx;
 	}
 	async run(interaction, data) {
 		const values = interaction.values ?? [];
@@ -9622,11 +9183,8 @@ var DiscordComponentButton = class extends Button {
 		});
 	}
 };
-function createSelectControl(spec, ctx, handlers) {
-	return new DiscordComponentSelectControl(spec, ctx, handlers);
-}
 function bindSelectControl(spec) {
-	return (ctx, handlers) => createSelectControl(spec, ctx, handlers);
+	return (ctx, handlers) => new DiscordComponentSelectControl(spec, ctx, handlers);
 }
 function createDiscordComponentButtonControl(ctx, handlers) {
 	return new DiscordComponentButton(ctx, handlers);
@@ -9638,24 +9196,15 @@ const createDiscordComponentMentionableSelectControl = bindSelectControl(SELECT_
 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
-];
+	createDiscordComponentButtonControl,
+	createDiscordComponentStringSelectControl,
+	createDiscordComponentUserSelectControl,
+	createDiscordComponentRoleSelectControl,
+	createDiscordComponentMentionableSelectControl,
+	createDiscordComponentChannelSelectControl
+].map((createControl) => (ctx) => createControl(ctx, discordComponentControlHandlers));
 function createDiscordComponentModal(ctx) {
 	return new DiscordComponentModal(ctx);
 }
@@ -9700,23 +9249,19 @@ var ExecApprovalButton = class extends Button {
 	async run(interaction, data) {
 		const parsed = parseExecApprovalData(data);
 		if (!parsed) {
-			try {
-				await interaction.reply({
-					content: "This approval is no longer valid.",
-					ephemeral: true
-				});
-			} catch {}
+			await replySilently(interaction, {
+				content: "This approval is no longer valid.",
+				ephemeral: true
+			});
 			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 {}
+			await replySilently(interaction, {
+				content: "⛔ You are not authorized to approve requests.",
+				ephemeral: true
+			});
 			return;
 		}
 		const decisionLabel = parsed.action === "allow-once" ? "Allowed (once)" : parsed.action === "allow-always" ? "Allowed (always)" : "Denied";
@@ -9854,6 +9399,16 @@ function createDiscordQuestionButton(params) {
 //#region extensions/discord/src/monitor/provider.interactions.ts
 function createDiscordProviderInteractionSurface(params) {
 	const createNativeCommand = params.createNativeCommand ?? createDiscordNativeCommand;
+	const commandContext = {
+		readPolicy: params.readPolicy,
+		cfg: params.cfg,
+		discordConfig: params.discordConfig,
+		accountId: params.accountId,
+		sessionPrefix: params.sessionPrefix,
+		threadBindings: params.threadBindings,
+		buildContext: params.channelRuntime?.inbound.buildContext,
+		dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
+	};
 	const commands = params.commandSpecs.map((spec) => {
 		if (params.nativeEnabled && params.voiceEnabled && spec.name === DISCORD_VOICE_COMMAND_SPEC.name) return createDiscordVoiceCommand({
 			readPolicy: params.readPolicy,
@@ -9866,15 +9421,9 @@ function createDiscordProviderInteractionSurface(params) {
 			ephemeralDefault: params.ephemeralDefault
 		});
 		return createNativeCommand({
-			readPolicy: params.readPolicy,
+			...commandContext,
 			command: spec,
-			cfg: params.cfg,
-			discordConfig: params.discordConfig,
-			accountId: params.accountId,
-			sessionPrefix: params.sessionPrefix,
-			ephemeralDefault: params.ephemeralDefault,
-			threadBindings: params.threadBindings,
-			dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
+			ephemeralDefault: params.ephemeralDefault
 		});
 	});
 	const execApprovalsConfig = params.discordConfig.execApprovals ?? {};
@@ -9899,61 +9448,29 @@ function createDiscordProviderInteractionSurface(params) {
 		},
 		abortSignal: params.abortSignal
 	});
-	const components = [
-		createDiscordQuestionButton({
-			cfg: params.cfg,
-			accountId: params.accountId,
-			authContext: {
-				readPolicy: params.readPolicy,
-				cfg: params.cfg,
-				accountId: params.accountId,
-				discordConfig: params.discordConfig,
-				runtime: params.runtime,
-				token: params.token,
-				guildEntries: params.guildEntries,
-				allowFrom: params.allowFrom,
-				dmPolicy: params.dmPolicy
-			}
-		}),
-		createDiscordCommandArgFallbackButton({
-			readPolicy: params.readPolicy,
-			cfg: params.cfg,
-			discordConfig: params.discordConfig,
-			accountId: params.accountId,
-			sessionPrefix: params.sessionPrefix,
-			threadBindings: params.threadBindings,
-			dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
-		}),
-		createDiscordModelPickerFallbackButton({
-			readPolicy: params.readPolicy,
-			cfg: params.cfg,
-			discordConfig: params.discordConfig,
-			accountId: params.accountId,
-			sessionPrefix: params.sessionPrefix,
-			threadBindings: params.threadBindings,
-			dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
-		}),
-		createDiscordModelPickerFallbackSelect({
-			readPolicy: params.readPolicy,
-			cfg: params.cfg,
-			discordConfig: params.discordConfig,
-			accountId: params.accountId,
-			sessionPrefix: params.sessionPrefix,
-			threadBindings: params.threadBindings,
-			dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
-		})
-	];
-	const activityButton = createDiscordActivityButton({
+	const componentContext = {
 		readPolicy: params.readPolicy,
 		cfg: params.cfg,
-		discordConfig: params.discordConfig,
 		accountId: params.accountId,
+		discordConfig: params.discordConfig,
+		runtime: params.runtime,
+		token: params.token,
 		guildEntries: params.guildEntries,
 		allowFrom: params.allowFrom,
-		dmPolicy: params.dmPolicy,
-		runtime: params.runtime,
-		channelRuntime: params.channelRuntime,
-		token: params.token
+		dmPolicy: params.dmPolicy
+	};
+	const components = [createDiscordQuestionButton({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		authContext: componentContext
+	}), ...[
+		createDiscordCommandArgFallbackButton,
+		createDiscordModelPickerFallbackButton,
+		createDiscordModelPickerFallbackSelect
+	].map((create) => create(commandContext))];
+	const activityButton = createDiscordActivityButton({
+		...componentContext,
+		channelRuntime: params.channelRuntime
 	}, params.applicationId);
 	if (activityButton) components.push(activityButton);
 	const modals = [];
@@ -9963,17 +9480,6 @@ function createDiscordProviderInteractionSurface(params) {
 		config: execApprovalsConfig
 	})));
 	if ((params.discordConfig.agentComponents ?? {}).enabled ?? true) {
-		const componentContext = {
-			readPolicy: params.readPolicy,
-			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));
@@ -10015,7 +9521,7 @@ var VoicePlugin = class extends Plugin {
 					}
 				},
 				destroy: () => {
-					this.adapters.delete(guildId);
+					if (this.adapters.get(guildId) === methods) this.adapters.delete(guildId);
 				}
 			};
 		};
@@ -10027,11 +9533,7 @@ function resolveDiscordPreflightChannelAccess(params) {
 	if (params.isGuildMessage && params.channelConfig?.enabled === false) {
 		logDebug(`[discord-preflight] drop: channel disabled`);
 		logVerbose(`Blocked discord channel ${params.messageChannelId} (channel disabled, ${params.channelMatchMeta})`);
-		return {
-			allowed: false,
-			channelAllowlistConfigured: false,
-			channelAllowed: false
-		};
+		return false;
 	}
 	const groupDmAllowed = params.isGroupDm && resolveGroupDmAllow({
 		channels: params.groupDmChannels,
@@ -10039,11 +9541,7 @@ function resolveDiscordPreflightChannelAccess(params) {
 		channelName: params.displayChannelName,
 		channelSlug: params.displayChannelSlug
 	});
-	if (params.isGroupDm && !groupDmAllowed) return {
-		allowed: false,
-		channelAllowlistConfigured: false,
-		channelAllowed: false
-	};
+	if (params.isGroupDm && !groupDmAllowed) return false;
 	const channelAllowlistConfigured = Boolean(params.guildInfo?.channels) && Object.keys(params.guildInfo?.channels ?? {}).length > 0;
 	const channelAllowed = params.channelConfig?.allowed !== false;
 	if (params.isGuildMessage && !isDiscordGroupAllowedByPolicy({
@@ -10062,30 +9560,18 @@ function resolveDiscordPreflightChannelAccess(params) {
 			logDebug(`[discord] Ignored message from channel ${params.messageChannelId} (not in guild allowlist). Add to guilds.<guildId>.channels to enable.`);
 			logVerbose(`Blocked discord channel ${params.messageChannelId} not in guild channel allowlist (groupPolicy: allowlist, ${params.channelMatchMeta})`);
 		}
-		return {
-			allowed: false,
-			channelAllowlistConfigured,
-			channelAllowed
-		};
+		return false;
 	}
 	if (params.isGuildMessage && params.channelConfig?.allowed === false) {
 		logDebug(`[discord-preflight] drop: channelConfig.allowed===false`);
 		logVerbose(`Blocked discord channel ${params.messageChannelId} not in guild channel allowlist (${params.channelMatchMeta})`);
-		return {
-			allowed: false,
-			channelAllowlistConfigured,
-			channelAllowed
-		};
+		return false;
 	}
 	if (params.isGuildMessage) {
 		logDebug(`[discord-preflight] pass: channel allowed`);
 		logVerbose(`discord: allow channel ${params.messageChannelId} (${params.channelMatchMeta})`);
 	}
-	return {
-		allowed: true,
-		channelAllowlistConfigured,
-		channelAllowed
-	};
+	return true;
 }
 //#endregion
 //#region extensions/discord/src/monitor/listeners.guild-join.ts
@@ -10142,7 +9628,7 @@ var DiscordGuildJoinIntroductionListener = class extends GuildCreateListener {
 				guildInfo,
 				channelConfig,
 				channelMatchMeta: `guild=${data.id} channel=${channel.id}`
-			}).allowed;
+			});
 			if (roomAllowed) {
 				targetChannel = channel;
 				break;
@@ -10216,11 +9702,7 @@ var DiscordGuildJoinIntroductionListener = class extends GuildCreateListener {
 //#region extensions/discord/src/monitor/provider.startup.ts
 function registerLatePlugin(client, plugin) {
 	plugin.registerClient?.(client);
-	plugin.registerRoutes?.(client);
-	if (!client.plugins.some((entry) => entry.id === plugin.id)) client.plugins.push({
-		id: plugin.id,
-		plugin
-	});
+	if (!client.plugins.some((entry) => entry.id === plugin.id)) client.plugins.push(plugin);
 }
 function createDiscordStatusReadyListener(params) {
 	return new class DiscordStatusReadyListener extends ReadyListener {
@@ -10232,21 +9714,17 @@ function createDiscordStatusReadyListener(params) {
 			}
 			const gateway = client.getPlugin("gateway");
 			if (!gateway) return;
-			const presence = resolveDiscordPresenceUpdate(params.discordConfig);
-			if (!presence) return;
-			gateway.updatePresence(presence);
+			gateway.updatePresence(resolveDiscordPresenceUpdate(params.discordConfig));
 		}
 	}();
 }
 async function createDiscordMonitorClient(params) {
 	let autoPresenceController = null;
-	const clientPlugins = [params.createGatewayPlugin({
+	const constructorPlugins = [params.createGatewayPlugin({
 		discordConfig: params.discordConfig,
 		runtime: params.runtime
 	})];
-	if (params.voiceEnabled) clientPlugins.push(new VoicePlugin());
-	const voicePlugin = clientPlugins.find((plugin) => plugin.id === "voice");
-	const constructorPlugins = voicePlugin ? clientPlugins.filter((plugin) => plugin !== voicePlugin) : clientPlugins;
+	const voicePlugin = params.voiceEnabled ? new VoicePlugin() : void 0;
 	const eventQueueOpts = {
 		listenerTimeout: 12e4,
 		slowListenerThreshold: 3e4
@@ -10256,16 +9734,11 @@ async function createDiscordMonitorClient(params) {
 		getAutoPresenceController: () => autoPresenceController
 	});
 	const client = params.createClient({
-		baseUrl: "http://localhost",
-		deploySecret: "a",
 		clientId: params.applicationId,
-		publicKey: "a",
 		token: params.token,
-		autoDeploy: false,
 		commandDeployHashStore: params.commandDeployHashStore,
 		requestOptions: {
 			timeout: DISCORD_REST_TIMEOUT_MS,
-			runtimeProfile: "persistent",
 			maxQueueSize: 1e3,
 			...params.restFetch ? { fetch: params.restFetch } : {}
 		},
@@ -10319,9 +9792,8 @@ async function fetchDiscordBotIdentity(params) {
 		params.logStartupPhase("fetch-bot-identity:error", String(err));
 		throw new Error("Failed to resolve Discord bot identity", { cause: err });
 	}
-	const botUserRecord = botUser;
-	const botUserId = normalizeOptionalString(botUserRecord?.id);
-	const botUserName = normalizeOptionalString(botUserRecord?.username) ?? normalizeOptionalString(botUserRecord?.globalName);
+	const botUserId = normalizeOptionalString(botUser?.id);
+	const botUserName = normalizeOptionalString(botUser?.username) ?? normalizeOptionalString(botUser?.globalName);
 	if (!botUserId) {
 		const details = "fetchUser(\"@me\") returned no usable id";
 		params.runtime.error?.(danger(`discord: failed to fetch bot identity: ${details}`));
@@ -10405,12 +9877,6 @@ function formatDiscordStartupStatusMessage(params) {
 //#endregion
 //#region extensions/discord/src/monitor/provider.ts
 const DEFAULT_DISCORD_MEDIA_MAX_MB = 100;
-function logDiscordStartupPhase(params) {
-	logDiscordStartupPhase$1({
-		...params,
-		isVerbose: discordProviderRuntime.isVerbose
-	});
-}
 const DISCORD_DISALLOWED_INTENTS_CODE = GatewayCloseCodes$1.DisallowedIntents;
 function isDiscordDisallowedIntentsError(err) {
 	if (!err) return false;
@@ -10427,6 +9893,16 @@ async function monitorDiscordProvider(opts = {}) {
 	const token = normalizeDiscordToken(opts.token ?? void 0, "channels.discord.token") ?? account.token;
 	if (!token) throw new Error(`Discord bot token missing for account "${account.accountId}" (set discord.accounts.${account.accountId}.token or DISCORD_BOT_TOKEN for default).`);
 	const runtime = opts.runtime ?? createNonExitingRuntime();
+	let lifecycleGateway;
+	const logStartupPhase = (phase, details) => logDiscordStartupPhase({
+		runtime,
+		accountId: account.accountId,
+		phase,
+		startAt: startupStartedAt,
+		gateway: lifecycleGateway,
+		details,
+		isVerbose: discordProviderRuntime.isVerbose
+	});
 	const rawDiscordCfg = account.config;
 	const discordRestFetch = resolveDiscordRestFetch(rawDiscordCfg.proxy, runtime);
 	const dmConfig = rawDiscordCfg.dm;
@@ -10456,7 +9932,7 @@ async function monitorDiscordProvider(opts = {}) {
 	let allowFrom = configuredDmAllowFrom ?? [];
 	const mediaMaxBytes = (opts.mediaMaxMb ?? discordCfg.mediaMaxMb ?? DEFAULT_DISCORD_MEDIA_MAX_MB) * 1024 * 1024;
 	const textLimit = resolveTextChunkLimit(cfg, "discord", account.accountId, { fallbackLimit: 2e3 });
-	const historyLimit = Math.max(0, opts.historyLimit ?? discordCfg.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? 20);
+	const historyLimit = resolvePromptHistoryLimit(opts.historyLimit ?? discordCfg.historyLimit ?? cfg.messages?.groupChat?.historyLimit, 20);
 	const replyToMode = opts.replyToMode ?? discordCfg.replyToMode ?? "off";
 	const dmEnabled = dmConfig?.enabled ?? true;
 	const dmPolicy = resolveDiscordAccountDmPolicy({
@@ -10532,12 +10008,7 @@ async function monitorDiscordProvider(opts = {}) {
 		threadBindingIdleTimeoutMs,
 		threadBindingMaxAgeMs
 	});
-	logDiscordStartupPhase({
-		runtime,
-		accountId: account.accountId,
-		phase: "fetch-application-id:start",
-		startAt: startupStartedAt
-	});
+	logStartupPhase("fetch-application-id:start");
 	const parsedApplicationId = (typeof discordCfg.applicationId === "string" && discordCfg.applicationId.trim() ? discordCfg.applicationId.trim() : void 0) ?? parseApplicationIdFromToken(token);
 	const applicationIdProbe = parsedApplicationId ? {
 		kind: "resolved",
@@ -10563,13 +10034,7 @@ async function monitorDiscordProvider(opts = {}) {
 		throw new Error(message, { cause: applicationIdProbe.error });
 	}
 	const applicationId = applicationIdProbe.applicationId;
-	logDiscordStartupPhase({
-		runtime,
-		accountId: account.accountId,
-		phase: "fetch-application-id:done",
-		startAt: startupStartedAt,
-		details: `applicationId=${applicationId}`
-	});
+	logStartupPhase("fetch-application-id:done", `applicationId=${applicationId}`);
 	const { commandSpecs } = await resolveDiscordProviderCommandSpecs({
 		cfg,
 		runtime,
@@ -10592,7 +10057,6 @@ async function monitorDiscordProvider(opts = {}) {
 	let deactivateMessageHandler;
 	let stopMonitorListeners;
 	let autoPresenceController = null;
-	let lifecycleGateway;
 	let earlyGatewayEmitter = gatewaySupervisor?.emitter;
 	let onEarlyGatewayDebug;
 	try {
@@ -10672,14 +10136,7 @@ async function monitorDiscordProvider(opts = {}) {
 			runtime.log?.(`discord startup [${account.accountId}] gateway-debug ${Math.max(0, Date.now() - startupStartedAt)}ms ${String(msg)}`);
 		};
 		earlyGatewayEmitter?.on("debug", onEarlyGatewayDebug);
-		logDiscordStartupPhase({
-			runtime,
-			accountId: account.accountId,
-			phase: "deploy-commands:schedule",
-			startAt: startupStartedAt,
-			gateway: lifecycleGateway,
-			details: `native=${nativeEnabled ? "on" : "off"} reconcile=on commandCount=${commands.length}`
-		});
+		logStartupPhase("deploy-commands:schedule", `native=${nativeEnabled ? "on" : "off"} reconcile=on commandCount=${commands.length}`);
 		runDiscordCommandDeployInBackground({
 			client,
 			runtime,
@@ -10695,14 +10152,7 @@ async function monitorDiscordProvider(opts = {}) {
 			client,
 			token,
 			runtime,
-			logStartupPhase: (phase, details) => logDiscordStartupPhase({
-				runtime,
-				accountId: account.accountId,
-				phase,
-				startAt: startupStartedAt,
-				gateway: lifecycleGateway,
-				details
-			})
+			logStartupPhase
 		});
 		let voiceManager = null;
 		if (voiceEnabled) {
@@ -10779,13 +10229,7 @@ async function monitorDiscordProvider(opts = {}) {
 			messageHandler,
 			trackInboundEvent
 		});
-		logDiscordStartupPhase({
-			runtime,
-			accountId: account.accountId,
-			phase: "client-start",
-			startAt: startupStartedAt,
-			gateway: lifecycleGateway
-		});
+		logStartupPhase("client-start");
 		const botIdentity = botUserId && botUserName ? `${botUserId} (${botUserName})` : botUserId ?? botUserName ?? "";
 		runtime.log?.(formatDiscordStartupStatusMessage({
 			gatewayReady: lifecycleGateway?.isConnected === true,
@@ -10824,4 +10268,4 @@ async function monitorDiscordProvider(opts = {}) {
 	}
 }
 //#endregion
-export { resolveDiscordTextCommandAccess as S, handleDiscordDmCommandDecision as _, formatDiscordReplySkip as a, registerDiscordListener as b, buildGuildLabel as c, resolveDiscordGatewayIntents as d, waitForDiscordGatewayPluginRegistration as f, createDiscordSupplementalContextAccessChecker as g, buildDiscordInboundAccessContext as h, formatDiscordReplyDeliveryFailure as i, resolveReplyContext as l, buildDiscordGroupSystemPrompt as m, resolveDiscordPreflightChannelAccess as n, sanitizeDiscordFrontChannelReplyPayloads as o, createDiscordNativeCommand as p, deliverDiscordReply as r, buildDirectLabel as s, monitorDiscordProvider as t, createDiscordGatewayPlugin as u, createDiscordLivePolicyReader as v, resolveDiscordDmCommandAccess as x, mapGatewayDispatchData as y };
+export { resolveDiscordDmCommandAccess as A, buildDiscordGroupSystemPrompt as C, createDiscordLivePolicyReader as D, handleDiscordDmCommandDecision as E, mapGatewayDispatchData as O, createDiscordNativeCommand as S, createDiscordSupplementalContextAccessChecker as T, resolveDiscordVoiceMode as _, formatDiscordReplySkip as a, resolveDiscordGatewayIntents as b, buildGuildLabel as c, MIN_SEGMENT_SECONDS as d, VOICE_CONNECT_READY_TIMEOUT_MS as f, logVoiceVerbose as g, isVoiceChannel as h, formatDiscordReplyDeliveryFailure as i, resolveDiscordTextCommandAccess as j, registerDiscordListener as k, resolveReplyContext as l, isDiscordRealtimeVoiceMode as m, resolveDiscordPreflightChannelAccess as n, sanitizeDiscordFrontChannelReplyPayloads as o, VOICE_RECONNECT_GRACE_MS as p, deliverDiscordReply as r, buildDirectLabel as s, monitorDiscordProvider as t, CAPTURE_FINALIZE_GRACE_MS as u, resolveVoiceTimeoutMs as v, buildDiscordInboundAccessContext as w, waitForDiscordGatewayPluginRegistration as x, createDiscordGatewayPlugin as y };