@openclaw/discord 2026.9.4 → 2026.9.6

package/dist/{provider-DmRHCZ_K.js → .setup/provider-iOf73HW-.mjs}

@@ -1,47 +1,48 @@
-import { C as Command, D as User, E as Message, I as Button, J as TextDisplay, K as Separator, N as Modal, O as hasDiscordV2Components, R as Container, T as Guild, W as Row, Z as BaseMessageInteractiveComponent, a as MessageCreateListener, c as PresenceUpdateListener, d as ThreadDeleteListener, f as ThreadUpdateListener, h as Plugin, i as InteractionCreateListener, l as ReadyListener, m as Client, n as GuildCreateListener, o as MessageReactionAddListener, q as StringSelectMenu, r as GuildDeleteListener, s as MessageReactionRemoveListener, t as discord_exports, v as RateLimitError, w as CommandWithSubcommands } from "./discord-CmL3ati-.js";
-import { C as parseDiscordActivityCustomIdForInteraction, D as parseDiscordModalCustomIdForInteraction, E as parseDiscordModalCustomId, O as decodeCustomIdComponent, T as parseDiscordComponentCustomIdForInteraction, c as parseExecApprovalData, k as encodeCustomIdComponent, o as parseDiscordQuestionData, w as parseDiscordComponentCustomId, y as buildDiscordActivityCustomId } from "./components-DBFTIN6P.js";
-import { S as resolveTimestampMs, _ as resolveGroupDmAllow, a as normalizeDiscordSlug, b as formatDiscordUserTag, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordGuildEntry, f as resolveDiscordMemberAccessState, h as resolveDiscordOwnerAllowFrom, i as normalizeDiscordDisplaySlug, l as resolveDiscordChannelPolicyCommandAuthorizer, m as resolveDiscordOwnerAccess, n as isDiscordGroupAllowedByPolicy, o as resolveDiscordAllowListMatch, p as resolveDiscordMemberAllowed, r as normalizeDiscordAllowList, s as resolveDiscordChannelConfig, v as shouldEmitDiscordReactionNotification, y as formatDiscordReactionEmoji } from "./allow-list-DWEio925.js";
-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.js";
-import { a as resolveDiscordComponentEntryWithPersistence, o as resolveDiscordModalEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-BWnkX4QN.js";
-import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
-import { a as isDiscordRateLimitResponseBody, o as summarizeDiscordResponseBody } from "./api-LIV--eMq.js";
-import { o as chunkDiscordTextWithMode } from "./retry-DKeoT7UO.js";
-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-BHPM3CSl.js";
-import { o as formatMention, t as sendMessageDiscord } from "./send.outbound-BVTWrl_4.js";
-import { t as isDiscordThreadChannelType } from "./channel-type-CVLZyGYS.js";
-import { n as getDiscordActivitiesRuntime } from "./runtime-CbknwoBH.js";
-import { t as resolveDiscordCommandOwnerAllowFrom } from "./command-owners-D78sAoOz.js";
-import { n as resolveDiscordChannelInfoSafe, o as resolveDiscordChannelTopicSafe, r as resolveDiscordChannelNameSafe } from "./channel-access-C12aDZ0p.js";
-import { T as resolveDiscordMessageStickers, a as authorizeDiscordVoiceIngress, c as resolveDiscordThreadLikeChannelContext, i as resolveDiscordVoiceEnabled, l as resolveFetchedDiscordThreadLikeChannelContext, o as resolveDiscordVoiceAccess, r as setDiscordTranscriptsVoiceManager } from "./transcripts-source-VkgenQv-.js";
-import { i as setPresence, t as clearPresences } from "./presence-cache-dYSHPWMx.js";
-import { _ as readMessagesDiscord, s as sendVoiceMessageDiscord } from "./send-CLpzfzJe.js";
-import { c as raceWithTimeout, u as withAbortTimeout } from "./timeouts-D86uWLt_.js";
-import { S as isDiscordExecApprovalClientEnabled, b as getDiscordExecApprovalApprovers, c as resolveDiscordEffectiveRoute, i as buildDiscordConversationRouteContext, n as DISCORD_APPROVAL_ALLOWED_MENTIONS, o as resolveDiscordBoundConversationRoute, r as formatDiscordApprovalDisplayValue, u as resolveDiscordConversationIdentity } from "./outbound-session-route-B0N6os97.js";
-import { n as discordIngressIdentity, t as selectDiscordLivePolicyConfig } from "./live-policy-config-BblutQAq.js";
-import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-VbpLmUS8.js";
-import { t as resolveDiscordUserAllowlist } from "./resolve-users-D-wRFsd5.js";
-import { a as isThreadArchived, l as formatThreadBindingDurationLabel, r as getThreadBindingManager } from "./thread-bindings.manager-BeUxc8nr.js";
-import { a as probeDiscordApplicationId, r as parseApplicationIdFromToken } from "./probe-BcoN44eK.js";
-import { i as sanitizeRecentModels, n as normalizeModelRef, r as preferenceTimestampMs, t as buildPreferenceModelKey } from "./model-picker-preference-primitives-BHT1LkR_.js";
-import { t as resolveDiscordSenderIdentity } from "./sender-identity-f3l5OYgV.js";
+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-yBEb75bB.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-ChY21qr-.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-BEYkDy0P.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-VNvWfX2T.mjs";
+import { o as formatMention, t as sendMessageDiscord } from "./send.outbound-QTyuFupn.mjs";
+import { n as getDiscordActivitiesRuntime } from "./runtime-DisDbixd.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 { O as resolveDiscordMessageStickers, c as authorizeDiscordVoiceIngress, d as resolveDiscordThreadLikeChannelContext, f as resolveFetchedDiscordThreadLikeChannelContext, i as setDiscordTranscriptsVoiceManager, l as resolveDiscordVoiceAccess, s as resolveDiscordVoiceEnabled } from "./transcripts-source-DVegW0WI.mjs";
+import { i as setPresence, t as clearPresences } from "./presence-cache-dYSHPWMx.mjs";
+import { _ as readMessagesDiscord, s as sendVoiceMessageDiscord } from "./send-CIBzvXjS.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, u as buildDiscordRoutePeer } from "./outbound-session-route-VulUE0yV.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 { o as isThreadArchived, r as getThreadBindingManager, u as formatThreadBindingDurationLabel } from "./thread-bindings.manager-ve-i6oqt.mjs";
+import { a as probeDiscordApplicationId, r as parseApplicationIdFromToken } from "./probe-CupW4we4.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-jf9zMaIC.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 { MAX_DATE_TIMESTAMP_MS, MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, asSafeIntegerInRange, parseFiniteNumber, parseStrictInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolvePromptHistoryLimit, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { inspect } from "node:util";
+import { createHttp1EnvHttpProxyAgent, createHttp1ProxyAgent, createNodeProxyAgent, resolveEnvHttpProxyAgentOptions, wrapFetchWithAbortSignal } from "openclaw/plugin-sdk/fetch-runtime";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
-import { PlatformMessageNotDispatchedError, formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
-import { fetchWithSsrFGuard, formatErrorMessage as formatErrorMessage$1 } from "openclaw/plugin-sdk/ssrf-runtime";
+import { fetchWithSsrFGuard, formatErrorMessage, resolvePinnedHostnameWithPolicy } from "openclaw/plugin-sdk/ssrf-runtime";
+import { PlatformMessageNotDispatchedError, formatErrorMessage as formatErrorMessage$1, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
 import { asFiniteNumber, asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries, parseFiniteNumber as parseFiniteNumber$1, parseStrictNonNegativeInteger as parseStrictNonNegativeInteger$1, summarizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createRuntimeConfigReader, getRuntimeConfig, getRuntimeConfigSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
-import { resolveSendableOutboundReplyParts, resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
-import { createHttp1EnvHttpProxyAgent, createHttp1ProxyAgent, createNodeProxyAgent, resolveEnvHttpProxyAgentOptions, wrapFetchWithAbortSignal } from "openclaw/plugin-sdk/fetch-runtime";
+import { renderPresentationForDelivery } from "openclaw/plugin-sdk/interactive-runtime";
+import { hasOutboundReplyContent, resolveSendableOutboundReplyParts, resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
 import { createNonExitingRuntime, createSubsystemLogger, danger, formatDurationSeconds, isVerbose, logVerbose, shouldLogVerbose, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { sliceUtf16Safe, truncateUtf16Safe, withTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
 import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, canonicalizeAllowlistWithResolvedIds, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
@@ -52,23 +53,23 @@ 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 { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-runtime";
-import { createChannelPartialDeliveryError, dispatchChannelInboundTurn, formatInboundEnvelope, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, resolveEnvelopeFormatOptions, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent } from "openclaw/plugin-sdk/channel-inbound";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+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 { 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 { 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 { clearExpiredCooldowns, ensureAuthProfileStore, formatReasoningMessage, getPreparedModelCatalogSnapshot, isProfileInCooldown, listAgentIds, loadPreparedModelCatalog, resolveAgentAvatar, resolveAgentDir, resolveDefaultModelForAgent, resolveHumanDelayConfig, resolveProfilesUnavailableReason } from "openclaw/plugin-sdk/agent-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 { resolveRequestUrl } from "openclaw/plugin-sdk/request-url";
@@ -78,6 +79,7 @@ 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";
 import { resolveDirectStatusReplyForSession } from "openclaw/plugin-sdk/command-status-runtime";
+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";
@@ -176,7 +178,7 @@ function resolveDiscordOnlinePresenceEvent(params) {
 //#region extensions/discord/src/monitor/presence-cooldown-store.ts
 const DISCORD_PRESENCE_COOLDOWN_MAX_ENTRIES = 25e3;
 function openDiscordPresenceCooldownStore() {
-	return getDiscordRuntime().state.openSyncKeyedStore({
+	return getDiscordRuntime().state.openKeyedStore({
 		namespace: "presence-greeting-cooldowns",
 		maxEntries: DISCORD_PRESENCE_COOLDOWN_MAX_ENTRIES,
 		overflowPolicy: "reject-new",
@@ -379,7 +381,7 @@ function createDiscordDynamicAccessGroupResolver(params) {
 	};
 }
 function createDiscordIngressResolver(params) {
-	return createChannelIngressResolver({
+	return getDiscordRuntime().channel.inbound.ingress.createResolver({
 		channelId: DISCORD_CHANNEL_ID,
 		accountId: params.accountId,
 		identity: discordIngressIdentity,
@@ -909,11 +911,14 @@ var DiscordPresenceListener = class extends PresenceUpdateListener {
 		this.pendingGuildSeeds = /* @__PURE__ */ new Map();
 		this.guildPresenceState = /* @__PURE__ */ new Map();
 		this.gatewayGeneration = 0;
+		this.stopped = false;
+		this.activeRuns = /* @__PURE__ */ new Set();
 		this.cooldownStore = params.cooldownStore ?? openDiscordPresenceCooldownStore();
 		this.presenceBaseline = params.presenceBaseline ?? new DiscordPresenceBaselineCache();
 		this.emissionGate = params.emissionGate ?? new DiscordPresenceEmissionGate();
 	}
 	async seedGuildSnapshot(data) {
+		if (this.stopped) return;
 		if (data.unavailable !== true && "presences" in data && Array.isArray(data.presences)) for (const presence of data.presences) {
 			const userId = presence.user?.id;
 			if (userId) setPresence(this.params.accountId, userId, {
@@ -970,23 +975,31 @@ var DiscordPresenceListener = class extends PresenceUpdateListener {
 	}
 	async handle(data, client) {
 		const userId = data.user?.id;
-		if (!userId) return;
+		if (!userId || this.stopped) return;
 		setPresence(this.params.accountId, userId, data);
 		const pendingSeed = this.pendingGuildSeeds.get(data.guild_id);
 		if (pendingSeed && !await pendingSeed) return;
+		if (this.stopped) return;
 		const presenceKey = `${this.params.accountId}:${data.guild_id}:${userId}`;
 		const gatewayGeneration = this.gatewayGeneration;
 		const guildGeneration = this.guildPresenceState.get(data.guild_id)?.generation ?? 0;
 		const run = (this.pendingByGuildUser.get(presenceKey) ?? Promise.resolve()).then(() => this.handleSerial(data, client, userId, presenceKey, gatewayGeneration, guildGeneration), () => this.handleSerial(data, client, userId, presenceKey, gatewayGeneration, guildGeneration));
 		this.pendingByGuildUser.set(presenceKey, run);
+		this.activeRuns.add(run);
 		try {
 			await run;
 		} catch (err) {
 			(this.params.logger ?? discordEventQueueLog).error(danger(`discord presence handler failed: ${String(err)}`));
 		} finally {
+			this.activeRuns.delete(run);
 			if (this.pendingByGuildUser.get(presenceKey) === run) this.pendingByGuildUser.delete(presenceKey);
 		}
 	}
+	async stop() {
+		this.stopped = true;
+		this.resetGatewaySession();
+		await Promise.allSettled(this.activeRuns);
+	}
 	resetGatewaySession() {
 		this.gatewayGeneration += 1;
 		this.emissionGate.noteGatewaySessionReset(this.params.nowMs?.() ?? Date.now());
@@ -1021,6 +1034,8 @@ var DiscordPresenceListener = class extends PresenceUpdateListener {
 		})?.presenceEvents;
 		if (!config || config.enabled === false) return;
 		if (config.users !== void 0 && !config.users.includes(userId)) return;
+		const lastEmittedAtMs = await this.cooldownStore.lookup(presenceKey);
+		if (!this.isCurrentGeneration(data.guild_id, gatewayGeneration, guildGeneration) || policy?.isCurrent() === false) return;
 		const nowMs = this.params.nowMs?.() ?? Date.now();
 		const presenceScope = data.guild_id;
 		const presenceEvent = resolveDiscordOnlinePresenceEvent({
@@ -1029,7 +1044,7 @@ var DiscordPresenceListener = class extends PresenceUpdateListener {
 			availabilityKind: this.presenceBaseline.isOffline(presenceScope, presenceKey) ? "observed-offline" : this.guildPresenceState.get(data.guild_id)?.inferUnknownAsNewlyAvailable === true && !this.presenceBaseline.isOnline(presenceScope, presenceKey) ? "first-seen-after-snapshot" : null,
 			botUserId: this.params.botUserId,
 			nowMs,
-			lastEmittedAtMs: this.cooldownStore.lookup(presenceKey)
+			lastEmittedAtMs
 		});
 		if (!presenceEvent) {
 			if (isDiscordOfflineStatus(data.status)) this.recordPresenceBaseline(data.guild_id, presenceKey, "offline");
@@ -1090,7 +1105,8 @@ var DiscordPresenceListener = class extends PresenceUpdateListener {
 				}
 			});
 			try {
-				cooldownReserved = this.cooldownStore.registerIfAbsent(presenceKey, nowMs, { ttlMs: DISCORD_PRESENCE_GREETING_COOLDOWN_MS });
+				cooldownReserved = await this.cooldownStore.registerIfAbsent(presenceKey, nowMs, { ttlMs: DISCORD_PRESENCE_GREETING_COOLDOWN_MS });
+				if (!this.isCurrentGeneration(data.guild_id, gatewayGeneration, guildGeneration) || policy?.isCurrent() === false) return;
 				if (!cooldownReserved) {
 					this.recordPresenceBaseline(data.guild_id, presenceKey, "online");
 					return;
@@ -1124,11 +1140,11 @@ var DiscordPresenceListener = class extends PresenceUpdateListener {
 			});
 		} finally {
 			if (!burstCommitted) this.emissionGate.releaseBurst(data.guild_id, burstReservation);
-			if (cooldownReserved && !burstCommitted && this.cooldownStore.lookup(presenceKey) === nowMs) this.cooldownStore.delete(presenceKey);
+			if (cooldownReserved && !burstCommitted) await this.cooldownStore.deleteIfEqual?.(presenceKey, nowMs);
 		}
 	}
 	isCurrentGeneration(guildId, gatewayGeneration, guildGeneration) {
-		return gatewayGeneration === this.gatewayGeneration && guildGeneration === (this.guildPresenceState.get(guildId)?.generation ?? 0);
+		return !this.stopped && gatewayGeneration === this.gatewayGeneration && guildGeneration === (this.guildPresenceState.get(guildId)?.generation ?? 0);
 	}
 	recordPresenceBaseline(guildId, key, status) {
 		const evictedGuildId = status === "offline" ? this.presenceBaseline.observeOffline(guildId, key) : this.presenceBaseline.observeOnline(guildId, key);
@@ -1164,30 +1180,49 @@ var DiscordPresenceReadyListener = class extends ReadyListener {
 		this.presenceListener.resetGatewaySession();
 	}
 };
+const DISCORD_THREAD_REJOIN_CLAIM_MAX_ENTRIES = 1e4;
 var DiscordThreadUpdateListener = class extends ThreadUpdateListener {
 	constructor(cfg, logger) {
 		super();
 		this.cfg = cfg;
 		this.logger = logger;
+		this.rejoinClaims = /* @__PURE__ */ new Map();
 	}
-	async handle(data) {
+	resetGatewaySession() {
+		this.rejoinClaims.clear();
+	}
+	async handle(data, client) {
 		await runDiscordListenerWithSlowLog({
 			logger: this.logger,
 			listener: this.constructor.name,
 			event: this.type,
 			run: async () => {
-				if (!isThreadArchived(data)) return;
 				const threadId = "id" in data && typeof data.id === "string" ? data.id : void 0;
 				if (!threadId) return;
 				const logger = this.logger ?? discordEventQueueLog;
-				const count = await closeDiscordThreadSessions({
-					cfg: this.cfg,
-					threadId
-				});
-				if (count > 0) logger.info("Discord thread archived — reset sessions", {
-					threadId,
-					count
-				});
+				if (isThreadArchived(data)) {
+					this.rejoinClaims.delete(threadId);
+					const count = await closeDiscordThreadSessions({
+						cfg: this.cfg,
+						threadId
+					});
+					if (count > 0) logger.info("Discord thread archived — reset sessions", {
+						threadId,
+						count
+					});
+					return;
+				}
+				if (this.rejoinClaims.has(threadId)) return;
+				const claim = Symbol(threadId);
+				this.rejoinClaims.set(threadId, claim);
+				pruneMapToMaxSize(this.rejoinClaims, DISCORD_THREAD_REJOIN_CLAIM_MAX_ENTRIES);
+				try {
+					await client.rest.put(`/channels/${threadId}/thread-members/@me`);
+					logger.info("Discord active thread — rejoined thread", { threadId });
+				} catch (err) {
+					if (this.rejoinClaims.get(threadId) === claim) this.rejoinClaims.delete(threadId);
+					logger.warn(danger(`discord thread rejoin failed: ${String(err)}`), { threadId });
+				}
 			},
 			onError: (err) => {
 				(this.logger ?? discordEventQueueLog).error(danger(`discord thread-update handler failed: ${String(err)}`));
@@ -1195,6 +1230,15 @@ var DiscordThreadUpdateListener = class extends ThreadUpdateListener {
 		});
 	}
 };
+var DiscordThreadReadyListener = class extends ReadyListener {
+	constructor(threadUpdateListener) {
+		super();
+		this.threadUpdateListener = threadUpdateListener;
+	}
+	handle() {
+		this.threadUpdateListener.resetGatewaySession();
+	}
+};
 var DiscordThreadDeleteListener = class extends ThreadDeleteListener {
 	constructor(cfg, accountId, logger) {
 		super();
@@ -1438,7 +1482,7 @@ async function resolveGuildEntriesByChannelAllowlist(params) {
 		summarizeMapping("discord channels", mapping, unresolved, params.runtime);
 		return nextGuilds;
 	} catch (err) {
-		params.runtime.log?.(`discord channel resolve failed; using config entries. ${formatErrorMessage$1(err)}`);
+		params.runtime.log?.(`discord channel resolve failed; using config entries. ${formatErrorMessage(err)}`);
 		return params.guildEntries;
 	}
 }
@@ -1462,7 +1506,7 @@ async function resolveAllowFromByUserAllowlist(params) {
 		summarizeMapping("discord users", mapping, unresolved, params.runtime);
 		return allowFrom;
 	} catch (err) {
-		params.runtime.log?.(`discord user resolve failed; using config entries. ${formatErrorMessage$1(err)}`);
+		params.runtime.log?.(`discord user resolve failed; using config entries. ${formatErrorMessage(err)}`);
 		return params.allowFrom;
 	}
 }
@@ -1509,7 +1553,7 @@ async function resolveGuildEntriesByUserAllowlist(params) {
 		summarizeMapping("discord channel users", mapping, unresolved, params.runtime);
 		return nextGuilds;
 	} catch (err) {
-		params.runtime.log?.(`discord channel user resolve failed; using config entries. ${formatErrorMessage$1(err)}`);
+		params.runtime.log?.(`discord channel user resolve failed; using config entries. ${formatErrorMessage(err)}`);
 		return params.guildEntries;
 	}
 }
@@ -1595,6 +1639,19 @@ function createDiscordDnsLookup() {
 		});
 	};
 }
+function createDiscordEndpointDnsLookup(endpointHostname) {
+	const normalizedEndpointHostname = normalizeHostname(endpointHostname);
+	if (!normalizedEndpointHostname) throw new Error("Discord endpoint Gateway hostname is required");
+	const policy = {
+		allowedHostnames: [normalizedEndpointHostname],
+		hostnameAllowlist: [normalizedEndpointHostname]
+	};
+	return (hostname, options, callback) => {
+		resolvePinnedHostnameWithPolicy(hostname, { policy }).then((pinned) => pinned.lookup(pinned.hostname, options, callback), (error) => {
+			callback(error instanceof Error ? error : new Error(String(error)), "", 4);
+		});
+	};
+}
 //#endregion
 //#region extensions/discord/src/monitor/rest-fetch.ts
 const discordDnsLookup$1 = createDiscordDnsLookup();
@@ -1613,7 +1670,7 @@ function createEnvProxyDiscordRestDispatcher(runtime) {
 			connect: { lookup: discordDnsLookup$1 }
 		});
 	} catch (err) {
-		runtime.error?.(danger(`discord: env proxy unavailable for REST fetch; using direct dispatcher: ${formatErrorMessage(err)}`));
+		runtime.error?.(danger(`discord: env proxy unavailable for REST fetch; using direct dispatcher: ${formatErrorMessage$1(err)}`));
 		return;
 	}
 }
@@ -1807,7 +1864,7 @@ function resolveDiscordInteractionMessageParts(payload) {
 }
 function hasRenderableReplyPayload(payload) {
 	const { components, embeds } = resolveDiscordInteractionMessageParts(payload);
-	return resolveSendableOutboundReplyParts(payload).hasContent || Boolean(components || embeds);
+	return hasOutboundReplyContent(payload) || Boolean(components || embeds);
 }
 async function safeDiscordInteractionCall(label, fn) {
 	try {
@@ -1825,9 +1882,24 @@ async function settleDiscordInteractionWithoutVisibleReply(interaction) {
 	await safeDiscordInteractionCall("interaction delete deferred reply", () => interaction.deleteReply());
 }
 async function deliverDiscordInteractionReply(params) {
-	const { interaction, payload, textLimit, maxLinesPerMessage, preferFollowUp, chunkMode } = params;
+	const { interaction, textLimit, maxLinesPerMessage, preferFollowUp, chunkMode } = params;
+	const nativeParts = resolveDiscordInteractionMessageParts(params.payload);
+	const preserveNativeParts = resolveSendableOutboundReplyParts(params.payload).hasMedia || Boolean(nativeParts.components || nativeParts.embeds);
+	const payload = await renderPresentationForDelivery({
+		presentationCapabilities: DISCORD_PRESENTATION_CAPABILITIES,
+		renderPresentation: (adapted) => preserveNativeParts ? null : buildDiscordPresentationPayload({
+			payload: adapted,
+			presentation: adapted.presentation
+		})
+	}, params.payload);
+	const componentSpec = preserveNativeParts ? void 0 : await resolveDiscordComponentSpec(payload);
+	let componentBuild = componentSpec ? buildDiscordComponentMessage({
+		spec: componentSpec,
+		...params.componentRoute
+	}) : void 0;
 	const reply = resolveSendableOutboundReplyParts(payload);
 	let { components: firstMessageComponents, embeds: firstMessageEmbeds } = resolveDiscordInteractionMessageParts(payload);
+	if (componentBuild) firstMessageComponents = componentBuild.components;
 	let payloadDelivered = false;
 	const sendMessage = async (content, files, components, embeds) => {
 		const hasV2 = hasDiscordV2Components(components);
@@ -1841,11 +1913,19 @@ async function deliverDiscordInteractionReply(params) {
 		let result;
 		try {
 			result = await safeDiscordInteractionCall("interaction send", async () => {
-				if (!preferFollowUp && !payloadDelivered) await interaction.reply(payloadLocal);
-				else await interaction.followUp(payloadLocal);
+				const sent = !preferFollowUp && !payloadDelivered ? await interaction.reply(payloadLocal) : await interaction.followUp(payloadLocal);
 				payloadDelivered = true;
 				firstMessageComponents = void 0;
 				firstMessageEmbeds = void 0;
+				if (componentBuild) {
+					const messageId = sent && typeof sent === "object" && "id" in sent && typeof sent.id === "string" ? sent.id : void 0;
+					await registerDiscordComponentEntries({
+						entries: componentBuild.entries,
+						modals: componentBuild.modals,
+						messageId
+					});
+					componentBuild = void 0;
+				}
 			});
 		} catch (error) {
 			if (!payloadDelivered) throw error;
@@ -1892,7 +1972,7 @@ async function deliverDiscordInteractionReply(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-command-route.ts
-async function resolveDiscordNativeInteractionRouteState(params) {
+function resolveDiscordNativeInteractionRouteState(params) {
 	const route = resolveDiscordBoundConversationRoute({
 		cfg: params.cfg,
 		accountId: params.accountId,
@@ -1904,7 +1984,7 @@ async function resolveDiscordNativeInteractionRouteState(params) {
 		conversationId: params.conversationId,
 		parentConversationId: params.parentConversationId
 	});
-	const configuredRoute = params.threadBinding == null ? conversationRuntime.resolveConfiguredBindingRoute({
+	const configuredRoute = params.threadBinding == null ? resolveConfiguredBindingRoute({
 		cfg: params.cfg,
 		route,
 		conversation: {
@@ -1927,17 +2007,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
@@ -1968,6 +2045,11 @@ async function dispatchDiscordNativeAgentReply(params) {
 				const payloadDelivered = await deliverDiscordInteractionReply({
 					interaction: params.interaction,
 					payload,
+					componentRoute: {
+						accountId: params.effectiveRoute.accountId,
+						agentId: params.effectiveRoute.agentId,
+						sessionKey: params.ctxPayload.CommandTargetSessionKey ?? params.effectiveRoute.sessionKey
+					},
 					mediaLocalRoots: params.mediaLocalRoots,
 					textLimit: resolveTextChunkLimit(params.cfg, "discord", params.accountId, { fallbackLimit: 2e3 }),
 					maxLinesPerMessage: resolveDiscordMaxLinesPerMessage({
@@ -2108,6 +2190,7 @@ async function handleDiscordCommandArgInteraction(params) {
 		preferFollowUp: true,
 		threadBindings: ctx.threadBindings,
 		responseEphemeral: resolveDiscordSlashCommandConfig(ctx.discordConfig?.slashCommand).ephemeral,
+		buildContext: ctx.buildContext,
 		dispatchReplyFromConfig: ctx.dispatchReplyFromConfig,
 		pluginCommandDispatch: { kind: "non-plugin" }
 	});
@@ -2177,6 +2260,200 @@ function createDiscordCommandArgFallbackButton$1(params) {
 	return new DiscordCommandArgFallbackButton(params);
 }
 //#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
+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
 async function resolveDiscordNativeInteractionChannelContext(params) {
 	const channelContext = await resolveDiscordThreadLikeChannelContext({
@@ -2200,6 +2477,62 @@ 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,
+			accountId: params.accountId,
+			sender: params.sender,
+			chatType: params.ctx.ChatType === "direct" ? "direct" : "channel",
+			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 {
@@ -2339,12 +2672,13 @@ 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: ""
+		channelIdFallback: interaction.rawData.channel_id ?? ""
 	});
+	const { isDirectMessage, isGroupDm, isThreadChannel, channelName, channelSlug, rawChannelId, threadParentId, threadParentName, threadParentSlug } = 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);
@@ -2421,162 +2755,75 @@ 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,
+			accountId,
+			discordConfig,
+			useAccessGroups,
+			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;
@@ -2665,6 +2912,16 @@ async function recordDiscordModelPickerRecentModel(params) {
 	} catch {}
 }
 //#endregion
+//#region extensions/discord/src/monitor/model-picker.runtime.ts
+const hostSdk = modelsProviderRuntime;
+const MODEL_PICKER_CHANGED_MESSAGE = hostSdk.MODEL_PICKER_CHANGED_MESSAGE ?? "Available models changed. Open /models and choose again.";
+function supportsDiscordModelPickerRuntimeChoices() {
+	return hostSdk.getModelsRuntimeChoices !== void 0;
+}
+function getDiscordModelPickerRuntimeChoices(...args) {
+	return hostSdk.getModelsRuntimeChoices?.(...args);
+}
+//#endregion
 //#region extensions/discord/src/monitor/model-picker.state.ts
 const DISCORD_MODEL_PICKER_CUSTOM_ID_KEY = "mdlpk";
 const DISCORD_CUSTOM_ID_MAX_CHARS = 100;
@@ -2701,10 +2958,13 @@ const PICKER_VIEWS = [
 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;
-const DISCORD_MODEL_PICKER_MODEL_TOKEN_PATTERN = /^[A-Za-z0-9_-]{8}$/u;
+const DISCORD_MODEL_PICKER_TOKEN_PATTERN = /^[A-Za-z0-9_-]{8}$/u;
 function createDiscordModelPickerModelToken(provider, model) {
 	return createHash("sha256").update(JSON.stringify([normalizeProviderId(provider), model]), "utf8").digest("base64url").slice(0, 8);
 }
+function createDiscordModelPickerRuntimeToken(runtime) {
+	return createHash("sha256").update(runtime, "utf8").digest("base64url").slice(0, 8);
+}
 const loadModelsProviderRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/models-provider-runtime"));
 function isValidCommandContext(value) {
 	return COMMAND_CONTEXTS.includes(value);
@@ -2754,9 +3014,9 @@ function paginateItems(params) {
 		hasNext: page < totalPages
 	};
 }
-async function loadDiscordModelPickerData(cfg, agentId) {
+async function loadDiscordModelPickerData(cfg, agentId, options) {
 	const { buildPreparedModelsProviderData } = await loadModelsProviderRuntime();
-	return buildPreparedModelsProviderData(cfg, agentId);
+	return buildPreparedModelsProviderData(cfg, agentId, options);
 }
 function buildDiscordModelPickerCustomId(params) {
 	const userId = params.userId.trim();
@@ -2767,7 +3027,7 @@ function buildDiscordModelPickerCustomId(params) {
 	const modelIndex = normalizeOptionalModelPickerIndex(params.modelIndex);
 	const recentSlot = normalizeOptionalModelPickerIndex(params.recentSlot);
 	const modelToken = params.modelToken?.trim();
-	if (modelToken && !DISCORD_MODEL_PICKER_MODEL_TOKEN_PATTERN.test(modelToken)) throw new Error("Discord model picker model token is invalid");
+	if (modelToken && !DISCORD_MODEL_PICKER_TOKEN_PATTERN.test(modelToken)) throw new Error("Discord model picker model token is invalid");
 	const parts = [
 		`${DISCORD_MODEL_PICKER_CUSTOM_ID_KEY}:c=${encodeCustomIdComponent(params.command)}`,
 		`a=${encodeCustomIdComponent(params.action)}`,
@@ -2778,6 +3038,9 @@ function buildDiscordModelPickerCustomId(params) {
 	if (normalizedProvider) parts.push(`p=${encodeCustomIdComponent(normalizedProvider)}`);
 	const runtime = params.runtime?.trim();
 	if (runtime) parts.push(`r=${encodeCustomIdComponent(runtime)}`);
+	const runtimeToken = params.runtimeToken?.trim();
+	if (runtimeToken && !DISCORD_MODEL_PICKER_TOKEN_PATTERN.test(runtimeToken)) throw new Error("Discord model picker runtime token is invalid");
+	if (runtimeToken) parts.push(`rt=${runtimeToken}`);
 	const runtimeIndex = normalizeOptionalModelPickerIndex(params.runtimeIndex);
 	if (runtimeIndex) parts.push(`ri=${String(runtimeIndex)}`);
 	if (providerPage) parts.push(`pp=${String(providerPage)}`);
@@ -2790,6 +3053,13 @@ function buildDiscordModelPickerCustomId(params) {
 	if (providerBucket) parts.push(`pb=${encodeCustomIdComponent(providerBucket)}`);
 	const modelBucket = params.modelBucket?.trim().toLowerCase();
 	if (modelBucket) parts.push(`mb=${encodeCustomIdComponent(modelBucket)}`);
+	if (parts.join(";").length > DISCORD_CUSTOM_ID_MAX_CHARS) {
+		for (let index = parts.length - 1; index >= 0; index -= 1) if (parts[index] === "g=1" || parts[index] === "pp=1") parts.splice(index, 1);
+	}
+	if (modelToken && parts.join(";").length > DISCORD_CUSTOM_ID_MAX_CHARS) {
+		const providerPart = parts.findIndex((part) => part.startsWith("p="));
+		if (providerPart >= 0) parts.splice(providerPart, 1);
+	}
 	const customId = parts.join(";");
 	if (customId.length > DISCORD_CUSTOM_ID_MAX_CHARS) throw new Error(`Discord model picker custom_id exceeds ${DISCORD_CUSTOM_ID_MAX_CHARS} chars (${customId.length})`);
 	return customId;
@@ -2803,11 +3073,18 @@ function parseDiscordModelPickerData(data) {
 	const providerRaw = decodeCustomIdComponent(coerceString(data.p));
 	const runtimeRaw = decodeCustomIdComponent(coerceString(data.r));
 	const runtimeIndex = parseStrictPositiveInteger(data.ri);
+	const runtimeTokenRaw = coerceString(data.rt).trim();
+	if (runtimeTokenRaw && !DISCORD_MODEL_PICKER_TOKEN_PATTERN.test(runtimeTokenRaw)) return null;
+	if ([
+		runtimeRaw.trim(),
+		runtimeTokenRaw,
+		runtimeIndex
+	].filter(Boolean).length > 1) return null;
 	const page = parseRawPage(data.g ?? data.pg);
 	const providerPage = parseStrictPositiveInteger(data.pp);
 	const modelIndex = parseStrictPositiveInteger(data.mi);
 	const modelTokenRaw = coerceString(data.m).trim();
-	const modelToken = DISCORD_MODEL_PICKER_MODEL_TOKEN_PATTERN.test(modelTokenRaw) ? modelTokenRaw : void 0;
+	const modelToken = DISCORD_MODEL_PICKER_TOKEN_PATTERN.test(modelTokenRaw) ? modelTokenRaw : void 0;
 	const recentSlot = parseStrictPositiveInteger(data.rs);
 	const providerBucketRaw = decodeCustomIdComponent(coerceString(data.pb)).trim().toLowerCase();
 	const modelBucketRaw = decodeCustomIdComponent(coerceString(data.mb)).trim().toLowerCase();
@@ -2821,6 +3098,7 @@ function parseDiscordModelPickerData(data) {
 		userId: trimmedUserId,
 		provider: providerRaw ? normalizeProviderId(providerRaw) : void 0,
 		runtime: runtimeRaw.trim() || void 0,
+		...runtimeTokenRaw ? { runtimeToken: runtimeTokenRaw } : {},
 		...typeof runtimeIndex === "number" ? { runtimeIndex } : {},
 		page,
 		...typeof providerPage === "number" ? { providerPage } : {},
@@ -3063,7 +3341,7 @@ function buildBucketSelectRow(params) {
 			page: 1,
 			provider: params.provider,
 			runtime: params.runtime,
-			runtimeIndex: params.runtimeIndex,
+			runtimeToken: params.runtimeToken,
 			providerPage: params.providerPage,
 			modelIndex: params.modelIndex
 		}),
@@ -3073,54 +3351,29 @@ function buildBucketSelectRow(params) {
 	return new Row([select]);
 }
 function getRuntimeChoices(params) {
-	const choices = params.data.runtimeChoicesByProvider?.get(normalizeProviderId(params.provider));
-	if (choices?.length) return choices;
-	return [{
-		id: "openclaw",
-		label: "OpenClaw Default",
-		description: "Use the built-in OpenClaw runtime."
-	}];
-}
-function resolveSelectedRuntime(params) {
-	const choices = getRuntimeChoices({
-		data: params.data,
-		provider: params.provider
-	});
-	const allowed = new Set(choices.map((choice) => choice.id));
-	const pending = params.pendingRuntime?.trim();
-	if (pending && allowed.has(pending)) return pending;
-	const current = params.currentRuntime?.trim();
-	if (current && allowed.has(current)) return current;
-	return choices[0]?.id ?? "openclaw";
+	const model = parseCurrentModelRef(params.modelRef);
+	return getDiscordModelPickerRuntimeChoices(params.data, params.provider, model?.provider === normalizeProviderId(params.provider) ? model.model : void 0);
 }
 function resolveExplicitRuntimeState(params) {
-	const allowed = new Set(params.choices.map((choice) => choice.id));
-	const pending = params.pendingRuntime?.trim();
-	if (pending && allowed.has(pending)) return pending;
-	const current = params.currentRuntime?.trim();
-	if (current && current !== "auto" && current !== "default" && allowed.has(current)) return current;
+	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;
 }
 function resolveCompactRuntimeState(params) {
-	const stateRuntime = resolveExplicitRuntimeState(params);
-	const stateRuntimeIndex = stateRuntime ? params.choices.findIndex((choice) => choice.id === stateRuntime) : -1;
-	if (stateRuntimeIndex >= 0) return { runtimeIndex: stateRuntimeIndex + 1 };
-	return stateRuntime ? { runtime: stateRuntime } : {};
+	if (!supportsDiscordModelPickerRuntimeChoices()) return {};
+	const runtime = resolveExplicitRuntimeState(params);
+	return runtime ? { runtimeToken: createDiscordModelPickerRuntimeToken(runtime) } : {};
 }
 function buildRenderedShell(params) {
-	if (params.layout === "classic") return {
-		layout: "classic",
-		content: [
-			params.title,
-			...params.detailLines,
-			"",
-			params.footer
-		].filter(Boolean).join("\n"),
-		components: params.rows
-	};
 	const containerComponents = [new TextDisplay(`## ${params.title}`)];
+	if (params.refreshWarning) containerComponents.push(new TextDisplay(params.refreshWarning));
 	if (params.detailLines.length > 0) containerComponents.push(new TextDisplay(params.detailLines.join("\n")));
 	containerComponents.push(new Separator({
 		divider: true,
@@ -3142,10 +3395,7 @@ function buildRenderedShell(params) {
 		}));
 		containerComponents.push(new TextDisplay(`-# ${params.footer}`));
 	}
-	return {
-		layout: "v2",
-		components: [new Container(containerComponents)]
-	};
+	return { components: [new Container(containerComponents)] };
 }
 function buildProviderSelectRow(params) {
 	if (params.page.items.length === 0) return null;
@@ -3226,20 +3476,22 @@ function buildModelRows(params) {
 	})]));
 	const runtimeChoices = getRuntimeChoices({
 		data: params.data,
-		provider: params.modelPage.provider
+		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,
-		currentRuntime: params.currentRuntime,
+		modelRef: params.pendingModel ?? params.currentModel,
+		currentRuntime,
 		pendingRuntime: params.pendingRuntime
 	});
 	const compactRuntime = resolveCompactRuntimeState({
-		choices: runtimeChoices,
-		currentRuntime: params.currentRuntime,
+		currentRuntime,
 		pendingRuntime: params.pendingRuntime
 	});
-	if (runtimeChoices.length > 1) rows.push(new Row([createModelSelect({
+	if (runtimeChoices && (runtimeChoices.length > 1 || runtimeChoices.length === 1 && selectedRuntime === void 0)) rows.push(new Row([createModelSelect({
 		customId: buildDiscordModelPickerCustomId({
 			command: params.command,
 			action: "runtime",
@@ -3261,7 +3513,7 @@ function buildModelRows(params) {
 			if (choice.description) option.description = choice.description;
 			return option;
 		}),
-		placeholder: "Select runtime"
+		placeholder: "Choose how to run this model"
 	})]));
 	const selectedModelRef = parsedPendingModel ?? parsedCurrentModel;
 	const modelOptions = params.modelPage.items.map((model) => ({
@@ -3352,7 +3604,7 @@ function buildModelRows(params) {
 	buttonRowItems.push(createModelPickerButton({
 		label: "Submit",
 		style: ButtonStyle.Primary,
-		disabled: !hasPendingSelection,
+		disabled: !hasPendingSelection || supportsDiscordModelPickerRuntimeChoices() && selectedRuntime === void 0,
 		customId: buildDiscordModelPickerCustomId({
 			...modelActionState,
 			action: "submit",
@@ -3406,8 +3658,8 @@ function renderDiscordModelPickerProvidersView(params) {
 	const detailLines = [formatCurrentModelLine(params.currentModel), page.bucket && page.bucket.id !== "all" ? `Select a provider (${page.totalItems} in ${page.bucket.label}, ${totalProviders} total).` : `Select a provider (${page.totalItems} available).`];
 	const footer = page.totalPages > 1 ? `Showing page ${page.page}/${page.totalPages} · ${page.totalItems} providers total` : `All ${page.totalItems} providers shown`;
 	return buildRenderedShell({
-		layout: params.layout ?? "v2",
 		title: "Model Picker",
+		refreshWarning: params.data.refreshWarning,
 		detailLines,
 		rows,
 		footer
@@ -3433,8 +3685,8 @@ function renderDiscordModelPickerModelsView(params) {
 			})
 		})])];
 		return buildRenderedShell({
-			layout: params.layout ?? "v2",
 			title: "Model Picker",
+			refreshWarning: params.data.refreshWarning,
 			detailLines: [formatCurrentModelLine(params.currentModel), `Provider not found: ${normalizeProviderId(params.provider)}`],
 			rows,
 			footer: "Choose a different provider."
@@ -3454,12 +3706,7 @@ function renderDiscordModelPickerModelsView(params) {
 		quickModels: params.quickModels,
 		providerBucket: params.providerBucket
 	});
-	const runtimeChoices = getRuntimeChoices({
-		data: params.data,
-		provider: modelPage.provider
-	});
 	const pendingRuntime = params.pendingRuntime?.trim();
-	const pendingRuntimeIndex = pendingRuntime ? runtimeChoices.findIndex((choice) => choice.id === pendingRuntime) : -1;
 	const rows = [];
 	const bucketRow = buildBucketSelectRow({
 		command: params.command,
@@ -3468,24 +3715,32 @@ function renderDiscordModelPickerModelsView(params) {
 		buckets: modelPage.buckets,
 		currentBucketId: modelPage.bucket?.id,
 		provider: modelPage.provider,
-		runtimeIndex: pendingRuntimeIndex >= 0 ? pendingRuntimeIndex + 1 : void 0,
+		runtimeToken: pendingRuntime ? createDiscordModelPickerRuntimeToken(pendingRuntime) : void 0,
 		providerPage,
 		providerBucket: params.providerBucket
 	});
 	if (bucketRow) rows.push(bucketRow);
 	rows.push(...modelRows);
 	const defaultModel = `${params.data.resolvedDefault.provider}/${params.data.resolvedDefault.model}`;
-	const pendingLine = params.pendingModel ? `Selected: ${params.pendingModel} · runtime ${resolveSelectedRuntime({
+	const choices = getRuntimeChoices({
 		data: params.data,
 		provider: modelPage.provider,
-		currentRuntime: params.currentRuntime,
+		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
-	})} (press Submit)` : "Select a model, then press Submit.";
+	});
+	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}`];
 	if (modelPage.totalPages > 1) detailLines.push(`${modelPage.provider}: page ${modelPage.page}/${modelPage.totalPages} · ${modelPage.totalItems} models`);
 	return buildRenderedShell({
-		layout: params.layout ?? "v2",
 		title: "Model Picker",
+		refreshWarning: params.data.refreshWarning,
 		detailLines,
 		preRowText: pendingLine,
 		rows,
@@ -3516,7 +3771,7 @@ function renderDiscordModelPickerRecentsView(params) {
 			modelToken: createModelRefToken(modelRef),
 			provider: params.provider,
 			runtime: params.runtime,
-			runtimeIndex: params.runtimeIndex,
+			runtimeToken: params.runtimeToken,
 			page: params.page,
 			providerPage: params.providerPage,
 			userId: params.userId
@@ -3530,7 +3785,7 @@ function renderDiscordModelPickerRecentsView(params) {
 			view: "models",
 			provider: params.provider,
 			runtime: params.runtime,
-			runtimeIndex: params.runtimeIndex,
+			runtimeToken: params.runtimeToken,
 			page: params.page,
 			providerPage: params.providerPage,
 			modelBucket: params.modelBucket,
@@ -3538,21 +3793,14 @@ function renderDiscordModelPickerRecentsView(params) {
 		})
 	})]);
 	return buildRenderedShell({
-		layout: params.layout ?? "v2",
 		title: "Recents",
+		refreshWarning: params.data.refreshWarning,
 		detailLines: ["Models you've previously selected appear here.", formatCurrentModelLine(params.currentModel)],
 		preRowText: "Tap a model to switch.",
 		rows,
 		trailingRows: [backRow]
 	});
 }
-function toDiscordModelPickerMessagePayload(view) {
-	if (view.layout === "classic") return {
-		content: view.content,
-		components: view.components
-	};
-	return { components: view.components };
-}
 //#endregion
 //#region extensions/discord/src/monitor/native-command-model-picker-apply.ts
 function normalizeExpectedRuntime(value) {
@@ -3575,6 +3823,7 @@ async function applyDiscordModelPickerSelection(params) {
 			preferFollowUp: true,
 			threadBindings: params.threadBindings,
 			suppressReplies: true,
+			buildContext: params.buildContext,
 			dispatchReplyFromConfig: params.dispatchReplyFromConfig,
 			pluginCommandDispatch: { kind: "non-plugin" }
 		}), 12e3);
@@ -3665,11 +3914,11 @@ async function resolveDiscordModelPickerRouteState(params) {
 		channel: interaction.channel,
 		client: interaction.client,
 		hasGuild: Boolean(interaction.guild),
-		channelIdFallback: "unknown"
+		channelIdFallback: interaction.rawData.channel_id ?? "unknown"
 	});
 	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,
@@ -3679,8 +3928,7 @@ async function resolveDiscordModelPickerRouteState(params) {
 		directUserId: interaction.user?.id ?? rawChannelId,
 		conversationId: rawChannelId,
 		parentConversationId: threadParentId,
-		threadBinding,
-		enforceConfiguredBindingReadiness: params.enforceConfiguredBindingReadiness
+		threadBinding
 	});
 }
 async function resolveDiscordModelPickerRoute(params) {
@@ -3688,15 +3936,7 @@ async function resolveDiscordModelPickerRoute(params) {
 }
 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
@@ -3780,7 +4020,12 @@ async function replyWithDiscordModelPickerProviders(params) {
 		accountId: params.accountId,
 		threadBindings: params.threadBindings
 	});
-	const data = await loadDiscordModelPickerData(params.cfg, route.agentId);
+	const sessionEntry = getSessionEntry({
+		storePath: resolveStorePath(params.cfg.session?.store, { agentId: route.agentId }),
+		sessionKey: route.sessionKey,
+		readConsistency: "latest"
+	});
+	const data = await loadDiscordModelPickerData(params.cfg, route.agentId, { sessionEntry });
 	const currentModel = resolveDiscordModelPickerCurrentModel({
 		cfg: params.cfg,
 		route,
@@ -3810,7 +4055,7 @@ async function replyWithDiscordModelPickerProviders(params) {
 	const initialModelBucket = initialResolved.bucket;
 	const initialProviderLocation = findProviderBucketLocation(data, initialProvider);
 	const payload = {
-		...toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
+		...renderDiscordModelPickerModelsView({
 			command: params.command,
 			userId: params.userId,
 			data,
@@ -3822,7 +4067,7 @@ async function replyWithDiscordModelPickerProviders(params) {
 			currentModel,
 			currentRuntime,
 			quickModels
-		})),
+		}),
 		ephemeral: true
 	};
 	await params.safeInteractionCall("model picker reply", async () => {
@@ -3854,9 +4099,10 @@ function resolveModelPickerSelectionValue(interaction) {
 	if (typeof first !== "string") return null;
 	return first.trim() || null;
 }
-function resolveModelPickerRuntimeByIndex(params) {
-	if (!params.provider || typeof params.runtimeIndex !== "number") return;
-	return (params.data.runtimeChoicesByProvider?.get(params.provider))?.[params.runtimeIndex - 1]?.id;
+function resolveRuntimeToken(choices, token) {
+	if (!token) return;
+	const matches = choices?.filter((choice) => createDiscordModelPickerRuntimeToken(choice.id) === token);
+	return matches?.length === 1 ? matches[0]?.id : void 0;
 }
 function resolveModelPickerProvider(params) {
 	return params.parsedProvider ?? splitDiscordModelRef(params.currentModelRef ?? "")?.provider ?? params.data.resolvedDefault.provider;
@@ -3866,20 +4112,7 @@ function resolveSelectedBucket(interaction) {
 	return raw && raw !== "all" ? raw : void 0;
 }
 function resolvePendingRuntime(params) {
-	return params.parsed.runtime ?? resolveModelPickerRuntimeByIndex({
-		data: params.data,
-		provider: params.provider,
-		runtimeIndex: params.parsed.runtimeIndex
-	});
-}
-function resolveParsedRuntimeForSubmission(params) {
-	if (params.parsed.runtime) return params.parsed.runtime;
-	if (params.parsed.provider !== params.selectedProvider) return;
-	return resolveModelPickerRuntimeByIndex({
-		data: params.data,
-		provider: params.selectedProvider,
-		runtimeIndex: params.parsed.runtimeIndex
-	});
+	return params.parsed.runtime ?? resolveRuntimeToken(getDiscordModelPickerRuntimeChoices(params.data, params.provider), params.parsed.runtimeToken);
 }
 function resolveSubmittedModelRef(params) {
 	if (params.parsed.action === "reset") return `${params.data.resolvedDefault.provider}/${params.data.resolvedDefault.model}`;
@@ -3947,22 +4180,6 @@ function resolveDiscordModelPickerModelSelection(params) {
 	if (params.requireModelToken || !params.modelIndex || params.modelIndex < 1) return null;
 	return models[params.modelIndex - 1] ?? null;
 }
-function resolveDiscordModelPickerRuntimeForProvider(params) {
-	const runtime = normalizeOptionalString(params.runtime);
-	if (!runtime) return;
-	if (runtime === "auto" || runtime === "default") return params.allowResetRuntime ? runtime : void 0;
-	const choices = params.data.runtimeChoicesByProvider?.get(params.provider);
-	if (!choices?.length) return runtime === "openclaw" ? runtime : void 0;
-	return choices.some((choice) => choice.id === runtime) ? runtime : void 0;
-}
-function resolveDiscordModelPickerSubmissionRuntime(params) {
-	return resolveDiscordModelPickerRuntimeForProvider({
-		data: params.data,
-		provider: params.provider,
-		runtime: params.parsedRuntime,
-		allowResetRuntime: true
-	});
-}
 async function handleDiscordModelPickerInteraction(params) {
 	const { interaction, data, ctx } = params;
 	const parsed = parseDiscordModelPickerData(data);
@@ -3987,7 +4204,14 @@ async function handleDiscordModelPickerInteraction(params) {
 		accountId: ctx.accountId,
 		threadBindings: ctx.threadBindings
 	});
-	const pickerData = await loadDiscordModelPickerData(cfg, route.agentId);
+	const sessionEntry = getSessionEntry({
+		storePath: resolveStorePath(cfg.session?.store, { agentId: route.agentId }),
+		sessionKey: route.sessionKey,
+		readConsistency: "latest"
+	});
+	const pickerData = await loadDiscordModelPickerData(cfg, route.agentId, { sessionEntry });
+	const tokenModel = parsed.modelToken ? resolveDiscordModelPickerModelRefByToken(pickerData, parsed.modelToken) : null;
+	const parsedProvider = parsed.provider ?? splitDiscordModelRef(tokenModel ?? "")?.provider;
 	const currentModelRef = resolveDiscordModelPickerCurrentModel({
 		cfg,
 		route,
@@ -4024,39 +4248,60 @@ async function handleDiscordModelPickerInteraction(params) {
 			quickModels,
 			...state
 		});
-		return await updatePicker(toDiscordModelPickerMessagePayload(rendered));
+		return await updatePicker(rendered);
 	};
+	if (parsed.action !== "cancel" && pickerData.isCurrent?.() === false) {
+		await showNotice("That model picker expired. Reopen /model to try again.");
+		return;
+	}
+	if (parsed.runtimeIndex !== void 0 && parsed.action !== "cancel") {
+		await showNotice("That runtime selection expired. Reopen /model and choose a runtime again.");
+		return;
+	}
+	if (parsed.runtimeToken && ![
+		"submit",
+		"reset",
+		"quick",
+		"cancel"
+	].includes(parsed.action) && parsedProvider && !resolvePendingRuntime({
+		data: pickerData,
+		provider: parsedProvider,
+		parsed
+	})) {
+		await showNotice("That runtime selection expired. Reopen /model and choose a runtime again.");
+		return;
+	}
 	if (parsed.action === "recents") {
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerRecentsView({
+		await updatePicker(renderDiscordModelPickerRecentsView({
 			command: parsed.command,
 			userId: parsed.userId,
 			data: pickerData,
 			quickModels,
 			currentModel: currentModelRef,
 			runtime: parsed.runtime,
-			runtimeIndex: parsed.runtimeIndex,
+			runtimeToken: parsed.runtimeToken,
 			provider: parsed.provider,
 			page: parsed.page,
 			providerPage: parsed.providerPage,
 			modelBucket: parsed.modelBucket
-		})));
+		}));
 		return;
 	}
 	if (parsed.view === "providers" && (parsed.action === "back" || parsed.action === "nav" || parsed.action === "bucket")) {
 		const selectingBucket = parsed.action === "bucket";
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerProvidersView({
+		await updatePicker(renderDiscordModelPickerProvidersView({
 			command: parsed.command,
 			userId: parsed.userId,
 			data: pickerData,
 			page: selectingBucket ? 1 : parsed.page,
 			providerBucket: selectingBucket ? resolveSelectedBucket(interaction) : parsed.providerBucket,
 			currentModel: currentModelRef
-		})));
+		}));
 		return;
 	}
 	if (parsed.action === "bucket" && parsed.view === "models") {
 		const provider = resolveModelPickerProvider({
-			parsedProvider: parsed.provider,
+			parsedProvider,
 			currentModelRef,
 			data: pickerData
 		});
@@ -4073,7 +4318,7 @@ async function handleDiscordModelPickerInteraction(params) {
 	}
 	if (parsed.action === "nav" && parsed.view === "models") {
 		const provider = resolveModelPickerProvider({
-			parsedProvider: parsed.provider,
+			parsedProvider,
 			currentModelRef,
 			data: pickerData
 		});
@@ -4085,7 +4330,7 @@ async function handleDiscordModelPickerInteraction(params) {
 			requireModelToken
 		});
 		if ((parsed.modelIndex || parsed.modelToken) && !pendingModel) {
-			await showNotice("That selection expired. Please choose a model again.");
+			await showNotice(MODEL_PICKER_CHANGED_MESSAGE);
 			return;
 		}
 		const pendingModelIndex = pendingModel ? resolveDiscordModelPickerModelIndex({
@@ -4107,7 +4352,7 @@ async function handleDiscordModelPickerInteraction(params) {
 	}
 	if (parsed.action === "back" && parsed.view === "models") {
 		const provider = resolveModelPickerProvider({
-			parsedProvider: parsed.provider,
+			parsedProvider,
 			currentModelRef,
 			data: pickerData
 		});
@@ -4124,7 +4369,7 @@ async function handleDiscordModelPickerInteraction(params) {
 	if (parsed.action === "provider") {
 		const selectedProvider = resolveModelPickerSelectionValue(interaction) ?? parsed.provider;
 		if (!selectedProvider || !pickerData.byProvider.has(selectedProvider)) {
-			await showNotice("Sorry, that provider isn't available anymore.");
+			await showNotice(MODEL_PICKER_CHANGED_MESSAGE);
 			return;
 		}
 		await updateModelsView(selectedProvider, {
@@ -4135,9 +4380,9 @@ async function handleDiscordModelPickerInteraction(params) {
 	}
 	if (parsed.action === "model") {
 		const selectedModel = resolveModelPickerSelectionValue(interaction);
-		const provider = parsed.provider;
+		const provider = parsedProvider;
 		if (!provider || !selectedModel) {
-			await showNotice("Sorry, I couldn't read that model selection.");
+			await showNotice(MODEL_PICKER_CHANGED_MESSAGE);
 			return;
 		}
 		const modelIndex = resolveDiscordModelPickerModelIndex({
@@ -4146,7 +4391,7 @@ async function handleDiscordModelPickerInteraction(params) {
 			model: selectedModel
 		});
 		if (!modelIndex) {
-			await showNotice("Sorry, that model isn't available anymore.");
+			await showNotice(MODEL_PICKER_CHANGED_MESSAGE);
 			return;
 		}
 		const modelRef = `${provider}/${selectedModel}`;
@@ -4163,10 +4408,10 @@ async function handleDiscordModelPickerInteraction(params) {
 		return;
 	}
 	if (parsed.action === "runtime") {
-		const selectedRuntime = resolveModelPickerSelectionValue(interaction) ?? parsed.runtime ?? "auto";
-		const provider = parsed.provider;
+		const selectedRuntime = resolveModelPickerSelectionValue(interaction) ?? parsed.runtime;
+		const provider = parsedProvider;
 		if (!provider || !pickerData.byProvider.has(provider)) {
-			await showNotice("Sorry, that provider isn't available anymore.");
+			await showNotice(MODEL_PICKER_CHANGED_MESSAGE);
 			return;
 		}
 		const selectedModel = resolveDiscordModelPickerModelSelection({
@@ -4177,7 +4422,13 @@ async function handleDiscordModelPickerInteraction(params) {
 			requireModelToken
 		});
 		if ((parsed.modelIndex || parsed.modelToken) && !selectedModel) {
-			await showNotice("That selection expired. Please choose a model again.");
+			await showNotice(MODEL_PICKER_CHANGED_MESSAGE);
+			return;
+		}
+		const currentModel = splitDiscordModelRef(currentModelRef ?? "");
+		const choices = getDiscordModelPickerRuntimeChoices(pickerData, provider, selectedModel ?? (currentModel?.provider === provider ? currentModel.model : void 0));
+		if (!selectedRuntime || !choices?.some((choice) => choice.id === selectedRuntime)) {
+			await showNotice("That runtime is not available for this model. Choose a runtime again.");
 			return;
 		}
 		const pendingModel = selectedModel ? `${provider}/${selectedModel}` : void 0;
@@ -4204,19 +4455,50 @@ async function handleDiscordModelPickerInteraction(params) {
 		});
 		const parsedModelRef = modelRef ? splitDiscordModelRef(modelRef) : null;
 		if (!parsedModelRef || !pickerData.byProvider.get(parsedModelRef.provider)?.has(parsedModelRef.model)) {
-			await showNotice("That selection expired. Please choose a model again.");
+			await showNotice(MODEL_PICKER_CHANGED_MESSAGE);
 			return;
 		}
 		const resolvedModelRef = `${parsedModelRef.provider}/${parsedModelRef.model}`;
-		const selectedRuntime = resolveDiscordModelPickerSubmissionRuntime({
-			data: pickerData,
-			provider: parsedModelRef.provider,
-			parsedRuntime: resolveParsedRuntimeForSubmission({
-				data: pickerData,
-				parsed,
-				selectedProvider: parsedModelRef.provider
-			})
-		});
+		const choices = getDiscordModelPickerRuntimeChoices(pickerData, parsedModelRef.provider, parsedModelRef.model);
+		const modelOnlyHost = !supportsDiscordModelPickerRuntimeChoices();
+		const supportsModelOnlySelection = () => {
+			const currentEntry = getSessionEntry({
+				storePath: resolveStorePath(cfg.session?.store, { agentId: route.agentId }),
+				sessionKey: route.sessionKey,
+				readConsistency: "latest"
+			});
+			const override = currentEntry?.agentRuntimeOverride?.trim();
+			if (override && ![
+				"auto",
+				"default",
+				"openclaw"
+			].includes(override)) return false;
+			const model = pickerData.modelCatalog?.find((entry) => entry.provider === parsedModelRef.provider && entry.id === parsedModelRef.model);
+			return resolveEffectiveAgentRuntime({
+				cfg,
+				provider: parsedModelRef.provider,
+				modelId: parsedModelRef.model,
+				modelApi: model?.api,
+				modelBaseUrl: model?.baseUrl,
+				agentId: route.agentId,
+				sessionKey: route.sessionKey,
+				sessionEntry: currentEntry
+			}) === "openclaw";
+		};
+		const legacyRuntimeNotice = "This OpenClaw version supports model-only selection here. Update OpenClaw to change runtimes in the picker.";
+		if (modelOnlyHost && (parsed.runtime || parsed.runtimeToken || !supportsModelOnlySelection())) {
+			await showNotice(legacyRuntimeNotice);
+			return;
+		}
+		if (!modelOnlyHost && choices === void 0) {
+			await showNotice("Runtime availability is not confirmed. Reopen /model to try again.");
+			return;
+		}
+		const selectedRuntime = normalizeOptionalString(parsed.runtime) ?? resolveRuntimeToken(choices, parsed.runtimeToken);
+		if (choices?.length === 0 || parsed.runtimeToken && selectedRuntime === void 0 || selectedRuntime && selectedRuntime !== "auto" && selectedRuntime !== "default" && !choices?.some((choice) => choice.id === selectedRuntime)) {
+			await showNotice("That runtime is not available for this model. Reopen /model and choose again.");
+			return;
+		}
 		const selectionCommand = buildDiscordModelPickerSelectionCommand({
 			modelRef: resolvedModelRef,
 			runtime: selectedRuntime
@@ -4226,17 +4508,20 @@ async function handleDiscordModelPickerInteraction(params) {
 			return;
 		}
 		if (await showNotice(`Applying model change to ${resolvedModelRef}...`) === null) return;
+		if (pickerData.isCurrent?.() === false) {
+			await showNotice("That model picker expired. Reopen /model to try again.");
+			return;
+		}
+		if (modelOnlyHost && !supportsModelOnlySelection()) {
+			await showNotice(legacyRuntimeNotice);
+			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,
@@ -4394,22 +4679,13 @@ function buildDiscordCommandOptions(params) {
 	if (!args || args.length === 0) return;
 	return args.map((arg) => {
 		const required = arg.required ?? false;
-		if (arg.type === "number") return {
-			name: arg.name,
-			description: truncateDiscordCommandDescription({
-				value: arg.description,
-				label: `command:${commandLabel} arg:${arg.name}`
-			}),
-			type: ApplicationCommandOptionType.Number,
-			required
-		};
-		if (arg.type === "boolean") return {
+		if (arg.type === "number" || arg.type === "boolean") return {
 			name: arg.name,
 			description: truncateDiscordCommandDescription({
 				value: arg.description,
 				label: `command:${commandLabel} arg:${arg.name}`
 			}),
-			type: ApplicationCommandOptionType.Boolean,
+			type: arg.type === "number" ? ApplicationCommandOptionType.Number : ApplicationCommandOptionType.Boolean,
 			required
 		};
 		const resolvedChoices = resolveCommandArgChoices({
@@ -4440,7 +4716,7 @@ function buildDiscordCommandOptions(params) {
 				provider: context?.provider,
 				model: context?.model,
 				agentRuntime: context?.agentRuntime,
-				...choiceCatalog?.length ? { catalog: choiceCatalog } : {}
+				catalog: choiceCatalog
 			});
 			const filtered = focusValue ? choices.filter((choice) => normalizeLowercaseStringOrEmpty(choice.label).includes(focusValue)) : choices;
 			await interaction.respond(filtered.slice(0, 25).map((choice) => ({
@@ -4469,18 +4745,8 @@ function buildDiscordCommandOptions(params) {
 //#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;
@@ -4499,6 +4765,9 @@ function createDiscordNativeCommand(params) {
 				...policy,
 				isPolicyCurrent: policy.isCurrent,
 				accountId,
+				sessionPrefix,
+				threadBindings,
+				buildContext,
 				skipCommandOwnerAllowFrom: pluginCommandCandidate !== void 0
 			});
 		},
@@ -4553,6 +4822,7 @@ function createDiscordNativeCommand(params) {
 				preferFollowUp: true,
 				threadBindings,
 				responseEphemeral: ephemeralDefault,
+				buildContext,
 				dispatchReplyFromConfig,
 				pluginCommandDispatch: preparedPluginCommand ?? NON_PLUGIN_COMMAND_DISPATCH
 			});
@@ -4560,7 +4830,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;
@@ -4587,12 +4857,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: ""
+		channelIdFallback: interaction.rawData.channel_id ?? ""
 	});
+	const { isDirectMessage, isGroupDm, isThreadChannel, channelName, channelSlug, rawChannelId, threadParentId, threadParentName, threadParentSlug } = channelContext;
 	if (policy?.isCurrent() === false) {
 		await respond("Access policy changed. Try this interaction again.", { ephemeral: true });
 		return { accepted: false };
@@ -4603,7 +4874,6 @@ async function dispatchDiscordCommandInteraction(params) {
 		cfg,
 		accountId
 	}) ?? [];
-	const commandOwnerAllowFrom = resolveDiscordCommandOwnerAllowFrom(cfg);
 	const { ownerAllowList: discordOwnerAllowList, ownerAllowed: discordOwnerOk } = resolveDiscordOwnerAccess({
 		allowFrom: configuredDmAllowFrom,
 		sender: {
@@ -4613,18 +4883,6 @@ async function dispatchDiscordCommandInteraction(params) {
 		},
 		allowNameMatching
 	});
-	const { ownerAllowed: commandOwnerOk } = resolveDiscordOwnerAccess({
-		allowFrom: commandOwnerAllowFrom,
-		sender: {
-			id: sender.id,
-			name: sender.name,
-			tag: sender.tag
-		},
-		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({
@@ -4642,8 +4900,8 @@ async function dispatchDiscordCommandInteraction(params) {
 		threadParentName,
 		threadParentSlug
 	});
-	let nativeRouteStatePromise;
-	const getNativeRouteState = () => nativeRouteStatePromise ??= nativeCommandRuntime.resolveDiscordNativeInteractionRouteState({
+	let nativeRouteState;
+	const getNativeRouteState = () => nativeRouteState ??= nativeCommandRuntime.resolveDiscordNativeInteractionRouteState({
 		cfg,
 		accountId,
 		guildId: interaction.guild?.id ?? void 0,
@@ -4653,19 +4911,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 };
 	}
@@ -4679,7 +4936,7 @@ async function dispatchDiscordCommandInteraction(params) {
 			groupPolicy,
 			guildInfo,
 			channelConfig
-		}).allowed && !await canBypassConfiguredAcpGuildGuards()) {
+		}).allowed && !canBypassConfiguredAcpGuildGuards()) {
 			await respond("This channel is not allowed.");
 			return { accepted: false };
 		}
@@ -4767,7 +5024,7 @@ async function dispatchDiscordCommandInteraction(params) {
 			ownerAllowListConfigured,
 			ownerAllowed: ownerOk
 		});
-		if (!commandAuthorized && !await canBypassConfiguredAcpGuildGuards()) {
+		if (!commandAuthorized && !canBypassConfiguredAcpGuildGuards()) {
 			await respond("You are not authorized to use this command.", { ephemeral: true });
 			return { accepted: false };
 		}
@@ -4776,18 +5033,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,
@@ -4797,17 +5099,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,
-		...menuModelCatalog?.length ? { catalog: menuModelCatalog } : {}
+		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,
@@ -4819,6 +5124,7 @@ async function dispatchDiscordCommandInteraction(params) {
 				accountId,
 				sessionPrefix,
 				threadBindings,
+				buildContext,
 				dispatchReplyFromConfig
 			},
 			safeInteractionCall: safeDiscordInteractionCall,
@@ -4846,19 +5152,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,
@@ -4919,58 +5226,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,
@@ -4982,7 +5245,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",
@@ -5975,7 +6238,7 @@ function parseDiscordGatewayInfoBody(body) {
 async function fetchDiscordGatewayInfo(params) {
 	let response;
 	try {
-		response = await params.fetchImpl(DISCORD_GATEWAY_BOT_URL, {
+		response = await params.fetchImpl(params.gatewayBotUrl ?? DISCORD_GATEWAY_BOT_URL, {
 			...params.fetchInit,
 			headers: {
 				...params.fetchInit?.headers,
@@ -5984,7 +6247,7 @@ async function fetchDiscordGatewayInfo(params) {
 		});
 	} catch (error) {
 		throw createGatewayMetadataError({
-			detail: formatErrorMessage(error),
+			detail: formatErrorMessage$1(error),
 			transient: true,
 			cause: error
 		});
@@ -5994,7 +6257,7 @@ async function fetchDiscordGatewayInfo(params) {
 		body = await response.text();
 	} catch (error) {
 		throw createGatewayMetadataError({
-			detail: formatErrorMessage(error),
+			detail: formatErrorMessage$1(error),
 			transient: true,
 			cause: error
 		});
@@ -6009,7 +6272,7 @@ async function fetchDiscordGatewayInfo(params) {
 		return parseDiscordGatewayInfoBody(body);
 	} catch (error) {
 		throw createGatewayMetadataError({
-			detail: `Discord API /gateway/bot returned invalid metadata: ${formatErrorMessage(error)} (${summary})`,
+			detail: `Discord API /gateway/bot returned invalid metadata: ${formatErrorMessage$1(error)} (${summary})`,
 			transient,
 			cause: error
 		});
@@ -6026,6 +6289,7 @@ async function fetchDiscordGatewayInfoWithTimeout(params) {
 		}),
 		run: async (signal) => await fetchDiscordGatewayInfo({
 			token: params.token,
+			gatewayBotUrl: params.gatewayBotUrl,
 			fetchImpl: params.fetchImpl,
 			fetchInit: {
 				...params.fetchInit,
@@ -6036,7 +6300,7 @@ async function fetchDiscordGatewayInfoWithTimeout(params) {
 }
 function resolveGatewayInfoWithFallback(params) {
 	if (!isTransientGatewayMetadataError(params.error)) throw params.error;
-	const message = formatErrorMessage(params.error);
+	const message = formatErrorMessage$1(params.error);
 	const now = Date.now();
 	if (params.runtime) {
 		const previous = gatewayMetadataFallbackLogLastAt.get(params.runtime);
@@ -6179,16 +6443,20 @@ function createGatewayPlugin(params) {
 			if (!this.gatewayInfo || this.gatewayInfoUsedFallback) {
 				const resolved = await fetchDiscordGatewayInfoWithTimeout({
 					token: client.options.token,
+					...params.endpoint ? { gatewayBotUrl: params.endpoint.gatewayBotUrl } : {},
 					fetchImpl: params.fetchImpl,
 					fetchInit: params.fetchInit,
 					timeoutMs: params.gatewayInfoTimeoutMs
 				}).then((info) => ({
 					info,
 					usedFallback: false
-				})).catch((error) => resolveGatewayInfoWithFallback({
-					runtime: params.runtime,
-					error
-				}));
+				})).catch((error) => {
+					if (params.endpoint) throw error;
+					return resolveGatewayInfoWithFallback({
+						runtime: params.runtime,
+						error
+					});
+				});
 				this.gatewayInfo = resolved.info;
 				this.gatewayInfoUsedFallback = resolved.usedFallback;
 			}
@@ -6201,6 +6469,7 @@ function createGatewayPlugin(params) {
 		}
 		createWebSocket(url) {
 			if (!url) throw new Error("Gateway URL is required");
+			assertDiscordEndpointGatewayUrl(url, params.endpoint?.gatewayOrigin);
 			const wsFlowId = randomUUID();
 			const socket = new ((params.testing?.webSocketCtor) ?? WebSocket)(url, {
 				...DISCORD_GATEWAY_WS_CLIENT_OPTIONS,
@@ -6274,13 +6543,21 @@ function createGatewayPlugin(params) {
 	}
 	return new OpenClawGatewayPlugin();
 }
-function createDiscordGatewayMetadataFetch(debugCaptureEnabled, proxyUrl) {
+function createDiscordGatewayMetadataFetch(debugCaptureEnabled, transport) {
+	const endpoint = transport?.endpoint;
+	if (endpoint) return (input, init) => {
+		const signal = init?.signal instanceof AbortSignal ? init.signal : void 0;
+		return endpoint.fetch(input, {
+			...init?.headers ? { headers: init.headers } : {},
+			...signal ? { signal } : {}
+		});
+	};
 	return (input, init) => fetchDiscordGatewayMetadataGuarded(input, init, {
 		...debugCaptureEnabled ? {} : { capture: {
 			flowId: randomUUID(),
 			meta: { subsystem: "discord-gateway-metadata" }
 		} },
-		...proxyUrl ? { proxyUrl } : {}
+		...transport?.proxyUrl ? { proxyUrl: transport.proxyUrl } : {}
 	});
 }
 function waitForDiscordGatewayPluginRegistration(plugin) {
@@ -6295,16 +6572,23 @@ function createDiscordGatewayPlugin(params) {
 	const proxy = resolveEffectiveDebugProxyUrl(params.discordConfig?.proxy);
 	const debugProxySettings = resolveDebugProxySettings();
 	const gatewayInfoTimeoutMs = resolveDiscordGatewayInfoTimeoutMs({ env: process.env });
-	let fetchImpl = createDiscordGatewayMetadataFetch(debugProxySettings.enabled);
-	let wsAgent = new Agent$1({ lookup: discordDnsLookup });
-	if (proxy) try {
+	const endpointRuntime = getDiscordEndpointRuntime();
+	const endpoint = endpointRuntime ? {
+		gatewayBotUrl: endpointRuntime.descriptor.gatewayBotUrl,
+		gatewayOrigin: endpointRuntime.descriptor.gatewayOrigin,
+		fetch: endpointRuntime.fetch
+	} : 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 });
+	if (proxy && !endpoint) try {
 		validateDiscordProxyUrl(proxy);
 		wsAgent = params.testing?.createProxyAgent?.(proxy) ?? createNodeProxyAgent({
 			mode: "explicit",
 			proxyUrl: proxy,
 			protocol: "https"
 		});
-		fetchImpl = createDiscordGatewayMetadataFetch(debugProxySettings.enabled, proxy);
+		fetchImpl = createDiscordGatewayMetadataFetch(debugProxySettings.enabled, { proxyUrl: proxy });
 		params.runtime.log?.("discord: gateway proxy enabled");
 	} catch (err) {
 		params.runtime.error?.(danger(`discord: invalid gateway proxy: ${String(err)}`));
@@ -6317,6 +6601,7 @@ function createDiscordGatewayPlugin(params) {
 			autoInteractions: false
 		},
 		gatewayInfoTimeoutMs,
+		...endpoint ? { endpoint } : {},
 		fetchImpl,
 		runtime: params.runtime,
 		testing: params.testing,
@@ -6362,12 +6647,12 @@ function readFirstStackFrame(err) {
 	return frame ? frame.replace(/^at\s+/, "") : void 0;
 }
 function formatDiscordGatewayErrorMessage(err) {
-	if (!(err instanceof Error)) return formatErrorMessage$1(err);
+	if (!(err instanceof Error)) return formatErrorMessage(err);
 	if (err.message) {
-		const detail = formatErrorMessage$1(err);
+		const detail = formatErrorMessage(err);
 		return err.name ? `${err.name}: ${detail}` : detail;
 	}
-	const detail = formatErrorMessage$1(err);
+	const detail = formatErrorMessage(err);
 	const firstFrame = readFirstStackFrame(err);
 	if (firstFrame && detail === (err.name || "Error")) return `${detail} @ ${firstFrame}`;
 	return detail;
@@ -6901,7 +7186,7 @@ async function runDiscordGatewayLifecycle(params) {
 	});
 	try {
 		if (drainPendingGatewayErrors() === "stop") return;
-		if (gatewayReadyAtLifecycleStart && params.voiceManager) params.voiceManager.autoJoin().catch((err) => params.runtime.error?.(danger(`discord voice: autoJoin failed: ${formatErrorMessage$1(err)}`)));
+		if (gatewayReadyAtLifecycleStart && params.voiceManager) params.voiceManager.autoJoin().catch((err) => params.runtime.error?.(danger(`discord voice: autoJoin failed: ${formatErrorMessage(err)}`)));
 		await waitForGatewayReady({
 			gateway,
 			abortSignal: params.abortSignal,
@@ -6946,7 +7231,7 @@ async function runDiscordGatewayLifecycle(params) {
 let discordVoiceRuntimePromise;
 let discordProviderSessionRuntimePromise;
 async function loadDiscordVoiceRuntime() {
-	const promise = discordVoiceRuntimePromise ?? import("./voice-runtime-DMYDMkJx.js").then((n) => n.t);
+	const promise = discordVoiceRuntimePromise ?? import("./voice-runtime-elTtjEIG.mjs").then((n) => n.t);
 	discordVoiceRuntimePromise = promise;
 	try {
 		return await promise;
@@ -6956,7 +7241,7 @@ async function loadDiscordVoiceRuntime() {
 	}
 }
 async function loadDiscordProviderSessionRuntime() {
-	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-U1M8_EYY.js");
+	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-DrGAYnZv.mjs");
 	discordProviderSessionRuntimePromise = promise;
 	try {
 		return await promise;
@@ -6990,13 +7275,13 @@ function isLegacyMissingSessionError(message) {
 function classifyAcpStatusProbeError(params) {
 	if (params.isAcpRuntimeError(params.error) && ["SESSION_OWNER_MIGRATION_REQUIRED", "SESSION_OWNER_UNSUPPORTED"].includes(params.error.detailCode ?? "")) return {
 		status: "uncertain",
-		reason: formatErrorMessage$1(params.error)
+		reason: formatErrorMessage(params.error)
 	};
 	if (params.isAcpRuntimeError(params.error) && params.error.code === "ACP_SESSION_INIT_FAILED") return {
 		status: "stale",
 		reason: "session-init-failed"
 	};
-	if (isLegacyMissingSessionError(formatErrorMessage$1(params.error))) return {
+	if (isLegacyMissingSessionError(formatErrorMessage(params.error))) return {
 		status: "stale",
 		reason: "session-missing"
 	};
@@ -7060,7 +7345,12 @@ async function probeDiscordAcpBindingHealth(params) {
 //#endregion
 //#region extensions/discord/src/monitor/provider.cleanup.ts
 async function cleanupDiscordProviderStartup(params) {
-	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);
@@ -7442,7 +7732,7 @@ function readDiscordDeployObjectField(value, field) {
 function isAbortLikeError(err) {
 	if (!err || typeof err !== "object") return false;
 	const name = "name" in err && typeof err.name === "string" ? err.name : void 0;
-	const message = formatErrorMessage$1(err);
+	const message = formatErrorMessage(err);
 	return name === "AbortError" || message === "This operation was aborted" || message === "The operation was aborted" || /\boperation was aborted\b/i.test(message);
 }
 function formatDiscordDeployRestOperation(err) {
@@ -7454,7 +7744,7 @@ function formatDiscordDeployRestOperation(err) {
 	return "request";
 }
 function formatDiscordDeployErrorMessage(err) {
-	if (!isAbortLikeError(err)) return formatErrorMessage$1(err);
+	if (!isAbortLikeError(err)) return formatErrorMessage(err);
 	const deployErr = err && typeof err === "object" ? err : {};
 	const requestMs = parseFiniteNumber$1(deployErr.deployRequestMs);
 	const timeoutMs = parseFiniteNumber$1(deployErr.deployTimeoutMs);
@@ -7563,7 +7853,7 @@ function isDiscordDeployDailyCreateLimit(err) {
 	const deployErr = err;
 	const discordCode = parseStrictNonNegativeInteger$1(deployErr.discordCode);
 	const rawCode = parseStrictNonNegativeInteger$1(readDiscordDeployObjectField(deployErr.rawBody, "code"));
-	return (discordCode === 30034 || rawCode === 30034) && /daily application command creates/i.test(formatErrorMessage$1(err));
+	return (discordCode === 30034 || rawCode === 30034) && /daily application command creates/i.test(formatErrorMessage(err));
 }
 //#endregion
 //#region extensions/discord/src/monitor/provider.startup-log.ts
@@ -7698,7 +7988,7 @@ function runDiscordCommandDeployInBackground(params) {
 			isVerbose: params.isVerbose
 		});
 	}).catch((err) => {
-		params.runtime.log?.(warn(`[${params.accountId}] slash command deploy failed in background (message send/receive unaffected): ${formatErrorMessage$1(err)}`));
+		params.runtime.log?.(warn(`[${params.accountId}] slash command deploy failed in background (message send/receive unaffected): ${formatErrorMessage(err)}`));
 	});
 }
 //#endregion
@@ -8596,8 +8886,8 @@ async function deliverDiscordReply(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.dispatch.ts
-const loadConversationRuntime$1 = createLazyRuntimeModule(() => import("./agent-components.runtime-CEPrf2SY.js"));
-const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing-DuBg1U8Q.js").then((n) => n.n));
+const loadConversationRuntime$1 = createLazyRuntimeModule(() => import("./agent-components.runtime-CEPrf2SY.mjs"));
+const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing-BKZL5fGj.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}`;
@@ -8742,13 +9032,11 @@ async function dispatchDiscordComponentEvent(params) {
 		Surface: "discord",
 		WasMentioned: true,
 		CommandAuthorized: commandAuthorized,
-		CommandTurn: {
-			kind: "text-slash",
-			source: "text",
+		CommandTurn: createCommandTurnContext(params.commandSource ?? "text", {
 			authorized: commandAuthorized,
 			body: eventText
-		},
-		CommandSource: "text",
+		}),
+		CommandSource: params.commandSource ?? "text",
 		MessageSid: interaction.rawData.id,
 		Timestamp: timestamp,
 		OriginatingChannel: "discord",
@@ -8881,7 +9169,7 @@ async function dispatchDiscordPluginInteractiveHandler(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.plugin-interactive.ts
-const loadConversationRuntime = createLazyRuntimeModule(() => import("./agent-components.runtime-CEPrf2SY.js"));
+const loadConversationRuntime = createLazyRuntimeModule(() => import("./agent-components.runtime-CEPrf2SY.mjs"));
 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;
@@ -9004,7 +9292,7 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.handlers.ts
-const loadComponentsRuntime = createLazyRuntimeModule(() => import("./components-DBFTIN6P.js").then((n) => n.t));
+const loadComponentsRuntime = createLazyRuntimeModule(() => import("./components-yBEb75bB.mjs").then((n) => n.t));
 async function handleDiscordComponentEvent(params) {
 	const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
 	if (!parsed) {
@@ -9090,6 +9378,7 @@ async function handleDiscordComponentEvent(params) {
 		channelCtx,
 		guildInfo,
 		eventText,
+		commandSource: consumed.callbackDataKind === "command" && (buttonCallbackFallback || selectedCommandFallback) ? "native" : void 0,
 		replyToId: consumed.messageId ?? params.interaction.message?.id,
 		routeOverrides: {
 			sessionKey: consumed.sessionKey,
@@ -9582,11 +9871,14 @@ var ExecApprovalButton = class extends Button {
 		const terminalLabel = resolveTerminalLabel(result.resolution.approval);
 		let terminalized = false;
 		try {
-			await interaction.editReply(buildTerminalPayload({
-				approval: result.resolution.approval,
-				applied: result.resolution.applied
-			}));
-			terminalized = true;
+			if (interaction.message) terminalized = await discordApprovalMessageUpdates.enqueue(interaction.message.id, async () => {
+				if (!hasDiscordApprovalControl(await interaction.fetchReply(), parsed)) return false;
+				await interaction.editReply(buildTerminalPayload({
+					approval: result.resolution.approval,
+					applied: result.resolution.applied
+				}));
+				return true;
+			});
 		} catch {}
 		if (!terminalized || !result.resolution.applied) try {
 			await interaction.followUp({
@@ -9717,6 +10009,7 @@ function createDiscordProviderInteractionSurface(params) {
 			sessionPrefix: params.sessionPrefix,
 			ephemeralDefault: params.ephemeralDefault,
 			threadBindings: params.threadBindings,
+			buildContext: params.channelRuntime?.inbound.buildContext,
 			dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
 		});
 	});
@@ -9765,6 +10058,7 @@ function createDiscordProviderInteractionSurface(params) {
 			accountId: params.accountId,
 			sessionPrefix: params.sessionPrefix,
 			threadBindings: params.threadBindings,
+			buildContext: params.channelRuntime?.inbound.buildContext,
 			dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
 		}),
 		createDiscordModelPickerFallbackButton({
@@ -9774,6 +10068,7 @@ function createDiscordProviderInteractionSurface(params) {
 			accountId: params.accountId,
 			sessionPrefix: params.sessionPrefix,
 			threadBindings: params.threadBindings,
+			buildContext: params.channelRuntime?.inbound.buildContext,
 			dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
 		}),
 		createDiscordModelPickerFallbackSelect({
@@ -9783,6 +10078,7 @@ function createDiscordProviderInteractionSurface(params) {
 			accountId: params.accountId,
 			sessionPrefix: params.sessionPrefix,
 			threadBindings: params.threadBindings,
+			buildContext: params.channelRuntime?.inbound.buildContext,
 			dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
 		})
 	];
@@ -9858,7 +10154,7 @@ var VoicePlugin = class extends Plugin {
 					}
 				},
 				destroy: () => {
-					this.adapters.delete(guildId);
+					if (this.adapters.get(guildId) === methods) this.adapters.delete(guildId);
 				}
 			};
 		};
@@ -9937,9 +10233,13 @@ var DiscordGuildJoinIntroductionListener = class extends GuildCreateListener {
 	constructor(params) {
 		super();
 		this.params = params;
+		this.stopped = false;
+		this.pendingReports = /* @__PURE__ */ new Set();
 	}
 	async handle(data, client) {
+		if (this.stopped) return;
 		const policy = await this.params.readPolicy?.();
+		if (this.stopped) return;
 		const params = {
 			...this.params,
 			...policy
@@ -9987,6 +10287,7 @@ var DiscordGuildJoinIntroductionListener = class extends GuildCreateListener {
 				break;
 			}
 		}
+		if (this.stopped) return;
 		if (policy?.isCurrent() === false) {
 			params.logger?.info("Discord guild join introduction skipped: access policy changed", {
 				guildId: data.id,
@@ -10002,7 +10303,7 @@ var DiscordGuildJoinIntroductionListener = class extends GuildCreateListener {
 			return;
 		}
 		const selectedChannel = targetChannel;
-		await reportChannelRoomJoin({
+		const report = reportChannelRoomJoin({
 			cfg: params.cfg,
 			channel: "discord",
 			accountId: params.accountId,
@@ -10038,6 +10339,16 @@ var DiscordGuildJoinIntroductionListener = class extends GuildCreateListener {
 				}
 			}
 		});
+		this.pendingReports.add(report);
+		try {
+			await report;
+		} finally {
+			this.pendingReports.delete(report);
+		}
+	}
+	async stop() {
+		this.stopped = true;
+		await Promise.allSettled(this.pendingReports);
 	}
 };
 //#endregion
@@ -10165,7 +10476,7 @@ async function fetchDiscordBotIdentity(params) {
 function registerDiscordMonitorListeners(params) {
 	registerDiscordListener(params.client.listeners, new DiscordInteractionListener(params.logger, params.trackInboundEvent));
 	registerDiscordListener(params.client.listeners, new DiscordMessageListener(params.messageHandler, params.logger, params.trackInboundEvent));
-	registerDiscordListener(params.client.listeners, new DiscordGuildJoinIntroductionListener({
+	const guildJoinListener = new DiscordGuildJoinIntroductionListener({
 		readPolicy: params.readPolicy,
 		cfg: params.cfg,
 		accountId: params.accountId,
@@ -10173,7 +10484,8 @@ function registerDiscordMonitorListeners(params) {
 		groupPolicy: params.groupPolicy,
 		guildEntries: params.guildEntries,
 		logger: params.logger
-	}));
+	});
+	registerDiscordListener(params.client.listeners, guildJoinListener);
 	const reactionListenerOptions = {
 		readPolicy: params.readPolicy,
 		cfg: params.cfg,
@@ -10193,10 +10505,13 @@ function registerDiscordMonitorListeners(params) {
 	};
 	registerDiscordListener(params.client.listeners, new DiscordReactionListener(reactionListenerOptions));
 	registerDiscordListener(params.client.listeners, new DiscordReactionRemoveListener(reactionListenerOptions));
-	registerDiscordListener(params.client.listeners, new DiscordThreadUpdateListener(params.cfg, params.logger));
+	const threadUpdateListener = new DiscordThreadUpdateListener(params.cfg, params.logger);
+	registerDiscordListener(params.client.listeners, threadUpdateListener);
+	registerDiscordListener(params.client.listeners, new DiscordThreadReadyListener(threadUpdateListener));
 	registerDiscordListener(params.client.listeners, new DiscordThreadDeleteListener(params.cfg, params.accountId, params.logger));
+	let presenceListener;
 	if (params.discordConfig.intents?.presence) {
-		const presenceListener = new DiscordPresenceListener({
+		presenceListener = new DiscordPresenceListener({
 			readPolicy: params.readPolicy,
 			cfg: params.cfg,
 			logger: params.logger,
@@ -10210,6 +10525,14 @@ function registerDiscordMonitorListeners(params) {
 		registerDiscordListener(params.client.listeners, new DiscordPresenceReadyListener(presenceListener));
 		params.runtime.log?.("discord: GuildPresences intent enabled — presence listener registered");
 	}
+	return async () => {
+		const introductionsStopped = guildJoinListener.stop();
+		try {
+			await presenceListener?.stop();
+		} finally {
+			await introductionsStopped;
+		}
+	};
 }
 //#endregion
 //#region extensions/discord/src/monitor/startup-status.ts
@@ -10230,7 +10553,7 @@ function logDiscordStartupPhase(params) {
 const DISCORD_DISALLOWED_INTENTS_CODE = GatewayCloseCodes$1.DisallowedIntents;
 function isDiscordDisallowedIntentsError(err) {
 	if (!err) return false;
-	return formatErrorMessage$1(err).includes(String(DISCORD_DISALLOWED_INTENTS_CODE));
+	return formatErrorMessage(err).includes(String(DISCORD_DISALLOWED_INTENTS_CODE));
 }
 async function monitorDiscordProvider(opts = {}) {
 	const startupStartedAt = Date.now();
@@ -10272,7 +10595,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({
@@ -10309,6 +10632,7 @@ async function monitorDiscordProvider(opts = {}) {
 	const sessionPrefix = "discord:slash";
 	const ephemeralDefault = slashCommand.ephemeral;
 	const voiceEnabled = resolveDiscordVoiceEnabled(discordCfg.voice);
+	if (voiceEnabled && getDiscordEndpointRuntime()) throw new Error("Discord voice transport is unavailable while DISCORD_API_URL is configured");
 	const allowlistResolved = await resolveDiscordAllowlistConfig({
 		token,
 		guildEntries,
@@ -10361,7 +10685,7 @@ async function monitorDiscordProvider(opts = {}) {
 	if (applicationIdProbe.kind !== "resolved") {
 		const at = Date.now();
 		const terminal = applicationIdProbe.kind === "rejected";
-		const probeError = formatErrorMessage$1(applicationIdProbe.error);
+		const probeError = formatErrorMessage(applicationIdProbe.error);
 		const message = `Failed to resolve Discord application id: ${probeError}`;
 		opts.setStatus?.({
 			connected: false,
@@ -10395,43 +10719,46 @@ async function monitorDiscordProvider(opts = {}) {
 		listNativeCommandSpecsForConfig: discordProviderRuntime.listNativeCommandSpecsForConfig
 	});
 	const voiceManagerRef = { current: null };
-	const threadBindings = threadBindingsEnabled ? discordProviderSessionRuntime.createThreadBindingManager({
+	const threadBindings = threadBindingsEnabled ? await discordProviderSessionRuntime.createThreadBindingManager({
 		accountId: account.accountId,
 		token,
 		cfg,
 		idleTimeoutMs: threadBindingIdleTimeoutMs,
 		maxAgeMs: threadBindingMaxAgeMs
 	}) : discordProviderSessionRuntime.createNoopThreadBindingManager(account.accountId);
-	if (threadBindingsEnabled) {
-		const uncertainProbeKeys = /* @__PURE__ */ new Set();
-		const reconciliation = await discordProviderSessionRuntime.reconcileAcpThreadBindingsOnStartup({
-			cfg,
-			accountId: account.accountId,
-			sendFarewell: false,
-			healthProbe: async ({ sessionKey, session }) => {
-				const probe = await probeDiscordAcpBindingHealth({
-					cfg,
-					sessionKey,
-					agentId: session.agentId,
-					storedState: session.acp?.state,
-					lastActivityAt: session.acp?.lastActivityAt,
-					providerSessionRuntime: discordProviderSessionRuntime
-				});
-				if (probe.status === "uncertain") uncertainProbeKeys.add(`${sessionKey}${probe.reason ? ` (${probe.reason})` : ""}`);
-				return probe;
-			}
-		});
-		if (reconciliation.removed > 0) logVerbose(`discord: removed ${reconciliation.removed}/${reconciliation.checked} stale ACP thread bindings on startup for account ${account.accountId}: ${reconciliation.staleSessionKeys.join(", ")}`);
-		if (uncertainProbeKeys.size > 0) logVerbose(`discord: ACP thread-binding health probe uncertain for account ${account.accountId}: ${[...uncertainProbeKeys].join(", ")}`);
-	}
 	let lifecycleStarted = false;
 	let gatewaySupervisor;
 	let deactivateMessageHandler;
+	let stopMonitorListeners;
 	let autoPresenceController = null;
 	let lifecycleGateway;
 	let earlyGatewayEmitter = gatewaySupervisor?.emitter;
 	let onEarlyGatewayDebug;
 	try {
+		if (opts.abortSignal?.aborted) return;
+		if (threadBindingsEnabled) {
+			const uncertainProbeKeys = /* @__PURE__ */ new Set();
+			const reconciliation = await discordProviderSessionRuntime.reconcileAcpThreadBindingsOnStartup({
+				cfg,
+				accountId: account.accountId,
+				sendFarewell: false,
+				healthProbe: async ({ sessionKey, session }) => {
+					const probe = await probeDiscordAcpBindingHealth({
+						cfg,
+						sessionKey,
+						agentId: session.agentId,
+						storedState: session.acp?.state,
+						lastActivityAt: session.acp?.lastActivityAt,
+						providerSessionRuntime: discordProviderSessionRuntime
+					});
+					if (probe.status === "uncertain") uncertainProbeKeys.add(`${sessionKey}${probe.reason ? ` (${probe.reason})` : ""}`);
+					return probe;
+				}
+			});
+			if (reconciliation.removed > 0) logVerbose(`discord: removed ${reconciliation.removed}/${reconciliation.checked} stale ACP thread bindings on startup for account ${account.accountId}: ${reconciliation.staleSessionKeys.join(", ")}`);
+			if (uncertainProbeKeys.size > 0) logVerbose(`discord: ACP thread-binding health probe uncertain for account ${account.accountId}: ${[...uncertainProbeKeys].join(", ")}`);
+		}
+		if (opts.abortSignal?.aborted) return;
 		const pluginChannelRuntime = opts.channelRuntime;
 		const { commands, components, modals } = createDiscordProviderInteractionSurface({
 			readPolicy,
@@ -10572,7 +10899,7 @@ async function monitorDiscordProvider(opts = {}) {
 				lastInboundAt: at
 			});
 		} : void 0;
-		registerDiscordMonitorListeners({
+		stopMonitorListeners = registerDiscordMonitorListeners({
 			readPolicy,
 			cfg,
 			client,
@@ -10622,6 +10949,7 @@ async function monitorDiscordProvider(opts = {}) {
 	} finally {
 		await cleanupDiscordProviderStartup({
 			deactivateMessageHandler,
+			stopMonitorListeners,
 			autoPresenceController,
 			setStatus: opts.setStatus,
 			onEarlyGatewayDebug,