@openclaw/discord 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/{provider-DfQJX3z5.js → provider-DvSNb-2v.js}

@@ -1,38 +1,38 @@
-import { C as Client, D as RateLimitError, F as Message, I as User, K as Container, M as Command, N as CommandWithSubcommands, P as Guild, Q as Row, V as Modal, W as Button, Yt as __exportAll, _ as MessageReactionRemoveListener, _t as editChannel, at as BaseMessageInteractiveComponent, bt as getChannelMessage, d as discord_exports, et as Separator, f as GuildCreateListener, g as MessageReactionAddListener, h as MessageCreateListener, m as InteractionCreateListener, mt as createThread, nt as TextDisplay, p as GuildDeleteListener, t as chunkDiscordTextWithMode, tt as StringSelectMenu, v as PresenceUpdateListener, w as Plugin, x as ThreadUpdateListener, y as ReadyListener } from "./chunk-DX4jpFQP.js";
+import { B as Message, C as ReadyListener, Ct as editChannel, E as ThreadUpdateListener, Et as getChannelMessage, K as Modal, L as Command, M as RateLimitError, O as Client, R as CommandWithSubcommands, S as PresenceUpdateListener, T as ThreadDeleteListener, V as User, Y as Button, Z as Container, _ as GuildDeleteListener, a as chunkDiscordTextWithMode, at as Separator, b as MessageReactionAddListener, bt as createThread, g as GuildCreateListener, h as discord_exports, k as Plugin, ot as StringSelectMenu, rt as Row, st as TextDisplay, tn as __exportAll, ut as BaseMessageInteractiveComponent, v as InteractionCreateListener, x as MessageReactionRemoveListener, y as MessageCreateListener, z as Guild } from "./retry-CLpJcXXf.js";
 import { c as resolveDiscordAccountAllowFrom, d as resolveDiscordAccountDmPolicy, f as resolveDiscordMaxLinesPerMessage, p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-DJTf1LtA.js";
-import { n as getDiscordActivitiesRuntime } from "./runtime-BmW_j_hl.js";
-import { C as parseDiscordActivityCustomIdForInteraction, D as parseDiscordModalCustomIdForInteraction, E as parseDiscordModalCustomId, O as decodeCustomIdComponent, T as parseDiscordComponentCustomIdForInteraction, k as encodeCustomIdComponent, l as parseExecApprovalData, s as parseDiscordQuestionData, w as parseDiscordComponentCustomId, y as buildDiscordActivityCustomId } from "./outbound-session-route-H-HoyH5U.js";
-import { D as canViewDiscordGuildChannel, F as createDiscordRestClient, H as registerGateway, K as validateDiscordProxyUrl, U as unregisterGateway, q as withValidatedDiscordProxy, z as DISCORD_REST_TIMEOUT_MS } from "./send.shared-jpvAG_u6.js";
-import { _ as resolveDiscordModalEntryWithPersistence, g as resolveDiscordComponentEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-5uqwkjgE.js";
+import { n as getDiscordActivitiesRuntime } from "./runtime-DoHjckYm.js";
+import { C as parseDiscordActivityCustomIdForInteraction, D as parseDiscordModalCustomIdForInteraction, E as parseDiscordModalCustomId, O as decodeCustomIdComponent, T as parseDiscordComponentCustomIdForInteraction, k as encodeCustomIdComponent, l as parseExecApprovalData, s as parseDiscordQuestionData, w as parseDiscordComponentCustomId, y as buildDiscordActivityCustomId } from "./outbound-session-route-DxLkrgKQ.js";
+import { D as canViewDiscordGuildChannel, F as createDiscordRestClient, H as registerGateway, K as validateDiscordProxyUrl, U as unregisterGateway, q as withValidatedDiscordProxy, z as DISCORD_REST_TIMEOUT_MS } from "./send.shared-BmwFjW6T.js";
+import { _ as resolveDiscordModalEntryWithPersistence, g as resolveDiscordComponentEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-iJyFXw9L.js";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
-import { a as isDiscordRateLimitResponseBody, o as summarizeDiscordResponseBody } from "./api-DnrK9gML.js";
-import { C as resolveTimestampMs, a as normalizeDiscordSlug, b as formatDiscordReactionEmoji, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordCommandOwnerAllowFrom, f as resolveDiscordGuildEntry, g as resolveDiscordOwnerAllowFrom, h as resolveDiscordOwnerAccess, i as normalizeDiscordDisplaySlug, l as resolveDiscordChannelPolicyCommandAuthorizer, m as resolveDiscordMemberAllowed, n as isDiscordGroupAllowedByPolicy, o as resolveDiscordAllowListMatch, p as resolveDiscordMemberAccessState, r as normalizeDiscordAllowList, t as allowListMatches, v as resolveGroupDmAllow, x as formatDiscordUserTag, y as shouldEmitDiscordReactionNotification } from "./allow-list-DzKrtfah.js";
-import { a as formatMention, t as sendMessageDiscord } from "./send.outbound-D-80Ej-t.js";
+import { a as isDiscordRateLimitResponseBody, o as summarizeDiscordResponseBody } from "./api-DNVbJyEy.js";
+import { C as resolveTimestampMs, a as normalizeDiscordSlug, b as formatDiscordReactionEmoji, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordCommandOwnerAllowFrom, f as resolveDiscordGuildEntry, g as resolveDiscordOwnerAllowFrom, h as resolveDiscordOwnerAccess, i as normalizeDiscordDisplaySlug, l as resolveDiscordChannelPolicyCommandAuthorizer, m as resolveDiscordMemberAllowed, n as isDiscordGroupAllowedByPolicy, o as resolveDiscordAllowListMatch, p as resolveDiscordMemberAccessState, r as normalizeDiscordAllowList, t as allowListMatches, v as resolveGroupDmAllow, x as formatDiscordUserTag, y as shouldEmitDiscordReactionNotification } from "./allow-list-DnxIlPP2.js";
+import { a as formatMention, t as sendMessageDiscord } from "./send.outbound-DS5tHwfR.js";
 import { i as setPresence, t as clearPresences } from "./presence-cache-z1N8MbJ3.js";
-import { n as sendVoiceMessageDiscord } from "./send-CdkZ6zeW.js";
+import { r as sendVoiceMessageDiscord } from "./send-B7Q6Oc1I.js";
 import { c as raceWithTimeout, u as withAbortTimeout } from "./timeouts-B9cy6RvQ.js";
-import { a as getDiscordExecApprovalApprovers, n as formatDiscordApprovalDisplayValue, r as resolveDiscordConversationIdentity, s as isDiscordExecApprovalClientEnabled, t as DISCORD_APPROVAL_ALLOWED_MENTIONS } from "./approval-message-safety-DEyKVsAw.js";
-import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-BjepAj8b.js";
-import { t as resolveDiscordUserAllowlist } from "./resolve-users-Bc28htgt.js";
-import { a as isThreadArchived, d as resolveDiscordChannelIdSafe, f as resolveDiscordChannelInfoSafe, g as resolveDiscordChannelTopicSafe, h as resolveDiscordChannelParentSafe, m as resolveDiscordChannelParentIdSafe, p as resolveDiscordChannelNameSafe, y as formatThreadBindingDurationLabel } from "./thread-bindings.discord-api-BoDNqamb.js";
-import { r as parseApplicationIdFromToken, t as fetchDiscordApplicationId } from "./probe-BeWKhjqX.js";
-import { i as timestampMs, n as normalizeModelRef, r as sanitizeRecentModels, t as buildPreferenceModelKey } from "./model-picker-preference-primitives-D25pnCOu.js";
-import { a as formatDiscordMediaText, d as resolveDiscordChannelInfo, f as resolveDiscordMessageChannelId, n as resolveDiscordForwardedMessagesTextFromSnapshots, t as resolveDiscordEmbedText } from "./message-utils-BgTwT_q7.js";
-import { t as resolveDiscordSenderIdentity } from "./sender-identity-mG_zsdox.js";
+import { a as getDiscordExecApprovalApprovers, n as formatDiscordApprovalDisplayValue, r as resolveDiscordConversationIdentity, s as isDiscordExecApprovalClientEnabled, t as DISCORD_APPROVAL_ALLOWED_MENTIONS } from "./approval-message-safety-AcIxvrf3.js";
+import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-Dm7jEeg6.js";
+import { t as resolveDiscordUserAllowlist } from "./resolve-users-bktrCUUU.js";
+import { a as isThreadArchived, c as resolveDiscordChannelInfoSafe, d as resolveDiscordChannelParentSafe, f as resolveDiscordChannelTopicSafe, h as formatThreadBindingDurationLabel, l as resolveDiscordChannelNameSafe, r as getThreadBindingManager, s as resolveDiscordChannelIdSafe, u as resolveDiscordChannelParentIdSafe } from "./thread-bindings.manager-DCIH6WDC.js";
+import { a as probeDiscordApplicationId, r as parseApplicationIdFromToken } from "./probe-Bl-k5_Ku.js";
+import { i as sanitizeRecentModels, n as normalizeModelRef, r as preferenceTimestampMs, t as buildPreferenceModelKey } from "./model-picker-preference-primitives-BHT1LkR_.js";
+import { a as formatDiscordMediaText, d as resolveDiscordChannelInfo, f as resolveDiscordMessageChannelId, n as resolveDiscordForwardedMessagesTextFromSnapshots, t as resolveDiscordEmbedText } from "./message-utils-BSCPVgy0.js";
+import { t as resolveDiscordSenderIdentity } from "./sender-identity-QtalnCYv.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { buildAgentSessionKey, deriveLastRoutePolicy, isAcpSessionKey, isSubagentSessionKey, parseAgentSessionKey, resolveAgentIdFromSessionKey, resolveAgentRoute } from "openclaw/plugin-sdk/routing";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeOptionalStringifiedId, normalizeStringEntries, normalizeStringEntriesLower, summarizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asFiniteNumber, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeOptionalStringifiedId, normalizeStringEntries, parseFiniteNumber, parseStrictNonNegativeInteger, summarizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getRuntimeConfig, getRuntimeConfigSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { logDebug, logError } from "openclaw/plugin-sdk/logging-core";
 import { ApplicationCommandOptionType, ButtonStyle, ChannelType, ComponentType, GatewayCloseCodes, GatewayCloseCodes as GatewayCloseCodes$1, GatewayDispatchEvents, GatewayIntentBits, GatewayOpcodes } from "discord-api-types/v10";
 import { createHash, randomUUID } from "node:crypto";
-import { MAX_DATE_TIMESTAMP_MS, asDateTimestampMs, parseFiniteNumber, parseStrictFiniteNumber, parseStrictInteger, parseStrictNonNegativeInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
+import { MAX_DATE_TIMESTAMP_MS, asDateTimestampMs, parseFiniteNumber as parseFiniteNumber$1, parseStrictInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { Type } from "typebox";
 import { Check, Errors } from "typebox/value";
 import { inspect } from "node:util";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
-import { PlatformMessageNotDispatchedError, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { PlatformMessageNotDispatchedError, formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { fetchWithSsrFGuard, formatErrorMessage as formatErrorMessage$1 } from "openclaw/plugin-sdk/ssrf-runtime";
 import { createHttp1EnvHttpProxyAgent, createHttp1ProxyAgent, createNodeProxyAgent, resolveEnvHttpProxyAgentOptions, wrapFetchWithAbortSignal } from "openclaw/plugin-sdk/fetch-runtime";
 import { createNonExitingRuntime, createSubsystemLogger, danger, formatDurationSeconds, isVerbose, logVerbose, shouldLogVerbose, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
@@ -40,45 +40,44 @@ import { sliceUtf16Safe, truncateUtf16Safe, withTimeout } from "openclaw/plugin-
 import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, canonicalizeAllowlistWithResolvedIds, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
-import { chunkItems, sanitizeAssistantVisibleText, sanitizeAssistantVisibleTextWithProfile } from "openclaw/plugin-sdk/text-chunking";
+import { chunkItems, findCodeRegions, sanitizeAssistantVisibleText, sanitizeAssistantVisibleTextWithProfile } from "openclaw/plugin-sdk/text-chunking";
 import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
-import { buildOutboundSessionContext, resolveChannelStreamingBlockEnabled, sendDurableMessageBatch } from "openclaw/plugin-sdk/channel-outbound";
+import { buildOutboundSessionContext, listMessageReceiptPlatformIds, resolveChannelStreamingBlockEnabled, sendDurableMessageBatch } from "openclaw/plugin-sdk/channel-outbound";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
 import { resolveSendableOutboundReplyParts, resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
 import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
-import { createLazyRuntimeModule, createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { resolvePinnedMainDmOwnerFromAllowlist as resolvePinnedMainDmOwnerFromAllowlist$1 } from "openclaw/plugin-sdk/security-runtime";
 import { GROUP_POLICY_BLOCKED_LABEL, resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
 import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 import { buildPairingReply, upsertChannelPairingRequest, upsertChannelPairingRequest as upsertChannelPairingRequest$1 } from "openclaw/plugin-sdk/conversation-runtime";
-import { clearExpiredCooldowns, ensureAuthProfileStore, formatReasoningMessage, getPreparedModelCatalogSnapshot, isProfileInCooldown, loadPreparedModelCatalog, resolveAgentAvatar, resolveAgentDir, resolveDefaultModelForAgent, resolveHumanDelayConfig, resolveProfilesUnavailableReason } from "openclaw/plugin-sdk/agent-runtime";
+import { clearExpiredCooldowns, ensureAuthProfileStore, formatReasoningMessage, getPreparedModelCatalogSnapshot, isProfileInCooldown, listAgentIds, loadPreparedModelCatalog, resolveAgentAvatar, resolveAgentDir, resolveDefaultModelForAgent, resolveHumanDelayConfig, resolveProfilesUnavailableReason } from "openclaw/plugin-sdk/agent-runtime";
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { resolveNativeCommandsEnabled, resolveNativeSkillsEnabled } from "openclaw/plugin-sdk/native-command-config-runtime";
-import { normalizeProviderId } from "openclaw/plugin-sdk/provider-model-shared";
 import { requestHeartbeat } from "openclaw/plugin-sdk/heartbeat-runtime";
-import { enqueueSystemEvent, enqueueSystemEvent as enqueueSystemEvent$1 } from "openclaw/plugin-sdk/system-event-runtime";
+import { enqueueRoutedSystemEvent, enqueueRoutedSystemEvent as enqueueRoutedSystemEvent$1 } from "openclaw/plugin-sdk/system-event-runtime";
 import { createChannelIngressResolver, defineStableChannelIngressIdentity, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { createChannelPartialDeliveryError, dispatchChannelInboundTurn, formatInboundEnvelope, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, resolveEnvelopeFormatOptions, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent } from "openclaw/plugin-sdk/channel-inbound";
-import { ModelSelectionLockedError, applyModelOverrideToSessionEntry, resolveChannelModelOverride } from "openclaw/plugin-sdk/model-session-runtime";
-import { completeWithPreparedSimpleCompletionModel, extractAssistantText, prepareSimpleCompletionModelForAgent } from "openclaw/plugin-sdk/simple-completion-runtime";
-import { deleteSessionEntry, getSessionEntry, listSessionEntries, patchSessionEntry, readSessionUpdatedAt as readSessionUpdatedAt$1, resolveStorePath, resolveStorePath as resolveStorePath$1 } from "openclaw/plugin-sdk/session-store-runtime";
+import { resolveChannelModelOverride } from "openclaw/plugin-sdk/model-session-runtime";
+import { finalizeInboundContext, generateConversationLabel } from "openclaw/plugin-sdk/reply-dispatch-runtime";
+import { deleteSessionEntry, getSessionEntry, listSessionEntries, readSessionUpdatedAt as readSessionUpdatedAt$1, resolveStorePath, resolveStorePath as resolveStorePath$1 } from "openclaw/plugin-sdk/session-store-runtime";
 import { buildCommandTextFromArgs, findCommandByNativeName, formatCommandArgMenuTitle, listChatCommands, listNativeCommandSpecsForConfig, listSkillCommandsForAgents, resolveCommandAuthorizedFromAuthorizers, resolveEffectiveAgentRuntime, resolveNativeCommandSessionTargets, resolveStoredModelOverride, serializeCommandArgs } from "openclaw/plugin-sdk/command-auth-native";
-import { buildCommandTextFromArgs as buildCommandTextFromArgs$1, findCommandByNativeName as findCommandByNativeName$1, parseCommandArgs, resolveCommandArgChoices, resolveCommandArgMenu, serializeCommandArgs as serializeCommandArgs$1 } from "openclaw/plugin-sdk/native-command-registry";
+import { 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 pluginRuntime from "openclaw/plugin-sdk/plugin-runtime";
-import { createInteractiveConversationBindingHelpers, dispatchPluginInteractiveHandler } from "openclaw/plugin-sdk/plugin-runtime";
 import * as conversationRuntime from "openclaw/plugin-sdk/conversation-binding-runtime";
-import { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-runtime";
-import { createConnectedChannelStatusPatch, createTransportActivityStatusPatch } from "openclaw/plugin-sdk/gateway-runtime";
+import { normalizeProviderId } from "openclaw/plugin-sdk/provider-model-shared";
 import { EventEmitter } from "node:events";
 import * as ws from "ws";
 import { Agent } from "node:https";
 import { captureHttpExchange, captureWsEvent, resolveDebugProxySettings, resolveEffectiveDebugProxyUrl } from "openclaw/plugin-sdk/proxy-capture";
 import * as dns from "node:dns";
+import { channelReadyPatch, createTransportActivityStatusPatch } from "openclaw/plugin-sdk/gateway-runtime";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
 import { stripPlainTextToolCallBlocks } from "openclaw/plugin-sdk/tool-payload";
+import { createChannelInteractiveDispatcher } from "openclaw/plugin-sdk/plugin-runtime";
 import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
 import { resolveRequestUrl } from "openclaw/plugin-sdk/request-url";
 import { fetchWithRuntimeDispatcher } from "openclaw/plugin-sdk/runtime-fetch";
@@ -253,8 +252,11 @@ async function resolveDiscordDmCommandAccess(params) {
 		subject: createDiscordDmIngressSubject(params.sender),
 		conversation: {
 			kind: "direct",
-			id: params.sender.id
+			id: params.conversationId ?? params.sender.id,
+			parentId: params.conversationParentId,
+			threadId: params.conversationThreadId
 		},
+		...params.contextBinding ? { contextBinding: params.contextBinding } : {},
 		event: {
 			kind: params.eventKind ?? "native-command",
 			authMode: "inbound",
@@ -275,7 +277,7 @@ async function resolveDiscordTextCommandAccess(params) {
 	const memberAccessGroup = "discord-member-access";
 	const commandGroup = params.memberAccessConfigured ? [`accessGroup:${memberAccessGroup}`] : [];
 	const accessGroupMembership = params.memberAccessConfigured ? [syntheticAccessGroupMembership(memberAccessGroup, params.memberAllowed)] : [];
-	return (await createDiscordIngressResolver({
+	return await createDiscordIngressResolver({
 		accountId: params.accountId,
 		cfg: params.cfg,
 		token: params.token,
@@ -283,9 +285,12 @@ async function resolveDiscordTextCommandAccess(params) {
 	}).command({
 		subject: createDiscordDmIngressSubject(params.sender),
 		conversation: {
-			kind: "group",
-			id: "discord-command"
+			kind: "channel",
+			id: params.conversationId ?? "discord-command",
+			parentId: params.conversationParentId,
+			threadId: params.conversationThreadId
 		},
+		...params.contextBinding ? { contextBinding: params.contextBinding } : {},
 		accessGroupMembership,
 		dmPolicy: "allowlist",
 		groupPolicy: "allowlist",
@@ -297,7 +302,7 @@ async function resolveDiscordTextCommandAccess(params) {
 			hasControlCommand: params.hasControlCommand,
 			modeWhenAccessGroupsOff: "configured"
 		}
-	})).commandAccess;
+	});
 }
 //#endregion
 //#region extensions/discord/src/monitor/thread-title.ts
@@ -305,23 +310,10 @@ const DEFAULT_THREAD_TITLE_TIMEOUT_MS = 6e4;
 const MAX_THREAD_TITLE_SOURCE_CHARS = 600;
 const MAX_THREAD_TITLE_CHANNEL_NAME_CHARS = 120;
 const MAX_THREAD_TITLE_CHANNEL_DESCRIPTION_CHARS = 320;
-const DISCORD_THREAD_TITLE_MAX_TOKENS = 4096;
 const DISCORD_THREAD_TITLE_SYSTEM_PROMPT = "Generate a concise Discord thread title (3-6 words). Return only the title. Use channel context when provided and avoid redundant channel-name words unless needed for clarity.";
 async function generateThreadTitle(params) {
 	const sourceText = params.messageText.trim();
 	if (!sourceText) return null;
-	const prepared = await prepareSimpleCompletionModelForAgent({
-		cfg: params.cfg,
-		agentId: params.agentId,
-		...params.modelRef ? { modelRef: params.modelRef } : {},
-		useUtilityModel: true,
-		allowMissingApiKeyModes: ["aws-sdk"]
-	});
-	if ("error" in prepared) {
-		const modelLabel = prepared.selection ? `${prepared.selection.provider}/${prepared.selection.modelId}` : "unknown";
-		logVerbose(`thread-title: ${prepared.error} (agent=${params.agentId}, model=${modelLabel})`);
-		return null;
-	}
 	try {
 		const userMessage = buildThreadTitleCompletionUserMessage({
 			sourceText,
@@ -329,40 +321,21 @@ async function generateThreadTitle(params) {
 			channelDescription: params.channelDescription
 		});
 		const timeoutMs = resolveThreadTitleTimeoutMs(params.timeoutMs);
-		return normalizeGeneratedThreadTitle(extractAssistantText(await completeThreadTitle({
-			model: prepared.model,
-			auth: prepared.auth,
+		const generated = await generateConversationLabel({
+			cfg: params.cfg,
+			agentId: params.agentId,
 			userMessage,
-			timeoutMs
-		}))) || null;
+			prompt: DISCORD_THREAD_TITLE_SYSTEM_PROMPT,
+			...params.modelRef ? { modelRef: params.modelRef } : {},
+			timeoutMs,
+			maxLength: MAX_THREAD_TITLE_SOURCE_CHARS
+		});
+		return generated ? normalizeGeneratedThreadTitle(generated) : null;
 	} catch (err) {
 		logVerbose(`thread-title: title generation failed for agent ${params.agentId}: ${String(err)}`);
 		return null;
 	}
 }
-async function completeThreadTitle(params) {
-	const maxTokens = Math.min(DISCORD_THREAD_TITLE_MAX_TOKENS, Math.floor(params.model.maxTokens));
-	return await withAbortTimeout({
-		timeoutMs: params.timeoutMs,
-		createTimeoutError: () => /* @__PURE__ */ new Error(`thread-title timed out after ${params.timeoutMs}ms`),
-		run: async (signal) => await completeWithPreparedSimpleCompletionModel({
-			model: params.model,
-			auth: params.auth,
-			context: {
-				systemPrompt: DISCORD_THREAD_TITLE_SYSTEM_PROMPT,
-				messages: [{
-					role: "user",
-					content: params.userMessage,
-					timestamp: Date.now()
-				}]
-			},
-			options: {
-				maxTokens,
-				signal
-			}
-		})
-	});
-}
 function buildThreadTitleCompletionUserMessage(params) {
 	const sourceText = truncateThreadTitleSourceText(params.sourceText);
 	const channelName = normalizeTitleContextField(params.channelName, MAX_THREAD_TITLE_CHANNEL_NAME_CHARS);
@@ -1113,7 +1086,7 @@ async function handleDiscordReactionEvent(params) {
 		const resolveReactionBase = () => {
 			if (reactionBase) return reactionBase;
 			const emojiLabel = formatDiscordReactionEmoji(data.emoji);
-			const actorLabel = formatDiscordUserTag(user);
+			const actorLabel = formatDiscordUserTag(user) || user.id;
 			const guildSlug = guildInfo?.slug || (data.guild?.name ? normalizeDiscordSlug(data.guild.name) : data.guild_id ?? (isGroupDm ? "group-dm" : "dm"));
 			const channelLabel = channelSlug ? `#${channelSlug}` : channelName ? `#${normalizeDiscordSlug(channelName)}` : `#${data.channel_id}`;
 			reactionBase = {
@@ -1124,24 +1097,21 @@ async function handleDiscordReactionEvent(params) {
 		};
 		const emitReaction = (text, parentPeerId) => {
 			const { contextKey } = resolveReactionBase();
-			enqueueSystemEvent(text, {
-				sessionKey: resolveAgentRoute({
-					cfg: params.cfg,
-					channel: "discord",
-					accountId: params.accountId,
-					guildId: data.guild_id ?? void 0,
-					memberRoleIds,
-					peer: {
-						kind: isDirectMessage ? "direct" : isGroupDm ? "group" : "channel",
-						id: isDirectMessage ? user.id : data.channel_id
-					},
-					parentPeer: parentPeerId ? {
-						kind: "channel",
-						id: parentPeerId
-					} : void 0
-				}).sessionKey,
-				contextKey
-			});
+			enqueueRoutedSystemEvent(text, resolveAgentRoute({
+				cfg: params.cfg,
+				channel: "discord",
+				accountId: params.accountId,
+				guildId: data.guild_id ?? void 0,
+				memberRoleIds,
+				peer: {
+					kind: isDirectMessage ? "direct" : isGroupDm ? "group" : "channel",
+					id: isDirectMessage ? user.id : data.channel_id
+				},
+				parentPeer: parentPeerId ? {
+					kind: "channel",
+					id: parentPeerId
+				} : void 0
+			}), { contextKey });
 		};
 		const shouldNotifyReaction = (options) => shouldEmitDiscordReactionNotification({
 			mode: options.mode,
@@ -1393,24 +1363,30 @@ var DiscordPresenceBaselineCache = class {
 * that a later inbound message starts a fresh session in every reset mode.
 */
 async function closeDiscordThreadSessions(params) {
-	const { cfg, accountId, threadId } = params;
+	const { cfg, threadId } = params;
 	const normalizedThreadId = normalizeOptionalLowercaseString(threadId) ?? "";
 	if (!normalizedThreadId) return 0;
 	const segmentRe = new RegExp(`:${normalizedThreadId}(?::|$)`, "i");
 	function sessionKeyContainsThreadId(key) {
 		return segmentRe.test(key);
 	}
-	const storePath = resolveStorePath(cfg.session?.store, { agentId: accountId });
 	let resetCount = 0;
-	for (const { sessionKey, entry } of listSessionEntries({ storePath })) {
-		if (!sessionKeyContainsThreadId(sessionKey)) continue;
-		if (await deleteSessionEntry({
-			archiveTranscript: true,
-			expectedSessionId: entry.sessionId ?? null,
-			expectedUpdatedAt: entry.updatedAt,
-			sessionKey,
-			storePath
-		})) resetCount += 1;
+	for (const agentId of listAgentIds(cfg)) {
+		const storePath = resolveStorePath(cfg.session?.store, { agentId });
+		for (const { sessionKey, entry } of listSessionEntries({
+			agentId,
+			storePath,
+			readOnly: true
+		})) {
+			if (!sessionKeyContainsThreadId(sessionKey)) continue;
+			if (await deleteSessionEntry({
+				archiveTranscript: true,
+				expectedSessionId: entry.sessionId ?? null,
+				expectedUpdatedAt: entry.updatedAt,
+				sessionKey,
+				storePath
+			})) resetCount += 1;
+		}
 	}
 	return resetCount;
 }
@@ -1612,8 +1588,7 @@ var DiscordPresenceListener = class extends PresenceUpdateListener {
 				(this.params.logger ?? discordEventQueueLog).warn(danger(`discord presence cooldown persistence failed: ${String(err)}`));
 				return;
 			}
-			if (!enqueueSystemEvent(presenceEvent.text, {
-				sessionKey: route.sessionKey,
+			if (!enqueueRoutedSystemEvent(presenceEvent.text, route, {
 				contextKey: `discord:presence-online:${this.params.accountId}:${data.guild_id}:${userId}`,
 				deliveryContext: {
 					channel: "discord",
@@ -1679,10 +1654,9 @@ var DiscordPresenceReadyListener = class extends ReadyListener {
 	}
 };
 var DiscordThreadUpdateListener = class extends ThreadUpdateListener {
-	constructor(cfg, accountId, logger) {
+	constructor(cfg, logger) {
 		super();
 		this.cfg = cfg;
-		this.accountId = accountId;
 		this.logger = logger;
 	}
 	async handle(data) {
@@ -1697,7 +1671,6 @@ var DiscordThreadUpdateListener = class extends ThreadUpdateListener {
 				const logger = this.logger ?? discordEventQueueLog;
 				const count = await closeDiscordThreadSessions({
 					cfg: this.cfg,
-					accountId: this.accountId,
 					threadId
 				});
 				if (count > 0) logger.info("Discord thread archived — reset sessions", {
@@ -1711,6 +1684,40 @@ var DiscordThreadUpdateListener = class extends ThreadUpdateListener {
 		});
 	}
 };
+var DiscordThreadDeleteListener = class extends ThreadDeleteListener {
+	constructor(cfg, accountId, logger) {
+		super();
+		this.cfg = cfg;
+		this.accountId = accountId;
+		this.logger = logger;
+	}
+	async handle(data) {
+		await runDiscordListenerWithSlowLog({
+			logger: this.logger,
+			listener: this.constructor.name,
+			event: this.type,
+			run: async () => {
+				const threadId = data.id;
+				getThreadBindingManager(this.accountId)?.unbindThread({
+					threadId,
+					reason: "thread-delete",
+					sendFarewell: false
+				});
+				const count = await closeDiscordThreadSessions({
+					cfg: this.cfg,
+					threadId
+				});
+				if (count > 0) (this.logger ?? discordEventQueueLog).info("Discord thread deleted — reset sessions", {
+					threadId,
+					count
+				});
+			},
+			onError: (err) => {
+				(this.logger ?? discordEventQueueLog).error(danger(`discord thread-delete handler failed: ${String(err)}`));
+			}
+		});
+	}
+};
 //#endregion
 //#region extensions/discord/src/internal/gateway-dispatch.ts
 function dispatchVoiceGatewayEvent(client, type, data) {
@@ -1841,17 +1848,7 @@ async function deliverDiscordInteractionReply(params) {
 			...contentPayload,
 			...components ? { components } : {},
 			...params.responseEphemeral !== void 0 ? { ephemeral: params.responseEphemeral } : {},
-			files: files.map((file) => {
-				if (file.data instanceof Blob) return {
-					name: file.name,
-					data: file.data
-				};
-				const arrayBuffer = Uint8Array.from(file.data).buffer;
-				return {
-					name: file.name,
-					data: new Blob([arrayBuffer])
-				};
-			})
+			files
 		} : {
 			...contentPayload,
 			...components ? { components } : {},
@@ -1884,7 +1881,8 @@ async function deliverDiscordInteractionReply(params) {
 			const loaded = await loadWebMedia(url, { localRoots: params.mediaLocalRoots });
 			return {
 				name: loaded.fileName ?? "upload",
-				data: loaded.buffer
+				data: loaded.buffer,
+				contentType: loaded.contentType
 			};
 		}));
 		const chunks = resolveTextChunksWithFallback(reply.text, chunkDiscordTextWithMode(reply.text, {
@@ -2031,8 +2029,6 @@ async function resolveDiscordNativeInteractionRouteState(params) {
 //#endregion
 //#region extensions/discord/src/monitor/native-command.runtime.ts
 const nativeCommandRuntime = {
-	matchPluginCommand: pluginRuntime.matchPluginCommand,
-	executePluginCommand: pluginRuntime.executePluginCommand,
 	dispatchChannelInboundTurn,
 	resolveDirectStatusReplyForSession,
 	resolveDiscordNativeInteractionRouteState,
@@ -2043,7 +2039,8 @@ const nativeCommandRuntime = {
 async function dispatchDiscordNativeAgentReply(params) {
 	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(params.discordConfig);
 	let didReply = false;
-	let settledWithoutVisibleReply = false;
+	let finalReplyOutcome;
+	let hiddenFinalReply;
 	const turnResult = await nativeCommandRuntime.dispatchChannelInboundTurn({
 		cfg: params.cfg,
 		channel: "discord",
@@ -2079,14 +2076,17 @@ async function dispatchDiscordNativeAgentReply(params) {
 					suppression: { reason: "no_visible_result" }
 				};
 			},
-			onDelivered: (_payload, _info, result) => {
-				if (result?.visibleReplySent === false) settledWithoutVisibleReply = true;
+			onDelivered: (payload, info, result) => {
+				if (params.suppressReplies && info.kind === "final" && result?.suppression?.reason === "no_visible_result" && payload.text?.trim()) hiddenFinalReply = payload;
+				if (info.kind === "final" && result?.visibleReplySent !== void 0 && (result.visibleReplySent || finalReplyOutcome !== "failed")) finalReplyOutcome = result.visibleReplySent ? "accepted" : "suppressed";
 			},
 			onError: (err, info) => {
-				if (isChannelPartialDeliveryError(err)) {
+				const partialDelivery = isChannelPartialDeliveryError(err);
+				if (partialDelivery) {
 					didReply = true;
 					logVerbose("discord: interaction reply partially delivered before expiry");
 				}
+				if (info.kind === "final") finalReplyOutcome = partialDelivery ? "accepted" : "failed";
 				const message = err instanceof Error ? err.stack ?? err.message : String(err);
 				params.log.error(`discord slash ${info.kind} reply failed: ${message}`);
 			}
@@ -2095,14 +2095,20 @@ async function dispatchDiscordNativeAgentReply(params) {
 		dispatcherOptions: { humanDelay: resolveHumanDelayConfig(params.cfg, params.effectiveRoute.agentId) },
 		replyOptions: {
 			skillFilter: params.channelConfig?.skills,
+			[PLUGIN_COMMAND_DISPATCH]: params.pluginCommandDispatch,
 			disableBlockStreaming: typeof blockStreamingEnabled === "boolean" ? !blockStreamingEnabled : void 0
 		}
 	});
-	if (!didReply && (params.suppressReplies || settledWithoutVisibleReply)) {
+	const deliberateSilentTerminalReply = turnResult.dispatched && turnResult.dispatchResult.deliberateSilentTerminalReply === true;
+	const dispatchResult = {
+		dispatched: turnResult.dispatched,
+		...hiddenFinalReply ? { hiddenFinalReply } : {}
+	};
+	if (!didReply && (params.suppressReplies || finalReplyOutcome === "suppressed" || deliberateSilentTerminalReply)) {
 		await settleDiscordInteractionWithoutVisibleReply(params.interaction);
-		return;
+		return dispatchResult;
 	}
-	if (params.suppressReplies || didReply || settledWithoutVisibleReply || turnResult.dispatched && hasVisibleInboundReplyDispatch(turnResult.dispatchResult)) return;
+	if (didReply || turnResult.dispatched && hasVisibleInboundReplyDispatch(turnResult.dispatchResult)) return dispatchResult;
 	await safeDiscordInteractionCall("interaction empty fallback", async () => {
 		const payload = {
 			content: DISCORD_EMPTY_VISIBLE_REPLY_WARNING,
@@ -2114,6 +2120,7 @@ async function dispatchDiscordNativeAgentReply(params) {
 		}
 		await params.interaction.reply(payload);
 	});
+	return dispatchResult;
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-interaction-channel-context.ts
@@ -2623,7 +2630,8 @@ async function handleDiscordCommandArgInteraction(params) {
 		sessionPrefix: ctx.sessionPrefix,
 		preferFollowUp: true,
 		threadBindings: ctx.threadBindings,
-		responseEphemeral: resolveDiscordSlashCommandConfig(ctx.discordConfig?.slashCommand).ephemeral
+		responseEphemeral: resolveDiscordSlashCommandConfig(ctx.discordConfig?.slashCommand).ephemeral,
+		pluginCommandDispatch: { kind: "non-plugin" }
 	});
 }
 async function runDiscordCommandArgButton(params) {
@@ -2730,10 +2738,10 @@ function timestampOrder(value) {
 	return value !== void 0 && value >= 0 ? value : 0;
 }
 function comparePreferenceEntries(left, right) {
-	return timestampMs(right.value.updatedAt) - timestampMs(left.value.updatedAt) || timestampOrder(right.value.updatedOrder) - timestampOrder(left.value.updatedOrder) || left.key.localeCompare(right.key);
+	return preferenceTimestampMs(right.value.updatedAt) - preferenceTimestampMs(left.value.updatedAt) || timestampOrder(right.value.updatedOrder) - timestampOrder(left.value.updatedOrder) || left.key.localeCompare(right.key);
 }
 function nextPreferenceTimestamp(existingEntries) {
-	const existingMaxTimestampMs = existingEntries.reduce((max, entry) => Math.max(max, timestampMs(entry.updatedAt)), 0);
+	const existingMaxTimestampMs = existingEntries.reduce((max, entry) => Math.max(max, preferenceTimestampMs(entry.updatedAt)), 0);
 	lastPreferenceTimestampMs = Math.min(Math.max(resolveDateTimestampMs(Date.now(), 0), lastPreferenceTimestampMs + 1, existingMaxTimestampMs + 1), MAX_DATE_TIMESTAMP_MS);
 	const existingMaxOrder = existingEntries.reduce((max, entry) => Math.max(max, timestampOrder(entry.updatedOrder)), 0);
 	lastPreferenceOrder = Math.max(lastPreferenceOrder + 1, existingMaxOrder + 1);
@@ -2782,8 +2790,6 @@ async function recordDiscordModelPickerRecentModel(params) {
 const DISCORD_MODEL_PICKER_CUSTOM_ID_KEY = "mdlpk";
 const DISCORD_CUSTOM_ID_MAX_CHARS = 100;
 const DISCORD_COMPONENT_MAX_SELECT_OPTIONS = 25;
-const DISCORD_MODEL_PICKER_PROVIDER_PAGE_SIZE = DISCORD_COMPONENT_MAX_SELECT_OPTIONS;
-const DISCORD_MODEL_PICKER_MODEL_PAGE_SIZE = DISCORD_COMPONENT_MAX_SELECT_OPTIONS;
 function compareBucketItems(left, right) {
 	const normalized = left.toLowerCase().localeCompare(right.toLowerCase());
 	return normalized === 0 ? left.localeCompare(right) : normalized;
@@ -2843,15 +2849,15 @@ function parseRawPage(value) {
 	}
 	return 1;
 }
-function parseRawPositiveInt(value) {
-	return parseStrictPositiveInteger(value);
-}
 function coerceString(value) {
 	return typeof value === "string" || typeof value === "number" ? String(value) : "";
 }
-function clampPageSize(rawPageSize, max, fallback) {
-	if (!Number.isFinite(rawPageSize)) return fallback;
-	return Math.min(max, Math.max(1, Math.floor(rawPageSize ?? fallback)));
+function clampPageSize(rawPageSize) {
+	if (!Number.isFinite(rawPageSize)) return DISCORD_COMPONENT_MAX_SELECT_OPTIONS;
+	return Math.min(DISCORD_COMPONENT_MAX_SELECT_OPTIONS, Math.max(1, Math.floor(rawPageSize ?? DISCORD_COMPONENT_MAX_SELECT_OPTIONS)));
+}
+function normalizeOptionalModelPickerIndex(value) {
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(1, Math.floor(value)) : void 0;
 }
 function paginateItems(params) {
 	const totalItems = params.items.length;
@@ -2877,10 +2883,10 @@ function buildDiscordModelPickerCustomId(params) {
 	const userId = params.userId.trim();
 	if (!userId) throw new Error("Discord model picker custom_id requires userId");
 	const page = normalizeModelPickerPage(params.page);
-	const providerPage = typeof params.providerPage === "number" && Number.isFinite(params.providerPage) ? Math.max(1, Math.floor(params.providerPage)) : void 0;
+	const providerPage = normalizeOptionalModelPickerIndex(params.providerPage);
 	const normalizedProvider = params.provider ? normalizeProviderId(params.provider) : void 0;
-	const modelIndex = typeof params.modelIndex === "number" && Number.isFinite(params.modelIndex) ? Math.max(1, Math.floor(params.modelIndex)) : void 0;
-	const recentSlot = typeof params.recentSlot === "number" && Number.isFinite(params.recentSlot) ? Math.max(1, Math.floor(params.recentSlot)) : void 0;
+	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");
 	const parts = [
@@ -2893,7 +2899,7 @@ function buildDiscordModelPickerCustomId(params) {
 	if (normalizedProvider) parts.push(`p=${encodeCustomIdComponent(normalizedProvider)}`);
 	const runtime = params.runtime?.trim();
 	if (runtime) parts.push(`r=${encodeCustomIdComponent(runtime)}`);
-	const runtimeIndex = typeof params.runtimeIndex === "number" && Number.isFinite(params.runtimeIndex) ? Math.max(1, Math.floor(params.runtimeIndex)) : void 0;
+	const runtimeIndex = normalizeOptionalModelPickerIndex(params.runtimeIndex);
 	if (runtimeIndex) parts.push(`ri=${String(runtimeIndex)}`);
 	if (providerPage) parts.push(`pp=${String(providerPage)}`);
 	if (modelToken) parts.push(`m=${modelToken}`);
@@ -2917,13 +2923,13 @@ function parseDiscordModelPickerData(data) {
 	const userId = decodeCustomIdComponent(coerceString(data.u));
 	const providerRaw = decodeCustomIdComponent(coerceString(data.p));
 	const runtimeRaw = decodeCustomIdComponent(coerceString(data.r));
-	const runtimeIndex = parseRawPositiveInt(data.ri);
+	const runtimeIndex = parseStrictPositiveInteger(data.ri);
 	const page = parseRawPage(data.g ?? data.pg);
-	const providerPage = parseRawPositiveInt(data.pp);
-	const modelIndex = parseRawPositiveInt(data.mi);
+	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 recentSlot = parseRawPositiveInt(data.rs);
+	const recentSlot = parseStrictPositiveInteger(data.rs);
 	const providerBucketRaw = decodeCustomIdComponent(coerceString(data.pb)).trim().toLowerCase();
 	const modelBucketRaw = decodeCustomIdComponent(coerceString(data.mb)).trim().toLowerCase();
 	if (!isValidCommandContext(command) || !isValidPickerAction(action) || !isValidPickerView(view)) return null;
@@ -3039,17 +3045,7 @@ function findProviderBucketId(data, provider) {
 	return findProviderBucketLocation(data, provider)?.bucket;
 }
 function findProviderBucketLocation(data, provider) {
-	const normalized = normalizeProviderId(provider);
-	const sorted = [...data.providers].toSorted();
-	const idx = sorted.indexOf(normalized);
-	if (idx < 0) return;
-	const containing = computeAlphaBuckets(sorted).find((bucket) => idx >= bucket.start && idx < bucket.end);
-	if (!containing) return;
-	const page = Math.floor((idx - containing.start) / DISCORD_MODEL_PICKER_PROVIDER_PAGE_SIZE) + 1;
-	return {
-		...containing.id !== "all" ? { bucket: containing.id } : {},
-		page
-	};
+	return findModelPickerBucketLocation([...data.providers].toSorted(), normalizeProviderId(provider));
 }
 /**
 * Derive the alpha-bucket id that contains a given model id within the
@@ -3059,28 +3055,24 @@ function findProviderBucketLocation(data, provider) {
 */
 function findModelBucketId(data, provider, model) {
 	const modelSet = data.byProvider.get(normalizeProviderId(provider));
-	if (!modelSet) return;
-	const sorted = [...modelSet].toSorted(compareBucketItems);
-	const idx = sorted.indexOf(model);
-	if (idx < 0) return;
-	const containing = computeAlphaBuckets(sorted).find((bucket) => idx >= bucket.start && idx < bucket.end);
-	return containing && containing.id !== "all" ? containing.id : void 0;
-}
-function buildDiscordModelPickerProviderItems(data) {
-	return [...data.providers].toSorted().map((provider) => ({
-		id: provider,
-		count: data.byProvider.get(provider)?.size ?? 0
-	}));
-}
-function getDiscordModelPickerProviderPage(params) {
-	const allItems = buildDiscordModelPickerProviderItems(params.data);
-	const buckets = computeAlphaBuckets(allItems.map((item) => item.id));
+	return modelSet ? findModelPickerBucketLocation([...modelSet].toSorted(compareBucketItems), model)?.bucket : void 0;
+}
+function findModelPickerBucketLocation(sortedItems, item, pageSize = DISCORD_COMPONENT_MAX_SELECT_OPTIONS) {
+	const index = sortedItems.indexOf(item);
+	const bucket = index < 0 ? void 0 : computeAlphaBuckets(sortedItems).find((entry) => index >= entry.start && index < entry.end);
+	return bucket ? {
+		...bucket.id === "all" ? {} : { bucket: bucket.id },
+		page: Math.floor((index - bucket.start) / pageSize) + 1
+	} : void 0;
+}
+function paginateDiscordModelPickerBucket(params) {
+	const buckets = computeAlphaBuckets(params.itemLabels);
 	const bucket = resolveBucket(buckets, params.bucket);
-	const bucketItems = bucket ? allItems.slice(bucket.start, bucket.end) : allItems;
-	const pageSize = clampPageSize(params.pageSize, DISCORD_MODEL_PICKER_PROVIDER_PAGE_SIZE, DISCORD_MODEL_PICKER_PROVIDER_PAGE_SIZE);
+	const items = bucket ? params.items.slice(bucket.start, bucket.end) : params.items;
+	const pageSize = clampPageSize(params.pageSize);
 	return {
 		...paginateItems({
-			items: bucketItems,
+			items,
 			page: normalizeModelPickerPage(params.page),
 			pageSize
 		}),
@@ -3088,24 +3080,29 @@ function getDiscordModelPickerProviderPage(params) {
 		buckets
 	};
 }
+function getDiscordModelPickerProviderPage(params) {
+	const providers = [...params.data.providers].toSorted();
+	return paginateDiscordModelPickerBucket({
+		...params,
+		itemLabels: providers,
+		items: providers.map((provider) => ({
+			id: provider,
+			count: params.data.byProvider.get(provider)?.size ?? 0
+		}))
+	});
+}
 function getDiscordModelPickerModelPage(params) {
 	const provider = normalizeProviderId(params.provider);
 	const modelSet = params.data.byProvider.get(provider);
 	if (!modelSet) return null;
 	const allModels = [...modelSet].toSorted(compareBucketItems);
-	const buckets = computeAlphaBuckets(allModels);
-	const bucket = resolveBucket(buckets, params.bucket);
-	const bucketItems = bucket ? allModels.slice(bucket.start, bucket.end) : allModels;
-	const pageSize = clampPageSize(params.pageSize, DISCORD_MODEL_PICKER_MODEL_PAGE_SIZE, DISCORD_MODEL_PICKER_MODEL_PAGE_SIZE);
 	return {
-		...paginateItems({
-			items: bucketItems,
-			page: normalizeModelPickerPage(params.page),
-			pageSize
+		...paginateDiscordModelPickerBucket({
+			...params,
+			items: allModels,
+			itemLabels: allModels
 		}),
-		provider,
-		bucket,
-		buckets
+		provider
 	};
 }
 function resolveDiscordModelPickerPageForModel(params) {
@@ -3113,16 +3110,8 @@ function resolveDiscordModelPickerPageForModel(params) {
 	const modelSet = params.data.byProvider.get(provider);
 	if (!modelSet) return { page: 1 };
 	const sorted = [...modelSet].toSorted(compareBucketItems);
-	const index = sorted.indexOf(params.model);
-	if (index < 0) return { page: 1 };
-	const pageSize = clampPageSize(params.pageSize, DISCORD_MODEL_PICKER_MODEL_PAGE_SIZE, DISCORD_MODEL_PICKER_MODEL_PAGE_SIZE);
-	const containingBucket = computeAlphaBuckets(sorted).find((bucket) => index >= bucket.start && index < bucket.end);
-	if (!containingBucket) return { page: Math.floor(index / pageSize) + 1 };
-	const offsetInBucket = index - containingBucket.start;
-	return {
-		page: Math.floor(offsetInBucket / pageSize) + 1,
-		bucket: containingBucket.id === "all" ? void 0 : containingBucket.id
-	};
+	const pageSize = clampPageSize(params.pageSize);
+	return findModelPickerBucketLocation(sorted, params.model, pageSize) ?? { page: 1 };
 }
 //#endregion
 //#region extensions/discord/src/monitor/model-picker.view.ts
@@ -3302,53 +3291,25 @@ function buildProviderSelectRow(params) {
 }
 function buildPaginationRow(params) {
 	if (params.totalPages <= 1) return null;
-	return new Row([
-		createModelPickerButton({
-			label: "◀ Prev",
-			style: ButtonStyle.Secondary,
-			disabled: !params.hasPrev,
-			customId: buildDiscordModelPickerCustomId({
-				command: params.command,
-				action: "nav",
-				view: params.view,
-				provider: params.provider,
-				runtime: params.runtime,
-				runtimeIndex: params.runtimeIndex,
-				page: Math.max(1, params.page - 1),
-				providerPage: params.providerPage,
-				modelIndex: params.modelIndex,
-				modelToken: params.modelToken,
-				providerBucket: params.providerBucket,
-				modelBucket: params.modelBucket,
-				userId: params.userId
-			})
-		}),
-		createModelPickerButton({
-			label: `Page ${params.page}/${params.totalPages}`,
-			style: ButtonStyle.Secondary,
-			disabled: true,
-			customId: DISCORD_MODEL_PICKER_PAGE_INDICATOR_CUSTOM_ID
-		}),
-		createModelPickerButton({
-			label: "Next ▶",
-			style: ButtonStyle.Secondary,
-			disabled: !params.hasNext,
-			customId: buildDiscordModelPickerCustomId({
-				command: params.command,
-				action: "nav",
-				view: params.view,
-				provider: params.provider,
-				runtime: params.runtime,
-				runtimeIndex: params.runtimeIndex,
-				page: Math.min(params.totalPages, params.page + 1),
-				providerPage: params.providerPage,
-				modelIndex: params.modelIndex,
-				modelToken: params.modelToken,
-				providerBucket: params.providerBucket,
-				modelBucket: params.modelBucket,
-				userId: params.userId
-			})
+	const { page, totalPages, hasPrev, hasNext, ...navigationState } = params;
+	const createNavigationButton = (label, targetPage, enabled) => createModelPickerButton({
+		label,
+		disabled: !enabled,
+		customId: buildDiscordModelPickerCustomId({
+			...navigationState,
+			action: "nav",
+			page: targetPage
 		})
+	});
+	const indicatorButton = createModelPickerButton({
+		label: `Page ${page}/${totalPages}`,
+		disabled: true,
+		customId: DISCORD_MODEL_PICKER_PAGE_INDICATOR_CUSTOM_ID
+	});
+	return new Row([
+		createNavigationButton("◀ Prev", Math.max(1, page - 1), hasPrev),
+		indicatorButton,
+		createNavigationButton("Next ▶", Math.min(totalPages, page + 1), hasNext)
 	]);
 }
 function buildModelRows(params) {
@@ -3461,10 +3422,17 @@ function buildModelRows(params) {
 	const resolvedDefault = params.data.resolvedDefault;
 	const shouldDisableReset = Boolean(parsedCurrentModel) && parsedCurrentModel?.provider === resolvedDefault.provider && parsedCurrentModel?.model === resolvedDefault.model;
 	const hasPendingSelection = Boolean(parsedPendingModel) && parsedPendingModel?.provider === params.modelPage.provider && typeof params.pendingModelIndex === "number" && params.pendingModelIndex > 0;
+	const modelActionState = {
+		command: params.command,
+		provider: params.modelPage.provider,
+		...compactRuntime,
+		page: params.modelPage.page,
+		providerPage: providerPage.page,
+		userId: params.userId
+	};
 	const buttonRowItems = [
 		createModelPickerButton({
 			label: "Providers",
-			style: ButtonStyle.Secondary,
 			customId: buildDiscordModelPickerCustomId({
 				command: params.command,
 				action: "back",
@@ -3476,47 +3444,29 @@ function buildModelRows(params) {
 		}),
 		createModelPickerButton({
 			label: "Cancel",
-			style: ButtonStyle.Secondary,
 			customId: buildDiscordModelPickerCustomId({
-				command: params.command,
+				...modelActionState,
 				action: "cancel",
-				view: "models",
-				provider: params.modelPage.provider,
-				...compactRuntime,
-				page: params.modelPage.page,
-				providerPage: providerPage.page,
-				userId: params.userId
+				view: "models"
 			})
 		}),
 		createModelPickerButton({
 			label: "Reset to default",
-			style: ButtonStyle.Secondary,
 			disabled: shouldDisableReset,
 			customId: buildDiscordModelPickerCustomId({
-				command: params.command,
+				...modelActionState,
 				action: "reset",
-				view: "models",
-				provider: params.modelPage.provider,
-				...compactRuntime,
-				page: params.modelPage.page,
-				providerPage: providerPage.page,
-				userId: params.userId
+				view: "models"
 			})
 		})
 	];
 	if (hasQuickModels) buttonRowItems.push(createModelPickerButton({
 		label: "Recents",
-		style: ButtonStyle.Secondary,
 		customId: buildDiscordModelPickerCustomId({
-			command: params.command,
+			...modelActionState,
 			action: "recents",
 			view: "recents",
-			provider: params.modelPage.provider,
-			...compactRuntime,
-			page: params.modelPage.page,
-			providerPage: providerPage.page,
-			modelBucket: activeModelBucket,
-			userId: params.userId
+			modelBucket: activeModelBucket
 		})
 	}));
 	buttonRowItems.push(createModelPickerButton({
@@ -3524,16 +3474,11 @@ function buildModelRows(params) {
 		style: ButtonStyle.Primary,
 		disabled: !hasPendingSelection,
 		customId: buildDiscordModelPickerCustomId({
-			command: params.command,
+			...modelActionState,
 			action: "submit",
 			view: "models",
-			provider: params.modelPage.provider,
-			...compactRuntime,
-			page: params.modelPage.page,
-			providerPage: providerPage.page,
 			modelIndex: params.pendingModelIndex,
-			modelToken: pendingModelToken,
-			userId: params.userId
+			modelToken: pendingModelToken
 		})
 	}));
 	return {
@@ -3680,32 +3625,14 @@ function createModelRefToken(modelRef) {
 function renderDiscordModelPickerRecentsView(params) {
 	const defaultModelRef = `${params.data.resolvedDefault.provider}/${params.data.resolvedDefault.model}`;
 	const rows = [];
-	const dedupedQuickModels = params.quickModels.filter((modelRef) => modelRef !== defaultModelRef);
-	rows.push(new Row([createModelPickerButton({
-		label: formatRecentsButtonLabel(defaultModelRef, "(default)"),
-		style: ButtonStyle.Secondary,
-		customId: buildDiscordModelPickerCustomId({
-			command: params.command,
-			action: "submit",
-			view: "recents",
-			recentSlot: 1,
-			modelToken: createModelRefToken(defaultModelRef),
-			provider: params.provider,
-			runtime: params.runtime,
-			runtimeIndex: params.runtimeIndex,
-			page: params.page,
-			providerPage: params.providerPage,
-			userId: params.userId
-		})
-	})]));
-	for (const [i, modelRef] of dedupedQuickModels.entries()) rows.push(new Row([createModelPickerButton({
-		label: formatRecentsButtonLabel(modelRef),
-		style: ButtonStyle.Secondary,
+	const recentModels = [defaultModelRef, ...params.quickModels.filter((modelRef) => modelRef !== defaultModelRef)];
+	for (const [index, modelRef] of recentModels.entries()) rows.push(new Row([createModelPickerButton({
+		label: formatRecentsButtonLabel(modelRef, index === 0 ? "(default)" : void 0),
 		customId: buildDiscordModelPickerCustomId({
 			command: params.command,
 			action: "submit",
 			view: "recents",
-			recentSlot: i + 2,
+			recentSlot: index + 1,
 			modelToken: createModelRefToken(modelRef),
 			provider: params.provider,
 			runtime: params.runtime,
@@ -3717,7 +3644,6 @@ function renderDiscordModelPickerRecentsView(params) {
 	})]));
 	const backRow = new Row([createModelPickerButton({
 		label: "Back",
-		style: ButtonStyle.Secondary,
 		customId: buildDiscordModelPickerCustomId({
 			command: params.command,
 			action: "back",
@@ -3749,43 +3675,10 @@ function toDiscordModelPickerMessagePayload(view) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-command-model-picker-apply.ts
-async function persistDiscordModelPickerOverride(params) {
-	const storePath = resolveStorePath(params.cfg.session?.store, { agentId: params.route.agentId });
-	let persisted = false;
-	await patchSessionEntry({
-		storePath,
-		sessionKey: params.route.sessionKey,
-		fallbackEntry: {
-			sessionId: randomUUID(),
-			updatedAt: Date.now()
-		},
-		replaceEntry: true,
-		update: (entry) => {
-			persisted = applyModelOverrideToSessionEntry({
-				entry,
-				selection: {
-					provider: params.provider,
-					model: params.model,
-					isDefault: params.isDefault
-				},
-				markLiveSwitchPending: true
-			}).updated || persisted;
-			const runtime = params.runtime?.trim();
-			if (runtime && runtime !== "auto" && runtime !== "default") {
-				if (entry.agentRuntimeOverride !== runtime) {
-					entry.agentRuntimeOverride = runtime;
-					delete entry.agentHarnessId;
-					persisted = true;
-				}
-			} else if (runtime && entry.agentRuntimeOverride) {
-				delete entry.agentRuntimeOverride;
-				delete entry.agentHarnessId;
-				persisted = true;
-			}
-			return entry;
-		}
-	});
-	return persisted;
+function normalizeExpectedRuntime(value) {
+	const runtime = value?.trim();
+	if (!runtime) return;
+	return runtime === "auto" || runtime === "default" ? "auto" : runtime;
 }
 async function applyDiscordModelPickerSelection(params) {
 	try {
@@ -3800,79 +3693,42 @@ async function applyDiscordModelPickerSelection(params) {
 			sessionPrefix: params.sessionPrefix,
 			preferFollowUp: true,
 			threadBindings: params.threadBindings,
-			suppressReplies: true
+			suppressReplies: true,
+			pluginCommandDispatch: { kind: "non-plugin" }
 		}), 12e3);
 		if (!dispatchResult.accepted) return {
 			status: "rejected",
 			noticeMessage: `❌ Failed to apply ${params.resolvedModelRef}. Try /model ${params.resolvedModelRef} directly.`
 		};
-		const fallbackRoute = dispatchResult.effectiveRoute ?? params.route;
+		const hiddenFinalReply = dispatchResult.hiddenFinalReply;
+		const effectiveRoute = dispatchResult.effectiveRoute ?? params.route;
 		if (params.settleMs > 0) await new Promise((resolve) => {
 			setTimeout(resolve, params.settleMs);
 		});
-		let effectiveModelRef = params.resolveCurrentModel(fallbackRoute);
-		let persisted = effectiveModelRef === params.resolvedModelRef;
-		if (params.selectedRuntime?.trim()) {
-			await persistDiscordModelPickerOverride({
-				cfg: params.cfg,
-				route: fallbackRoute,
-				provider: params.selectedProvider,
-				model: params.selectedModel,
-				isDefault: params.selectedProvider === params.defaultProvider && params.selectedModel === params.defaultModel,
-				runtime: params.selectedRuntime
-			});
-			await new Promise((resolve) => {
-				setTimeout(resolve, 100);
-			});
-			effectiveModelRef = params.resolveCurrentModel(fallbackRoute);
-			persisted = effectiveModelRef === params.resolvedModelRef;
-		}
-		if (!persisted) {
-			logVerbose(`discord: model picker override mismatch — expected ${params.resolvedModelRef} but read ${effectiveModelRef} from session key ${fallbackRoute.sessionKey}; attempting direct session override persist`);
-			try {
-				const directlyPersisted = await persistDiscordModelPickerOverride({
-					cfg: params.cfg,
-					route: fallbackRoute,
-					provider: params.selectedProvider,
-					model: params.selectedModel,
-					isDefault: params.selectedProvider === params.defaultProvider && params.selectedModel === params.defaultModel,
-					runtime: params.selectedRuntime
-				});
-				await new Promise((resolve) => {
-					setTimeout(resolve, 100);
-				});
-				effectiveModelRef = params.resolveCurrentModel(fallbackRoute);
-				persisted = effectiveModelRef === params.resolvedModelRef;
-				if (!persisted) logVerbose(`discord: direct session override persist failed — expected ${params.resolvedModelRef} but read ${effectiveModelRef} from session key ${fallbackRoute.sessionKey}`);
-				else if (!directlyPersisted) logVerbose(`discord: direct session override persist became a no-op because ${params.resolvedModelRef} was already present on re-read for session key ${fallbackRoute.sessionKey}`);
-			} catch (error) {
-				if (error instanceof ModelSelectionLockedError) return {
-					status: "rejected",
-					noticeMessage: `❌ ${error.message}`
-				};
-				const message = error instanceof Error ? error.message : String(error);
-				logVerbose(`discord: direct session override persist threw for session key ${fallbackRoute.sessionKey}: ${message}`);
-			}
-		}
-		if (persisted) await recordDiscordModelPickerRecentModel({
+		const effectiveModelRef = params.resolveCurrentModel(effectiveRoute);
+		const effectiveRuntime = params.resolveCurrentRuntime(effectiveRoute);
+		const currentSelection = `Current selection: ${effectiveModelRef} with runtime ${effectiveRuntime}.`;
+		if (hiddenFinalReply?.isError) return {
+			status: "rejected",
+			noticeMessage: `${hiddenFinalReply.text?.trim()}\n${currentSelection}`
+		};
+		const expectedRuntime = normalizeExpectedRuntime(params.selectedRuntime);
+		const verified = effectiveModelRef === params.resolvedModelRef && (expectedRuntime === void 0 || effectiveRuntime === expectedRuntime);
+		if (verified) await recordDiscordModelPickerRecentModel({
 			scope: params.preferenceScope,
 			modelRef: params.resolvedModelRef,
 			limit: 5
 		}).catch(() => void 0);
-		return persisted ? {
+		return verified ? {
 			status: "success",
 			effectiveModelRef,
-			noticeMessage: `✅ Model set to ${params.resolvedModelRef}.`
+			noticeMessage: hiddenFinalReply?.text?.trim() || `✅ Model set to ${params.resolvedModelRef}.`
 		} : {
 			status: "mismatch",
 			effectiveModelRef,
-			noticeMessage: `⚠️ Tried to set ${params.resolvedModelRef}, but current model is ${effectiveModelRef}.`
+			noticeMessage: `⚠️ Tried to set ${params.resolvedModelRef}${expectedRuntime ? ` with runtime ${expectedRuntime}` : ""}, but current selection is ${effectiveModelRef} with runtime ${effectiveRuntime}.`
 		};
 	} catch (error) {
-		if (error instanceof ModelSelectionLockedError) return {
-			status: "rejected",
-			noticeMessage: `❌ ${error.message}`
-		};
 		if (error instanceof Error && error.message === "timeout") return {
 			status: "timeout",
 			noticeMessage: `⏳ Model change to ${params.resolvedModelRef} is still processing. Check /status in a few seconds.`
@@ -3902,9 +3758,6 @@ function shouldOpenDiscordModelPickerFromCommand(params) {
 	if (context === "model") return !resolveCommandArgStringValue(params.commandArgs, "model") && !serializedArgs ? context : null;
 	return serializedArgs ? null : context;
 }
-function buildDiscordModelPickerCurrentModel(defaultProvider, defaultModel) {
-	return `${defaultProvider}/${defaultModel}`;
-}
 function buildDiscordModelPickerAllowedModelRefs(data) {
 	const out = /* @__PURE__ */ new Set();
 	for (const provider of data.providers) {
@@ -4000,7 +3853,7 @@ async function resolveDiscordNativeChoiceContext(params) {
 	}
 }
 function resolveDiscordModelPickerCurrentModel(params) {
-	const fallback = buildDiscordModelPickerCurrentModel(params.data.resolvedDefault.provider, params.data.resolvedDefault.model);
+	const fallback = `${params.data.resolvedDefault.provider}/${params.data.resolvedDefault.model}`;
 	try {
 		const storePath = resolveStorePath(params.cfg.session?.store, { agentId: params.route.agentId });
 		const override = resolveStoredModelOverride({
@@ -4175,7 +4028,7 @@ function buildDiscordModelPickerSelectionCommand(params) {
 	if (!commandDefinition) return null;
 	const commandArgs = {
 		values: { model: params.modelRef },
-		raw: params.modelRef
+		raw: params.runtime ? `${params.modelRef} --runtime ${params.runtime}` : params.modelRef
 	};
 	return {
 		command: commandDefinition,
@@ -4186,7 +4039,7 @@ function buildDiscordModelPickerSelectionCommand(params) {
 function listDiscordModelPickerProviderModels(data, provider) {
 	const modelSet = data.byProvider.get(provider);
 	if (!modelSet) return [];
-	return [...modelSet].toSorted();
+	return [...modelSet].toSorted((left, right) => left < right ? -1 : left > right ? 1 : 0);
 }
 function resolveDiscordModelPickerModelRefByToken(data, modelToken) {
 	const matchingRefs = [];
@@ -4224,10 +4077,6 @@ function resolveDiscordModelPickerSubmissionRuntime(params) {
 		provider: params.provider,
 		runtime: params.parsedRuntime,
 		allowResetRuntime: true
-	}) ?? resolveDiscordModelPickerRuntimeForProvider({
-		data: params.data,
-		provider: params.provider,
-		runtime: params.currentRuntime
 	});
 }
 async function handleDiscordModelPickerInteraction(params) {
@@ -4277,6 +4126,22 @@ async function handleDiscordModelPickerInteraction(params) {
 	});
 	const updatePicker = async (payload) => await params.safeInteractionCall("model picker update", () => deferredUpdate ? interaction.editReply(payload) : interaction.update(payload));
 	const showNotice = async (message) => await updatePicker(buildDiscordModelPickerNoticePayload(message));
+	const updateModelsView = async (provider, state = {}) => {
+		const rendered = renderDiscordModelPickerModelsView({
+			command: parsed.command,
+			userId: parsed.userId,
+			data: pickerData,
+			provider,
+			page: parsed.page,
+			providerPage: parsed.providerPage ?? 1,
+			providerBucket: parsed.providerBucket ?? findProviderBucketId(pickerData, provider),
+			currentModel: currentModelRef,
+			currentRuntime,
+			quickModels,
+			...state
+		});
+		return await updatePicker(toDiscordModelPickerMessagePayload(rendered));
+	};
 	if (parsed.action === "recents") {
 		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerRecentsView({
 			command: parsed.command,
@@ -4293,35 +4158,14 @@ async function handleDiscordModelPickerInteraction(params) {
 		})));
 		return;
 	}
-	if (parsed.action === "back" && parsed.view === "providers") {
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerProvidersView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			page: parsed.page,
-			providerBucket: parsed.providerBucket,
-			currentModel: currentModelRef
-		})));
-		return;
-	}
-	if (parsed.action === "nav" && parsed.view === "providers") {
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerProvidersView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			page: parsed.page,
-			providerBucket: parsed.providerBucket,
-			currentModel: currentModelRef
-		})));
-		return;
-	}
-	if (parsed.action === "bucket" && parsed.view === "providers") {
+	if (parsed.view === "providers" && (parsed.action === "back" || parsed.action === "nav" || parsed.action === "bucket")) {
+		const selectingBucket = parsed.action === "bucket";
 		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerProvidersView({
 			command: parsed.command,
 			userId: parsed.userId,
 			data: pickerData,
-			page: 1,
-			providerBucket: resolveSelectedBucket(interaction),
+			page: selectingBucket ? 1 : parsed.page,
+			providerBucket: selectingBucket ? resolveSelectedBucket(interaction) : parsed.providerBucket,
 			currentModel: currentModelRef
 		})));
 		return;
@@ -4332,24 +4176,15 @@ async function handleDiscordModelPickerInteraction(params) {
 			currentModelRef,
 			data: pickerData
 		});
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			provider,
+		await updateModelsView(provider, {
 			page: 1,
-			providerPage: parsed.providerPage ?? 1,
-			providerBucket: parsed.providerBucket ?? findProviderBucketId(pickerData, provider),
 			modelBucket: resolveSelectedBucket(interaction),
-			currentModel: currentModelRef,
-			currentRuntime,
 			pendingRuntime: resolvePendingRuntime({
 				data: pickerData,
 				provider,
 				parsed
-			}),
-			quickModels
-		})));
+			})
+		});
 		return;
 	}
 	if (parsed.action === "nav" && parsed.view === "models") {
@@ -4374,26 +4209,16 @@ async function handleDiscordModelPickerInteraction(params) {
 			provider,
 			model: pendingModel
 		}) : void 0;
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			provider,
-			page: parsed.page,
-			providerPage: parsed.providerPage ?? 1,
-			providerBucket: parsed.providerBucket ?? findProviderBucketId(pickerData, provider),
+		await updateModelsView(provider, {
 			modelBucket: parsed.modelBucket,
-			currentModel: currentModelRef,
-			currentRuntime,
 			...pendingModel ? { pendingModel: `${provider}/${pendingModel}` } : {},
 			pendingModelIndex: pendingModelIndex ?? void 0,
 			pendingRuntime: resolvePendingRuntime({
 				data: pickerData,
 				provider,
 				parsed
-			}),
-			quickModels
-		})));
+			})
+		});
 		return;
 	}
 	if (parsed.action === "back" && parsed.view === "models") {
@@ -4402,24 +4227,14 @@ async function handleDiscordModelPickerInteraction(params) {
 			currentModelRef,
 			data: pickerData
 		});
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			provider,
-			page: parsed.page ?? 1,
-			providerPage: parsed.providerPage ?? 1,
-			providerBucket: parsed.providerBucket ?? findProviderBucketId(pickerData, provider),
+		await updateModelsView(provider, {
 			modelBucket: parsed.modelBucket,
-			currentModel: currentModelRef,
-			currentRuntime,
 			pendingRuntime: resolvePendingRuntime({
 				data: pickerData,
 				provider,
 				parsed
-			}),
-			quickModels
-		})));
+			})
+		});
 		return;
 	}
 	if (parsed.action === "provider") {
@@ -4428,18 +4243,10 @@ async function handleDiscordModelPickerInteraction(params) {
 			await showNotice("Sorry, that provider isn't available anymore.");
 			return;
 		}
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			provider: selectedProvider,
+		await updateModelsView(selectedProvider, {
 			page: 1,
-			providerPage: parsed.providerPage ?? parsed.page,
-			providerBucket: parsed.providerBucket ?? findProviderBucketId(pickerData, selectedProvider),
-			currentModel: currentModelRef,
-			currentRuntime,
-			quickModels
-		})));
+			providerPage: parsed.providerPage ?? parsed.page
+		});
 		return;
 	}
 	if (parsed.action === "model") {
@@ -4459,28 +4266,16 @@ async function handleDiscordModelPickerInteraction(params) {
 			return;
 		}
 		const modelRef = `${provider}/${selectedModel}`;
-		const derivedProviderBucket = parsed.providerBucket ?? findProviderBucketId(pickerData, provider);
-		const derivedModelBucket = parsed.modelBucket ?? findModelBucketId(pickerData, provider, selectedModel);
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			provider,
-			page: parsed.page,
-			providerPage: parsed.providerPage ?? 1,
-			providerBucket: derivedProviderBucket,
-			modelBucket: derivedModelBucket,
-			currentModel: currentModelRef,
-			currentRuntime,
+		await updateModelsView(provider, {
+			modelBucket: parsed.modelBucket ?? findModelBucketId(pickerData, provider, selectedModel),
 			pendingModel: modelRef,
 			pendingModelIndex: modelIndex,
 			pendingRuntime: resolvePendingRuntime({
 				data: pickerData,
 				provider,
 				parsed
-			}),
-			quickModels
-		})));
+			})
+		});
 		return;
 	}
 	if (parsed.action === "runtime") {
@@ -4507,25 +4302,13 @@ async function handleDiscordModelPickerInteraction(params) {
 			provider,
 			model: selectedModel
 		}) : void 0;
-		const derivedProviderBucket = parsed.providerBucket ?? findProviderBucketId(pickerData, provider);
 		const currentModelOnly = splitDiscordModelRef(currentModelRef ?? "");
-		const derivedModelBucket = parsed.modelBucket ?? (selectedModel ? findModelBucketId(pickerData, provider, selectedModel) : currentModelOnly && currentModelOnly.provider === provider ? findModelBucketId(pickerData, provider, currentModelOnly.model) : void 0);
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			provider,
-			page: parsed.page,
-			providerPage: parsed.providerPage ?? 1,
-			providerBucket: derivedProviderBucket,
-			modelBucket: derivedModelBucket,
-			currentModel: currentModelRef,
-			currentRuntime,
+		await updateModelsView(provider, {
+			modelBucket: parsed.modelBucket ?? (selectedModel ? findModelBucketId(pickerData, provider, selectedModel) : currentModelOnly && currentModelOnly.provider === provider ? findModelBucketId(pickerData, provider, currentModelOnly.model) : void 0),
 			...pendingModel ? { pendingModel } : {},
 			pendingModelIndex: pendingModelIndex ?? void 0,
-			pendingRuntime: selectedRuntime,
-			quickModels
-		})));
+			pendingRuntime: selectedRuntime
+		});
 		return;
 	}
 	if (parsed.action === "submit" || parsed.action === "reset" || parsed.action === "quick") {
@@ -4548,10 +4331,12 @@ async function handleDiscordModelPickerInteraction(params) {
 				data: pickerData,
 				parsed,
 				selectedProvider: parsedModelRef.provider
-			}),
-			currentRuntime
+			})
+		});
+		const selectionCommand = buildDiscordModelPickerSelectionCommand({
+			modelRef: resolvedModelRef,
+			runtime: selectedRuntime
 		});
-		const selectionCommand = buildDiscordModelPickerSelectionCommand({ modelRef: resolvedModelRef });
 		if (!selectionCommand) {
 			await showNotice("Sorry, /model is unavailable right now.");
 			return;
@@ -4568,17 +4353,17 @@ async function handleDiscordModelPickerInteraction(params) {
 			threadBindings: ctx.threadBindings,
 			route,
 			resolvedModelRef,
-			selectedProvider: parsedModelRef.provider,
-			selectedModel: parsedModelRef.model,
 			selectedRuntime,
-			defaultProvider: pickerData.resolvedDefault.provider,
-			defaultModel: pickerData.resolvedDefault.model,
 			preferenceScope,
 			settleMs: ctx.postApplySettleMs ?? 250,
 			resolveCurrentModel: (currentRoute) => resolveDiscordModelPickerCurrentModel({
 				cfg,
 				route: currentRoute,
 				data: pickerData
+			}),
+			resolveCurrentRuntime: (currentRoute) => resolveDiscordModelPickerCurrentRuntime({
+				cfg,
+				route: currentRoute
 			})
 		});
 		await params.safeInteractionCall("model picker follow-up", () => interaction.followUp({
@@ -4756,12 +4541,13 @@ function buildDiscordCommandOptions(params) {
 //#endregion
 //#region extensions/discord/src/monitor/native-command.ts
 const log = createSubsystemLogger("discord/native-command");
+const NON_PLUGIN_COMMAND_DISPATCH = Object.freeze({ kind: "non-plugin" });
 function createDiscordNativeCommand(params) {
 	const { command, cfg, discordConfig, accountId, sessionPrefix, ephemeralDefault, threadBindings } = params;
 	const fallbackCommandDefinition = createNativeCommandDefinition(command);
-	const pluginCommandMatch = nativeCommandRuntime.matchPluginCommand(`/${command.name}`);
-	const commandDefinition = pluginCommandMatch !== null ? fallbackCommandDefinition : findCommandByNativeName$1(command.name, "discord", { includeBundledChannelFallback: false }) ?? fallbackCommandDefinition;
-	const argDefinitions = commandDefinition.args ?? command.args;
+	const pluginCommandCandidate = "prepareDispatch" in command ? command : void 0;
+	const commandDefinition = pluginCommandCandidate ? fallbackCommandDefinition : findCommandByNativeName$1(command.name, "discord", { includeBundledChannelFallback: false }) ?? fallbackCommandDefinition;
+	const argDefinitions = commandDefinition.args ?? ("args" in command ? command.args : void 0);
 	const resolveCurrentConfig = () => getRuntimeConfigSnapshot() ?? cfg;
 	const commandOptions = buildDiscordCommandOptions({
 		command: commandDefinition,
@@ -4772,7 +4558,7 @@ function createDiscordNativeCommand(params) {
 			cfg: resolveCurrentConfig(),
 			discordConfig,
 			accountId,
-			skipCommandOwnerAllowFrom: pluginCommandMatch !== null
+			skipCommandOwnerAllowFrom: pluginCommandCandidate !== void 0
 		}),
 		resolveChoiceContext: async (interaction) => resolveDiscordNativeChoiceContext({
 			interaction,
@@ -4810,9 +4596,11 @@ function createDiscordNativeCommand(params) {
 				...commandArgs,
 				raw: serializeCommandArgs$1(commandDefinition, commandArgs) ?? commandArgs.raw
 			} : void 0;
+			const prompt = buildCommandTextFromArgs$1(commandDefinition, commandArgsWithRaw);
+			const preparedPluginCommand = pluginCommandCandidate?.prepareDispatch(commandArgsWithRaw?.raw);
 			await dispatchDiscordCommandInteraction({
 				interaction,
-				prompt: buildCommandTextFromArgs$1(commandDefinition, commandArgsWithRaw),
+				prompt,
 				command: commandDefinition,
 				commandArgs: commandArgsWithRaw,
 				cfg,
@@ -4821,7 +4609,8 @@ function createDiscordNativeCommand(params) {
 				sessionPrefix,
 				preferFollowUp: true,
 				threadBindings,
-				responseEphemeral: ephemeralDefault
+				responseEphemeral: ephemeralDefault,
+				pluginCommandDispatch: preparedPluginCommand ?? NON_PLUGIN_COMMAND_DISPATCH
 			});
 		}
 	}();
@@ -4884,7 +4673,8 @@ async function dispatchDiscordCommandInteraction(params) {
 		allowNameMatching
 	});
 	const commandOwnerAllowAll = commandOwnerAllowFrom?.includes("*") === true;
-	const senderIsCommandOwner = commandOwnerOk || commandOwnerAllowAll;
+	const senderIsCommandOwner = commandOwnerOk;
+	const commandOwnerAccessAllowed = senderIsCommandOwner || commandOwnerAllowAll;
 	const ownerAllowListConfigured = discordOwnerAllowList != null;
 	const ownerOk = discordOwnerOk;
 	const { commandsAllowFromAccess, guildInfo, channelConfig } = resolveDiscordNativeCommandChannelAccessContext({
@@ -5024,8 +4814,7 @@ async function dispatchDiscordCommandInteraction(params) {
 			return { accepted: false };
 		}
 	}
-	const pluginMatch = nativeCommandRuntime.matchPluginCommand(prompt);
-	if (commandOwnerAllowFrom && !senderIsCommandOwner && !commandsAllowFromAccess.allowed && commandName !== "status" && !pluginMatch) {
+	if (commandOwnerAllowFrom && !commandOwnerAccessAllowed && !commandsAllowFromAccess.allowed && commandName !== "status" && params.pluginCommandDispatch.kind !== "plugin") {
 		await respond("You are not authorized to use this command.", { ephemeral: true });
 		return { accepted: false };
 	}
@@ -5085,7 +4874,7 @@ async function dispatchDiscordCommandInteraction(params) {
 		}));
 		return { accepted: true };
 	}
-	if (pluginMatch && commandName !== "status") {
+	if (params.pluginCommandDispatch.kind === "plugin" && commandName !== "status") {
 		if (suppressReplies) {
 			await settleDiscordInteractionWithoutVisibleReply(interaction);
 			return { accepted: true };
@@ -5099,9 +4888,7 @@ async function dispatchDiscordCommandInteraction(params) {
 			agentId: pluginCommandAgentId,
 			sessionKey: effectiveRoute.sessionKey
 		});
-		const pluginReply = await nativeCommandRuntime.executePluginCommand({
-			command: pluginMatch.command,
-			args: pluginMatch.args,
+		const pluginReply = await params.pluginCommandDispatch.execute({
 			senderId: sender.id,
 			channel: "discord",
 			channelId,
@@ -5242,7 +5029,7 @@ async function dispatchDiscordCommandInteraction(params) {
 		respond
 	});
 	if (directStatusResult) return directStatusResult;
-	await dispatchDiscordNativeAgentReply({
+	const { dispatched, hiddenFinalReply } = await dispatchDiscordNativeAgentReply({
 		cfg,
 		discordConfig,
 		accountId,
@@ -5254,11 +5041,13 @@ async function dispatchDiscordCommandInteraction(params) {
 		preferFollowUp,
 		responseEphemeral,
 		suppressReplies,
-		log
+		log,
+		pluginCommandDispatch: params.pluginCommandDispatch
 	});
 	return {
-		accepted: true,
-		effectiveRoute
+		accepted: dispatched,
+		effectiveRoute,
+		hiddenFinalReply
 	};
 }
 function createDiscordCommandArgFallbackButton(params) {
@@ -5308,7 +5097,7 @@ function canResumeAfterGatewayClose(code) {
 //#region extensions/discord/src/internal/gateway-identify-limiter.ts
 const IDENTIFY_WINDOW_MS = 5e3;
 function normalizeMaxConcurrency(value) {
-	const parsed = parseFiniteNumber(value);
+	const parsed = parseFiniteNumber$1(value);
 	return parsed === void 0 ? 1 : Math.max(1, Math.floor(parsed));
 }
 var GatewayIdentifyLimiter = class {
@@ -6429,8 +6218,7 @@ function readStringProperty(value, key) {
 	return typeof property === "string" && property ? property : void 0;
 }
 function readNumberProperty(value, key) {
-	const property = value[key];
-	return typeof property === "number" && Number.isFinite(property) ? property : void 0;
+	return asFiniteNumber(value[key]);
 }
 function describeDiscordGatewayTransportError(error) {
 	const code = readStringProperty(error, "code");
@@ -6480,7 +6268,8 @@ function resolveDiscordGatewayIntents(params) {
 	const intentsConfig = params?.intentsConfig;
 	const voiceEnabled = params?.voiceEnabled;
 	const voiceStatesEnabled = intentsConfig?.voiceStates ?? voiceEnabled ?? false;
-	let intents = GatewayIntents.Guilds | GatewayIntents.GuildMessages | GatewayIntents.MessageContent | GatewayIntents.DirectMessages | GatewayIntents.GuildMessageReactions | GatewayIntents.DirectMessageReactions;
+	let intents = GatewayIntents.Guilds | GatewayIntents.GuildMessages | GatewayIntents.DirectMessages | GatewayIntents.GuildMessageReactions | GatewayIntents.DirectMessageReactions;
+	if (intentsConfig?.messageContent !== false) intents |= GatewayIntents.MessageContent;
 	if (voiceStatesEnabled) intents |= GatewayIntents.GuildVoiceStates;
 	if (intentsConfig?.presence) intents |= GatewayIntents.GuildPresences;
 	if (intentsConfig?.guildMembers) intents |= GatewayIntents.GuildMembers;
@@ -6860,7 +6649,7 @@ async function waitForDiscordGatewayStop(params) {
 				gateway?.disconnect?.();
 			} finally {
 				cleanup();
-				reject(toLintErrorObject(err, "Non-Error rejection"));
+				reject(toErrorObject(err, "Non-Error rejection"));
 			}
 		};
 		const onAbort = () => {
@@ -6881,12 +6670,15 @@ async function waitForDiscordGatewayStop(params) {
 		params.registerForceStop?.(onForceStop);
 	});
 }
-function toLintErrorObject(value, fallbackMessage) {
-	if (value instanceof Error) return value;
-	if (typeof value === "string") return new Error(value);
-	const error = new Error(fallbackMessage, { cause: value });
-	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
-	return error;
+//#endregion
+//#region extensions/discord/src/monitor/status.ts
+/** READY proves a prior terminal failure was repaired, so the account is restartable again. */
+function createDiscordReadyStatusPatch(at = Date.now()) {
+	return channelReadyPatch({
+		lastConnectedAt: at,
+		lastEventAt: at,
+		lastDisconnect: null
+	});
 }
 //#endregion
 //#region extensions/discord/src/monitor/provider.lifecycle.ts
@@ -7018,11 +6810,7 @@ function createGatewayStatusObserver(params) {
 		queuedForceStopError = err;
 	};
 	const pushConnectedStatus = (at) => {
-		params.pushStatus({
-			...createConnectedChannelStatusPatch(at),
-			lastDisconnect: null,
-			lastError: null
-		});
+		params.pushStatus(createDiscordReadyStatusPatch(at));
 	};
 	const startReadyWatch = () => {
 		clearReadyWatch();
@@ -7046,6 +6834,7 @@ function createGatewayStatusObserver(params) {
 				const error = /* @__PURE__ */ new Error(`discord gateway opened but did not reach READY within ${params.runtimeReadyTimeoutMs}ms`);
 				params.pushStatus({
 					connected: false,
+					lifecycle: "recovering",
 					lastEventAt: at,
 					lastDisconnect: {
 						at,
@@ -7074,8 +6863,14 @@ function createGatewayStatusObserver(params) {
 		if (message.includes("Gateway websocket closed")) {
 			clearReadyWatch();
 			const code = parseGatewayCloseCode(message);
+			const terminalDisconnect = code !== void 0 && isFatalGatewayCloseCode(code);
 			params.pushStatus({
 				connected: false,
+				lifecycle: terminalDisconnect ? "blocked" : "recovering",
+				...terminalDisconnect ? {
+					terminalDisconnect: true,
+					lastError: message
+				} : {},
 				lastEventAt: at,
 				lastDisconnect: {
 					at,
@@ -7088,6 +6883,7 @@ function createGatewayStatusObserver(params) {
 			clearReadyWatch();
 			params.pushStatus({
 				connected: false,
+				lifecycle: "recovering",
 				lastEventAt: at,
 				lastError: message
 			});
@@ -7118,11 +6914,7 @@ async function waitForGatewayReady(params) {
 			if (await params.beforePoll?.() === "stop") return "stopped";
 			if (params.gateway?.isConnected === true) {
 				const at = Date.now();
-				params.pushStatus?.({
-					...createConnectedChannelStatusPatch(at),
-					lastDisconnect: null,
-					lastError: null
-				});
+				params.pushStatus?.(createDiscordReadyStatusPatch(at));
 				return "ready";
 			}
 			if (Date.now() >= deadlineAt) return "timeout";
@@ -7144,6 +6936,7 @@ async function waitForGatewayReady(params) {
 		params.runtime.error?.(danger(`discord: gateway READY wait timed out after ${params.readyTimeoutMs}ms; reconnecting with backoff (attempt ${attempt})`));
 		params.pushStatus?.({
 			connected: false,
+			lifecycle: "recovering",
 			lastEventAt: restartAt,
 			lastDisconnect: {
 				at: restartAt,
@@ -7252,7 +7045,7 @@ async function runDiscordGatewayLifecycle(params) {
 		gatewayEmitter?.removeListener(DISCORD_GATEWAY_TRANSPORT_ACTIVITY_EVENT, onGatewayTransportActivity);
 		if (params.voiceManager) {
 			await params.voiceManager.destroy();
-			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-DIKGsTGT.js").then((n) => n.n);
+			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-CfFMexGt.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: params.accountId,
 				manager: null
@@ -7267,7 +7060,7 @@ async function runDiscordGatewayLifecycle(params) {
 let discordVoiceRuntimePromise;
 let discordProviderSessionRuntimePromise;
 async function loadDiscordVoiceRuntime() {
-	const promise = discordVoiceRuntimePromise ?? import("./manager.runtime-Bjav3pfC.js");
+	const promise = discordVoiceRuntimePromise ?? import("./voice-runtime-BEdqNcST.js");
 	discordVoiceRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7277,7 +7070,7 @@ async function loadDiscordVoiceRuntime() {
 	}
 }
 async function loadDiscordProviderSessionRuntime() {
-	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-Bo88k0pV.js");
+	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-BUEqD0rA.js");
 	discordProviderSessionRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7287,13 +7080,12 @@ async function loadDiscordProviderSessionRuntime() {
 	}
 }
 const discordProviderRuntime = {
-	fetchDiscordApplicationId,
+	probeDiscordApplicationId,
 	createDiscordNativeCommand,
 	runDiscordGatewayLifecycle,
 	loadDiscordVoiceRuntime,
 	loadDiscordProviderSessionRuntime,
 	createClient: (...args) => new Client(...args),
-	getPluginCommandSpecs: void 0,
 	resolveDiscordAccount,
 	resolveNativeCommandsEnabled,
 	resolveNativeSkillsEnabled,
@@ -7639,112 +7431,431 @@ async function cleanupDiscordProviderStartup(params) {
 	if (!params.lifecycleStarted) params.threadBindings.stop();
 }
 //#endregion
-//#region extensions/discord/src/monitor/provider.commands.ts
-const loadPluginCommandSpecs = createLazyRuntimeNamedExport(() => import("openclaw/plugin-sdk/plugin-runtime"), "getPluginCommandSpecs");
-async function appendPluginCommandSpecs(params) {
-	const merged = [...params.commandSpecs];
-	const existingNames = new Set(normalizeStringEntriesLower(merged.map((spec) => spec.name)));
-	const getPluginCommandSpecs = params.getPluginCommandSpecs ?? await loadPluginCommandSpecs();
-	for (const pluginCommand of getPluginCommandSpecs("discord", { config: params.cfg })) {
-		const normalizedName = normalizeLowercaseStringOrEmpty(pluginCommand.name);
-		if (!normalizedName) continue;
-		if (existingNames.has(normalizedName)) {
-			params.runtime.error?.(danger(`discord: plugin command "/${normalizedName}" duplicates an existing native command. Skipping.`));
-			continue;
-		}
-		existingNames.add(normalizedName);
-		merged.push({
-			name: pluginCommand.name,
-			description: pluginCommand.description,
-			acceptsArgs: pluginCommand.acceptsArgs
-		});
-	}
-	return merged;
-}
-async function resolveDiscordProviderCommandSpecs(params) {
-	const listSkillCommands = params.listSkillCommandsForAgents ?? listSkillCommandsForAgents;
-	const listNativeCommandSpecs = params.listNativeCommandSpecsForConfig ?? listNativeCommandSpecsForConfig;
-	const maxDiscordCommands = params.maxDiscordCommands ?? 100;
-	let skillCommands = params.nativeEnabled && params.nativeSkillsEnabled ? listSkillCommands({ cfg: params.cfg }) : [];
-	let commandSpecs = params.nativeEnabled ? listNativeCommandSpecs(params.cfg, {
-		skillCommands,
-		provider: "discord"
-	}) : [];
-	if (params.nativeEnabled) commandSpecs = await appendPluginCommandSpecs({
-		commandSpecs,
-		runtime: params.runtime,
-		cfg: params.cfg,
-		getPluginCommandSpecs: params.getPluginCommandSpecs
+//#region extensions/discord/src/voice/access.ts
+async function authorizeDiscordVoiceIngress(params) {
+	const groupPolicy = params.groupPolicy ?? resolveOpenProviderRuntimeGroupPolicy({
+		providerConfigPresent: params.cfg.channels?.discord !== void 0,
+		groupPolicy: params.discordConfig.groupPolicy,
+		defaultGroupPolicy: params.cfg.channels?.defaults?.groupPolicy
+	}).groupPolicy;
+	const guildInfo = resolveDiscordGuildEntry({
+		guild: params.guild ?? {
+			id: params.guildId,
+			...params.guildName ? { name: params.guildName } : {}
+		},
+		guildId: params.guildId,
+		guildEntries: params.discordConfig.guilds
 	});
-	const initialCommandCount = commandSpecs.length;
-	if (params.nativeEnabled && params.nativeSkillsEnabled && commandSpecs.length > maxDiscordCommands) {
-		skillCommands = [];
-		commandSpecs = listNativeCommandSpecs(params.cfg, {
-			skillCommands: [],
-			provider: "discord"
-		});
-		commandSpecs = await appendPluginCommandSpecs({
-			commandSpecs,
-			runtime: params.runtime,
-			cfg: params.cfg,
-			getPluginCommandSpecs: params.getPluginCommandSpecs
-		});
-		params.runtime.log?.(warn(`${initialCommandCount} commands exceed the ${maxDiscordCommands}-command Discord limit; removing per-skill commands and keeping /skill.`));
-	}
-	if (params.nativeEnabled && commandSpecs.length > maxDiscordCommands) params.runtime.log?.(warn(`${commandSpecs.length} commands exceed the ${maxDiscordCommands}-command Discord limit; some commands may fail to deploy.`));
-	return {
-		skillCommands,
-		commandSpecs
+	const channelConfig = params.channelId ? resolveDiscordChannelConfigWithFallback({
+		guildInfo,
+		channelId: params.channelId,
+		channelName: params.channelName,
+		channelSlug: params.channelSlug,
+		parentId: params.parentId,
+		parentName: params.parentName,
+		parentSlug: params.parentSlug,
+		scope: params.scope
+	}) : null;
+	if (channelConfig?.enabled === false) return {
+		ok: false,
+		message: "This channel is disabled."
+	};
+	const channelAllowlistConfigured = Boolean(guildInfo?.channels) && Object.keys(guildInfo?.channels ?? {}).length > 0;
+	if (!params.channelId && groupPolicy === "allowlist" && channelAllowlistConfigured) return {
+		ok: false,
+		message: `${params.channelLabel ?? "This channel"} is not allowlisted for voice commands.`
+	};
+	const channelAllowed = channelConfig ? channelConfig.allowed : !channelAllowlistConfigured;
+	if (!isDiscordGroupAllowedByPolicy({
+		groupPolicy,
+		guildAllowlisted: Boolean(guildInfo),
+		channelAllowlistConfigured,
+		channelAllowed
+	}) || channelConfig?.allowed === false) return {
+		ok: false,
+		message: `${params.channelLabel ?? "This channel"} is not allowlisted for voice commands.`
+	};
+	const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
+		channelConfig,
+		guildInfo,
+		memberRoleIds: params.memberRoleIds,
+		sender: params.sender,
+		allowNameMatching: false
+	});
+	const admissionAllowList = normalizeDiscordAllowList(params.admissionAllowFrom ?? params.discordConfig.allowFrom ?? params.discordConfig.allowFrom, [
+		"discord:",
+		"user:",
+		"pk:"
+	]);
+	const admissionAllowed = admissionAllowList ? allowListMatches(admissionAllowList, params.sender, { allowNameMatching: false }) : false;
+	const useAccessGroups = params.useAccessGroups ?? true;
+	return resolveCommandAuthorizedFromAuthorizers({
+		useAccessGroups,
+		authorizers: useAccessGroups ? [{
+			configured: admissionAllowList != null,
+			allowed: admissionAllowed
+		}, {
+			configured: hasAccessRestrictions,
+			allowed: memberAllowed
+		}] : [{
+			configured: hasAccessRestrictions,
+			allowed: memberAllowed
+		}],
+		modeWhenAccessGroupsOff: "configured"
+	}) ? {
+		ok: true,
+		channelConfig
+	} : {
+		ok: false,
+		message: "You are not authorized to use this command."
 	};
 }
 //#endregion
-//#region extensions/discord/src/monitor/provider.config-log.ts
-function formatThreadBindingDurationForConfigLabel(durationMs) {
-	const label = formatThreadBindingDurationLabel(durationMs);
-	return label === "disabled" ? "off" : label;
+//#region extensions/discord/src/voice/owner-access.ts
+function resolveDiscordVoiceAccess(params) {
+	const commandOwnerAllowFrom = resolveDiscordCommandOwnerAllowFrom(params.cfg);
+	if (commandOwnerAllowFrom) return {
+		admissionAllowFrom: commandOwnerAllowFrom,
+		ownerAllowFrom: commandOwnerAllowFrom
+	};
+	return {
+		admissionAllowFrom: resolveDiscordAccountAllowFrom({
+			cfg: params.cfg,
+			accountId: params.accountId
+		}) ?? params.discordConfig.allowFrom ?? [],
+		ownerAllowFrom: []
+	};
 }
-function logDiscordResolvedConfig(params) {
-	const allowFromSummary = summarizeStringEntries({
-		entries: params.allowFrom ?? [],
-		limit: 4,
-		emptyText: "any"
+//#endregion
+//#region extensions/discord/src/voice/command.ts
+const VOICE_CHANNEL_TYPES = [ChannelType.GuildVoice, ChannelType.GuildStageVoice];
+const DISCORD_VOICE_COMMAND_SPEC = {
+	name: "vc",
+	description: "Voice channel controls",
+	acceptsArgs: false
+};
+async function authorizeVoiceCommand(interaction, params, options) {
+	const channelOverride = options?.channelOverride;
+	const channel = channelOverride ? void 0 : interaction.channel;
+	if (!interaction.guild) return {
+		ok: false,
+		message: "Voice commands are only available in guilds."
+	};
+	const user = interaction.user;
+	if (!user) return {
+		ok: false,
+		message: "Unable to resolve command user."
+	};
+	const channelId = channelOverride?.id ?? channel?.id ?? "";
+	const channelContext = await resolveDiscordThreadLikeChannelContext({
+		client: interaction.client,
+		channel: channelOverride ?? channel,
+		channelIdFallback: channelId
 	});
-	const groupDmChannelSummary = summarizeStringEntries({
-		entries: params.groupDmChannels ?? [],
-		limit: 4,
-		emptyText: "any"
+	const channelName = channelOverride?.name ?? channelContext.channelName;
+	const memberRoleIds = Array.isArray(interaction.rawData.member?.roles) ? interaction.rawData.member.roles.map((roleId) => roleId) : [];
+	const sender = resolveDiscordSenderIdentity({
+		author: user,
+		member: interaction.rawData.member
 	});
-	const guildSummary = summarizeStringEntries({
-		entries: Object.keys(params.guildEntries ?? {}),
-		limit: 4,
-		emptyText: "any"
+	const voiceAccess = resolveDiscordVoiceAccess(params);
+	const access = await authorizeDiscordVoiceIngress({
+		cfg: params.cfg,
+		discordConfig: params.discordConfig,
+		accountId: params.accountId,
+		groupPolicy: params.groupPolicy,
+		useAccessGroups: params.useAccessGroups,
+		guild: interaction.guild,
+		guildId: interaction.guild.id,
+		channelId,
+		channelName,
+		channelSlug: channelContext.channelSlug,
+		parentId: channelOverride?.parentId ?? channelContext.threadParentId,
+		parentName: channelContext.threadParentName,
+		parentSlug: channelContext.threadParentSlug,
+		scope: channelContext.isThreadChannel ? "thread" : "channel",
+		channelLabel: channelId ? formatMention({ channelId }) : "This channel",
+		memberRoleIds,
+		admissionAllowFrom: voiceAccess.admissionAllowFrom,
+		sender: {
+			id: sender.id,
+			name: sender.name,
+			tag: sender.tag
+		}
 	});
-	logVerbose(`discord: config dm=${params.dmEnabled ? "on" : "off"} dmPolicy=${params.dmPolicy} allowFrom=${allowFromSummary} groupDm=${params.groupDmEnabled ? "on" : "off"} groupDmChannels=${groupDmChannelSummary} groupPolicy=${params.groupPolicy} guilds=${guildSummary} historyLimit=${params.historyLimit} mediaMaxMb=${Math.round(params.mediaMaxBytes / (1024 * 1024))} native=${params.nativeEnabled ? "on" : "off"} nativeSkills=${params.nativeSkillsEnabled ? "on" : "off"} accessGroups=${params.useAccessGroups ? "on" : "off"} threadBindings=${params.threadBindingsEnabled ? "on" : "off"} threadIdleTimeout=${formatThreadBindingDurationForConfigLabel(params.threadBindingIdleTimeoutMs)} threadMaxAge=${formatThreadBindingDurationForConfigLabel(params.threadBindingMaxAgeMs)}`);
-}
-//#endregion
-//#region extensions/discord/src/monitor/provider.deploy-errors.ts
-const DISCORD_DEPLOY_REJECTED_ENTRY_LIMIT = 3;
-function attachDiscordDeployRequestBody(err, body) {
-	if (!err || typeof err !== "object" || body === void 0) return;
-	const deployErr = err;
-	if (deployErr.deployRequestBody === void 0) deployErr.deployRequestBody = body;
-}
-function attachDiscordDeployRestContext(err, context) {
-	if (!err || typeof err !== "object") return;
-	const deployErr = err;
-	deployErr.deployRestMethod = context.method;
-	deployErr.deployRestPath = context.path;
-	deployErr.deployRequestMs = context.requestMs;
-	if (typeof context.timeoutMs === "number" && Number.isFinite(context.timeoutMs)) deployErr.deployTimeoutMs = context.timeoutMs;
+	if (!access.ok) return {
+		ok: false,
+		message: access.message
+	};
+	return {
+		ok: true,
+		guildId: interaction.guild.id
+	};
 }
-function stringifyDiscordDeployField(value) {
-	if (typeof value === "string") return JSON.stringify(value);
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return inspect(value, {
-			depth: 2,
-			breakLength: 120
+async function resolveVoiceCommandRuntimeContext(interaction, params) {
+	const guildId = interaction.guild?.id;
+	if (!guildId) {
+		await interaction.reply({
+			content: "Unable to resolve guild for this command.",
+			ephemeral: true
+		});
+		return null;
+	}
+	const manager = params.getManager();
+	if (!manager) {
+		await interaction.reply({
+			content: "Voice manager is not available yet.",
+			ephemeral: true
+		});
+		return null;
+	}
+	return {
+		guildId,
+		manager
+	};
+}
+async function ensureVoiceCommandAccess(params) {
+	const access = await authorizeVoiceCommand(params.interaction, params.context, { channelOverride: params.channelOverride });
+	if (access.ok) return true;
+	await params.interaction.reply({
+		content: access.message ?? "Not authorized.",
+		ephemeral: true
+	});
+	return false;
+}
+function createDiscordVoiceCommand(params) {
+	const resolveSessionChannelId = (manager, guildId) => manager.status().find((entry) => entry.guildId === guildId)?.channelId;
+	class JoinCommand extends Command {
+		constructor(..._args) {
+			super(..._args);
+			this.name = "join";
+			this.description = "Join a voice channel";
+			this.defer = true;
+			this.ephemeral = params.ephemeralDefault;
+			this.options = [{
+				name: "channel",
+				description: "Voice channel to join",
+				type: ApplicationCommandOptionType.Channel,
+				required: true,
+				channel_types: VOICE_CHANNEL_TYPES
+			}];
+		}
+		async run(interaction) {
+			const channel = await interaction.options.getChannel("channel", true);
+			if (!channel || !("id" in channel)) {
+				await interaction.reply({
+					content: "Voice channel not found.",
+					ephemeral: true
+				});
+				return;
+			}
+			const access = await authorizeVoiceCommand(interaction, params, { channelOverride: {
+				id: channel.id,
+				name: resolveDiscordChannelNameSafe(channel)
+			} });
+			if (!access.ok) {
+				await interaction.reply({
+					content: access.message ?? "Not authorized.",
+					ephemeral: true
+				});
+				return;
+			}
+			if (!isVoiceChannelType(channel.type)) {
+				await interaction.reply({
+					content: "That is not a voice channel.",
+					ephemeral: true
+				});
+				return;
+			}
+			const guildId = access.guildId ?? ("guildId" in channel ? channel.guildId : void 0);
+			if (!guildId) {
+				await interaction.reply({
+					content: "Unable to resolve guild for this voice channel.",
+					ephemeral: true
+				});
+				return;
+			}
+			const manager = params.getManager();
+			if (!manager) {
+				await interaction.reply({
+					content: "Voice manager is not available yet.",
+					ephemeral: true
+				});
+				return;
+			}
+			const result = await manager.join({
+				guildId,
+				channelId: channel.id
+			});
+			await interaction.reply({
+				content: result.message,
+				ephemeral: true
+			});
+		}
+	}
+	class LeaveCommand extends Command {
+		constructor(..._args2) {
+			super(..._args2);
+			this.name = "leave";
+			this.description = "Leave the current voice channel";
+			this.defer = true;
+			this.ephemeral = params.ephemeralDefault;
+		}
+		async run(interaction) {
+			const runtimeContext = await resolveVoiceCommandRuntimeContext(interaction, params);
+			if (!runtimeContext) return;
+			const sessionChannelId = resolveSessionChannelId(runtimeContext.manager, runtimeContext.guildId);
+			if (!await ensureVoiceCommandAccess({
+				interaction,
+				context: params,
+				channelOverride: sessionChannelId ? { id: sessionChannelId } : void 0
+			})) return;
+			const result = await runtimeContext.manager.leave({ guildId: runtimeContext.guildId });
+			await interaction.reply({
+				content: result.message,
+				ephemeral: true
+			});
+		}
+	}
+	class StatusCommand extends Command {
+		constructor(..._args3) {
+			super(..._args3);
+			this.name = "status";
+			this.description = "Show active voice sessions";
+			this.defer = true;
+			this.ephemeral = params.ephemeralDefault;
+		}
+		async run(interaction) {
+			const runtimeContext = await resolveVoiceCommandRuntimeContext(interaction, params);
+			if (!runtimeContext) return;
+			const sessions = runtimeContext.manager.status().filter((entry) => entry.guildId === runtimeContext.guildId);
+			const sessionChannelId = sessions[0]?.channelId;
+			if (!await ensureVoiceCommandAccess({
+				interaction,
+				context: params,
+				channelOverride: sessionChannelId ? { id: sessionChannelId } : void 0
+			})) return;
+			if (sessions.length === 0) {
+				await interaction.reply({
+					content: "No active voice sessions.",
+					ephemeral: true
+				});
+				return;
+			}
+			const lines = sessions.map((entry) => `• ${formatMention({ channelId: entry.channelId })} (guild ${entry.guildId})`);
+			await interaction.reply({
+				content: lines.join("\n"),
+				ephemeral: true
+			});
+		}
+	}
+	return new class extends CommandWithSubcommands {
+		constructor(..._args4) {
+			super(..._args4);
+			this.name = DISCORD_VOICE_COMMAND_SPEC.name;
+			this.description = DISCORD_VOICE_COMMAND_SPEC.description;
+			this.subcommands = [
+				new JoinCommand(),
+				new LeaveCommand(),
+				new StatusCommand()
+			];
+		}
+	}();
+}
+function isVoiceChannelType(type) {
+	return type === ChannelType.GuildVoice || type === ChannelType.GuildStageVoice;
+}
+//#endregion
+//#region extensions/discord/src/monitor/provider.commands.ts
+const loadPluginCommandRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/plugin-command-runtime"));
+async function resolveDiscordProviderCommandSpecs(params) {
+	const listSkillCommands = params.listSkillCommandsForAgents ?? listSkillCommandsForAgents;
+	const listNativeCommandSpecs = params.listNativeCommandSpecsForConfig ?? listNativeCommandSpecsForConfig;
+	const maxDiscordCommands = params.maxDiscordCommands ?? 100;
+	let pluginCommandRuntime;
+	if (params.nativeEnabled) pluginCommandRuntime = (await loadPluginCommandRuntime()).createPluginCommandRuntime();
+	const pluginCommandSpecs = pluginCommandRuntime?.listNativeCandidates("discord") ?? [];
+	const onCollision = (normalizedName) => {
+		params.runtime.error?.(danger(`discord: plugin command "/${normalizedName}" duplicates an existing native command. Skipping.`));
+	};
+	const mergePluginCommandSpecs = (primary, collisionHandler) => mergeNativeCommandSpecs({
+		primary,
+		secondary: pluginCommandSpecs,
+		onCollision: collisionHandler
+	});
+	const listPrimaryCommandSpecs = (skillCommands) => {
+		const standardSpecs = listNativeCommandSpecs(params.cfg, {
+			skillCommands,
+			provider: "discord"
+		});
+		if (!params.voiceEnabled) return standardSpecs;
+		const voiceName = DISCORD_VOICE_COMMAND_SPEC.name;
+		return [...standardSpecs.filter((spec) => normalizeLowercaseStringOrEmpty(spec.name) !== voiceName), DISCORD_VOICE_COMMAND_SPEC];
+	};
+	const provisionalCollisions = [];
+	let skillCommands = params.nativeEnabled && params.nativeSkillsEnabled ? listSkillCommands({ cfg: params.cfg }) : [];
+	let commandSpecs = params.nativeEnabled ? mergePluginCommandSpecs(listPrimaryCommandSpecs(skillCommands), (normalizedName) => provisionalCollisions.push(normalizedName)) : [];
+	const initialCommandCount = commandSpecs.length;
+	if (params.nativeEnabled && params.nativeSkillsEnabled && commandSpecs.length > maxDiscordCommands) {
+		skillCommands = [];
+		commandSpecs = mergePluginCommandSpecs(listPrimaryCommandSpecs([]), onCollision);
+		params.runtime.log?.(warn(`${initialCommandCount} commands exceed the ${maxDiscordCommands}-command Discord limit; removing per-skill commands and keeping /skill.`));
+	} else for (const normalizedName of provisionalCollisions) onCollision(normalizedName);
+	if (params.nativeEnabled && commandSpecs.length > maxDiscordCommands) params.runtime.log?.(warn(`${commandSpecs.length} commands exceed the ${maxDiscordCommands}-command Discord limit; some commands may fail to deploy.`));
+	if (commandSpecs.some((command) => "prepareDispatch" in command)) pluginCommandRuntime?.retainNativeCatalog("discord");
+	return {
+		skillCommands,
+		commandSpecs
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/provider.config-log.ts
+function formatThreadBindingDurationForConfigLabel(durationMs) {
+	const label = formatThreadBindingDurationLabel(durationMs);
+	return label === "disabled" ? "off" : label;
+}
+function logDiscordResolvedConfig(params) {
+	const allowFromSummary = summarizeStringEntries({
+		entries: params.allowFrom ?? [],
+		limit: 4,
+		emptyText: "any"
+	});
+	const groupDmChannelSummary = summarizeStringEntries({
+		entries: params.groupDmChannels ?? [],
+		limit: 4,
+		emptyText: "any"
+	});
+	const guildSummary = summarizeStringEntries({
+		entries: Object.keys(params.guildEntries ?? {}),
+		limit: 4,
+		emptyText: "any"
+	});
+	logVerbose(`discord: config dm=${params.dmEnabled ? "on" : "off"} dmPolicy=${params.dmPolicy} allowFrom=${allowFromSummary} groupDm=${params.groupDmEnabled ? "on" : "off"} groupDmChannels=${groupDmChannelSummary} groupPolicy=${params.groupPolicy} guilds=${guildSummary} historyLimit=${params.historyLimit} mediaMaxMb=${Math.round(params.mediaMaxBytes / (1024 * 1024))} native=${params.nativeEnabled ? "on" : "off"} nativeSkills=${params.nativeSkillsEnabled ? "on" : "off"} accessGroups=${params.useAccessGroups ? "on" : "off"} threadBindings=${params.threadBindingsEnabled ? "on" : "off"} threadIdleTimeout=${formatThreadBindingDurationForConfigLabel(params.threadBindingIdleTimeoutMs)} threadMaxAge=${formatThreadBindingDurationForConfigLabel(params.threadBindingMaxAgeMs)}`);
+}
+//#endregion
+//#region extensions/discord/src/monitor/provider.deploy-errors.ts
+const DISCORD_DEPLOY_REJECTED_ENTRY_LIMIT = 3;
+function attachDiscordDeployRequestBody(err, body) {
+	if (!err || typeof err !== "object" || body === void 0) return;
+	const deployErr = err;
+	if (deployErr.deployRequestBody === void 0) deployErr.deployRequestBody = body;
+}
+function attachDiscordDeployRestContext(err, context) {
+	if (!err || typeof err !== "object") return;
+	const deployErr = err;
+	deployErr.deployRestMethod = context.method;
+	deployErr.deployRestPath = context.path;
+	deployErr.deployRequestMs = context.requestMs;
+	if (typeof context.timeoutMs === "number" && Number.isFinite(context.timeoutMs)) deployErr.deployTimeoutMs = context.timeoutMs;
+}
+function stringifyDiscordDeployField(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return inspect(value, {
+			depth: 2,
+			breakLength: 120
 		});
 	}
 }
@@ -7762,13 +7873,6 @@ function resolveDiscordRejectedDeployEntriesSource(rawBody) {
 function readDiscordDeployObjectField(value, field) {
 	return value && typeof value === "object" && field in value ? value[field] : void 0;
 }
-function readFiniteNumber(value) {
-	if (typeof value === "number" && Number.isFinite(value)) return value;
-	if (typeof value === "string" && value.trim().length > 0) return parseStrictFiniteNumber(value);
-}
-function readNonNegativeInteger(value) {
-	return parseStrictNonNegativeInteger(value);
-}
 function isAbortLikeError(err) {
 	if (!err || typeof err !== "object") return false;
 	const name = "name" in err && typeof err.name === "string" ? err.name : void 0;
@@ -7786,8 +7890,8 @@ function formatDiscordDeployRestOperation(err) {
 function formatDiscordDeployErrorMessage(err) {
 	if (!isAbortLikeError(err)) return formatErrorMessage$1(err);
 	const deployErr = err && typeof err === "object" ? err : {};
-	const requestMs = readFiniteNumber(deployErr.deployRequestMs);
-	const timeoutMs = readFiniteNumber(deployErr.deployTimeoutMs);
+	const requestMs = parseFiniteNumber(deployErr.deployRequestMs);
+	const timeoutMs = parseFiniteNumber(deployErr.deployTimeoutMs);
 	const operation = formatDiscordDeployRestOperation(deployErr);
 	if (!(requestMs !== void 0 || timeoutMs !== void 0 || deployErr.deployRestMethod !== void 0 || deployErr.deployRestPath !== void 0)) return "Discord REST request was aborted";
 	const timing = [];
@@ -7800,8 +7904,8 @@ function formatDiscordDeployErrorMessage(err) {
 function resolveDiscordDeployRateLimitDetails(err) {
 	if (!err || typeof err !== "object") return;
 	const deployErr = err;
-	const status = readNonNegativeInteger(deployErr.status) ?? readNonNegativeInteger(deployErr.statusCode);
-	const retryAfterSeconds = readFiniteNumber(deployErr.retryAfter) ?? readFiniteNumber(readDiscordDeployObjectField(deployErr.rawBody, "retry_after"));
+	const status = parseStrictNonNegativeInteger(deployErr.status) ?? parseStrictNonNegativeInteger(deployErr.statusCode);
+	const retryAfterSeconds = parseFiniteNumber(deployErr.retryAfter) ?? parseFiniteNumber(readDiscordDeployObjectField(deployErr.rawBody, "retry_after"));
 	if (!(err instanceof RateLimitError || status === 429 || retryAfterSeconds !== void 0)) return;
 	const rawGlobal = readDiscordDeployObjectField(deployErr.rawBody, "global");
 	const scope = typeof deployErr.scope === "string" && deployErr.scope.trim().length > 0 ? deployErr.scope : rawGlobal === true ? "global" : rawGlobal === false ? "route" : void 0;
@@ -7891,8 +7995,8 @@ function formatDiscordDeployErrorDetails(err) {
 function isDiscordDeployDailyCreateLimit(err) {
 	if (!err || typeof err !== "object") return false;
 	const deployErr = err;
-	const discordCode = readNonNegativeInteger(deployErr.discordCode);
-	const rawCode = readNonNegativeInteger(readDiscordDeployObjectField(deployErr.rawBody, "code"));
+	const discordCode = parseStrictNonNegativeInteger(deployErr.discordCode);
+	const rawCode = parseStrictNonNegativeInteger(readDiscordDeployObjectField(deployErr.rawBody, "code"));
 	return (discordCode === 30034 || rawCode === 30034) && /daily application command creates/i.test(formatErrorMessage$1(err));
 }
 //#endregion
@@ -8011,430 +8115,98 @@ async function deployDiscordCommands(params) {
 function runDiscordCommandDeployInBackground(params) {
 	if (!params.enabled) return;
 	logDiscordStartupPhase$1({
-		runtime: params.runtime,
-		accountId: params.accountId,
-		phase: "deploy-commands:scheduled",
-		startAt: params.startupStartedAt,
-		details: "mode=reconcile background=true",
-		isVerbose: params.isVerbose
-	});
-	deployDiscordCommands(params).then(() => {
-		logDiscordStartupPhase$1({
-			runtime: params.runtime,
-			accountId: params.accountId,
-			phase: "deploy-commands:done",
-			startAt: params.startupStartedAt,
-			details: "background=true",
-			isVerbose: params.isVerbose
-		});
-	}).catch((err) => {
-		params.runtime.log?.(warn(`[${params.accountId}] slash command deploy failed in background (message send/receive unaffected): ${formatErrorMessage$1(err)}`));
-	});
-}
-//#endregion
-//#region extensions/discord/src/monitor/agent-components-reply.ts
-async function replySilently(interaction, params) {
-	try {
-		await interaction.reply(params);
-	} catch {}
-}
-//#endregion
-//#region extensions/discord/src/activities/interaction.ts
-const REGISTRATION_WIDGET_ID = "AAAAAAAAAAAAAAAAAAAAAA";
-const PENDING_LAUNCH_WRITE_BUDGET_MS = 250;
-var DiscordActivityButton = class extends Button {
-	constructor(ctx, deps) {
-		super();
-		this.ctx = ctx;
-		this.deps = deps;
-		this.label = "Open widget";
-		this.customId = buildDiscordActivityCustomId(REGISTRATION_WIDGET_ID);
-		this.customIdParser = parseDiscordActivityCustomIdForInteraction;
-		this.pendingLaunchFailureLogged = false;
-	}
-	logPendingLaunchFailure(error) {
-		if (this.pendingLaunchFailureLogged) return;
-		this.pendingLaunchFailureLogged = true;
-		this.deps.logError(`discord activity: failed to record pending launch: ${String(error)}`);
-	}
-	async run(interaction, data) {
-		if (typeof data.widgetId !== "string") {
-			await this.deps.reply(interaction, {
-				content: "This widget is no longer valid.",
-				ephemeral: true
-			});
-			return;
-		}
-		const runtime = getDiscordActivitiesRuntime();
-		const channelId = interaction.rawData.channel_id;
-		const discordUserId = interaction.userId;
-		if (!runtime || !channelId || !discordUserId) this.logPendingLaunchFailure(/* @__PURE__ */ new Error("missing activity runtime or interaction identity"));
-		else {
-			const write = runtime.store.recordPendingLaunch({
-				accountId: this.ctx.accountId,
-				channelId,
-				discordUserId,
-				widgetId: data.widgetId,
-				createdAt: Date.now()
-			}).then(() => "written").catch((error) => {
-				this.logPendingLaunchFailure(error);
-				return "failed";
-			});
-			let timer;
-			const timeout = new Promise((resolve) => {
-				timer = setTimeout(() => resolve("timeout"), PENDING_LAUNCH_WRITE_BUDGET_MS);
-				timer.unref?.();
-			});
-			try {
-				if (await Promise.race([write, timeout]) === "timeout") this.logPendingLaunchFailure(/* @__PURE__ */ new Error(`pending launch write exceeded ${PENDING_LAUNCH_WRITE_BUDGET_MS}ms`));
-			} finally {
-				if (timer) clearTimeout(timer);
-			}
-		}
-		await interaction.launchActivity();
-	}
-};
-function createDiscordActivityButton(ctx, applicationId, deps = {}) {
-	const runtime = getDiscordActivitiesRuntime();
-	if (!runtime || !runtime.isAccountEnabled(ctx.accountId, ctx.cfg)) return null;
-	if (applicationId) runtime.registerApplicationId(ctx.accountId, applicationId);
-	if (!runtime.resolveAccount(ctx.accountId, ctx.cfg)) return null;
-	return new DiscordActivityButton(ctx, {
-		reply: deps.reply ?? replySilently,
-		logError: deps.logError ?? logError
-	});
-}
-//#endregion
-//#region extensions/discord/src/voice/access.ts
-async function authorizeDiscordVoiceIngress(params) {
-	const groupPolicy = params.groupPolicy ?? resolveOpenProviderRuntimeGroupPolicy({
-		providerConfigPresent: params.cfg.channels?.discord !== void 0,
-		groupPolicy: params.discordConfig.groupPolicy,
-		defaultGroupPolicy: params.cfg.channels?.defaults?.groupPolicy
-	}).groupPolicy;
-	const guildInfo = resolveDiscordGuildEntry({
-		guild: params.guild ?? {
-			id: params.guildId,
-			...params.guildName ? { name: params.guildName } : {}
-		},
-		guildId: params.guildId,
-		guildEntries: params.discordConfig.guilds
-	});
-	const channelConfig = params.channelId ? resolveDiscordChannelConfigWithFallback({
-		guildInfo,
-		channelId: params.channelId,
-		channelName: params.channelName,
-		channelSlug: params.channelSlug,
-		parentId: params.parentId,
-		parentName: params.parentName,
-		parentSlug: params.parentSlug,
-		scope: params.scope
-	}) : null;
-	if (channelConfig?.enabled === false) return {
-		ok: false,
-		message: "This channel is disabled."
-	};
-	const channelAllowlistConfigured = Boolean(guildInfo?.channels) && Object.keys(guildInfo?.channels ?? {}).length > 0;
-	if (!params.channelId && groupPolicy === "allowlist" && channelAllowlistConfigured) return {
-		ok: false,
-		message: `${params.channelLabel ?? "This channel"} is not allowlisted for voice commands.`
-	};
-	const channelAllowed = channelConfig ? channelConfig.allowed : !channelAllowlistConfigured;
-	if (!isDiscordGroupAllowedByPolicy({
-		groupPolicy,
-		guildAllowlisted: Boolean(guildInfo),
-		channelAllowlistConfigured,
-		channelAllowed
-	}) || channelConfig?.allowed === false) return {
-		ok: false,
-		message: `${params.channelLabel ?? "This channel"} is not allowlisted for voice commands.`
-	};
-	const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
-		channelConfig,
-		guildInfo,
-		memberRoleIds: params.memberRoleIds,
-		sender: params.sender,
-		allowNameMatching: false
-	});
-	const admissionAllowList = normalizeDiscordAllowList(params.admissionAllowFrom ?? params.discordConfig.allowFrom ?? params.discordConfig.allowFrom, [
-		"discord:",
-		"user:",
-		"pk:"
-	]);
-	const admissionAllowed = admissionAllowList ? allowListMatches(admissionAllowList, params.sender, { allowNameMatching: false }) : false;
-	const useAccessGroups = params.useAccessGroups ?? true;
-	return resolveCommandAuthorizedFromAuthorizers({
-		useAccessGroups,
-		authorizers: useAccessGroups ? [{
-			configured: admissionAllowList != null,
-			allowed: admissionAllowed
-		}, {
-			configured: hasAccessRestrictions,
-			allowed: memberAllowed
-		}] : [{
-			configured: hasAccessRestrictions,
-			allowed: memberAllowed
-		}],
-		modeWhenAccessGroupsOff: "configured"
-	}) ? {
-		ok: true,
-		channelConfig
-	} : {
-		ok: false,
-		message: "You are not authorized to use this command."
-	};
-}
-//#endregion
-//#region extensions/discord/src/voice/owner-access.ts
-function resolveDiscordVoiceAccess(params) {
-	const commandOwnerAllowFrom = resolveDiscordCommandOwnerAllowFrom(params.cfg);
-	if (commandOwnerAllowFrom) return {
-		admissionAllowFrom: commandOwnerAllowFrom,
-		ownerAllowFrom: commandOwnerAllowFrom,
-		ownerAllowAll: commandOwnerAllowFrom.includes("*")
-	};
-	return {
-		admissionAllowFrom: resolveDiscordAccountAllowFrom({
-			cfg: params.cfg,
-			accountId: params.accountId
-		}) ?? params.discordConfig.allowFrom ?? params.discordConfig.allowFrom ?? [],
-		ownerAllowFrom: [],
-		ownerAllowAll: false
-	};
-}
-//#endregion
-//#region extensions/discord/src/voice/command.ts
-const VOICE_CHANNEL_TYPES = [ChannelType.GuildVoice, ChannelType.GuildStageVoice];
-async function authorizeVoiceCommand(interaction, params, options) {
-	const channelOverride = options?.channelOverride;
-	const channel = channelOverride ? void 0 : interaction.channel;
-	if (!interaction.guild) return {
-		ok: false,
-		message: "Voice commands are only available in guilds."
-	};
-	const user = interaction.user;
-	if (!user) return {
-		ok: false,
-		message: "Unable to resolve command user."
-	};
-	const channelId = channelOverride?.id ?? channel?.id ?? "";
-	const channelContext = await resolveDiscordThreadLikeChannelContext({
-		client: interaction.client,
-		channel: channelOverride ?? channel,
-		channelIdFallback: channelId
-	});
-	const channelName = channelOverride?.name ?? channelContext.channelName;
-	const memberRoleIds = Array.isArray(interaction.rawData.member?.roles) ? interaction.rawData.member.roles.map((roleId) => roleId) : [];
-	const sender = resolveDiscordSenderIdentity({
-		author: user,
-		member: interaction.rawData.member
-	});
-	const voiceAccess = resolveDiscordVoiceAccess(params);
-	const access = await authorizeDiscordVoiceIngress({
-		cfg: params.cfg,
-		discordConfig: params.discordConfig,
-		accountId: params.accountId,
-		groupPolicy: params.groupPolicy,
-		useAccessGroups: params.useAccessGroups,
-		guild: interaction.guild,
-		guildId: interaction.guild.id,
-		channelId,
-		channelName,
-		channelSlug: channelContext.channelSlug,
-		parentId: channelOverride?.parentId ?? channelContext.threadParentId,
-		parentName: channelContext.threadParentName,
-		parentSlug: channelContext.threadParentSlug,
-		scope: channelContext.isThreadChannel ? "thread" : "channel",
-		channelLabel: channelId ? formatMention({ channelId }) : "This channel",
-		memberRoleIds,
-		admissionAllowFrom: voiceAccess.admissionAllowFrom,
-		sender: {
-			id: sender.id,
-			name: sender.name,
-			tag: sender.tag
-		}
-	});
-	if (!access.ok) return {
-		ok: false,
-		message: access.message
-	};
-	return {
-		ok: true,
-		guildId: interaction.guild.id
-	};
-}
-async function resolveVoiceCommandRuntimeContext(interaction, params) {
-	const guildId = interaction.guild?.id;
-	if (!guildId) {
-		await interaction.reply({
-			content: "Unable to resolve guild for this command.",
-			ephemeral: true
-		});
-		return null;
-	}
-	const manager = params.getManager();
-	if (!manager) {
-		await interaction.reply({
-			content: "Voice manager is not available yet.",
-			ephemeral: true
-		});
-		return null;
-	}
-	return {
-		guildId,
-		manager
-	};
-}
-async function ensureVoiceCommandAccess(params) {
-	const access = await authorizeVoiceCommand(params.interaction, params.context, { channelOverride: params.channelOverride });
-	if (access.ok) return true;
-	await params.interaction.reply({
-		content: access.message ?? "Not authorized.",
-		ephemeral: true
-	});
-	return false;
-}
-function createDiscordVoiceCommand(params) {
-	const resolveSessionChannelId = (manager, guildId) => manager.status().find((entry) => entry.guildId === guildId)?.channelId;
-	class JoinCommand extends Command {
-		constructor(..._args) {
-			super(..._args);
-			this.name = "join";
-			this.description = "Join a voice channel";
-			this.defer = true;
-			this.ephemeral = params.ephemeralDefault;
-			this.options = [{
-				name: "channel",
-				description: "Voice channel to join",
-				type: ApplicationCommandOptionType.Channel,
-				required: true,
-				channel_types: VOICE_CHANNEL_TYPES
-			}];
-		}
-		async run(interaction) {
-			const channel = await interaction.options.getChannel("channel", true);
-			if (!channel || !("id" in channel)) {
-				await interaction.reply({
-					content: "Voice channel not found.",
-					ephemeral: true
-				});
-				return;
-			}
-			const access = await authorizeVoiceCommand(interaction, params, { channelOverride: {
-				id: channel.id,
-				name: resolveDiscordChannelNameSafe(channel)
-			} });
-			if (!access.ok) {
-				await interaction.reply({
-					content: access.message ?? "Not authorized.",
-					ephemeral: true
-				});
-				return;
-			}
-			if (!isVoiceChannelType(channel.type)) {
-				await interaction.reply({
-					content: "That is not a voice channel.",
-					ephemeral: true
-				});
-				return;
-			}
-			const guildId = access.guildId ?? ("guildId" in channel ? channel.guildId : void 0);
-			if (!guildId) {
-				await interaction.reply({
-					content: "Unable to resolve guild for this voice channel.",
-					ephemeral: true
-				});
-				return;
-			}
-			const manager = params.getManager();
-			if (!manager) {
-				await interaction.reply({
-					content: "Voice manager is not available yet.",
-					ephemeral: true
-				});
-				return;
-			}
-			const result = await manager.join({
-				guildId,
-				channelId: channel.id
-			});
-			await interaction.reply({
-				content: result.message,
-				ephemeral: true
-			});
-		}
+		runtime: params.runtime,
+		accountId: params.accountId,
+		phase: "deploy-commands:scheduled",
+		startAt: params.startupStartedAt,
+		details: "mode=reconcile background=true",
+		isVerbose: params.isVerbose
+	});
+	deployDiscordCommands(params).then(() => {
+		logDiscordStartupPhase$1({
+			runtime: params.runtime,
+			accountId: params.accountId,
+			phase: "deploy-commands:done",
+			startAt: params.startupStartedAt,
+			details: "background=true",
+			isVerbose: params.isVerbose
+		});
+	}).catch((err) => {
+		params.runtime.log?.(warn(`[${params.accountId}] slash command deploy failed in background (message send/receive unaffected): ${formatErrorMessage$1(err)}`));
+	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/agent-components-reply.ts
+async function replySilently(interaction, params) {
+	try {
+		await interaction.reply(params);
+	} catch {}
+}
+//#endregion
+//#region extensions/discord/src/activities/interaction.ts
+const REGISTRATION_WIDGET_ID = "AAAAAAAAAAAAAAAAAAAAAA";
+const PENDING_LAUNCH_WRITE_BUDGET_MS = 250;
+var DiscordActivityButton = class extends Button {
+	constructor(ctx, deps) {
+		super();
+		this.ctx = ctx;
+		this.deps = deps;
+		this.label = "Open widget";
+		this.customId = buildDiscordActivityCustomId(REGISTRATION_WIDGET_ID);
+		this.customIdParser = parseDiscordActivityCustomIdForInteraction;
+		this.pendingLaunchFailureLogged = false;
 	}
-	class LeaveCommand extends Command {
-		constructor(..._args2) {
-			super(..._args2);
-			this.name = "leave";
-			this.description = "Leave the current voice channel";
-			this.defer = true;
-			this.ephemeral = params.ephemeralDefault;
-		}
-		async run(interaction) {
-			const runtimeContext = await resolveVoiceCommandRuntimeContext(interaction, params);
-			if (!runtimeContext) return;
-			const sessionChannelId = resolveSessionChannelId(runtimeContext.manager, runtimeContext.guildId);
-			if (!await ensureVoiceCommandAccess({
-				interaction,
-				context: params,
-				channelOverride: sessionChannelId ? { id: sessionChannelId } : void 0
-			})) return;
-			const result = await runtimeContext.manager.leave({ guildId: runtimeContext.guildId });
-			await interaction.reply({
-				content: result.message,
+	logPendingLaunchFailure(error) {
+		if (this.pendingLaunchFailureLogged) return;
+		this.pendingLaunchFailureLogged = true;
+		this.deps.logError(`discord activity: failed to record pending launch: ${String(error)}`);
+	}
+	async run(interaction, data) {
+		if (typeof data.widgetId !== "string") {
+			await this.deps.reply(interaction, {
+				content: "This widget is no longer valid.",
 				ephemeral: true
 			});
+			return;
 		}
-	}
-	class StatusCommand extends Command {
-		constructor(..._args3) {
-			super(..._args3);
-			this.name = "status";
-			this.description = "Show active voice sessions";
-			this.defer = true;
-			this.ephemeral = params.ephemeralDefault;
-		}
-		async run(interaction) {
-			const runtimeContext = await resolveVoiceCommandRuntimeContext(interaction, params);
-			if (!runtimeContext) return;
-			const sessions = runtimeContext.manager.status().filter((entry) => entry.guildId === runtimeContext.guildId);
-			const sessionChannelId = sessions[0]?.channelId;
-			if (!await ensureVoiceCommandAccess({
-				interaction,
-				context: params,
-				channelOverride: sessionChannelId ? { id: sessionChannelId } : void 0
-			})) return;
-			if (sessions.length === 0) {
-				await interaction.reply({
-					content: "No active voice sessions.",
-					ephemeral: true
-				});
-				return;
-			}
-			const lines = sessions.map((entry) => `• ${formatMention({ channelId: entry.channelId })} (guild ${entry.guildId})`);
-			await interaction.reply({
-				content: lines.join("\n"),
-				ephemeral: true
+		const runtime = getDiscordActivitiesRuntime();
+		const channelId = interaction.rawData.channel_id;
+		const discordUserId = interaction.userId;
+		if (!runtime || !channelId || !discordUserId) this.logPendingLaunchFailure(/* @__PURE__ */ new Error("missing activity runtime or interaction identity"));
+		else {
+			const write = runtime.store.recordPendingLaunch({
+				accountId: this.ctx.accountId,
+				channelId,
+				discordUserId,
+				widgetId: data.widgetId,
+				createdAt: Date.now()
+			}).then(() => "written").catch((error) => {
+				this.logPendingLaunchFailure(error);
+				return "failed";
+			});
+			let timer;
+			const timeout = new Promise((resolve) => {
+				timer = setTimeout(() => resolve("timeout"), PENDING_LAUNCH_WRITE_BUDGET_MS);
+				timer.unref?.();
 			});
+			try {
+				if (await Promise.race([write, timeout]) === "timeout") this.logPendingLaunchFailure(/* @__PURE__ */ new Error(`pending launch write exceeded ${PENDING_LAUNCH_WRITE_BUDGET_MS}ms`));
+			} finally {
+				if (timer) clearTimeout(timer);
+			}
 		}
+		await interaction.launchActivity();
 	}
-	return new class extends CommandWithSubcommands {
-		constructor(..._args4) {
-			super(..._args4);
-			this.name = "vc";
-			this.description = "Voice channel controls";
-			this.subcommands = [
-				new JoinCommand(),
-				new LeaveCommand(),
-				new StatusCommand()
-			];
-		}
-	}();
-}
-function isVoiceChannelType(type) {
-	return type === ChannelType.GuildVoice || type === ChannelType.GuildStageVoice;
+};
+function createDiscordActivityButton(ctx, applicationId, deps = {}) {
+	const runtime = getDiscordActivitiesRuntime();
+	if (!runtime || !runtime.isAccountEnabled(ctx.accountId, ctx.cfg)) return null;
+	if (applicationId) runtime.registerApplicationId(ctx.accountId, applicationId);
+	if (!runtime.resolveAccount(ctx.accountId, ctx.cfg)) return null;
+	return new DiscordActivityButton(ctx, {
+		reply: deps.reply ?? replySilently,
+		logError: deps.logError ?? logError
+	});
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components-context.ts
@@ -8472,6 +8244,14 @@ async function ackComponentInteraction(params) {
 		logError(`${params.label}: failed to acknowledge interaction: ${String(err)}`);
 	}
 }
+async function replyUnavailableComponentInteraction(interaction, content) {
+	try {
+		await interaction.reply({
+			content,
+			ephemeral: true
+		});
+	} catch {}
+}
 function resolveDiscordChannelContext(interaction) {
 	const channel = interaction.channel;
 	const channelInfo = resolveDiscordChannelInfoSafe(channel);
@@ -8967,12 +8747,6 @@ function formatModalSubmissionText(entry, interaction) {
 	if (lines.length === 1) lines.push("- (no values)");
 	return lines.join("\n");
 }
-function resolveDiscordInteractionId(interaction) {
-	const rawId = interaction.rawData && typeof interaction.rawData === "object" && "id" in interaction.rawData ? interaction.rawData.id : void 0;
-	if (typeof rawId === "string" && rawId.trim()) return rawId.trim();
-	if (typeof rawId === "number" && Number.isFinite(rawId)) return String(rawId);
-	return `discord-interaction:${Date.now()}`;
-}
 //#endregion
 //#region extensions/discord/src/monitor/agent-components-helpers.ts
 const AGENT_BUTTON_KEY = "agent";
@@ -9046,7 +8820,7 @@ function stripDiscordInternalChannelLines(text) {
 	return kept.join("\n");
 }
 function sanitizeDiscordFrontChannelText(text) {
-	return collapseExcessBlankLines(stripDiscordInternalChannelLines(stripPlainTextToolCallBlocks(sanitizeAssistantVisibleText(stripPlainTextToolCallBlocks(text))))).trim();
+	return collapseExcessBlankLines(stripDiscordInternalChannelLines(stripPlainTextToolCallBlocks(sanitizeAssistantVisibleText(stripPlainTextToolCallBlocks(text, { resolveProtectedRanges: findCodeRegions })), { resolveProtectedRanges: findCodeRegions }))).trim();
 }
 function sanitizeDiscordFrontChannelReplyPayloads(payloads, options = {}) {
 	const preserveVerboseToolProgress = options.kind === "tool";
@@ -9143,7 +8917,7 @@ function formatDiscordReasoningPayload(payload) {
 async function deliverDiscordReply(params) {
 	params.runtime;
 	const delivery = resolveDiscordDeliveryOptions(params);
-	const payloads = sanitizeDiscordFrontChannelReplyPayloads(params.replies, { kind: params.kind }).map(formatDiscordReasoningPayload);
+	const payloads = sanitizeDiscordFrontChannelReplyPayloads(params.replies, { kind: params.kind }).map(formatDiscordReasoningPayload).map((payload) => params.bindPendingFinalDelivery?.(payload) ?? payload);
 	if (payloads.length === 0) return {
 		visibleReplySent: false,
 		suppression: { reason: "no_visible_result" }
@@ -9173,7 +8947,7 @@ async function deliverDiscordReply(params) {
 			requesterAccountId: params.accountId
 		})
 	});
-	if (send.status === "failed" || send.status === "partial_failed") throw send.error;
+	if (send.status === "failed") throw send.error;
 	if (send.status === "suppressed") {
 		const hookEffect = send.payloadOutcomes?.find((outcome) => outcome.status === "suppressed")?.hookEffect;
 		return {
@@ -9185,17 +8959,19 @@ async function deliverDiscordReply(params) {
 			}
 		};
 	}
-	const results = send.results;
-	if (results.length === 0) throw new Error(`discord final reply produced no delivered message for ${delivery.to}`);
-	return {
-		messageIds: results.flatMap((result) => result.messageId ? [result.messageId] : []),
+	if (send.results.length === 0) throw new Error(`discord final reply produced no delivered message for ${delivery.to}`);
+	const deliveryResult = {
+		messageIds: listMessageReceiptPlatformIds(send.receipt),
+		receipt: send.receipt,
 		visibleReplySent: true
 	};
+	if (send.status === "partial_failed") throw createChannelPartialDeliveryError(send.error, deliveryResult);
+	return deliveryResult;
 }
 //#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--Mzo2kM7.js").then((n) => n.n));
+const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing-CS-nNVoe.js").then((n) => n.n));
 function buildDiscordComponentConversationLabel(params) {
 	if (params.interactionCtx.isDirectMessage) return buildDirectLabel(params.interactionCtx.user);
 	if (params.interactionCtx.isGroupDm) return `Group DM #${params.channelCtx.channelName ?? params.interactionCtx.channelId} channel id:${params.interactionCtx.channelId}`;
@@ -9425,7 +9201,8 @@ async function dispatchDiscordComponentEvent(params) {
 							tableMode,
 							chunkMode: resolveChunkMode(ctx.cfg, "discord", accountId),
 							mediaLocalRoots,
-							kind: info.kind
+							kind: info.kind,
+							bindPendingFinalDelivery: info.bindPendingFinalDelivery
 						});
 						if (result.visibleReplySent) replyReference.markSent();
 						return result;
@@ -9455,33 +9232,14 @@ async function dispatchDiscordComponentEvent(params) {
 }
 //#endregion
 //#region extensions/discord/src/interactive-dispatch.ts
+const dispatchDiscordInteractive = createChannelInteractiveDispatcher({
+	channel: "discord",
+	interactiveKey: "interaction"
+});
 async function dispatchDiscordPluginInteractiveHandler(params) {
-	return await dispatchPluginInteractiveHandler({
-		channel: "discord",
-		data: params.data,
-		dedupeId: params.interactionId,
-		onMatched: params.onMatched,
-		invoke: ({ registration, namespace, payload }) => registration.handler({
-			...params.ctx,
-			channel: "discord",
-			interaction: {
-				...params.ctx.interaction,
-				data: params.data,
-				namespace,
-				payload
-			},
-			respond: params.respond,
-			...createInteractiveConversationBindingHelpers({
-				registration,
-				senderId: params.ctx.senderId,
-				conversation: {
-					channel: "discord",
-					accountId: params.ctx.accountId,
-					conversationId: params.ctx.conversationId,
-					parentConversationId: params.ctx.parentConversationId
-				}
-			})
-		})
+	return await dispatchDiscordInteractive({
+		...params,
+		dedupeId: params.interactionId
 	});
 }
 //#endregion
@@ -9512,10 +9270,11 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 		},
 		reply: async ({ text, ephemeral = true }) => {
 			responded = true;
-			await params.interaction.reply({
+			const payload = {
 				content: text,
 				ephemeral
-			});
+			};
+			await (acknowledged ? params.interaction.followUp(payload) : params.interaction.reply(payload));
 		},
 		followUp: async ({ text, ephemeral = true }) => {
 			responded = true;
@@ -9573,10 +9332,10 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 	}
 	const dispatched = await dispatchDiscordPluginInteractiveHandler({
 		data: params.data,
-		interactionId: resolveDiscordInteractionId(params.interaction),
+		interactionId: params.interaction.id,
 		ctx: {
 			accountId: params.ctx.accountId,
-			interactionId: resolveDiscordInteractionId(params.interaction),
+			interactionId: params.interaction.id,
 			conversationId: normalizedConversationId,
 			parentConversationId: params.channelCtx.parentId,
 			guildId: params.interactionCtx.rawGuildId,
@@ -9608,17 +9367,12 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.handlers.ts
-const loadComponentsRuntime = createLazyRuntimeModule(() => import("./outbound-session-route-H-HoyH5U.js").then((n) => n.n));
+const loadComponentsRuntime = createLazyRuntimeModule(() => import("./outbound-session-route-DxLkrgKQ.js").then((n) => n.n));
 async function handleDiscordComponentEvent(params) {
 	const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
 	if (!parsed) {
 		logError(`${params.label}: failed to parse component data`);
-		try {
-			await params.interaction.reply({
-				content: "This component is no longer valid.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This component is no longer valid.");
 		return;
 	}
 	const entry = await resolveDiscordComponentEntryWithPersistence({
@@ -9626,12 +9380,7 @@ async function handleDiscordComponentEvent(params) {
 		consume: false
 	});
 	if (!entry) {
-		try {
-			await params.interaction.reply({
-				content: "This component has expired.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This component has expired.");
 		return;
 	}
 	const unauthorizedReply = `You are not authorized to use this ${params.componentLabel}.`;
@@ -9659,21 +9408,11 @@ async function handleDiscordComponentEvent(params) {
 		consume: !entry.reusable
 	});
 	if (!consumed) {
-		try {
-			await params.interaction.reply({
-				content: "This component has expired.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This component has expired.");
 		return;
 	}
 	if (consumed.kind === "modal-trigger") {
-		try {
-			await params.interaction.reply({
-				content: "This form is no longer available.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This form is no longer available.");
 		return;
 	}
 	const values = params.values ? mapSelectValues(consumed, params.values) : void 0;
@@ -9726,12 +9465,7 @@ async function handleDiscordModalTrigger(params) {
 	const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
 	if (!parsed) {
 		logError(`${params.label}: failed to parse modal trigger data`);
-		try {
-			await params.interaction.reply({
-				content: "This button is no longer valid.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This button is no longer valid.");
 		return;
 	}
 	const entry = await resolveDiscordComponentEntryWithPersistence({
@@ -9739,22 +9473,12 @@ async function handleDiscordModalTrigger(params) {
 		consume: false
 	});
 	if (!entry || entry.kind !== "modal-trigger") {
-		try {
-			await params.interaction.reply({
-				content: "This button has expired.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This button has expired.");
 		return;
 	}
 	const modalId = entry.modalId ?? parsed.modalId;
 	if (!modalId) {
-		try {
-			await params.interaction.reply({
-				content: "This form is no longer available.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This form is no longer available.");
 		return;
 	}
 	const unauthorizedReply = "You are not authorized to use this form.";
@@ -9782,12 +9506,7 @@ async function handleDiscordModalTrigger(params) {
 		consume: !entry.reusable
 	});
 	if (!consumed) {
-		try {
-			await params.interaction.reply({
-				content: "This form has expired.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This form has expired.");
 		return;
 	}
 	const modalEntry = await resolveDiscordModalEntryWithPersistence({
@@ -9795,18 +9514,14 @@ async function handleDiscordModalTrigger(params) {
 		consume: false
 	});
 	if (!modalEntry) {
-		try {
-			await params.interaction.reply({
-				content: "This form has expired.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This form has expired.");
 		return;
 	}
 	try {
 		await params.interaction.showModal((await loadComponentsRuntime()).createDiscordFormModal(modalEntry));
 	} catch (err) {
 		logError(`${params.label}: failed to show modal: ${String(err)}`);
+		await replyUnavailableComponentInteraction(params.interaction, "Could not open this form. Request a new form and try again.");
 	}
 }
 const discordComponentControlHandlers = {
@@ -9828,12 +9543,7 @@ var DiscordComponentModal = class extends Modal {
 		const modalId = parseDiscordModalId(data, resolveInteractionCustomId(interaction));
 		if (!modalId) {
 			logError("discord component modal: missing modal id");
-			try {
-				await interaction.reply({
-					content: "This form is no longer valid.",
-					ephemeral: true
-				});
-			} catch {}
+			await replyUnavailableComponentInteraction(interaction, "This form is no longer valid.");
 			return;
 		}
 		const modalEntry = await resolveDiscordModalEntryWithPersistence({
@@ -9841,12 +9551,7 @@ var DiscordComponentModal = class extends Modal {
 			consume: false
 		});
 		if (!modalEntry) {
-			try {
-				await interaction.reply({
-					content: "This form has expired.",
-					ephemeral: true
-				});
-			} catch {}
+			await replyUnavailableComponentInteraction(interaction, "This form has expired.");
 			return;
 		}
 		const unauthorizedReply = "You are not authorized to use this form.";
@@ -9879,12 +9584,7 @@ var DiscordComponentModal = class extends Modal {
 			consume: !modalEntry.reusable
 		});
 		if (!consumed) {
-			try {
-				await interaction.reply({
-					content: "This form has expired.",
-					ephemeral: true
-				});
-			} catch {}
+			await replyUnavailableComponentInteraction(interaction, "This form has expired.");
 			return;
 		}
 		if (consumed.callbackData) {
@@ -9933,12 +9633,7 @@ async function runAgentSystemControlInteraction(params) {
 	const parsed = parseAgentComponentData(params.data);
 	if (!parsed) {
 		logError(`${params.label}: failed to parse component data`);
-		try {
-			await params.interaction.reply({
-				content: params.invalidReply,
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, params.invalidReply);
 		return;
 	}
 	const { componentId } = parsed;
@@ -9979,10 +9674,7 @@ async function runAgentSystemControlInteraction(params) {
 		userId
 	});
 	logDebug(`${params.label}: enqueuing event for channel ${channelId}: ${eventText}`);
-	enqueueSystemEvent$1(eventText, {
-		sessionKey: route.sessionKey,
-		contextKey: `${params.contextKeyPrefix}:${channelId}:${componentId}:${userId}`
-	});
+	enqueueRoutedSystemEvent$1(eventText, route, { contextKey: `${params.contextKeyPrefix}:${channelId}:${componentId}:${userId}:${params.interaction.id}` });
 	await ackComponentInteraction({
 		interaction: params.interaction,
 		replyOpts,
@@ -10237,7 +9929,7 @@ var ExecApprovalButton = class extends Button {
 		try {
 			await interaction.acknowledge();
 		} catch {}
-		const result = await this.ctx.resolveApproval(parsed.approvalId, parsed.approvalKind, parsed.action);
+		const result = await this.ctx.resolveApproval(parsed.approvalId, parsed.approvalKind, parsed.action, userId);
 		if (!result.ok) {
 			try {
 				await interaction.followUp({
@@ -10274,7 +9966,7 @@ function createDiscordExecApprovalButtonContext(params) {
 			accountId: params.accountId,
 			configOverride: params.config
 		}),
-		resolveApproval: async (approvalId, approvalKind, decision) => {
+		resolveApproval: async (approvalId, approvalKind, decision, senderId) => {
 			try {
 				return {
 					ok: true,
@@ -10283,8 +9975,10 @@ function createDiscordExecApprovalButtonContext(params) {
 						approvalId,
 						approvalKind,
 						decision,
-						gatewayUrl: params.gatewayUrl,
-						clientDisplayName: `Discord approval (${params.accountId})`
+						channel: "discord",
+						accountId: params.accountId,
+						senderId,
+						gatewayUrl: params.gatewayUrl
 					})
 				};
 			} catch (err) {
@@ -10368,24 +10062,26 @@ function createDiscordQuestionButton(params) {
 //#region extensions/discord/src/monitor/provider.interactions.ts
 function createDiscordProviderInteractionSurface(params) {
 	const createNativeCommand = params.createNativeCommand ?? createDiscordNativeCommand;
-	const commands = params.commandSpecs.map((spec) => createNativeCommand({
-		command: spec,
-		cfg: params.cfg,
-		discordConfig: params.discordConfig,
-		accountId: params.accountId,
-		sessionPrefix: params.sessionPrefix,
-		ephemeralDefault: params.ephemeralDefault,
-		threadBindings: params.threadBindings
-	}));
-	if (params.nativeEnabled && params.voiceEnabled) commands.push(createDiscordVoiceCommand({
-		cfg: params.cfg,
-		discordConfig: params.discordConfig,
-		accountId: params.accountId,
-		groupPolicy: params.groupPolicy,
-		useAccessGroups: params.useAccessGroups,
-		getManager: () => params.voiceManagerRef.current,
-		ephemeralDefault: params.ephemeralDefault
-	}));
+	const commands = params.commandSpecs.map((spec) => {
+		if (params.nativeEnabled && params.voiceEnabled && spec.name === DISCORD_VOICE_COMMAND_SPEC.name) return createDiscordVoiceCommand({
+			cfg: params.cfg,
+			discordConfig: params.discordConfig,
+			accountId: params.accountId,
+			groupPolicy: params.groupPolicy,
+			useAccessGroups: params.useAccessGroups,
+			getManager: () => params.voiceManagerRef.current,
+			ephemeralDefault: params.ephemeralDefault
+		});
+		return createNativeCommand({
+			command: spec,
+			cfg: params.cfg,
+			discordConfig: params.discordConfig,
+			accountId: params.accountId,
+			sessionPrefix: params.sessionPrefix,
+			ephemeralDefault: params.ephemeralDefault,
+			threadBindings: params.threadBindings
+		});
+	});
 	const execApprovalsConfig = params.discordConfig.execApprovals ?? {};
 	const execApprovalsEnabled = isDiscordExecApprovalClientEnabled({
 		cfg: params.cfg,
@@ -10665,7 +10361,8 @@ 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.accountId, params.logger));
+	registerDiscordListener(params.client.listeners, new DiscordThreadUpdateListener(params.cfg, params.logger));
+	registerDiscordListener(params.client.listeners, new DiscordThreadDeleteListener(params.cfg, params.accountId, params.logger));
 	if (params.discordConfig.intents?.presence) {
 		const presenceListener = new DiscordPresenceListener({
 			cfg: params.cfg,
@@ -10866,8 +10563,31 @@ async function monitorDiscordProvider(opts = {}) {
 		phase: "fetch-application-id:start",
 		startAt: startupStartedAt
 	});
-	const applicationId = (typeof discordCfg.applicationId === "string" && discordCfg.applicationId.trim() ? discordCfg.applicationId.trim() : void 0) ?? parseApplicationIdFromToken(token) ?? await discordProviderRuntime.fetchDiscordApplicationId(token, 4e3, discordRestFetch);
-	if (!applicationId) throw new Error("Failed to resolve Discord application id");
+	const parsedApplicationId = (typeof discordCfg.applicationId === "string" && discordCfg.applicationId.trim() ? discordCfg.applicationId.trim() : void 0) ?? parseApplicationIdFromToken(token);
+	const applicationIdProbe = parsedApplicationId ? {
+		kind: "resolved",
+		applicationId: parsedApplicationId
+	} : await discordProviderRuntime.probeDiscordApplicationId(token, 4e3, discordRestFetch);
+	if (applicationIdProbe.kind !== "resolved") {
+		const at = Date.now();
+		const terminal = applicationIdProbe.kind === "rejected";
+		const probeError = formatErrorMessage$1(applicationIdProbe.error);
+		const message = `Failed to resolve Discord application id: ${probeError}`;
+		opts.setStatus?.({
+			connected: false,
+			lifecycle: terminal ? "blocked" : "recovering",
+			terminalDisconnect: terminal ? true : void 0,
+			lastEventAt: at,
+			lastDisconnect: {
+				at,
+				...applicationIdProbe.status !== null ? { status: applicationIdProbe.status } : {},
+				error: probeError
+			},
+			lastError: message
+		});
+		throw new Error(message, { cause: applicationIdProbe.error });
+	}
+	const applicationId = applicationIdProbe.applicationId;
 	logDiscordStartupPhase({
 		runtime,
 		accountId: account.accountId,
@@ -10880,9 +10600,9 @@ async function monitorDiscordProvider(opts = {}) {
 		runtime,
 		nativeEnabled,
 		nativeSkillsEnabled,
+		voiceEnabled,
 		listSkillCommandsForAgents: discordProviderRuntime.listSkillCommandsForAgents,
-		listNativeCommandSpecsForConfig: discordProviderRuntime.listNativeCommandSpecsForConfig,
-		getPluginCommandSpecs: discordProviderRuntime.getPluginCommandSpecs
+		listNativeCommandSpecsForConfig: discordProviderRuntime.listNativeCommandSpecsForConfig
 	});
 	const voiceManagerRef = { current: null };
 	const threadBindings = threadBindingsEnabled ? discordProviderSessionRuntime.createThreadBindingManager({
@@ -11014,7 +10734,7 @@ async function monitorDiscordProvider(opts = {}) {
 				runtime,
 				botUserId
 			});
-			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-DIKGsTGT.js").then((n) => n.n);
+			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-CfFMexGt.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: account.accountId,
 				manager: voiceManager
@@ -11032,6 +10752,7 @@ async function monitorDiscordProvider(opts = {}) {
 			accountId: account.accountId,
 			token,
 			runtime,
+			buildContext: opts.channelRuntime?.inbound.buildContext,
 			setStatus: opts.setStatus,
 			abortSignal: opts.abortSignal,
 			botUserId,
@@ -11087,7 +10808,7 @@ async function monitorDiscordProvider(opts = {}) {
 			gatewayReady: lifecycleGateway?.isConnected === true,
 			botIdentity: botIdentity || void 0
 		}));
-		if (lifecycleGateway?.isConnected) opts.setStatus?.(createConnectedChannelStatusPatch());
+		if (lifecycleGateway?.isConnected) opts.setStatus?.(createDiscordReadyStatusPatch());
 		lifecycleStarted = true;
 		earlyGatewayEmitter?.removeListener("debug", onEarlyGatewayDebug);
 		onEarlyGatewayDebug = void 0;