@openclaw/discord 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{provider-PRlF_lZm.js → provider-CfiChtjf.js}

@@ -1,24 +1,23 @@
-import { C as ThreadUpdateListener, E as Plugin, F as CommandWithSubcommands, I as Guild, J as Container, K as Button, L as Message, P as Command, R as User, St as getChannelMessage, T as Client, U as Modal, Zt as __exportAll, _ as MessageCreateListener, b as PresenceUpdateListener, et as Row, g as InteractionCreateListener, gt as createThread, h as GuildDeleteListener, it as TextDisplay, k as RateLimitError, m as GuildCreateListener, nt as Separator, p as discord_exports, rt as StringSelectMenu, st as BaseMessageInteractiveComponent, t as chunkDiscordTextWithMode, v as MessageReactionAddListener, x as ReadyListener, y as MessageReactionRemoveListener, yt as editChannel } from "./chunk-CHpY_lsO.js";
-import { c as resolveDiscordAccountAllowFrom, d as resolveDiscordAccountDmPolicy, f as resolveDiscordMaxLinesPerMessage, p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-CMd4nzLB.js";
-import { n as getDiscordActivitiesRuntime } from "./runtime-CCf5nkV3.js";
-import { C as parseDiscordComponentCustomId, D as decodeCustomIdComponent, E as parseDiscordModalCustomIdForInteraction, O as encodeCustomIdComponent, S as parseDiscordActivityCustomIdForInteraction, T as parseDiscordModalCustomId, c as parseExecApprovalData, v as buildDiscordActivityCustomId, w as parseDiscordComponentCustomIdForInteraction } from "./outbound-session-route-D4QqePZN.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-B7qOH5xu.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-XuOTO1dW.js";
-import { _ as resolveDiscordModalEntryWithPersistence, g as resolveDiscordComponentEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-CCRW54gK.js";
+import { C as Client, D as RateLimitError, F as Message, I as User, K as Container, M as Command, N as CommandWithSubcommands, P as Guild, Q as Row, V as Modal, W as Button, Yt as __exportAll, _ as MessageReactionRemoveListener, _t as editChannel, at as BaseMessageInteractiveComponent, bt as getChannelMessage, d as discord_exports, et as Separator, f as GuildCreateListener, g as MessageReactionAddListener, h as MessageCreateListener, m as InteractionCreateListener, mt as createThread, nt as TextDisplay, p as GuildDeleteListener, t as chunkDiscordTextWithMode, tt as StringSelectMenu, v as PresenceUpdateListener, w as Plugin, x as ThreadUpdateListener, y as ReadyListener } from "./chunk-BrZocpfs.js";
+import { c as resolveDiscordAccountAllowFrom, d as resolveDiscordAccountDmPolicy, f as resolveDiscordMaxLinesPerMessage, p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-D2LKPukU.js";
+import { n as getDiscordActivitiesRuntime } from "./runtime-TwM8IrZU.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-D_nc_Ayk.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-Dfacnk-E.js";
+import { _ as resolveDiscordModalEntryWithPersistence, g as resolveDiscordComponentEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-V7cyCKbH.js";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
-import { a as isDiscordRateLimitResponseBody, o as summarizeDiscordResponseBody } from "./api-B88T4rFN.js";
-import { a as formatMention, t as sendMessageDiscord } from "./send.outbound-Cvulb-k_.js";
+import { a as isDiscordRateLimitResponseBody, o as summarizeDiscordResponseBody } from "./api-C43z8vUm.js";
+import { C as resolveTimestampMs, a as normalizeDiscordSlug, b as formatDiscordReactionEmoji, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordCommandOwnerAllowFrom, f as resolveDiscordGuildEntry, g as resolveDiscordOwnerAllowFrom, h as resolveDiscordOwnerAccess, i as normalizeDiscordDisplaySlug, l as resolveDiscordChannelPolicyCommandAuthorizer, m as resolveDiscordMemberAllowed, n as isDiscordGroupAllowedByPolicy, o as resolveDiscordAllowListMatch, p as resolveDiscordMemberAccessState, r as normalizeDiscordAllowList, t as allowListMatches, v as resolveGroupDmAllow, x as formatDiscordUserTag, y as shouldEmitDiscordReactionNotification } from "./allow-list-DzKrtfah.js";
+import { a as formatMention, t as sendMessageDiscord } from "./send.outbound-BbC2qjpH.js";
 import { i as setPresence, t as clearPresences } from "./presence-cache-z1N8MbJ3.js";
-import { s as sendVoiceMessageDiscord } from "./send-JJzVo_sK.js";
-import { d as withAbortTimeout, l as raceWithTimeout } from "./timeouts-D5lWili0.js";
-import { a as isDiscordExecApprovalClientEnabled, r as getDiscordExecApprovalApprovers, t as resolveDiscordConversationIdentity } from "./conversation-identity-BPcbhCAH.js";
-import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-BO9NUPlS.js";
-import { t as resolveDiscordUserAllowlist } from "./resolve-users-CU3oG5-m.js";
-import { _ as formatThreadBindingDurationLabel, a as isThreadArchived, d as resolveDiscordChannelNameSafe, f as resolveDiscordChannelParentIdSafe, l as resolveDiscordChannelIdSafe, m as resolveDiscordChannelTopicSafe, p as resolveDiscordChannelParentSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-DXfXsHGZ.js";
-import { r as parseApplicationIdFromToken, t as fetchDiscordApplicationId } from "./probe-WKeTYyJX.js";
-import { d as resolveDiscordMessageChannelId, n as resolveDiscordForwardedMessagesTextFromSnapshots, t as resolveDiscordEmbedText, u as resolveDiscordChannelInfo } from "./message-utils-BU3gc01v.js";
-import { t as resolveDiscordSenderIdentity } from "./sender-identity-C62lBe18.js";
-import { n as formatDiscordApprovalDisplayValue, t as DISCORD_APPROVAL_ALLOWED_MENTIONS } from "./approval-message-safety-C-8BL6Kv.js";
+import { n as sendVoiceMessageDiscord } from "./send-CfnXLUXq.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-LyND6GR3.js";
+import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-CmFAdMeQ.js";
+import { t as resolveDiscordUserAllowlist } from "./resolve-users-Cmu75lZy.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-C_tCQcv3.js";
+import { r as parseApplicationIdFromToken, t as fetchDiscordApplicationId } from "./probe-Bci2pS8M.js";
+import { a as formatDiscordMediaText, d as resolveDiscordChannelInfo, f as resolveDiscordMessageChannelId, n as resolveDiscordForwardedMessagesTextFromSnapshots, t as resolveDiscordEmbedText } from "./message-utils-ajbkdTVA.js";
+import { t as resolveDiscordSenderIdentity } from "./sender-identity-mG_zsdox.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";
@@ -33,11 +32,11 @@ import { Check, Errors } from "typebox/value";
 import { inspect } from "node:util";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-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";
 import { sliceUtf16Safe, truncateUtf16Safe, withTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
+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";
@@ -51,18 +50,19 @@ import { resolvePinnedMainDmOwnerFromAllowlist as resolvePinnedMainDmOwnerFromAl
 import { GROUP_POLICY_BLOCKED_LABEL, resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
-import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, canonicalizeAllowlistWithResolvedIds, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
+import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 import { buildPairingReply, upsertChannelPairingRequest, upsertChannelPairingRequest as upsertChannelPairingRequest$1 } from "openclaw/plugin-sdk/conversation-runtime";
-import { clearExpiredCooldowns, ensureAuthProfileStore, formatReasoningMessage, isProfileInCooldown, loadModelCatalog, resolveAgentAvatar, resolveDefaultModelForAgent, resolveHumanDelayConfig, resolveProfilesUnavailableReason } from "openclaw/plugin-sdk/agent-runtime";
+import { clearExpiredCooldowns, ensureAuthProfileStore, formatReasoningMessage, getPreparedModelCatalogSnapshot, isProfileInCooldown, 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 { createChannelIngressResolver, defineStableChannelIngressIdentity, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { formatInboundEnvelope, 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 { getSessionEntry, listSessionEntries, patchSessionEntry, readSessionUpdatedAt as readSessionUpdatedAt$1, resolveStorePath, resolveStorePath as resolveStorePath$1 } from "openclaw/plugin-sdk/session-store-runtime";
-import { formatInboundEnvelope, resolveEnvelopeFormatOptions, runChannelInboundEvent } from "openclaw/plugin-sdk/channel-inbound";
+import { deleteSessionEntry, getSessionEntry, listSessionEntries, patchSessionEntry, 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 { resolveDirectStatusReplyForSession } from "openclaw/plugin-sdk/command-status-runtime";
@@ -537,7 +537,10 @@ function resolveDiscordThreadStarterText(starter) {
 	const content = normalizeOptionalString(starter.content) ?? "";
 	const embedText = resolveDiscordEmbedText(starter.embeds?.[0]);
 	const forwardedText = resolveDiscordForwardedMessagesTextFromSnapshots(starter.message_snapshots);
-	return content || embedText || forwardedText;
+	return [content || embedText || forwardedText, formatDiscordMediaText({
+		attachments: starter.attachments ?? void 0,
+		stickers: starter.sticker_items ?? void 0
+	})].filter(Boolean).join("\n");
 }
 function resolveDiscordThreadStarterIdentity(starter) {
 	return {
@@ -1384,13 +1387,9 @@ var DiscordPresenceBaselineCache = class {
 //#endregion
 //#region extensions/discord/src/monitor/thread-session-close.ts
 /**
-* Marks every session entry in the store whose key contains {@link threadId}
-* as "reset" by setting `updatedAt` to 0.
-*
-* This mirrors how the daily / idle session reset works: zeroing `updatedAt`
-* makes `evaluateSessionFreshness` treat the session as stale on the next
-* inbound message, so the bot starts a fresh conversation without deleting
-* any on-disk transcript history.
+* Closes every session entry in the store whose key contains {@link threadId}.
+* The explicit lifecycle deletion archives the old transcript and guarantees
+* that a later inbound message starts a fresh session in every reset mode.
 */
 async function closeDiscordThreadSessions(params) {
 	const { cfg, accountId, threadId } = params;
@@ -1403,23 +1402,14 @@ async function closeDiscordThreadSessions(params) {
 	const storePath = resolveStorePath(cfg.session?.store, { agentId: accountId });
 	let resetCount = 0;
 	for (const { sessionKey, entry } of listSessionEntries({ storePath })) {
-		if (!sessionKeyContainsThreadId(sessionKey) || entry.updatedAt === 0) continue;
-		let resetEntry = false;
-		await patchSessionEntry({
-			storePath,
+		if (!sessionKeyContainsThreadId(sessionKey)) continue;
+		if (await deleteSessionEntry({
+			archiveTranscript: true,
+			expectedSessionId: entry.sessionId ?? null,
+			expectedUpdatedAt: entry.updatedAt,
 			sessionKey,
-			replaceEntry: true,
-			update: (current) => {
-				if (current.updatedAt === 0) return null;
-				if (current.updatedAt !== entry.updatedAt || current.sessionId !== entry.sessionId) return null;
-				resetEntry = true;
-				return {
-					...current,
-					updatedAt: 0
-				};
-			}
-		});
-		if (resetEntry) resetCount += 1;
+			storePath
+		})) resetCount += 1;
 	}
 	return resetCount;
 }
@@ -1439,9 +1429,11 @@ var DiscordMessageListener = class extends MessageCreateListener {
 	}
 	async handle(data, client) {
 		this.onEvent?.();
-		Promise.resolve().then(() => this.handler(data, client)).catch((err) => {
+		try {
+			await this.handler(data, client);
+		} catch (err) {
 			(this.logger ?? discordEventQueueLog).error(danger(`discord handler failed: ${String(err)}`));
-		});
+		}
 	}
 };
 var DiscordInteractionListener = class extends InteractionCreateListener {
@@ -1719,6 +1711,62 @@ var DiscordThreadUpdateListener = class extends ThreadUpdateListener {
 	}
 };
 //#endregion
+//#region extensions/discord/src/internal/gateway-dispatch.ts
+function dispatchVoiceGatewayEvent(client, type, data) {
+	const guildId = readGuildId(data);
+	if (!guildId) return;
+	const adapter = (client.getPlugin("voice")?.adapters)?.get(guildId);
+	const voiceServerUpdate = GatewayDispatchEvents.VoiceServerUpdate;
+	const voiceStateUpdate = GatewayDispatchEvents.VoiceStateUpdate;
+	if (type === voiceServerUpdate) adapter?.onVoiceServerUpdate?.(data);
+	if (type === voiceStateUpdate) adapter?.onVoiceStateUpdate?.(data);
+}
+function mapGatewayDispatchData(client, type, data) {
+	const messageCreate = GatewayDispatchEvents.MessageCreate;
+	const reactionAdd = GatewayDispatchEvents.MessageReactionAdd;
+	const reactionRemove = GatewayDispatchEvents.MessageReactionRemove;
+	if (type === messageCreate) return createMessageDispatchData(client, data);
+	if (type === reactionAdd || type === reactionRemove) return createReactionDispatchData(client, data);
+	return data;
+}
+function createMessageDispatchData(client, data) {
+	const message = new Message(client, data);
+	return {
+		...data,
+		id: data.id,
+		channel_id: data.channel_id,
+		channelId: data.channel_id,
+		message,
+		author: message.author ?? (data.author ? new User(client, data.author) : null),
+		member: data.member,
+		rawMember: data.member,
+		guild: data.guild_id ? new Guild(client, data.guild_id) : null
+	};
+}
+function createReactionDispatchData(client, data) {
+	const userRaw = data.member?.user && typeof data.member.user === "object" ? {
+		id: data.user_id,
+		username: "",
+		...data.member.user
+	} : {
+		id: data.user_id,
+		username: ""
+	};
+	return {
+		...data,
+		user: new User(client, userRaw),
+		rawMember: data.member,
+		guild: data.guild_id ? new Guild(client, data.guild_id) : null,
+		message: new Message(client, {
+			id: data.message_id,
+			channelId: data.channel_id
+		})
+	};
+}
+function readGuildId(data) {
+	return data && typeof data === "object" && typeof data.guild_id === "string" ? data.guild_id : void 0;
+}
+//#endregion
 //#region extensions/discord/src/monitor/dm-command-decision.ts
 async function handleDiscordDmCommandDecision(params) {
 	if (params.senderAccess.decision === "allow") return true;
@@ -2212,7 +2260,7 @@ async function resolveDiscordNativeAutocompleteAuthorized(params) {
 	});
 	const memberRoleIds = Array.isArray(interaction.rawData.member?.roles) ? interaction.rawData.member.roles.map((roleId) => roleId) : [];
 	const allowNameMatching = isDangerousNameMatchingEnabled(discordConfig);
-	const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+	const useAccessGroups = true;
 	const configuredDmAllowFrom = resolveDiscordAccountAllowFrom({
 		cfg,
 		accountId
@@ -2243,7 +2291,7 @@ async function resolveDiscordNativeAutocompleteAuthorized(params) {
 	});
 	if (channelConfig?.enabled === false) return false;
 	if (interaction.guild && channelConfig?.allowed === false) return false;
-	if (useAccessGroups && interaction.guild) {
+	if (interaction.guild) {
 		const { groupPolicy } = resolveOpenProviderRuntimeGroupPolicy({
 			providerConfigPresent: cfg.channels?.discord !== void 0,
 			groupPolicy: discordConfig?.groupPolicy,
@@ -2326,16 +2374,23 @@ function shouldBypassConfiguredAcpGuildGuards(commandName) {
 //#endregion
 //#region extensions/discord/src/monitor/inbound-context.ts
 function createDiscordSupplementalContextAccessChecker(params) {
+	const userAllowList = params.channelConfig?.users ?? params.guildInfo?.users ?? [];
+	const roleAllowList = params.channelConfig?.roles ?? params.guildInfo?.roles ?? [];
+	const allowFrom = [...userAllowList, ...roleAllowList];
 	return (sender) => {
-		if (!params.isGuild) return true;
-		return resolveDiscordMemberAllowed({
-			userAllowList: params.channelConfig?.users ?? params.guildInfo?.users,
-			roleAllowList: params.channelConfig?.roles ?? params.guildInfo?.roles,
-			memberRoleIds: sender.memberRoleIds ?? [],
-			userId: sender.id ?? "",
-			userName: sender.name,
-			userTag: sender.tag,
-			allowNameMatching: params.allowNameMatching
+		return resolveInboundSupplementalSenderAllowed({
+			isGroup: params.isGuild,
+			groupPolicy: allowFrom.length === 0 ? "open" : "allowlist",
+			allowFrom,
+			isSenderAllowed: () => resolveDiscordMemberAllowed({
+				userAllowList,
+				roleAllowList,
+				memberRoleIds: sender.memberRoleIds ?? [],
+				userId: sender.id ?? "",
+				userName: sender.name,
+				userTag: sender.tag,
+				allowNameMatching: params.allowNameMatching
+			})
 		});
 	};
 }
@@ -3936,6 +3991,7 @@ async function resolveDiscordNativeChoiceContext(params) {
 		return {
 			provider,
 			model,
+			agentId: route.agentId,
 			agentRuntime: resolveEffectiveAgentRuntime({
 				cfg: params.cfg,
 				provider,
@@ -4664,7 +4720,13 @@ function buildDiscordCommandOptions(params) {
 			const focusValue = normalizeLowercaseStringOrEmpty(interaction.options.getFocused()?.value);
 			const context = typeof arg.choices === "function" && resolveChoiceContext ? await resolveChoiceContext(interaction) : null;
 			const currentCfg = resolveConfig?.() ?? cfg;
-			const choiceCatalog = command.key === "think" ? await loadModelCatalog({ cacheOnly: true }) : void 0;
+			const choiceCatalog = command.key === "think" ? getPreparedModelCatalogSnapshot({
+				config: currentCfg,
+				...context?.agentId ? {
+					agentId: context.agentId,
+					agentDir: resolveAgentDir(currentCfg, context.agentId)
+				} : {}
+			})?.entries : void 0;
 			const choices = resolveCommandArgChoices({
 				command,
 				arg,
@@ -4679,7 +4741,6 @@ function buildDiscordCommandOptions(params) {
 				name: choice.label,
 				value: choice.value
 			})));
-			if (command.key === "think" && !choiceCatalog?.length) loadModelCatalog({ config: currentCfg });
 		} : void 0;
 		const choices = resolvedChoices.length > 0 && !autocomplete ? resolvedChoices.slice(0, 25).map((choice) => ({
 			name: choice.label,
@@ -4789,7 +4850,7 @@ async function dispatchDiscordCommandInteraction(params) {
 			await interaction.reply(payload);
 		});
 	};
-	const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+	const useAccessGroups = true;
 	const user = interaction.user;
 	if (!user) return { accepted: false };
 	const sender = resolveDiscordSenderIdentity({
@@ -4874,7 +4935,7 @@ async function dispatchDiscordCommandInteraction(params) {
 		await respond("This channel is not allowed.");
 		return { accepted: false };
 	}
-	if (useAccessGroups && interaction.guild) {
+	if (interaction.guild) {
 		const { groupPolicy } = resolveOpenProviderRuntimeGroupPolicy({
 			providerConfigPresent: cfg.channels?.discord !== void 0,
 			groupPolicy: discordConfig?.groupPolicy,
@@ -4983,8 +5044,12 @@ async function dispatchDiscordCommandInteraction(params) {
 		accountId,
 		threadBindings
 	}) : null;
-	const menuModelCatalog = command.key === "think" && menuNeedsModelContext ? await loadModelCatalog({
+	const menuModelCatalog = command.key === "think" && menuNeedsModelContext ? await loadPreparedModelCatalog({
 		config: cfg,
+		...menuModelContext?.agentId ? {
+			agentId: menuModelContext.agentId,
+			agentDir: resolveAgentDir(cfg, menuModelContext.agentId)
+		} : {},
 		readOnly: true
 	}) : void 0;
 	const menu = resolveCommandArgMenu({
@@ -5240,62 +5305,6 @@ function canResumeAfterGatewayClose(code) {
 	return !nonResumableGatewayCloseCodes.has(code);
 }
 //#endregion
-//#region extensions/discord/src/internal/gateway-dispatch.ts
-function dispatchVoiceGatewayEvent(client, type, data) {
-	const guildId = readGuildId(data);
-	if (!guildId) return;
-	const adapter = (client.getPlugin("voice")?.adapters)?.get(guildId);
-	const voiceServerUpdate = GatewayDispatchEvents.VoiceServerUpdate;
-	const voiceStateUpdate = GatewayDispatchEvents.VoiceStateUpdate;
-	if (type === voiceServerUpdate) adapter?.onVoiceServerUpdate?.(data);
-	if (type === voiceStateUpdate) adapter?.onVoiceStateUpdate?.(data);
-}
-function mapGatewayDispatchData(client, type, data) {
-	const messageCreate = GatewayDispatchEvents.MessageCreate;
-	const reactionAdd = GatewayDispatchEvents.MessageReactionAdd;
-	const reactionRemove = GatewayDispatchEvents.MessageReactionRemove;
-	if (type === messageCreate) return createMessageDispatchData(client, data);
-	if (type === reactionAdd || type === reactionRemove) return createReactionDispatchData(client, data);
-	return data;
-}
-function createMessageDispatchData(client, data) {
-	const message = new Message(client, data);
-	return {
-		...data,
-		id: data.id,
-		channel_id: data.channel_id,
-		channelId: data.channel_id,
-		message,
-		author: message.author ?? (data.author ? new User(client, data.author) : null),
-		member: data.member,
-		rawMember: data.member,
-		guild: data.guild_id ? new Guild(client, data.guild_id) : null
-	};
-}
-function createReactionDispatchData(client, data) {
-	const userRaw = data.member?.user && typeof data.member.user === "object" ? {
-		id: data.user_id,
-		username: "",
-		...data.member.user
-	} : {
-		id: data.user_id,
-		username: ""
-	};
-	return {
-		...data,
-		user: new User(client, userRaw),
-		rawMember: data.member,
-		guild: data.guild_id ? new Guild(client, data.guild_id) : null,
-		message: new Message(client, {
-			id: data.message_id,
-			channelId: data.channel_id
-		})
-	};
-}
-function readGuildId(data) {
-	return data && typeof data === "object" && typeof data.guild_id === "string" ? data.guild_id : void 0;
-}
-//#endregion
 //#region extensions/discord/src/internal/gateway-identify-limiter.ts
 const IDENTIFY_WINDOW_MS = 5e3;
 function normalizeMaxConcurrency(value) {
@@ -5399,19 +5408,38 @@ function decodeGatewayMessage(incoming) {
 //#region extensions/discord/src/internal/gateway-rate-limit.ts
 const GATEWAY_SEND_LIMIT = 120;
 const GATEWAY_SEND_WINDOW_MS = 6e4;
+const GATEWAY_SEND_QUEUE_LIMIT = GATEWAY_SEND_LIMIT;
 var GatewaySendLimiter = class {
-	constructor(sendNow, emitError) {
+	constructor(sendNow, emitError, emitOverflowWarning) {
 		this.sendNow = sendNow;
 		this.emitError = emitError;
+		this.emitOverflowWarning = emitOverflowWarning;
 		this.outboundSendTimestamps = [];
 		this.outboundQueue = [];
+		this.droppedEvents = 0;
+		this.overflowWarningEmitted = false;
 	}
 	send(serialized, options) {
 		if (options?.critical || this.canSend(Date.now())) {
 			this.sendSerialized(serialized);
 			return;
 		}
+		let shouldEmitOverflowWarning = false;
+		if (this.outboundQueue.length >= GATEWAY_SEND_QUEUE_LIMIT) {
+			this.outboundQueue.shift();
+			this.droppedEvents += 1;
+			if (!this.overflowWarningEmitted) {
+				this.overflowWarningEmitted = true;
+				shouldEmitOverflowWarning = true;
+			}
+		}
 		this.outboundQueue.push({ payload: serialized });
+		if (shouldEmitOverflowWarning) this.emitOverflowWarning({
+			droppedEvents: this.droppedEvents,
+			maxQueuedEvents: GATEWAY_SEND_QUEUE_LIMIT,
+			policy: "drop-oldest",
+			queuedEvents: this.outboundQueue.length
+		});
 		this.scheduleFlush();
 	}
 	clear() {
@@ -5420,6 +5448,8 @@ var GatewaySendLimiter = class {
 			this.outboundFlushTimer = void 0;
 		}
 		this.outboundQueue = [];
+		this.droppedEvents = 0;
+		this.overflowWarningEmitted = false;
 	}
 	getStatus() {
 		const now = Date.now();
@@ -5429,7 +5459,8 @@ var GatewaySendLimiter = class {
 			remainingEvents: Math.max(0, GATEWAY_SEND_LIMIT - this.outboundSendTimestamps.length),
 			resetTime: this.outboundSendTimestamps.length > 0 ? oldest + GATEWAY_SEND_WINDOW_MS : now + GATEWAY_SEND_WINDOW_MS,
 			currentEventCount: this.outboundSendTimestamps.length,
-			queuedEvents: this.outboundQueue.length
+			queuedEvents: this.outboundQueue.length,
+			droppedEvents: this.droppedEvents
 		};
 	}
 	pruneWindow(now) {
@@ -5468,6 +5499,7 @@ var GatewaySendLimiter = class {
 				return;
 			}
 		}
+		if (this.outboundQueue.length < GATEWAY_SEND_QUEUE_LIMIT) this.overflowWarningEmitted = false;
 		this.scheduleFlush();
 	}
 };
@@ -5576,7 +5608,7 @@ var GatewayPlugin = class extends Plugin {
 		this.heartbeatTimers = new GatewayHeartbeatTimers();
 		this.reconnectTimer = new GatewayReconnectTimer();
 		this.voiceStateCache = new DiscordGatewayVoiceStateCache();
-		this.outboundLimiter = new GatewaySendLimiter((payload) => this.sendSerializedGatewayEvent(payload), (error) => this.emitter.emit("error", error));
+		this.outboundLimiter = new GatewaySendLimiter((payload) => this.sendSerializedGatewayEvent(payload), (error) => this.emitter.emit("error", error), (warning) => this.emitter.emit("warning", `Gateway outbound queue overflow policy=${warning.policy} droppedEvents=${warning.droppedEvents} queuedEvents=${warning.queuedEvents} maxQueuedEvents=${warning.maxQueuedEvents}`));
 		this.options = {
 			...options,
 			reconnect: {
@@ -5825,7 +5857,7 @@ var GatewayPlugin = class extends Plugin {
 		}
 		this.voiceStateCache.apply(payload);
 		dispatchVoiceGatewayEvent(this.client, payload.t, payload.d);
-		const data = mapGatewayDispatchData(this.client, payload.t, payload.d);
+		const data = payload.t === GatewayDispatchEvents.MessageCreate ? payload.d : mapGatewayDispatchData(this.client, payload.t, payload.d);
 		await this.client.dispatchGatewayEvent(payload.t, data);
 		if (payload.t === GatewayDispatchEvents.InteractionCreate && this.options.autoInteractions) await this.client.handleInteraction(payload.d);
 	}
@@ -5950,11 +5982,6 @@ const DEFAULT_INTERVAL_MS = 3e4;
 const DEFAULT_MIN_UPDATE_INTERVAL_MS = 15e3;
 const MIN_INTERVAL_MS = 5e3;
 const MIN_UPDATE_INTERVAL_MS = 1e3;
-function normalizeOptionalText(value) {
-	if (typeof value !== "string") return;
-	const trimmed = value.trim();
-	return trimmed.length > 0 ? trimmed : void 0;
-}
 function clampPositiveInt(value, fallback, minValue) {
 	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
 	const rounded = Math.round(value);
@@ -5967,10 +5994,7 @@ function resolveAutoPresenceConfig(config) {
 	return {
 		enabled: config?.enabled === true,
 		intervalMs,
-		minUpdateIntervalMs,
-		healthyText: normalizeOptionalText(config?.healthyText),
-		degradedText: normalizeOptionalText(config?.degradedText),
-		exhaustedText: normalizeOptionalText(config?.exhaustedText)
+		minUpdateIntervalMs
 	};
 }
 function buildCustomStatusActivity(text) {
@@ -6019,16 +6043,12 @@ function resolveAuthAvailability(params) {
 }
 function resolvePresenceActivities(params) {
 	const reasonLabel = formatUnavailableReason(params.unavailableReason ?? null);
-	if (params.state === "healthy") {
-		if (params.cfg.healthyText) return [buildCustomStatusActivity(params.cfg.healthyText)];
-		return params.basePresence?.activities ?? [];
-	}
+	if (params.state === "healthy") return params.basePresence?.activities ?? [];
 	if (params.state === "degraded") {
-		const text = renderTemplate(params.cfg.degradedText ?? "runtime degraded", { reason: reasonLabel });
+		const text = renderTemplate("runtime degraded", { reason: reasonLabel });
 		return text ? [buildCustomStatusActivity(text)] : [];
 	}
-	const defaultTemplate = isExhaustedUnavailableReason(params.unavailableReason ?? null) ? "token exhausted" : "model unavailable ({reason})";
-	const text = renderTemplate(params.cfg.exhaustedText ?? defaultTemplate, { reason: reasonLabel });
+	const text = renderTemplate(isExhaustedUnavailableReason(params.unavailableReason ?? null) ? "token exhausted" : "model unavailable ({reason})", { reason: reasonLabel });
 	return text ? [buildCustomStatusActivity(text)] : [];
 }
 function resolvePresenceStatus(state) {
@@ -6228,7 +6248,7 @@ function normalizeGatewayInfoTimeoutMs(value) {
 	return Math.min(numeric, MAX_DISCORD_GATEWAY_INFO_TIMEOUT_MS);
 }
 function resolveDiscordGatewayInfoTimeoutMs(params) {
-	return normalizeGatewayInfoTimeoutMs(params?.configuredTimeoutMs) ?? normalizeGatewayInfoTimeoutMs(params?.env?.[DISCORD_GATEWAY_INFO_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_INFO_TIMEOUT_MS;
+	return normalizeGatewayInfoTimeoutMs(params?.env?.[DISCORD_GATEWAY_INFO_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_INFO_TIMEOUT_MS;
 }
 function summarizeGatewayResponseBody(body) {
 	return summarizeDiscordResponseBody(body, { emptyText: "<empty>" }) ?? "<empty>";
@@ -6599,10 +6619,7 @@ function createDiscordGatewayPlugin(params) {
 	});
 	const proxy = resolveEffectiveDebugProxyUrl(params.discordConfig?.proxy);
 	const debugProxySettings = resolveDebugProxySettings();
-	const gatewayInfoTimeoutMs = resolveDiscordGatewayInfoTimeoutMs({
-		configuredTimeoutMs: params.discordConfig?.gatewayInfoTimeoutMs,
-		env: process.env
-	});
+	const gatewayInfoTimeoutMs = resolveDiscordGatewayInfoTimeoutMs({ env: process.env });
 	let fetchImpl = createDiscordGatewayMetadataFetch(debugProxySettings.enabled);
 	let wsAgent = new Agent({ lookup: discordDnsLookup$1 });
 	if (proxy) try {
@@ -6800,7 +6817,9 @@ function attachDiscordGatewayLogging(params) {
 		if (shouldPromoteGatewayDebug(message)) runtime.log?.(`discord gateway: ${message}`);
 	};
 	const onGatewayWarning = (warning) => {
-		logVerbose(`discord gateway warning: ${String(warning)}`);
+		const message = `discord gateway warning: ${String(warning)}`;
+		logVerbose(message);
+		runtime.log?.(warn(message));
 	};
 	const onGatewayMetrics = (metrics) => {
 		logVerbose(`discord gateway metrics: ${formatGatewayMetrics(metrics)}`);
@@ -6887,10 +6906,10 @@ function normalizeGatewayReadyTimeoutMs(value) {
 	return Math.min(numeric, MAX_DISCORD_GATEWAY_READY_TIMEOUT_MS);
 }
 function resolveDiscordGatewayReadyTimeoutMs(params) {
-	return normalizeGatewayReadyTimeoutMs(params?.configuredTimeoutMs) ?? normalizeGatewayReadyTimeoutMs(params?.env?.[DISCORD_GATEWAY_READY_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_READY_TIMEOUT_MS;
+	return normalizeGatewayReadyTimeoutMs(params?.env?.[DISCORD_GATEWAY_READY_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_READY_TIMEOUT_MS;
 }
 function resolveDiscordGatewayRuntimeReadyTimeoutMs(params) {
-	return normalizeGatewayReadyTimeoutMs(params?.configuredTimeoutMs) ?? normalizeGatewayReadyTimeoutMs(params?.env?.[DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_MS;
+	return normalizeGatewayReadyTimeoutMs(params?.env?.[DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_ENV]) ?? DEFAULT_DISCORD_GATEWAY_RUNTIME_READY_TIMEOUT_MS;
 }
 async function restartGatewayAfterReadyTimeout(params) {
 	if (!params.gateway || params.abortSignal?.aborted) return;
@@ -7159,14 +7178,8 @@ async function runDiscordGatewayLifecycle(params) {
 	const pushStatus = (patch) => {
 		params.statusSink?.(patch);
 	};
-	const gatewayReadyTimeoutMs = resolveDiscordGatewayReadyTimeoutMs({
-		configuredTimeoutMs: params.gatewayReadyTimeoutMs,
-		env: process.env
-	});
-	const gatewayRuntimeReadyTimeoutMs = resolveDiscordGatewayRuntimeReadyTimeoutMs({
-		configuredTimeoutMs: params.gatewayRuntimeReadyTimeoutMs,
-		env: process.env
-	});
+	const gatewayReadyTimeoutMs = resolveDiscordGatewayReadyTimeoutMs({ env: process.env });
+	const gatewayRuntimeReadyTimeoutMs = resolveDiscordGatewayRuntimeReadyTimeoutMs({ env: process.env });
 	const statusObserver = createGatewayStatusObserver({
 		gateway,
 		abortSignal: params.abortSignal,
@@ -7239,7 +7252,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-TDZcMriu.js").then((n) => n.n);
+			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-CyJ-sc3n.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: params.accountId,
 				manager: null
@@ -7254,7 +7267,7 @@ async function runDiscordGatewayLifecycle(params) {
 let discordVoiceRuntimePromise;
 let discordProviderSessionRuntimePromise;
 async function loadDiscordVoiceRuntime() {
-	const promise = discordVoiceRuntimePromise ?? import("./manager.runtime-w6VVYQMl.js");
+	const promise = discordVoiceRuntimePromise ?? import("./manager.runtime-DVvlH8NR.js");
 	discordVoiceRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7264,7 +7277,7 @@ async function loadDiscordVoiceRuntime() {
 	}
 }
 async function loadDiscordProviderSessionRuntime() {
-	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-BZPUZRjn.js");
+	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-D9GTBKPg.js");
 	discordProviderSessionRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7612,8 +7625,8 @@ async function resolveDiscordAllowlistConfig(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/provider.cleanup.ts
-function cleanupDiscordProviderStartup(params) {
-	params.deactivateMessageHandler?.();
+async function cleanupDiscordProviderStartup(params) {
+	await params.deactivateMessageHandler?.();
 	params.autoPresenceController?.stop();
 	params.setStatus?.({ connected: false });
 	if (params.onEarlyGatewayDebug) params.earlyGatewayEmitter?.removeListener("debug", params.onEarlyGatewayDebug);
@@ -8019,107 +8032,6 @@ function runDiscordCommandDeployInBackground(params) {
 	});
 }
 //#endregion
-//#region extensions/discord/src/monitor/agent-components-context.ts
-function formatUsername(user) {
-	if (user.discriminator && user.discriminator !== "0") return `${user.username}#${user.discriminator}`;
-	return user.username;
-}
-function isThreadChannelType(channelType) {
-	return channelType === ChannelType.PublicThread || channelType === ChannelType.PrivateThread || channelType === ChannelType.AnnouncementThread;
-}
-function resolveAgentComponentRoute(params) {
-	return resolveAgentRoute({
-		cfg: params.ctx.cfg,
-		channel: "discord",
-		accountId: params.ctx.accountId,
-		guildId: params.rawGuildId,
-		memberRoleIds: params.memberRoleIds,
-		peer: {
-			kind: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
-			id: params.isDirectMessage ? params.userId : params.channelId
-		},
-		parentPeer: params.parentId ? {
-			kind: "channel",
-			id: params.parentId
-		} : void 0
-	});
-}
-async function ackComponentInteraction(params) {
-	try {
-		await params.interaction.reply({
-			content: "✓",
-			...params.replyOpts
-		});
-	} catch (err) {
-		logError(`${params.label}: failed to acknowledge interaction: ${String(err)}`);
-	}
-}
-function resolveDiscordChannelContext(interaction) {
-	const channel = interaction.channel;
-	const channelInfo = resolveDiscordChannelInfoSafe(channel);
-	const channelName = channelInfo.name;
-	const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
-	const displayChannelSlug = channelName ? normalizeDiscordDisplaySlug(channelName) : "";
-	const channelType = channelInfo.type;
-	const isThread = isThreadChannelType(channelType);
-	let parentId;
-	let parentName;
-	let parentSlug = "";
-	if (isThread) {
-		parentId = channelInfo.parentId;
-		parentName = channelInfo.parentName;
-		if (parentName) parentSlug = normalizeDiscordSlug(parentName);
-	}
-	return {
-		channelName,
-		channelSlug,
-		displayChannelSlug,
-		channelType,
-		isThread,
-		parentId,
-		parentName,
-		parentSlug
-	};
-}
-async function resolveComponentInteractionContext(params) {
-	const { interaction, label } = params;
-	const channelId = interaction.rawData.channel_id;
-	if (!channelId) {
-		logError(`${label}: missing channel_id in interaction`);
-		return null;
-	}
-	const user = interaction.user;
-	if (!user) {
-		logError(`${label}: missing user in interaction`);
-		return null;
-	}
-	const shouldDefer = params.defer !== false && "defer" in interaction;
-	let didDefer = false;
-	if (shouldDefer) try {
-		await interaction.defer({ ephemeral: true });
-		didDefer = true;
-	} catch (err) {
-		logError(`${label}: failed to defer interaction: ${String(err)}`);
-	}
-	const replyOpts = didDefer ? {} : { ephemeral: true };
-	const username = formatUsername(user);
-	const userId = user.id;
-	const rawGuildId = interaction.rawData.guild_id;
-	const channelType = resolveDiscordChannelContext(interaction).channelType;
-	const isGroupDm = channelType === ChannelType.GroupDM;
-	return {
-		channelId,
-		user,
-		username,
-		userId,
-		replyOpts,
-		rawGuildId,
-		isDirectMessage: channelType === ChannelType.DM || !rawGuildId && !isGroupDm && channelType == null,
-		isGroupDm,
-		memberRoleIds: Array.isArray(interaction.rawData.member?.roles) ? interaction.rawData.member.roles.map((roleId) => roleId) : []
-	};
-}
-//#endregion
 //#region extensions/discord/src/monitor/agent-components-reply.ts
 async function replySilently(interaction, params) {
 	try {
@@ -8127,469 +8039,124 @@ async function replySilently(interaction, params) {
 	} catch {}
 }
 //#endregion
-//#region extensions/discord/src/monitor/agent-components-dm-auth.ts
-async function ensureDmComponentAuthorized(params) {
-	const { ctx, interaction, user, componentLabel, replyOpts } = params;
-	const dmPolicy = ctx.dmPolicy ?? "pairing";
-	if (dmPolicy === "disabled") {
-		logVerbose(`agent ${componentLabel}: blocked (DM policy disabled)`);
-		await replySilently(interaction, {
-			content: "DM interactions are disabled.",
-			...replyOpts
-		});
-		return false;
-	}
-	const access = await resolveDiscordDmCommandAccess({
-		accountId: ctx.accountId,
-		dmPolicy,
-		configuredAllowFrom: ctx.allowFrom ?? [],
-		sender: {
-			id: user.id,
-			name: user.username,
-			tag: formatDiscordUserTag(user)
-		},
-		allowNameMatching: isDangerousNameMatchingEnabled(ctx.discordConfig),
-		cfg: ctx.cfg,
-		token: ctx.token,
-		readStoreAllowFrom: async ({ accountId, dmPolicy: dmPolicyLocal }) => await readChannelIngressStoreAllowFromForDmPolicy({
-			provider: "discord",
-			accountId,
-			dmPolicy: dmPolicyLocal
-		}),
-		eventKind: "button"
-	});
-	if (access.senderAccess.decision === "allow") return true;
-	if (access.senderAccess.decision !== "pairing") {
-		logVerbose(`agent ${componentLabel}: blocked DM user ${user.id} (not in allowFrom)`);
-		await replySilently(interaction, {
-			content: `You are not authorized to use this ${componentLabel}.`,
-			...replyOpts
-		});
-		return false;
+//#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;
 	}
-	if (!(await createChannelPairingChallengeIssuer({
-		channel: "discord",
-		accountId: ctx.accountId,
-		upsertPairingRequest: async ({ id, meta }) => {
-			return await upsertChannelPairingRequest$1({
-				channel: "discord",
-				id,
-				accountId: ctx.accountId,
-				meta
+	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;
 		}
-	})({
-		senderId: user.id,
-		senderIdLine: `Your Discord user id: ${user.id}`,
-		meta: {
-			tag: formatDiscordUserTag(user),
-			name: user.username
-		},
-		sendPairingReply: async (text) => {
-			await interaction.reply({
-				content: text,
-				...replyOpts
+		const runtime = getDiscordActivitiesRuntime();
+		const channelId = interaction.rawData.channel_id;
+		const discordUserId = interaction.userId;
+		if (!runtime || !channelId || !discordUserId) this.logPendingLaunchFailure(/* @__PURE__ */ new Error("missing activity runtime or interaction identity"));
+		else {
+			const write = runtime.store.recordPendingLaunch({
+				accountId: this.ctx.accountId,
+				channelId,
+				discordUserId,
+				widgetId: data.widgetId,
+				createdAt: Date.now()
+			}).then(() => "written").catch((error) => {
+				this.logPendingLaunchFailure(error);
+				return "failed";
 			});
+			const timeout = new Promise((resolve) => {
+				setTimeout(() => resolve("timeout"), PENDING_LAUNCH_WRITE_BUDGET_MS).unref?.();
+			});
+			if (await Promise.race([write, timeout]) === "timeout") this.logPendingLaunchFailure(/* @__PURE__ */ new Error(`pending launch write exceeded ${PENDING_LAUNCH_WRITE_BUDGET_MS}ms`));
 		}
-	})).created) await replySilently(interaction, {
-		content: "Pairing already requested. Ask the bot owner to approve your code.",
-		...replyOpts
-	});
-	return false;
-}
-async function ensureGroupDmComponentAuthorized(params) {
-	const { ctx, interaction, channelId, componentLabel, replyOpts } = params;
-	if (!(ctx.discordConfig?.dm?.groupEnabled ?? false)) {
-		logVerbose(`agent ${componentLabel}: blocked group dm ${channelId} (group DMs disabled)`);
-		await replySilently(interaction, {
-			content: "Group DM interactions are disabled.",
-			...replyOpts
-		});
-		return false;
+		await interaction.launchActivity();
 	}
-	const channelCtx = resolveDiscordChannelContext(interaction);
-	if (resolveGroupDmAllow({
-		channels: ctx.discordConfig?.dm?.groupChannels,
-		channelId,
-		channelName: channelCtx.channelName,
-		channelSlug: channelCtx.channelSlug
-	})) return true;
-	logVerbose(`agent ${componentLabel}: blocked group dm ${channelId} (not allowlisted)`);
-	await replySilently(interaction, {
-		content: `You are not authorized to use this ${componentLabel}.`,
-		...replyOpts
-	});
-	return false;
-}
-async function resolveInteractionContextWithDmAuth(params) {
-	const interactionCtx = await resolveComponentInteractionContext({
-		interaction: params.interaction,
-		label: params.label,
-		defer: params.defer
+};
+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
 	});
-	if (!interactionCtx) return null;
-	if (interactionCtx.isDirectMessage) {
-		if (!await ensureDmComponentAuthorized({
-			ctx: params.ctx,
-			interaction: params.interaction,
-			user: interactionCtx.user,
-			componentLabel: params.componentLabel,
-			replyOpts: interactionCtx.replyOpts
-		})) return null;
-	}
-	if (interactionCtx.isGroupDm) {
-		if (!await ensureGroupDmComponentAuthorized({
-			ctx: params.ctx,
-			interaction: params.interaction,
-			channelId: interactionCtx.channelId,
-			componentLabel: params.componentLabel,
-			replyOpts: interactionCtx.replyOpts
-		})) return null;
-	}
-	return interactionCtx;
 }
 //#endregion
-//#region extensions/discord/src/monitor/agent-components-guild-auth.ts
-function resolveComponentRuntimeGroupPolicy(ctx) {
-	return resolveOpenProviderRuntimeGroupPolicy({
-		providerConfigPresent: ctx.cfg.channels?.discord !== void 0,
-		groupPolicy: ctx.discordConfig?.groupPolicy,
-		defaultGroupPolicy: ctx.cfg.channels?.defaults?.groupPolicy
+//#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;
-}
-async function ensureGuildComponentMemberAllowed(params) {
-	const { interaction, guildInfo, channelId, rawGuildId, channelCtx, memberRoleIds, user, replyOpts, componentLabel, unauthorizedReply } = params;
-	if (!rawGuildId) return true;
-	const replyUnauthorized = async () => {
-		await replySilently(interaction, {
-			content: unauthorizedReply,
-			...replyOpts
-		});
-	};
-	const channelConfig = resolveDiscordChannelConfigWithFallback({
-		guildInfo,
-		channelId,
-		channelName: channelCtx.channelName,
-		channelSlug: channelCtx.channelSlug,
-		parentId: channelCtx.parentId,
-		parentName: channelCtx.parentName,
-		parentSlug: channelCtx.parentSlug,
-		scope: channelCtx.isThread ? "thread" : "channel"
+	const guildInfo = resolveDiscordGuildEntry({
+		guild: params.guild ?? {
+			id: params.guildId,
+			...params.guildName ? { name: params.guildName } : {}
+		},
+		guildId: params.guildId,
+		guildEntries: params.discordConfig.guilds
 	});
-	if (channelConfig?.enabled === false) {
-		await replyUnauthorized();
-		return false;
-	}
+	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;
-	const channelAllowed = channelConfig?.allowed !== false;
+	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: params.groupPolicy,
+		groupPolicy,
 		guildAllowlisted: Boolean(guildInfo),
 		channelAllowlistConfigured,
 		channelAllowed
-	})) {
-		await replyUnauthorized();
-		return false;
-	}
-	if (channelConfig?.allowed === false) {
-		await replyUnauthorized();
-		return false;
-	}
-	const { memberAllowed } = resolveDiscordMemberAccessState({
+	}) || channelConfig?.allowed === false) return {
+		ok: false,
+		message: `${params.channelLabel ?? "This channel"} is not allowlisted for voice commands.`
+	};
+	const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
 		channelConfig,
 		guildInfo,
-		memberRoleIds,
-		sender: {
-			id: user.id,
-			name: user.username,
-			tag: user.discriminator ? `${user.username}#${user.discriminator}` : void 0
-		},
-		allowNameMatching: params.allowNameMatching
+		memberRoleIds: params.memberRoleIds,
+		sender: params.sender,
+		allowNameMatching: false
 	});
-	if (memberAllowed) return true;
-	logVerbose(`agent ${componentLabel}: blocked user ${user.id} (not in users/roles allowlist)`);
-	await replyUnauthorized();
-	return false;
-}
-async function ensureComponentUserAllowed(params) {
-	const allowList = normalizeDiscordAllowList(params.entry.allowedUsers, [
-		"discord:",
-		"user:",
-		"pk:"
-	]);
-	if (!allowList) return true;
-	if (resolveDiscordAllowListMatch({
-		allowList,
-		candidate: {
-			id: params.user.id,
-			name: params.user.username,
-			tag: formatDiscordUserTag(params.user)
-		},
-		allowNameMatching: params.allowNameMatching
-	}).allowed) return true;
-	logVerbose(`discord component ${params.componentLabel}: blocked user ${params.user.id} (not in allowedUsers)`);
-	await replySilently(params.interaction, {
-		content: params.unauthorizedReply,
-		...params.replyOpts
-	});
-	return false;
-}
-async function ensureAgentComponentInteractionAllowed(params) {
-	const guildInfo = resolveDiscordGuildEntry({
-		guild: params.interaction.guild ?? void 0,
-		guildId: params.rawGuildId,
-		guildEntries: params.ctx.guildEntries
-	});
-	const channelCtx = resolveDiscordChannelContext(params.interaction);
-	if (!await ensureGuildComponentMemberAllowed({
-		interaction: params.interaction,
-		guildInfo,
-		channelId: params.channelId,
-		rawGuildId: params.rawGuildId,
-		channelCtx,
-		memberRoleIds: params.memberRoleIds,
-		user: params.user,
-		replyOpts: params.replyOpts,
-		componentLabel: params.componentLabel,
-		unauthorizedReply: params.unauthorizedReply,
-		allowNameMatching: isDangerousNameMatchingEnabled(params.ctx.discordConfig),
-		groupPolicy: resolveComponentRuntimeGroupPolicy(params.ctx)
-	})) return null;
-	return { parentId: channelCtx.parentId };
-}
-async function resolveAuthorizedComponentInteraction(params) {
-	const interactionCtx = await resolveInteractionContextWithDmAuth({
-		ctx: params.ctx,
-		interaction: params.interaction,
-		label: params.label,
-		componentLabel: params.componentLabel,
-		defer: params.defer
-	});
-	if (!interactionCtx) return null;
-	const { channelId, user, replyOpts, rawGuildId, memberRoleIds } = interactionCtx;
-	const guildInfo = resolveDiscordGuildEntry({
-		guild: params.interaction.guild ?? void 0,
-		guildId: rawGuildId,
-		guildEntries: params.ctx.guildEntries
-	});
-	const channelCtx = resolveDiscordChannelContext(params.interaction);
-	const allowNameMatching = isDangerousNameMatchingEnabled(params.ctx.discordConfig);
-	const channelConfig = resolveDiscordChannelConfigWithFallback({
-		guildInfo,
-		channelId,
-		channelName: channelCtx.channelName,
-		channelSlug: channelCtx.channelSlug,
-		parentId: channelCtx.parentId,
-		parentName: channelCtx.parentName,
-		parentSlug: channelCtx.parentSlug,
-		scope: channelCtx.isThread ? "thread" : "channel"
-	});
-	if (!await ensureGuildComponentMemberAllowed({
-		interaction: params.interaction,
-		guildInfo,
-		channelId,
-		rawGuildId,
-		channelCtx,
-		memberRoleIds,
-		user,
-		replyOpts,
-		componentLabel: params.componentLabel,
-		unauthorizedReply: params.unauthorizedReply,
-		allowNameMatching,
-		groupPolicy: resolveComponentRuntimeGroupPolicy(params.ctx)
-	})) return null;
-	return {
-		interactionCtx,
-		channelCtx,
-		guildInfo,
-		channelConfig,
-		allowNameMatching,
-		commandAuthorized: await resolveComponentCommandAuthorized({
-			ctx: params.ctx,
-			interactionCtx,
-			channelConfig,
-			guildInfo,
-			allowNameMatching
-		}),
-		user,
-		replyOpts
-	};
-}
-async function resolveComponentCommandAuthorized(params) {
-	const { ctx, interactionCtx, channelConfig, guildInfo } = params;
-	if (interactionCtx.isDirectMessage) return true;
-	const { ownerAllowList, ownerAllowed: ownerOk } = resolveDiscordOwnerAccess({
-		allowFrom: ctx.allowFrom,
-		sender: {
-			id: interactionCtx.user.id,
-			name: interactionCtx.user.username,
-			tag: formatDiscordUserTag(interactionCtx.user)
-		},
-		allowNameMatching: params.allowNameMatching
-	});
-	const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
-		channelConfig,
-		guildInfo,
-		memberRoleIds: interactionCtx.memberRoleIds,
-		sender: {
-			id: interactionCtx.user.id,
-			name: interactionCtx.user.username,
-			tag: formatDiscordUserTag(interactionCtx.user)
-		},
-		allowNameMatching: params.allowNameMatching
-	});
-	const useAccessGroups = ctx.cfg.commands?.useAccessGroups !== false;
-	return resolveCommandAuthorizedFromAuthorizers({
-		useAccessGroups,
-		authorizers: useAccessGroups ? [{
-			configured: ownerAllowList != null,
-			allowed: ownerOk
-		}, {
-			configured: hasAccessRestrictions,
-			allowed: memberAllowed
-		}] : [{
-			configured: hasAccessRestrictions,
-			allowed: memberAllowed
-		}],
-		modeWhenAccessGroupsOff: "configured"
-	});
-}
-//#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 authorized = await this.deps.authorize({
-			ctx: this.ctx,
-			interaction,
-			label: "discord activity",
-			componentLabel: "widget button",
-			unauthorizedReply: "not allowed",
-			defer: false
-		});
-		if (!authorized) return;
-		if (!authorized.commandAuthorized) {
-			await this.deps.reply(interaction, {
-				content: "not allowed",
-				ephemeral: true
-			});
-			return;
-		}
-		const runtime = getDiscordActivitiesRuntime();
-		const channelId = interaction.rawData.channel_id;
-		const discordUserId = interaction.userId;
-		if (!runtime || !channelId || !discordUserId) this.logPendingLaunchFailure(/* @__PURE__ */ new Error("missing activity runtime or interaction identity"));
-		else {
-			const write = runtime.store.recordPendingLaunch({
-				accountId: this.ctx.accountId,
-				channelId,
-				discordUserId,
-				widgetId: data.widgetId,
-				createdAt: Date.now()
-			}).then(() => "written").catch((error) => {
-				this.logPendingLaunchFailure(error);
-				return "failed";
-			});
-			const timeout = new Promise((resolve) => {
-				setTimeout(() => resolve("timeout"), PENDING_LAUNCH_WRITE_BUDGET_MS).unref?.();
-			});
-			if (await Promise.race([write, timeout]) === "timeout") this.logPendingLaunchFailure(/* @__PURE__ */ new Error(`pending launch write exceeded ${PENDING_LAUNCH_WRITE_BUDGET_MS}ms`));
-		}
-		await interaction.launchActivity();
-	}
-};
-function createDiscordActivityButton(ctx, applicationId, deps = {}) {
-	const runtime = getDiscordActivitiesRuntime();
-	if (!runtime || !runtime.isAccountEnabled(ctx.accountId, ctx.cfg)) return null;
-	if (applicationId) runtime.registerApplicationId(ctx.accountId, applicationId);
-	if (!runtime.resolveAccount(ctx.accountId, ctx.cfg)) return null;
-	return new DiscordActivityButton(ctx, {
-		authorize: deps.authorize ?? resolveAuthorizedComponentInteraction,
-		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.dm?.allowFrom, [
+	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 ?? params.cfg.commands?.useAccessGroups !== false;
+	const useAccessGroups = params.useAccessGroups ?? true;
 	return resolveCommandAuthorizedFromAuthorizers({
 		useAccessGroups,
 		authorizers: useAccessGroups ? [{
@@ -8624,7 +8191,7 @@ function resolveDiscordVoiceAccess(params) {
 		admissionAllowFrom: resolveDiscordAccountAllowFrom({
 			cfg: params.cfg,
 			accountId: params.accountId
-		}) ?? params.discordConfig.allowFrom ?? params.discordConfig.dm?.allowFrom ?? [],
+		}) ?? params.discordConfig.allowFrom ?? params.discordConfig.allowFrom ?? [],
 		ownerAllowFrom: [],
 		ownerAllowAll: false
 	};
@@ -8708,160 +8275,585 @@ async function resolveVoiceCommandRuntimeContext(interaction, params) {
 		return null;
 	}
 	return {
-		guildId,
-		manager
+		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 = "vc";
+			this.description = "Voice channel controls";
+			this.subcommands = [
+				new JoinCommand(),
+				new LeaveCommand(),
+				new StatusCommand()
+			];
+		}
+	}();
+}
+function isVoiceChannelType(type) {
+	return type === ChannelType.GuildVoice || type === ChannelType.GuildStageVoice;
+}
+//#endregion
+//#region extensions/discord/src/monitor/agent-components-context.ts
+function formatUsername(user) {
+	if (user.discriminator && user.discriminator !== "0") return `${user.username}#${user.discriminator}`;
+	return user.username;
+}
+function isThreadChannelType(channelType) {
+	return channelType === ChannelType.PublicThread || channelType === ChannelType.PrivateThread || channelType === ChannelType.AnnouncementThread;
+}
+function resolveAgentComponentRoute(params) {
+	return resolveAgentRoute({
+		cfg: params.ctx.cfg,
+		channel: "discord",
+		accountId: params.ctx.accountId,
+		guildId: params.rawGuildId,
+		memberRoleIds: params.memberRoleIds,
+		peer: {
+			kind: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
+			id: params.isDirectMessage ? params.userId : params.channelId
+		},
+		parentPeer: params.parentId ? {
+			kind: "channel",
+			id: params.parentId
+		} : void 0
+	});
+}
+async function ackComponentInteraction(params) {
+	try {
+		await params.interaction.reply({
+			content: "✓",
+			...params.replyOpts
+		});
+	} catch (err) {
+		logError(`${params.label}: failed to acknowledge interaction: ${String(err)}`);
+	}
+}
+function resolveDiscordChannelContext(interaction) {
+	const channel = interaction.channel;
+	const channelInfo = resolveDiscordChannelInfoSafe(channel);
+	const channelName = channelInfo.name;
+	const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
+	const displayChannelSlug = channelName ? normalizeDiscordDisplaySlug(channelName) : "";
+	const channelType = channelInfo.type;
+	const isThread = isThreadChannelType(channelType);
+	let parentId;
+	let parentName;
+	let parentSlug = "";
+	if (isThread) {
+		parentId = channelInfo.parentId;
+		parentName = channelInfo.parentName;
+		if (parentName) parentSlug = normalizeDiscordSlug(parentName);
+	}
+	return {
+		channelName,
+		channelSlug,
+		displayChannelSlug,
+		channelType,
+		isThread,
+		parentId,
+		parentName,
+		parentSlug
+	};
+}
+async function resolveComponentInteractionContext(params) {
+	const { interaction, label } = params;
+	const channelId = interaction.rawData.channel_id;
+	if (!channelId) {
+		logError(`${label}: missing channel_id in interaction`);
+		return null;
+	}
+	const user = interaction.user;
+	if (!user) {
+		logError(`${label}: missing user in interaction`);
+		return null;
+	}
+	const shouldDefer = params.defer !== false && "defer" in interaction;
+	let didDefer = false;
+	if (shouldDefer) try {
+		await interaction.defer({ ephemeral: true });
+		didDefer = true;
+	} catch (err) {
+		logError(`${label}: failed to defer interaction: ${String(err)}`);
+	}
+	const replyOpts = didDefer ? {} : { ephemeral: true };
+	const username = formatUsername(user);
+	const userId = user.id;
+	const rawGuildId = interaction.rawData.guild_id;
+	const channelType = resolveDiscordChannelContext(interaction).channelType;
+	const isGroupDm = channelType === ChannelType.GroupDM;
+	return {
+		channelId,
+		user,
+		username,
+		userId,
+		replyOpts,
+		rawGuildId,
+		isDirectMessage: channelType === ChannelType.DM || !rawGuildId && !isGroupDm && channelType == null,
+		isGroupDm,
+		memberRoleIds: Array.isArray(interaction.rawData.member?.roles) ? interaction.rawData.member.roles.map((roleId) => roleId) : []
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/agent-components-dm-auth.ts
+async function ensureDmComponentAuthorized(params) {
+	const { ctx, interaction, user, componentLabel, replyOpts } = params;
+	const dmPolicy = ctx.dmPolicy ?? "pairing";
+	if (dmPolicy === "disabled") {
+		logVerbose(`agent ${componentLabel}: blocked (DM policy disabled)`);
+		await replySilently(interaction, {
+			content: "DM interactions are disabled.",
+			...replyOpts
+		});
+		return false;
+	}
+	const access = await resolveDiscordDmCommandAccess({
+		accountId: ctx.accountId,
+		dmPolicy,
+		configuredAllowFrom: ctx.allowFrom ?? [],
+		sender: {
+			id: user.id,
+			name: user.username,
+			tag: formatDiscordUserTag(user)
+		},
+		allowNameMatching: isDangerousNameMatchingEnabled(ctx.discordConfig),
+		cfg: ctx.cfg,
+		token: ctx.token,
+		readStoreAllowFrom: async ({ accountId, dmPolicy: dmPolicyLocal }) => await readChannelIngressStoreAllowFromForDmPolicy({
+			provider: "discord",
+			accountId,
+			dmPolicy: dmPolicyLocal
+		}),
+		eventKind: "button"
+	});
+	if (access.senderAccess.decision === "allow") return true;
+	if (access.senderAccess.decision !== "pairing") {
+		logVerbose(`agent ${componentLabel}: blocked DM user ${user.id} (not in allowFrom)`);
+		await replySilently(interaction, {
+			content: `You are not authorized to use this ${componentLabel}.`,
+			...replyOpts
+		});
+		return false;
+	}
+	if (!(await createChannelPairingChallengeIssuer({
+		channel: "discord",
+		accountId: ctx.accountId,
+		upsertPairingRequest: async ({ id, meta }) => {
+			return await upsertChannelPairingRequest$1({
+				channel: "discord",
+				id,
+				accountId: ctx.accountId,
+				meta
+			});
+		}
+	})({
+		senderId: user.id,
+		senderIdLine: `Your Discord user id: ${user.id}`,
+		meta: {
+			tag: formatDiscordUserTag(user),
+			name: user.username
+		},
+		sendPairingReply: async (text) => {
+			await interaction.reply({
+				content: text,
+				...replyOpts
+			});
+		}
+	})).created) await replySilently(interaction, {
+		content: "Pairing already requested. Ask the bot owner to approve your code.",
+		...replyOpts
+	});
+	return false;
+}
+async function ensureGroupDmComponentAuthorized(params) {
+	const { ctx, interaction, channelId, componentLabel, replyOpts } = params;
+	if (!(ctx.discordConfig?.dm?.groupEnabled ?? false)) {
+		logVerbose(`agent ${componentLabel}: blocked group dm ${channelId} (group DMs disabled)`);
+		await replySilently(interaction, {
+			content: "Group DM interactions are disabled.",
+			...replyOpts
+		});
+		return false;
+	}
+	const channelCtx = resolveDiscordChannelContext(interaction);
+	if (resolveGroupDmAllow({
+		channels: ctx.discordConfig?.dm?.groupChannels,
+		channelId,
+		channelName: channelCtx.channelName,
+		channelSlug: channelCtx.channelSlug
+	})) return true;
+	logVerbose(`agent ${componentLabel}: blocked group dm ${channelId} (not allowlisted)`);
+	await replySilently(interaction, {
+		content: `You are not authorized to use this ${componentLabel}.`,
+		...replyOpts
+	});
+	return false;
+}
+async function resolveInteractionContextWithDmAuth(params) {
+	const interactionCtx = await resolveComponentInteractionContext({
+		interaction: params.interaction,
+		label: params.label,
+		defer: params.defer
+	});
+	if (!interactionCtx) return null;
+	if (interactionCtx.isDirectMessage) {
+		if (!await ensureDmComponentAuthorized({
+			ctx: params.ctx,
+			interaction: params.interaction,
+			user: interactionCtx.user,
+			componentLabel: params.componentLabel,
+			replyOpts: interactionCtx.replyOpts
+		})) return null;
+	}
+	if (interactionCtx.isGroupDm) {
+		if (!await ensureGroupDmComponentAuthorized({
+			ctx: params.ctx,
+			interaction: params.interaction,
+			channelId: interactionCtx.channelId,
+			componentLabel: params.componentLabel,
+			replyOpts: interactionCtx.replyOpts
+		})) return null;
+	}
+	return interactionCtx;
+}
+//#endregion
+//#region extensions/discord/src/monitor/agent-components-guild-auth.ts
+function resolveComponentRuntimeGroupPolicy(ctx) {
+	return resolveOpenProviderRuntimeGroupPolicy({
+		providerConfigPresent: ctx.cfg.channels?.discord !== void 0,
+		groupPolicy: ctx.discordConfig?.groupPolicy,
+		defaultGroupPolicy: ctx.cfg.channels?.defaults?.groupPolicy
+	}).groupPolicy;
+}
+async function ensureGuildComponentMemberAllowed(params) {
+	const { interaction, guildInfo, channelId, rawGuildId, channelCtx, memberRoleIds, user, replyOpts, componentLabel, unauthorizedReply } = params;
+	if (!rawGuildId) return true;
+	const replyUnauthorized = async () => {
+		await replySilently(interaction, {
+			content: unauthorizedReply,
+			...replyOpts
+		});
+	};
+	const channelConfig = resolveDiscordChannelConfigWithFallback({
+		guildInfo,
+		channelId,
+		channelName: channelCtx.channelName,
+		channelSlug: channelCtx.channelSlug,
+		parentId: channelCtx.parentId,
+		parentName: channelCtx.parentName,
+		parentSlug: channelCtx.parentSlug,
+		scope: channelCtx.isThread ? "thread" : "channel"
+	});
+	if (channelConfig?.enabled === false) {
+		await replyUnauthorized();
+		return false;
+	}
+	const channelAllowlistConfigured = Boolean(guildInfo?.channels) && Object.keys(guildInfo?.channels ?? {}).length > 0;
+	const channelAllowed = channelConfig?.allowed !== false;
+	if (!isDiscordGroupAllowedByPolicy({
+		groupPolicy: params.groupPolicy,
+		guildAllowlisted: Boolean(guildInfo),
+		channelAllowlistConfigured,
+		channelAllowed
+	})) {
+		await replyUnauthorized();
+		return false;
+	}
+	if (channelConfig?.allowed === false) {
+		await replyUnauthorized();
+		return false;
+	}
+	const { memberAllowed } = resolveDiscordMemberAccessState({
+		channelConfig,
+		guildInfo,
+		memberRoleIds,
+		sender: {
+			id: user.id,
+			name: user.username,
+			tag: user.discriminator ? `${user.username}#${user.discriminator}` : void 0
+		},
+		allowNameMatching: params.allowNameMatching
+	});
+	if (memberAllowed) return true;
+	logVerbose(`agent ${componentLabel}: blocked user ${user.id} (not in users/roles allowlist)`);
+	await replyUnauthorized();
+	return false;
+}
+async function ensureComponentUserAllowed(params) {
+	const allowList = normalizeDiscordAllowList(params.entry.allowedUsers, [
+		"discord:",
+		"user:",
+		"pk:"
+	]);
+	if (!allowList) return true;
+	if (resolveDiscordAllowListMatch({
+		allowList,
+		candidate: {
+			id: params.user.id,
+			name: params.user.username,
+			tag: formatDiscordUserTag(params.user)
+		},
+		allowNameMatching: params.allowNameMatching
+	}).allowed) return true;
+	logVerbose(`discord component ${params.componentLabel}: blocked user ${params.user.id} (not in allowedUsers)`);
+	await replySilently(params.interaction, {
+		content: params.unauthorizedReply,
+		...params.replyOpts
+	});
+	return false;
+}
+async function ensureAgentComponentInteractionAllowed(params) {
+	const guildInfo = resolveDiscordGuildEntry({
+		guild: params.interaction.guild ?? void 0,
+		guildId: params.rawGuildId,
+		guildEntries: params.ctx.guildEntries
+	});
+	const channelCtx = resolveDiscordChannelContext(params.interaction);
+	if (!await ensureGuildComponentMemberAllowed({
+		interaction: params.interaction,
+		guildInfo,
+		channelId: params.channelId,
+		rawGuildId: params.rawGuildId,
+		channelCtx,
+		memberRoleIds: params.memberRoleIds,
+		user: params.user,
+		replyOpts: params.replyOpts,
+		componentLabel: params.componentLabel,
+		unauthorizedReply: params.unauthorizedReply,
+		allowNameMatching: isDangerousNameMatchingEnabled(params.ctx.discordConfig),
+		groupPolicy: resolveComponentRuntimeGroupPolicy(params.ctx)
+	})) return null;
+	return { parentId: channelCtx.parentId };
+}
+async function resolveAuthorizedComponentInteraction(params) {
+	const interactionCtx = await resolveInteractionContextWithDmAuth({
+		ctx: params.ctx,
+		interaction: params.interaction,
+		label: params.label,
+		componentLabel: params.componentLabel,
+		defer: params.defer
+	});
+	if (!interactionCtx) return null;
+	const { channelId, user, replyOpts, rawGuildId, memberRoleIds } = interactionCtx;
+	const guildInfo = resolveDiscordGuildEntry({
+		guild: params.interaction.guild ?? void 0,
+		guildId: rawGuildId,
+		guildEntries: params.ctx.guildEntries
+	});
+	const channelCtx = resolveDiscordChannelContext(params.interaction);
+	const allowNameMatching = isDangerousNameMatchingEnabled(params.ctx.discordConfig);
+	const channelConfig = resolveDiscordChannelConfigWithFallback({
+		guildInfo,
+		channelId,
+		channelName: channelCtx.channelName,
+		channelSlug: channelCtx.channelSlug,
+		parentId: channelCtx.parentId,
+		parentName: channelCtx.parentName,
+		parentSlug: channelCtx.parentSlug,
+		scope: channelCtx.isThread ? "thread" : "channel"
+	});
+	if (!await ensureGuildComponentMemberAllowed({
+		interaction: params.interaction,
+		guildInfo,
+		channelId,
+		rawGuildId,
+		channelCtx,
+		memberRoleIds,
+		user,
+		replyOpts,
+		componentLabel: params.componentLabel,
+		unauthorizedReply: params.unauthorizedReply,
+		allowNameMatching,
+		groupPolicy: resolveComponentRuntimeGroupPolicy(params.ctx)
+	})) return null;
+	return {
+		interactionCtx,
+		channelCtx,
+		guildInfo,
+		channelConfig,
+		allowNameMatching,
+		commandAuthorized: await resolveComponentCommandAuthorized({
+			ctx: params.ctx,
+			interactionCtx,
+			channelConfig,
+			guildInfo,
+			allowNameMatching
+		}),
+		user,
+		replyOpts
 	};
 }
-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
+async function resolveComponentCommandAuthorized(params) {
+	const { ctx, interactionCtx, channelConfig, guildInfo } = params;
+	if (interactionCtx.isDirectMessage) return true;
+	const { ownerAllowList, ownerAllowed: ownerOk } = resolveDiscordOwnerAccess({
+		allowFrom: ctx.allowFrom,
+		sender: {
+			id: interactionCtx.user.id,
+			name: interactionCtx.user.username,
+			tag: formatDiscordUserTag(interactionCtx.user)
+		},
+		allowNameMatching: params.allowNameMatching
+	});
+	const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
+		channelConfig,
+		guildInfo,
+		memberRoleIds: interactionCtx.memberRoleIds,
+		sender: {
+			id: interactionCtx.user.id,
+			name: interactionCtx.user.username,
+			tag: formatDiscordUserTag(interactionCtx.user)
+		},
+		allowNameMatching: params.allowNameMatching
+	});
+	return resolveCommandAuthorizedFromAuthorizers({
+		useAccessGroups: true,
+		authorizers: [{
+			configured: ownerAllowList != null,
+			allowed: ownerOk
+		}, {
+			configured: hasAccessRestrictions,
+			allowed: memberAllowed
+		}],
+		modeWhenAccessGroupsOff: "configured"
 	});
-	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 = "vc";
-			this.description = "Voice channel controls";
-			this.subcommands = [
-				new JoinCommand(),
-				new LeaveCommand(),
-				new StatusCommand()
-			];
-		}
-	}();
-}
-function isVoiceChannelType(type) {
-	return type === ChannelType.GuildVoice || type === ChannelType.GuildStageVoice;
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components-data.ts
@@ -9070,6 +9062,10 @@ function formatDiscordReplyDeliveryFailure(params) {
 	const context = [`target=${params.target}`, params.sessionKey ? `session=${params.sessionKey}` : void 0].filter(Boolean).join(" ");
 	return `discord ${params.kind} reply failed (${context}): ${String(params.err)}`;
 }
+function formatDiscordReplySkip(params) {
+	const context = [`target=${params.target}`, params.sessionKey ? `session=${params.sessionKey}` : void 0].filter(Boolean).join(" ");
+	return `discord ${params.kind} reply skipped (${params.reason}): ${context}`;
+}
 function resolveTargetChannelId(target) {
 	if (!target.startsWith("channel:")) return;
 	return target.slice(8).trim() || void 0;
@@ -9174,7 +9170,7 @@ async function deliverDiscordReply(params) {
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.dispatch.ts
 const loadConversationRuntime$1 = createLazyRuntimeModule(() => import("./agent-components.runtime-CEPrf2SY.js"));
-const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing-CKd2NMWG.js").then((n) => n.n));
+const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing-Ci9nhuSi.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}`;
@@ -9283,7 +9279,7 @@ async function dispatchDiscordComponentEvent(params) {
 		previousTimestamp,
 		envelope: envelopeOptions
 	});
-	const { createReplyReferencePlanner, dispatchReplyWithBufferedBlockDispatcher, finalizeInboundContext, resolveChunkMode, resolveTextChunkLimit, recordInboundSession } = await (async () => {
+	const { createReplyReferencePlanner, finalizeInboundContext, resolveChunkMode, resolveTextChunkLimit } = await (async () => {
 		return { ...await loadConversationRuntime$1() };
 	})();
 	const ctxPayload = finalizeInboundContext({
@@ -9359,12 +9355,11 @@ async function dispatchDiscordComponentEvent(params) {
 				cfg: ctx.cfg,
 				channel: "discord",
 				accountId,
-				agentId,
-				routeSessionKey: sessionKey,
-				storePath,
+				route: {
+					agentId,
+					sessionKey
+				},
 				ctxPayload,
-				recordInboundSession,
-				dispatchReplyWithBufferedBlockDispatcher,
 				record: {
 					updateLastRoute: interactionCtx.isDirectMessage ? {
 						sessionKey: inboundLastRouteSessionKey,
@@ -9587,7 +9582,7 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.handlers.ts
-const loadComponentsRuntime = createLazyRuntimeModule(() => import("./outbound-session-route-D4QqePZN.js").then((n) => n.n));
+const loadComponentsRuntime = createLazyRuntimeModule(() => import("./outbound-session-route-D_nc_Ayk.js").then((n) => n.n));
 async function handleDiscordComponentEvent(params) {
 	const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
 	if (!parsed) {
@@ -10276,6 +10271,74 @@ function createDiscordExecApprovalButtonContext(params) {
 	};
 }
 //#endregion
+//#region extensions/discord/src/monitor/questions.ts
+var QuestionButton = class extends Button {
+	constructor(ctx) {
+		super();
+		this.ctx = ctx;
+		this.label = "question";
+		this.customId = "ocq:id=seed;i=0";
+		this.style = ButtonStyle.Primary;
+	}
+	async run(interaction, data) {
+		const callback = parseDiscordQuestionData(data);
+		if (!callback) {
+			await interaction.reply({
+				content: "This question is no longer valid.",
+				ephemeral: true
+			});
+			return;
+		}
+		if (!await this.ctx.authorizeQuestion(interaction)) return;
+		try {
+			await interaction.acknowledge();
+		} catch {}
+		let result;
+		try {
+			result = await this.ctx.resolveQuestion({
+				cfg: this.ctx.cfg,
+				questionId: callback.questionId,
+				optionIndex: callback.optionIndex,
+				senderId: interaction.userId,
+				clientDisplayName: `Discord question (${this.ctx.accountId})`
+			});
+		} catch {
+			try {
+				await interaction.followUp({
+					content: "Could not submit this answer.",
+					ephemeral: true
+				});
+			} catch {}
+			return;
+		}
+		try {
+			await interaction.followUp({
+				content: result.status === "answered" ? "Answer submitted." : "This question was already answered.",
+				ephemeral: true
+			});
+		} catch {}
+	}
+};
+function createDiscordQuestionButton(params) {
+	const authContext = params.authContext ?? {
+		cfg: params.cfg,
+		accountId: params.accountId
+	};
+	return new QuestionButton({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		resolveQuestion: params.resolveQuestion ?? questionGatewayRuntime.resolveOption,
+		authorizeQuestion: params.authorizeQuestion ?? (async (interaction) => Boolean(await resolveAuthorizedComponentInteraction({
+			ctx: authContext,
+			interaction,
+			label: "discord question",
+			componentLabel: "button",
+			unauthorizedReply: "You are not authorized to answer this question.",
+			defer: false
+		})))
+	});
+}
+//#endregion
 //#region extensions/discord/src/monitor/provider.interactions.ts
 function createDiscordProviderInteractionSurface(params) {
 	const createNativeCommand = params.createNativeCommand ?? createDiscordNativeCommand;
@@ -10320,6 +10383,20 @@ function createDiscordProviderInteractionSurface(params) {
 		abortSignal: params.abortSignal
 	});
 	const components = [
+		createDiscordQuestionButton({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			authContext: {
+				cfg: params.cfg,
+				accountId: params.accountId,
+				discordConfig: params.discordConfig,
+				runtime: params.runtime,
+				token: params.token,
+				guildEntries: params.guildEntries,
+				allowFrom: params.allowFrom,
+				dmPolicy: params.dmPolicy
+			}
+		}),
 		createDiscordCommandArgFallbackButton({
 			cfg: params.cfg,
 			discordConfig: params.discordConfig,
@@ -10454,8 +10531,7 @@ async function createDiscordMonitorClient(params) {
 	const constructorPlugins = voicePlugin ? clientPlugins.filter((plugin) => plugin !== voicePlugin) : clientPlugins;
 	const eventQueueOpts = {
 		listenerTimeout: 12e4,
-		slowListenerThreshold: 3e4,
-		...params.discordConfig.eventQueue
+		slowListenerThreshold: 3e4
 	};
 	const readyListener = createDiscordStatusReadyListener({
 		discordConfig: params.discordConfig,
@@ -10667,8 +10743,6 @@ async function monitorDiscordProvider(opts = {}) {
 	if (!token) throw new Error(`Discord bot token missing for account "${account.accountId}" (set discord.accounts.${account.accountId}.token or DISCORD_BOT_TOKEN for default).`);
 	const runtime = opts.runtime ?? createNonExitingRuntime();
 	const rawDiscordCfg = account.config;
-	const discordRootThreadBindings = cfg.channels?.discord?.threadBindings;
-	const discordAccountThreadBindings = cfg.channels?.discord?.accounts?.[account.accountId]?.threadBindings;
 	const discordRestFetch = resolveDiscordRestFetch(rawDiscordCfg.proxy, runtime);
 	const dmConfig = rawDiscordCfg.dm;
 	const configuredDmAllowFrom = resolveDiscordAccountAllowFrom({
@@ -10705,15 +10779,15 @@ async function monitorDiscordProvider(opts = {}) {
 	}) ?? "pairing";
 	const discordProviderSessionRuntime = await discordProviderRuntime.loadDiscordProviderSessionRuntime();
 	const threadBindingIdleTimeoutMs = discordProviderSessionRuntime.resolveThreadBindingIdleTimeoutMs({
-		channelIdleHoursRaw: discordAccountThreadBindings?.idleHours ?? discordRootThreadBindings?.idleHours,
+		channelIdleHoursRaw: discordCfg.threadBindings?.idleHours,
 		sessionIdleHoursRaw: cfg.session?.threadBindings?.idleHours
 	});
 	const threadBindingMaxAgeMs = discordProviderSessionRuntime.resolveThreadBindingMaxAgeMs({
-		channelMaxAgeHoursRaw: discordAccountThreadBindings?.maxAgeHours ?? discordRootThreadBindings?.maxAgeHours,
+		channelMaxAgeHoursRaw: discordCfg.threadBindings?.maxAgeHours,
 		sessionMaxAgeHoursRaw: cfg.session?.threadBindings?.maxAgeHours
 	});
 	const threadBindingsEnabled = discordProviderSessionRuntime.resolveThreadBindingsEnabled({
-		channelEnabledRaw: discordAccountThreadBindings?.enabled ?? discordRootThreadBindings?.enabled,
+		channelEnabledRaw: discordCfg.threadBindings?.enabled,
 		sessionEnabledRaw: cfg.session?.threadBindings?.enabled
 	});
 	const groupDmEnabled = dmConfig?.groupEnabled ?? false;
@@ -10728,7 +10802,7 @@ async function monitorDiscordProvider(opts = {}) {
 		providerSetting: discordCfg.commands?.nativeSkills,
 		globalSetting: cfg.commands?.nativeSkills
 	});
-	const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+	const useAccessGroups = true;
 	const slashCommand = resolveDiscordSlashCommandConfig(discordCfg.slashCommand);
 	const sessionPrefix = "discord:slash";
 	const ephemeralDefault = slashCommand.ephemeral;
@@ -10821,7 +10895,6 @@ async function monitorDiscordProvider(opts = {}) {
 	let earlyGatewayEmitter = gatewaySupervisor?.emitter;
 	let onEarlyGatewayDebug;
 	try {
-		if (nativeEnabled && commandSpecs.some((command) => command.name === "think")) loadModelCatalog({ config: cfg });
 		const { commands, components, modals } = createDiscordProviderInteractionSurface({
 			cfg,
 			discordConfig: discordCfg,
@@ -10915,7 +10988,7 @@ async function monitorDiscordProvider(opts = {}) {
 				runtime,
 				botUserId
 			});
-			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-TDZcMriu.js").then((n) => n.n);
+			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-CyJ-sc3n.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: account.accountId,
 				manager: voiceManager
@@ -10927,6 +11000,7 @@ async function monitorDiscordProvider(opts = {}) {
 			registerDiscordListener(client.listeners, new DiscordVoiceStateUpdateListener(voiceManager));
 		}
 		const messageHandler = discordProviderSessionRuntime.createDiscordMessageHandler({
+			client,
 			cfg,
 			discordConfig: discordCfg,
 			accountId: account.accountId,
@@ -11001,12 +11075,10 @@ async function monitorDiscordProvider(opts = {}) {
 			voiceManager,
 			voiceManagerRef,
 			threadBindings,
-			gatewaySupervisor,
-			gatewayReadyTimeoutMs: account.config.gatewayReadyTimeoutMs,
-			gatewayRuntimeReadyTimeoutMs: account.config.gatewayRuntimeReadyTimeoutMs
+			gatewaySupervisor
 		});
 	} finally {
-		cleanupDiscordProviderStartup({
+		await cleanupDiscordProviderStartup({
 			deactivateMessageHandler,
 			autoPresenceController,
 			setStatus: opts.setStatus,
@@ -11021,4 +11093,4 @@ async function monitorDiscordProvider(opts = {}) {
 	}
 }
 //#endregion
-export { resolveDiscordTextCommandAccess as A, registerDiscordListener as C, resolveDiscordThreadStarter as D, resolveDiscordReplyTarget as E, sanitizeDiscordThreadName as O, handleDiscordDmCommandDecision as S, resolveDiscordAutoThreadReplyPlan as T, createDiscordSupplementalContextAccessChecker as _, buildDirectLabel as a, resolveDiscordEffectiveRoute as b, resolveDiscordVoiceAccess as c, resolveDiscordGatewayIntents as d, waitForDiscordGatewayPluginRegistration as f, buildDiscordInboundAccessContext as g, buildDiscordGroupSystemPrompt as h, sanitizeDiscordFrontChannelReplyPayloads as i, resolveDiscordDmCommandAccess as k, authorizeDiscordVoiceIngress as l, createDiscordNativeCommand as m, deliverDiscordReply as n, buildGuildLabel as o, resolveDiscordVoiceEnabled as p, formatDiscordReplyDeliveryFailure as r, resolveReplyContext as s, monitorDiscordProvider as t, createDiscordGatewayPlugin as u, buildDiscordRoutePeer as v, threading_exports as w, shouldIgnoreStaleDiscordRouteBinding as x, resolveDiscordConversationRoute as y };
+export { sanitizeDiscordThreadName as A, handleDiscordDmCommandDecision as C, resolveDiscordAutoThreadReplyPlan as D, threading_exports as E, resolveDiscordTextCommandAccess as M, resolveDiscordReplyTarget as O, shouldIgnoreStaleDiscordRouteBinding as S, registerDiscordListener as T, buildDiscordInboundAccessContext as _, sanitizeDiscordFrontChannelReplyPayloads as a, resolveDiscordConversationRoute as b, resolveReplyContext as c, createDiscordGatewayPlugin as d, resolveDiscordGatewayIntents as f, buildDiscordGroupSystemPrompt as g, createDiscordNativeCommand as h, formatDiscordReplySkip as i, resolveDiscordDmCommandAccess as j, resolveDiscordThreadStarter as k, resolveDiscordVoiceAccess as l, resolveDiscordVoiceEnabled as m, deliverDiscordReply as n, buildDirectLabel as o, waitForDiscordGatewayPluginRegistration as p, formatDiscordReplyDeliveryFailure as r, buildGuildLabel as s, monitorDiscordProvider as t, authorizeDiscordVoiceIngress as u, createDiscordSupplementalContextAccessChecker as v, mapGatewayDispatchData as w, resolveDiscordEffectiveRoute as x, buildDiscordRoutePeer as y };