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

package/dist/{provider-DfQJX3z5.js → provider-DlK_ynqt.js}

@@ -1,84 +1,83 @@
-import { C as Client, D as RateLimitError, F as Message, I as User, K as Container, M as Command, N as CommandWithSubcommands, P as Guild, Q as Row, V as Modal, W as Button, Yt as __exportAll, _ as MessageReactionRemoveListener, _t as editChannel, at as BaseMessageInteractiveComponent, bt as getChannelMessage, d as discord_exports, et as Separator, f as GuildCreateListener, g as MessageReactionAddListener, h as MessageCreateListener, m as InteractionCreateListener, mt as createThread, nt as TextDisplay, p as GuildDeleteListener, t as chunkDiscordTextWithMode, tt as StringSelectMenu, v as PresenceUpdateListener, w as Plugin, x as ThreadUpdateListener, y as ReadyListener } from "./chunk-DX4jpFQP.js";
-import { c as resolveDiscordAccountAllowFrom, d as resolveDiscordAccountDmPolicy, f as resolveDiscordMaxLinesPerMessage, p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-DJTf1LtA.js";
-import { n as getDiscordActivitiesRuntime } from "./runtime-BmW_j_hl.js";
-import { C as parseDiscordActivityCustomIdForInteraction, D as parseDiscordModalCustomIdForInteraction, E as parseDiscordModalCustomId, O as decodeCustomIdComponent, T as parseDiscordComponentCustomIdForInteraction, k as encodeCustomIdComponent, l as parseExecApprovalData, s as parseDiscordQuestionData, w as parseDiscordComponentCustomId, y as buildDiscordActivityCustomId } from "./outbound-session-route-H-HoyH5U.js";
-import { D as canViewDiscordGuildChannel, F as createDiscordRestClient, H as registerGateway, K as validateDiscordProxyUrl, U as unregisterGateway, q as withValidatedDiscordProxy, z as DISCORD_REST_TIMEOUT_MS } from "./send.shared-jpvAG_u6.js";
-import { _ as resolveDiscordModalEntryWithPersistence, g as resolveDiscordComponentEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-5uqwkjgE.js";
+import { A as RateLimitError, B as hasDiscordV2Components, C as ThreadDeleteListener, D as Plugin, E as Client, F as Command, G as Modal, I as CommandWithSubcommands, J as Button, L as Guild, R as Message, X as Container, _ as MessageCreateListener, a as chunkDiscordTextWithMode, at as StringSelectMenu, b as PresenceUpdateListener, g as InteractionCreateListener, h as GuildDeleteListener, it as Separator, lt as BaseMessageInteractiveComponent, m as GuildCreateListener, nt as Row, ot as TextDisplay, p as discord_exports, v as MessageReactionAddListener, w as ThreadUpdateListener, x as ReadyListener, y as MessageReactionRemoveListener, z as User } from "./retry-DNsVTeTo.js";
+import { C as parseDiscordComponentCustomId, D as decodeCustomIdComponent, E as parseDiscordModalCustomIdForInteraction, O as encodeCustomIdComponent, S as parseDiscordActivityCustomIdForInteraction, T as parseDiscordModalCustomId, c as parseExecApprovalData, o as parseDiscordQuestionData, v as buildDiscordActivityCustomId, w as parseDiscordComponentCustomIdForInteraction } from "./components-ezGKo_Yh.js";
+import { c as resolveDiscordAccount, f as resolveDiscordAccountDmPolicy, l as resolveDiscordAccountAllowFrom, m as normalizeDiscordToken, p as resolveDiscordMaxLinesPerMessage } from "./accounts-DNl-oCEw.js";
+import { a as resolveDiscordComponentEntryWithPersistence, o as resolveDiscordModalEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-ChK1wS7w.js";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
-import { a as isDiscordRateLimitResponseBody, o as summarizeDiscordResponseBody } from "./api-DnrK9gML.js";
-import { C as resolveTimestampMs, a as normalizeDiscordSlug, b as formatDiscordReactionEmoji, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordCommandOwnerAllowFrom, f as resolveDiscordGuildEntry, g as resolveDiscordOwnerAllowFrom, h as resolveDiscordOwnerAccess, i as normalizeDiscordDisplaySlug, l as resolveDiscordChannelPolicyCommandAuthorizer, m as resolveDiscordMemberAllowed, n as isDiscordGroupAllowedByPolicy, o as resolveDiscordAllowListMatch, p as resolveDiscordMemberAccessState, r as normalizeDiscordAllowList, t as allowListMatches, v as resolveGroupDmAllow, x as formatDiscordUserTag, y as shouldEmitDiscordReactionNotification } from "./allow-list-DzKrtfah.js";
-import { a as formatMention, t as sendMessageDiscord } from "./send.outbound-D-80Ej-t.js";
+import { a as isDiscordRateLimitResponseBody, o as summarizeDiscordResponseBody } from "./api-DNVbJyEy.js";
+import { C as resolveTimestampMs, a as normalizeDiscordSlug, b as formatDiscordReactionEmoji, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordCommandOwnerAllowFrom, f as resolveDiscordGuildEntry, g as resolveDiscordOwnerAllowFrom, h as resolveDiscordOwnerAccess, i as normalizeDiscordDisplaySlug, l as resolveDiscordChannelPolicyCommandAuthorizer, m as resolveDiscordMemberAllowed, n as isDiscordGroupAllowedByPolicy, o as resolveDiscordAllowListMatch, p as resolveDiscordMemberAccessState, r as normalizeDiscordAllowList, v as resolveGroupDmAllow, x as formatDiscordUserTag, y as shouldEmitDiscordReactionNotification } from "./allow-list-BDMimASD.js";
+import { F as createDiscordRestClient, G as registerGateway, H as withValidatedDiscordProxy, K as unregisterGateway, V as validateDiscordProxyUrl, b as canViewDiscordGuildChannel, z as DISCORD_REST_TIMEOUT_MS } from "./send.shared-B3fpaLWJ.js";
+import { a as formatMention, t as sendMessageDiscord } from "./send.outbound-HIkgji_7.js";
+import { n as getDiscordActivitiesRuntime } from "./runtime-CQovMsH3.js";
+import { n as resolveDiscordVoiceEnabled, r as authorizeDiscordVoiceIngress, t as resolveDiscordVoiceAccess } from "./owner-access-Bg41VzAf.js";
 import { i as setPresence, t as clearPresences } from "./presence-cache-z1N8MbJ3.js";
-import { n as sendVoiceMessageDiscord } from "./send-CdkZ6zeW.js";
+import { r as sendVoiceMessageDiscord } from "./send-rQIffSYu.js";
 import { c as raceWithTimeout, u as withAbortTimeout } from "./timeouts-B9cy6RvQ.js";
-import { a as getDiscordExecApprovalApprovers, n as formatDiscordApprovalDisplayValue, r as resolveDiscordConversationIdentity, s as isDiscordExecApprovalClientEnabled, t as DISCORD_APPROVAL_ALLOWED_MENTIONS } from "./approval-message-safety-DEyKVsAw.js";
-import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-BjepAj8b.js";
-import { t as resolveDiscordUserAllowlist } from "./resolve-users-Bc28htgt.js";
-import { a as isThreadArchived, d as resolveDiscordChannelIdSafe, f as resolveDiscordChannelInfoSafe, g as resolveDiscordChannelTopicSafe, h as resolveDiscordChannelParentSafe, m as resolveDiscordChannelParentIdSafe, p as resolveDiscordChannelNameSafe, y as formatThreadBindingDurationLabel } from "./thread-bindings.discord-api-BoDNqamb.js";
-import { r as parseApplicationIdFromToken, t as fetchDiscordApplicationId } from "./probe-BeWKhjqX.js";
-import { i as timestampMs, n as normalizeModelRef, r as sanitizeRecentModels, t as buildPreferenceModelKey } from "./model-picker-preference-primitives-D25pnCOu.js";
-import { a as formatDiscordMediaText, d as resolveDiscordChannelInfo, f as resolveDiscordMessageChannelId, n as resolveDiscordForwardedMessagesTextFromSnapshots, t as resolveDiscordEmbedText } from "./message-utils-BgTwT_q7.js";
-import { t as resolveDiscordSenderIdentity } from "./sender-identity-mG_zsdox.js";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import { buildAgentSessionKey, deriveLastRoutePolicy, isAcpSessionKey, isSubagentSessionKey, parseAgentSessionKey, resolveAgentIdFromSessionKey, resolveAgentRoute } from "openclaw/plugin-sdk/routing";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeOptionalStringifiedId, normalizeStringEntries, normalizeStringEntriesLower, summarizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { getRuntimeConfig, getRuntimeConfigSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
+import { a as resolveDiscordBoundConversationRoute, f as getDiscordExecApprovalApprovers, l as resolveDiscordConversationIdentity, m as isDiscordExecApprovalClientEnabled, n as formatDiscordApprovalDisplayValue, r as buildDiscordConversationRouteContext, s as resolveDiscordEffectiveRoute, t as DISCORD_APPROVAL_ALLOWED_MENTIONS } from "./approval-message-safety-XGFPbDoI.js";
+import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-CGeUoIqb.js";
+import { t as resolveDiscordUserAllowlist } from "./resolve-users-BtKxLUZv.js";
+import { a as isThreadArchived, c as resolveDiscordChannelInfoSafe, f as resolveDiscordChannelTopicSafe, h as formatThreadBindingDurationLabel, l as resolveDiscordChannelNameSafe, r as getThreadBindingManager, s as resolveDiscordChannelIdSafe, u as resolveDiscordChannelParentIdSafe } from "./thread-bindings.manager-CngsgErq.js";
+import { a as probeDiscordApplicationId, r as parseApplicationIdFromToken } from "./probe-BTdtVRwU.js";
+import { i as sanitizeRecentModels, n as normalizeModelRef, r as preferenceTimestampMs, t as buildPreferenceModelKey } from "./model-picker-preference-primitives-BHT1LkR_.js";
+import { d as resolveDiscordMessageStickers, f as resolveDiscordChannelInfo } from "./message-utils-BXLLnFl6.js";
+import { i as resolveDiscordThreadParentInfo } from "./threading-DU6pgeGm.js";
+import { t as resolveDiscordSenderIdentity } from "./sender-identity-BJtfyise.js";
 import { logDebug, logError } from "openclaw/plugin-sdk/logging-core";
 import { ApplicationCommandOptionType, ButtonStyle, ChannelType, ComponentType, GatewayCloseCodes, GatewayCloseCodes as GatewayCloseCodes$1, GatewayDispatchEvents, GatewayIntentBits, GatewayOpcodes } from "discord-api-types/v10";
 import { createHash, randomUUID } from "node:crypto";
-import { MAX_DATE_TIMESTAMP_MS, asDateTimestampMs, parseFiniteNumber, parseStrictFiniteNumber, parseStrictInteger, parseStrictNonNegativeInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
+import { MAX_DATE_TIMESTAMP_MS, MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, asSafeIntegerInRange, parseFiniteNumber, parseStrictInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { Type } from "typebox";
 import { Check, Errors } from "typebox/value";
 import { inspect } from "node:util";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
-import { PlatformMessageNotDispatchedError, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { PlatformMessageNotDispatchedError, formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { fetchWithSsrFGuard, formatErrorMessage as formatErrorMessage$1 } from "openclaw/plugin-sdk/ssrf-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
+import { asFiniteNumber, asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries, parseFiniteNumber as parseFiniteNumber$1, parseStrictNonNegativeInteger as parseStrictNonNegativeInteger$1, summarizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { getRuntimeConfig, getRuntimeConfigSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
 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";
-import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
-import { buildOutboundSessionContext, resolveChannelStreamingBlockEnabled, sendDurableMessageBatch } from "openclaw/plugin-sdk/channel-outbound";
+import { chunkItems, findCodeRegions, sanitizeAssistantVisibleText, sanitizeAssistantVisibleTextWithProfile } from "openclaw/plugin-sdk/text-chunking";
+import { buildOutboundSessionContext, listMessageReceiptPlatformIds, resolveChannelStreamingBlockEnabled, sendDurableMessageBatch } from "openclaw/plugin-sdk/channel-outbound";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
 import { resolveSendableOutboundReplyParts, resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
 import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
-import { createLazyRuntimeModule, createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
-import { resolvePinnedMainDmOwnerFromAllowlist as resolvePinnedMainDmOwnerFromAllowlist$1 } from "openclaw/plugin-sdk/security-runtime";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { buildCommandTextFromArgs, findCommandByNativeName, formatCommandArgMenuTitle, listChatCommands, listNativeCommandSpecsForConfig, listSkillCommandsForAgents, resolveCommandAuthorizedFromAuthorizers, resolveEffectiveAgentRuntime, resolveNativeCommandSessionTargets, resolveStoredModelOverride, serializeCommandArgs } from "openclaw/plugin-sdk/command-auth-native";
 import { GROUP_POLICY_BLOCKED_LABEL, resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
+import { resolvePinnedMainDmOwnerFromAllowlist as resolvePinnedMainDmOwnerFromAllowlist$1 } from "openclaw/plugin-sdk/security-runtime";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
-import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 import { buildPairingReply, upsertChannelPairingRequest, upsertChannelPairingRequest as upsertChannelPairingRequest$1 } from "openclaw/plugin-sdk/conversation-runtime";
-import { clearExpiredCooldowns, ensureAuthProfileStore, formatReasoningMessage, getPreparedModelCatalogSnapshot, isProfileInCooldown, loadPreparedModelCatalog, resolveAgentAvatar, resolveAgentDir, resolveDefaultModelForAgent, resolveHumanDelayConfig, resolveProfilesUnavailableReason } from "openclaw/plugin-sdk/agent-runtime";
+import * as conversationRuntime from "openclaw/plugin-sdk/conversation-binding-runtime";
+import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
+import { clearExpiredCooldowns, ensureAuthProfileStore, formatReasoningMessage, getPreparedModelCatalogSnapshot, isProfileInCooldown, listAgentIds, loadPreparedModelCatalog, resolveAgentAvatar, resolveAgentDir, resolveDefaultModelForAgent, resolveHumanDelayConfig, resolveProfilesUnavailableReason } from "openclaw/plugin-sdk/agent-runtime";
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { resolveNativeCommandsEnabled, resolveNativeSkillsEnabled } from "openclaw/plugin-sdk/native-command-config-runtime";
-import { normalizeProviderId } from "openclaw/plugin-sdk/provider-model-shared";
 import { requestHeartbeat } from "openclaw/plugin-sdk/heartbeat-runtime";
-import { enqueueSystemEvent, enqueueSystemEvent as enqueueSystemEvent$1 } from "openclaw/plugin-sdk/system-event-runtime";
+import { enqueueRoutedSystemEvent, enqueueRoutedSystemEvent as enqueueRoutedSystemEvent$1 } from "openclaw/plugin-sdk/system-event-runtime";
+import { deleteSessionEntry, getSessionEntry, listSessionEntries, readSessionUpdatedAt as readSessionUpdatedAt$1, resolveStorePath, resolveStorePath as resolveStorePath$1 } from "openclaw/plugin-sdk/session-store-runtime";
 import { createChannelIngressResolver, defineStableChannelIngressIdentity, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { createChannelPartialDeliveryError, dispatchChannelInboundTurn, formatInboundEnvelope, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, resolveEnvelopeFormatOptions, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent } from "openclaw/plugin-sdk/channel-inbound";
-import { ModelSelectionLockedError, applyModelOverrideToSessionEntry, resolveChannelModelOverride } from "openclaw/plugin-sdk/model-session-runtime";
-import { completeWithPreparedSimpleCompletionModel, extractAssistantText, prepareSimpleCompletionModelForAgent } from "openclaw/plugin-sdk/simple-completion-runtime";
-import { deleteSessionEntry, getSessionEntry, listSessionEntries, patchSessionEntry, readSessionUpdatedAt as readSessionUpdatedAt$1, resolveStorePath, resolveStorePath as resolveStorePath$1 } from "openclaw/plugin-sdk/session-store-runtime";
-import { 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";
-import * as pluginRuntime from "openclaw/plugin-sdk/plugin-runtime";
-import { createInteractiveConversationBindingHelpers, dispatchPluginInteractiveHandler } from "openclaw/plugin-sdk/plugin-runtime";
-import * as conversationRuntime from "openclaw/plugin-sdk/conversation-binding-runtime";
 import { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-runtime";
-import { createConnectedChannelStatusPatch, createTransportActivityStatusPatch } from "openclaw/plugin-sdk/gateway-runtime";
+import { buildCommandTextFromArgs as buildCommandTextFromArgs$1, findCommandByNativeName as findCommandByNativeName$1, mergeNativeCommandSpecs, parseCommandArgs, resolveCommandArgChoices, resolveCommandArgMenu, serializeCommandArgs as serializeCommandArgs$1 } from "openclaw/plugin-sdk/native-command-registry";
+import { PLUGIN_COMMAND_DISPATCH } from "openclaw/plugin-sdk/plugin-command-runtime";
+import { resolveDirectStatusReplyForSession } from "openclaw/plugin-sdk/command-status-runtime";
+import { normalizeProviderId } from "openclaw/plugin-sdk/provider-model-shared";
 import { EventEmitter } from "node:events";
 import * as ws from "ws";
 import { Agent } from "node:https";
 import { captureHttpExchange, captureWsEvent, resolveDebugProxySettings, resolveEffectiveDebugProxyUrl } from "openclaw/plugin-sdk/proxy-capture";
 import * as dns from "node:dns";
+import { channelReadyPatch, createTransportActivityStatusPatch } from "openclaw/plugin-sdk/gateway-runtime";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
 import { stripPlainTextToolCallBlocks } from "openclaw/plugin-sdk/tool-payload";
+import { createChannelInteractiveDispatcher } from "openclaw/plugin-sdk/plugin-runtime";
 import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
 import { resolveRequestUrl } from "openclaw/plugin-sdk/request-url";
 import { fetchWithRuntimeDispatcher } from "openclaw/plugin-sdk/runtime-fetch";
@@ -141,6 +140,205 @@ async function runDiscordListenerWithSlowLog(params) {
 	}
 }
 //#endregion
+//#region extensions/discord/src/monitor/presence-events.ts
+const DISCORD_PRESENCE_GREETING_COOLDOWN_MS = 480 * 60 * 1e3;
+function isDiscordOnlineStatus(status) {
+	return status === "online" || status === "idle" || status === "dnd";
+}
+function isDiscordOfflineStatus(status) {
+	return status === "offline";
+}
+function resolveDiscordOnlinePresenceEvent(params) {
+	const config = params.config;
+	const userId = params.data.user?.id?.trim();
+	if (!config || config.enabled === false || !userId || userId === params.botUserId || params.data.user.bot === true || !isDiscordOnlineStatus(params.data.status) || !params.availabilityKind) return null;
+	if (config.users !== void 0 && !config.users.includes(userId)) return null;
+	if (params.lastEmittedAtMs !== void 0 && params.nowMs - params.lastEmittedAtMs < 288e5) return null;
+	const lines = [
+		"Discord online-presence event:",
+		params.availabilityKind === "observed-offline" ? `A human member became available online after being observed offline in guild_id=${JSON.stringify(params.data.guild_id)} user_id=${JSON.stringify(userId)} status=${JSON.stringify(params.data.status)}.` : `A human member became newly visible online since the current guild snapshot in guild_id=${JSON.stringify(params.data.guild_id)} user_id=${JSON.stringify(userId)} status=${JSON.stringify(params.data.status)}. They may have come online or joined after the snapshot; do not claim an exact prior status.`,
+		`The authorized greeting target is channel_id=${JSON.stringify(config.channelId)}.`,
+		"Before greeting, retrieve relevant memory and wiki context for this immutable user_id, including a known timezone when available. Use their local time for the greeting; if their timezone is unknown, do not guess.",
+		"Send at most one short, natural greeting to the target channel. Do not reveal private memory. If no greeting is appropriate, stay silent."
+	];
+	return {
+		channelId: config.channelId,
+		userId,
+		text: lines.join("\n")
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/presence-cooldown-store.ts
+const DISCORD_PRESENCE_COOLDOWN_MAX_ENTRIES = 25e3;
+function openDiscordPresenceCooldownStore() {
+	return getDiscordRuntime().state.openSyncKeyedStore({
+		namespace: "presence-greeting-cooldowns",
+		maxEntries: DISCORD_PRESENCE_COOLDOWN_MAX_ENTRIES,
+		overflowPolicy: "reject-new",
+		defaultTtlMs: DISCORD_PRESENCE_GREETING_COOLDOWN_MS
+	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/presence-emission-gate.ts
+const DISCORD_PRESENCE_RECONNECT_SUPPRESS_MS = 300 * 1e3;
+const DISCORD_PRESENCE_BURST_LIMIT = 8;
+const DISCORD_PRESENCE_BURST_WINDOW_MS = 60 * 1e3;
+function resolveDiscordPresenceGateOptions(config) {
+	return {
+		reconnectSuppressMs: config?.reconnectSuppressSeconds !== void 0 ? config.reconnectSuppressSeconds * 1e3 : DISCORD_PRESENCE_RECONNECT_SUPPRESS_MS,
+		burstLimit: config?.burstLimit ?? DISCORD_PRESENCE_BURST_LIMIT,
+		burstWindowMs: config?.burstWindowSeconds !== void 0 ? config.burstWindowSeconds * 1e3 : DISCORD_PRESENCE_BURST_WINDOW_MS
+	};
+}
+/**
+* Per-account lifecycle gate for online-presence events. Reconnect state belongs to the Gateway
+* session, while burst state follows the guild-owned configuration that supplies its limits.
+*/
+var DiscordPresenceEmissionGate = class {
+	constructor() {
+		this.reconnectLogged = false;
+		this.burstByGuild = /* @__PURE__ */ new Map();
+		this.nextReservationId = 0;
+	}
+	noteGatewaySessionReset(nowMs) {
+		this.lastSessionResetAtMs = nowMs;
+		this.reconnectLogged = false;
+	}
+	evaluateReconnectWindow(nowMs, options) {
+		if (this.lastSessionResetAtMs !== void 0 && options.reconnectSuppressMs > 0 && nowMs - this.lastSessionResetAtMs < options.reconnectSuppressMs) {
+			const shouldLog = !this.reconnectLogged;
+			this.reconnectLogged = true;
+			return {
+				allowed: false,
+				reason: "reconnect-window",
+				shouldLog
+			};
+		}
+		return { allowed: true };
+	}
+	reserveBurst(guildId, nowMs, options) {
+		const state = this.burstByGuild.get(guildId) ?? {
+			reservations: [],
+			logged: false
+		};
+		state.reservations = state.reservations.filter((reservation) => !reservation.committed || nowMs - reservation.atMs < options.burstWindowMs);
+		this.burstByGuild.set(guildId, state);
+		if (state.reservations.length >= options.burstLimit) {
+			const shouldLog = !state.logged;
+			state.logged = true;
+			return {
+				allowed: false,
+				reason: state.reservations.some((reservation) => !reservation.committed) ? "burst-pending" : "burst",
+				shouldLog
+			};
+		}
+		state.logged = false;
+		const reservation = {
+			id: this.nextReservationId++,
+			atMs: nowMs,
+			committed: false
+		};
+		state.reservations.push(reservation);
+		return {
+			allowed: true,
+			reservation: reservation.id
+		};
+	}
+	commitBurst(guildId, reservation, nowMs) {
+		const entry = this.burstByGuild.get(guildId)?.reservations.find((candidate) => candidate.id === reservation);
+		if (!entry) return;
+		entry.atMs = nowMs;
+		entry.committed = true;
+	}
+	releaseBurst(guildId, reservation) {
+		const state = this.burstByGuild.get(guildId);
+		if (!state) return;
+		state.reservations = state.reservations.filter((candidate) => candidate.id !== reservation);
+		if (state.reservations.length === 0 && !state.logged) this.burstByGuild.delete(guildId);
+	}
+};
+//#endregion
+//#region extensions/discord/src/monitor/presence-transition-cache.ts
+const DEFAULT_PRESENCE_BASELINE_MAX_ENTRIES = 75e3;
+var DiscordPresenceBaselineCache = class {
+	constructor(maxEntries = DEFAULT_PRESENCE_BASELINE_MAX_ENTRIES) {
+		this.maxEntries = maxEntries;
+		this.offlineByKey = /* @__PURE__ */ new Map();
+		this.onlineByKey = /* @__PURE__ */ new Map();
+	}
+	clear() {
+		this.offlineByKey.clear();
+		this.onlineByKey.clear();
+	}
+	clearScope(scope) {
+		for (const markers of [this.offlineByKey, this.onlineByKey]) for (const [key, markerScope] of markers) if (markerScope === scope) markers.delete(key);
+	}
+	isOffline(scope, key) {
+		return this.offlineByKey.get(key) === scope;
+	}
+	isOnline(scope, key) {
+		return this.onlineByKey.get(key) === scope;
+	}
+	observeOffline(scope, key) {
+		this.deleteMarker(this.onlineByKey, scope, key);
+		return this.observe(this.offlineByKey, scope, key);
+	}
+	observeOnline(scope, key) {
+		this.deleteMarker(this.offlineByKey, scope, key);
+		return this.observe(this.onlineByKey, scope, key);
+	}
+	deleteMarker(markers, scope, key) {
+		if (markers.get(key) === scope) markers.delete(key);
+	}
+	observe(markers, scope, key) {
+		markers.delete(key);
+		markers.set(key, scope);
+		let evictedScope;
+		while (markers.size > this.maxEntries) {
+			const oldestKey = markers.keys().next().value;
+			if (oldestKey === void 0) break;
+			evictedScope = markers.get(oldestKey);
+			markers.delete(oldestKey);
+		}
+		return evictedScope;
+	}
+};
+//#endregion
+//#region extensions/discord/src/monitor/thread-session-close.ts
+/**
+* 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, threadId } = params;
+	const normalizedThreadId = normalizeOptionalLowercaseString(threadId) ?? "";
+	if (!normalizedThreadId) return 0;
+	const segmentRe = new RegExp(`:${normalizedThreadId}(?::|$)`, "i");
+	function sessionKeyContainsThreadId(key) {
+		return segmentRe.test(key);
+	}
+	let resetCount = 0;
+	for (const agentId of listAgentIds(cfg)) {
+		const storePath = resolveStorePath(cfg.session?.store, { agentId });
+		for (const { sessionKey, entry } of listSessionEntries({
+			agentId,
+			storePath,
+			readOnly: true
+		})) {
+			if (!sessionKeyContainsThreadId(sessionKey)) continue;
+			if (await deleteSessionEntry({
+				archiveTranscript: true,
+				expectedSessionId: entry.sessionId ?? null,
+				expectedUpdatedAt: entry.updatedAt,
+				sessionKey,
+				storePath
+			})) resetCount += 1;
+		}
+	}
+	return resetCount;
+}
+//#endregion
 //#region extensions/discord/src/monitor/dm-command-auth.ts
 const DISCORD_ALLOW_LIST_PREFIXES = [
 	"discord:",
@@ -253,8 +451,11 @@ async function resolveDiscordDmCommandAccess(params) {
 		subject: createDiscordDmIngressSubject(params.sender),
 		conversation: {
 			kind: "direct",
-			id: params.sender.id
+			id: params.conversationId ?? params.sender.id,
+			parentId: params.conversationParentId,
+			threadId: params.conversationThreadId
 		},
+		...params.contextBinding ? { contextBinding: params.contextBinding } : {},
 		event: {
 			kind: params.eventKind ?? "native-command",
 			authMode: "inbound",
@@ -275,7 +476,7 @@ async function resolveDiscordTextCommandAccess(params) {
 	const memberAccessGroup = "discord-member-access";
 	const commandGroup = params.memberAccessConfigured ? [`accessGroup:${memberAccessGroup}`] : [];
 	const accessGroupMembership = params.memberAccessConfigured ? [syntheticAccessGroupMembership(memberAccessGroup, params.memberAllowed)] : [];
-	return (await createDiscordIngressResolver({
+	return await createDiscordIngressResolver({
 		accountId: params.accountId,
 		cfg: params.cfg,
 		token: params.token,
@@ -283,9 +484,12 @@ async function resolveDiscordTextCommandAccess(params) {
 	}).command({
 		subject: createDiscordDmIngressSubject(params.sender),
 		conversation: {
-			kind: "group",
-			id: "discord-command"
+			kind: "channel",
+			id: params.conversationId ?? "discord-command",
+			parentId: params.conversationParentId,
+			threadId: params.conversationThreadId
 		},
+		...params.contextBinding ? { contextBinding: params.contextBinding } : {},
 		accessGroupMembership,
 		dmPolicy: "allowlist",
 		groupPolicy: "allowlist",
@@ -297,525 +501,38 @@ async function resolveDiscordTextCommandAccess(params) {
 			hasControlCommand: params.hasControlCommand,
 			modeWhenAccessGroupsOff: "configured"
 		}
-	})).commandAccess;
-}
-//#endregion
-//#region extensions/discord/src/monitor/thread-title.ts
-const DEFAULT_THREAD_TITLE_TIMEOUT_MS = 6e4;
-const MAX_THREAD_TITLE_SOURCE_CHARS = 600;
-const MAX_THREAD_TITLE_CHANNEL_NAME_CHARS = 120;
-const MAX_THREAD_TITLE_CHANNEL_DESCRIPTION_CHARS = 320;
-const DISCORD_THREAD_TITLE_MAX_TOKENS = 4096;
-const DISCORD_THREAD_TITLE_SYSTEM_PROMPT = "Generate a concise Discord thread title (3-6 words). Return only the title. Use channel context when provided and avoid redundant channel-name words unless needed for clarity.";
-async function generateThreadTitle(params) {
-	const sourceText = params.messageText.trim();
-	if (!sourceText) return null;
-	const prepared = await prepareSimpleCompletionModelForAgent({
-		cfg: params.cfg,
-		agentId: params.agentId,
-		...params.modelRef ? { modelRef: params.modelRef } : {},
-		useUtilityModel: true,
-		allowMissingApiKeyModes: ["aws-sdk"]
-	});
-	if ("error" in prepared) {
-		const modelLabel = prepared.selection ? `${prepared.selection.provider}/${prepared.selection.modelId}` : "unknown";
-		logVerbose(`thread-title: ${prepared.error} (agent=${params.agentId}, model=${modelLabel})`);
-		return null;
-	}
-	try {
-		const userMessage = buildThreadTitleCompletionUserMessage({
-			sourceText,
-			channelName: params.channelName,
-			channelDescription: params.channelDescription
-		});
-		const timeoutMs = resolveThreadTitleTimeoutMs(params.timeoutMs);
-		return normalizeGeneratedThreadTitle(extractAssistantText(await completeThreadTitle({
-			model: prepared.model,
-			auth: prepared.auth,
-			userMessage,
-			timeoutMs
-		}))) || null;
-	} catch (err) {
-		logVerbose(`thread-title: title generation failed for agent ${params.agentId}: ${String(err)}`);
-		return null;
-	}
-}
-async function completeThreadTitle(params) {
-	const maxTokens = Math.min(DISCORD_THREAD_TITLE_MAX_TOKENS, Math.floor(params.model.maxTokens));
-	return await withAbortTimeout({
-		timeoutMs: params.timeoutMs,
-		createTimeoutError: () => /* @__PURE__ */ new Error(`thread-title timed out after ${params.timeoutMs}ms`),
-		run: async (signal) => await completeWithPreparedSimpleCompletionModel({
-			model: params.model,
-			auth: params.auth,
-			context: {
-				systemPrompt: DISCORD_THREAD_TITLE_SYSTEM_PROMPT,
-				messages: [{
-					role: "user",
-					content: params.userMessage,
-					timestamp: Date.now()
-				}]
-			},
-			options: {
-				maxTokens,
-				signal
-			}
-		})
-	});
-}
-function buildThreadTitleCompletionUserMessage(params) {
-	const sourceText = truncateThreadTitleSourceText(params.sourceText);
-	const channelName = normalizeTitleContextField(params.channelName, MAX_THREAD_TITLE_CHANNEL_NAME_CHARS);
-	const channelDescription = normalizeTitleContextField(params.channelDescription, MAX_THREAD_TITLE_CHANNEL_DESCRIPTION_CHARS);
-	const messageLines = [];
-	if (channelName) messageLines.push(`Channel: ${channelName}`);
-	if (channelDescription) messageLines.push(`Channel description: ${channelDescription}`);
-	messageLines.push(`Message:\n${sourceText}`);
-	return messageLines.join("\n\n");
-}
-function truncateThreadTitleSourceText(sourceText) {
-	if (sourceText.length <= MAX_THREAD_TITLE_SOURCE_CHARS) return sourceText;
-	return `${truncateUtf16Safe(sourceText, MAX_THREAD_TITLE_SOURCE_CHARS)}...`;
-}
-function resolveThreadTitleTimeoutMs(timeoutMs) {
-	return Math.max(100, Math.floor(timeoutMs ?? DEFAULT_THREAD_TITLE_TIMEOUT_MS));
-}
-function normalizeGeneratedThreadTitle(raw) {
-	const lines = raw.replace(/\r/g, "").split("\n");
-	let firstLine = "";
-	for (const line of lines) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		if (!firstLine && trimmed.startsWith("```")) continue;
-		firstLine = trimmed;
-		break;
-	}
-	return stripThreadTitleWrappers(firstLine);
-}
-function stripThreadTitleWrappers(raw) {
-	let current = raw.trim();
-	let previous = "";
-	while (current && current !== previous) {
-		previous = current;
-		current = current.replace(/^["'`]+|["'`]+$/g, "").trim();
-		current = stripBalancedWrapper(current, "**");
-		current = stripBalancedWrapper(current, "__");
-		current = stripBalancedWrapper(current, "*");
-		current = stripBalancedWrapper(current, "_");
-		current = stripBalancedWrapper(current, "~~");
-	}
-	return current;
-}
-function stripBalancedWrapper(text, marker) {
-	if (text.length < marker.length * 2 + 1) return text;
-	if (!text.startsWith(marker) || !text.endsWith(marker)) return text;
-	const inner = text.slice(marker.length, text.length - marker.length);
-	if (!inner || inner.includes(marker)) return text;
-	return inner;
-}
-function normalizeTitleContextField(raw, maxChars) {
-	const value = raw?.trim();
-	if (!value) return;
-	const singleLine = value.replace(/\s+/g, " ");
-	if (singleLine.length <= maxChars) return singleLine;
-	return `${truncateUtf16Safe(singleLine, maxChars)}...`;
-}
-//#endregion
-//#region extensions/discord/src/monitor/threading.cache.ts
-const DISCORD_THREAD_STARTER_CACHE_TTL_MS = 300 * 1e3;
-const DISCORD_THREAD_STARTER_CACHE_MAX = 500;
-const DISCORD_THREAD_STARTER_CACHE = /* @__PURE__ */ new Map();
-function resetDiscordThreadStarterCacheForTest() {
-	DISCORD_THREAD_STARTER_CACHE.clear();
-}
-function getCachedThreadStarter(key, now) {
-	const entry = DISCORD_THREAD_STARTER_CACHE.get(key);
-	if (!entry) return;
-	if (now - entry.updatedAt > DISCORD_THREAD_STARTER_CACHE_TTL_MS) {
-		DISCORD_THREAD_STARTER_CACHE.delete(key);
-		return;
-	}
-	DISCORD_THREAD_STARTER_CACHE.delete(key);
-	DISCORD_THREAD_STARTER_CACHE.set(key, {
-		...entry,
-		updatedAt: now
-	});
-	return entry.value;
-}
-function setCachedThreadStarter(key, value, now) {
-	DISCORD_THREAD_STARTER_CACHE.delete(key);
-	DISCORD_THREAD_STARTER_CACHE.set(key, {
-		value,
-		updatedAt: now
 	});
-	while (DISCORD_THREAD_STARTER_CACHE.size > DISCORD_THREAD_STARTER_CACHE_MAX) {
-		const iter = DISCORD_THREAD_STARTER_CACHE.keys().next();
-		if (iter.done) break;
-		DISCORD_THREAD_STARTER_CACHE.delete(iter.value);
-	}
 }
 //#endregion
-//#region extensions/discord/src/monitor/threading.starter.ts
-function isDiscordThreadType(type) {
+//#region extensions/discord/src/monitor/thread-channel-context.ts
+function isDiscordThreadChannelType(type) {
 	return type === discord_exports.ChannelType.PublicThread || type === discord_exports.ChannelType.PrivateThread || type === discord_exports.ChannelType.AnnouncementThread;
 }
-function isDiscordForumParentType(parentType) {
-	return parentType === discord_exports.ChannelType.GuildForum || parentType === discord_exports.ChannelType.GuildMedia;
-}
-function resolveDiscordThreadChannel(params) {
-	if (!params.isGuildMessage) return null;
-	const { message, channelInfo } = params;
-	const channel = "channel" in message ? message.channel : void 0;
-	if (channel && typeof channel === "object" && "isThread" in channel && typeof channel.isThread === "function" && channel.isThread()) return channel;
-	if (!isDiscordThreadType(channelInfo?.type)) return null;
-	const messageChannelId = params.messageChannelId || resolveDiscordMessageChannelId({ message });
-	if (!messageChannelId) return null;
-	return {
-		id: messageChannelId,
-		name: channelInfo?.name ?? void 0,
-		parentId: channelInfo?.parentId ?? void 0,
-		parent: void 0,
-		ownerId: channelInfo?.ownerId ?? void 0
-	};
-}
-async function resolveDiscordThreadParentInfo(params) {
-	const { threadChannel, channelInfo, client } = params;
-	const parent = resolveDiscordChannelParentSafe(threadChannel);
-	let parentId = resolveDiscordChannelParentIdSafe(threadChannel) ?? resolveDiscordChannelIdSafe(parent) ?? channelInfo?.parentId ?? void 0;
-	if (!parentId && threadChannel.id) parentId = (await resolveDiscordChannelInfo(client, threadChannel.id))?.parentId ?? void 0;
-	if (!parentId) return {};
-	let parentName = resolveDiscordChannelNameSafe(parent);
-	const parentInfo = await resolveDiscordChannelInfo(client, parentId);
-	parentName = parentName ?? parentInfo?.name;
-	const parentType = parentInfo?.type;
+function buildFetchedChannelInfo(channel) {
+	const channelInfo = resolveDiscordChannelInfoSafe(channel);
+	if (channelInfo.type === void 0) return null;
 	return {
-		id: parentId,
-		name: parentName,
-		type: parentType
+		type: channelInfo.type,
+		name: channelInfo.name,
+		topic: channelInfo.topic,
+		parentId: channelInfo.parentId,
+		ownerId: channelInfo.ownerId
 	};
 }
-async function resolveDiscordThreadStarter(params) {
-	const cacheKey = params.channel.id;
-	const cached = getCachedThreadStarter(cacheKey, Date.now());
-	if (cached) return cached;
-	try {
-		const messageChannelId = resolveDiscordThreadStarterMessageChannelId(params);
-		if (!messageChannelId) return null;
-		const starter = await fetchDiscordThreadStarterMessage({
-			client: params.client,
-			messageChannelId,
-			threadId: params.channel.id
-		});
-		if (!starter) return null;
-		const payload = buildDiscordThreadStarterPayload({
-			starter,
-			resolveTimestampMs: params.resolveTimestampMs
-		});
-		if (!payload) return null;
-		setCachedThreadStarter(cacheKey, payload, Date.now());
-		return payload;
-	} catch {
-		return null;
-	}
-}
-function resolveDiscordThreadStarterMessageChannelId(params) {
-	return isDiscordForumParentType(params.parentType) ? params.channel.id : params.parentId;
-}
-async function fetchDiscordThreadStarterMessage(params) {
-	const starter = await getChannelMessage(params.client.rest, params.messageChannelId, params.threadId);
-	return starter ? starter : null;
-}
-function buildDiscordThreadStarterPayload(params) {
-	const text = resolveDiscordThreadStarterText(params.starter);
-	if (!text) return null;
-	return {
-		text,
-		...resolveDiscordThreadStarterIdentity(params.starter),
-		timestamp: params.resolveTimestampMs(params.starter.timestamp) ?? void 0
-	};
-}
-function resolveDiscordThreadStarterText(starter) {
-	const content = normalizeOptionalString(starter.content) ?? "";
-	const embedText = resolveDiscordEmbedText(starter.embeds?.[0]);
-	const forwardedText = resolveDiscordForwardedMessagesTextFromSnapshots(starter.message_snapshots);
-	return [content || embedText || forwardedText, formatDiscordMediaText({
-		attachments: starter.attachments ?? void 0,
-		stickers: starter.sticker_items ?? void 0
-	})].filter(Boolean).join("\n");
-}
-function resolveDiscordThreadStarterIdentity(starter) {
-	return {
-		author: resolveDiscordThreadStarterAuthor(starter),
-		authorId: starter.author?.id ?? void 0,
-		authorName: starter.author?.username ?? void 0,
-		authorTag: resolveDiscordThreadStarterAuthorTag(starter.author),
-		memberRoleIds: resolveDiscordThreadStarterRoleIds(starter.member)
-	};
-}
-function resolveDiscordThreadStarterAuthor(starter) {
-	return starter.member?.nick ?? starter.member?.displayName ?? resolveDiscordThreadStarterAuthorTag(starter.author) ?? starter.author?.username ?? starter.author?.id ?? "Unknown";
-}
-function resolveDiscordThreadStarterAuthorTag(author) {
-	if (!author?.username || !author.discriminator) return;
-	if (author.discriminator !== "0") return `${author.username}#${author.discriminator}`;
-	return author.username;
-}
-function resolveDiscordThreadStarterRoleIds(member) {
-	return Array.isArray(member?.roles) ? member.roles : void 0;
-}
-function resolveDiscordReplyTarget(opts) {
-	if (opts.replyToMode === "off") return;
-	const replyToId = normalizeOptionalString(opts.replyToId);
-	if (!replyToId) return;
-	if (opts.replyToMode === "all") return replyToId;
-	return opts.hasReplied ? void 0 : replyToId;
-}
-function sanitizeDiscordThreadName(rawName, fallbackId) {
-	return truncateUtf16Safe(truncateUtf16Safe(rawName.replace(/<@!?\d+>/g, "").replace(/<@&\d+>/g, "").replace(/<#\d+>/g, "").replace(/\s+/g, " ").trim() || `Thread ${fallbackId}`, 80), 100) || `Thread ${fallbackId}`;
-}
-function resolveDiscordReplyDeliveryPlan(params) {
-	const originalReplyTarget = params.replyTarget;
-	let deliverTarget = originalReplyTarget;
-	let replyTarget = originalReplyTarget;
-	if (params.createdThreadId) {
-		deliverTarget = `channel:${params.createdThreadId}`;
-		replyTarget = deliverTarget;
-	}
-	const allowReference = deliverTarget === originalReplyTarget;
-	const replyReference = createReplyReferencePlanner({
-		replyToMode: allowReference ? params.replyToMode : "off",
-		existingId: params.threadChannel ? params.messageId : void 0,
-		startId: params.messageId,
-		allowReference
-	});
-	return {
-		deliverTarget,
-		replyTarget,
-		replyReference
-	};
-}
-//#endregion
-//#region extensions/discord/src/monitor/threading.auto-thread.ts
-function resolveTrimmedDiscordMessageChannelId(params) {
-	return (params.messageChannelId || resolveDiscordMessageChannelId({ message: params.message })).trim();
-}
-function resolveDiscordAutoThreadContext(params) {
-	const createdThreadId = normalizeOptionalStringifiedId(params.createdThreadId) ?? "";
-	if (!createdThreadId) return null;
-	const messageChannelId = normalizeOptionalString(params.messageChannelId) ?? "";
-	if (!messageChannelId) return null;
-	const threadSessionKey = buildAgentSessionKey({
-		agentId: params.agentId,
-		channel: params.channel,
-		peer: {
-			kind: "channel",
-			id: createdThreadId
-		}
-	});
-	const parentSessionKey = buildAgentSessionKey({
-		agentId: params.agentId,
-		channel: params.channel,
-		peer: {
-			kind: "channel",
-			id: messageChannelId
-		}
-	});
-	return {
-		createdThreadId,
-		From: `${params.channel}:channel:${createdThreadId}`,
-		To: `channel:${createdThreadId}`,
-		OriginatingTo: `channel:${createdThreadId}`,
-		SessionKey: threadSessionKey,
-		ModelParentSessionKey: parentSessionKey,
-		...params.parentInheritanceEnabled === true ? { ParentSessionKey: parentSessionKey } : {}
-	};
-}
-async function resolveDiscordAutoThreadReplyPlan(params) {
-	const messageChannelId = resolveTrimmedDiscordMessageChannelId(params);
-	const originalReplyTarget = `channel:${params.threadChannel?.id ?? (messageChannelId || "unknown")}`;
-	const createdThreadId = await maybeCreateDiscordAutoThread({
-		client: params.client,
-		message: params.message,
-		messageChannelId: messageChannelId || void 0,
-		channel: params.channel,
-		isGuildMessage: params.isGuildMessage,
-		channelConfig: params.channelConfig,
-		threadChannel: params.threadChannel,
-		channelType: params.channelType,
-		channelName: params.channelName,
-		channelDescription: params.channelDescription,
-		baseText: params.baseText,
-		combinedBody: params.combinedBody,
-		cfg: params.cfg,
-		agentId: params.agentId
-	});
-	const deliveryPlan = resolveDiscordReplyDeliveryPlan({
-		replyTarget: originalReplyTarget,
-		replyToMode: params.replyToMode,
-		messageId: params.message.id,
-		threadChannel: params.threadChannel,
-		createdThreadId
-	});
-	const autoThreadContext = params.isGuildMessage ? resolveDiscordAutoThreadContext({
-		agentId: params.agentId,
-		channel: params.channel,
-		messageChannelId,
-		createdThreadId,
-		parentInheritanceEnabled: params.threadParentInheritanceEnabled
-	}) : null;
-	return {
-		...deliveryPlan,
-		createdThreadId,
-		autoThreadContext
-	};
-}
-async function maybeCreateDiscordAutoThread(params) {
-	if (!params.isGuildMessage) return;
-	if (!params.channelConfig?.autoThread) return;
-	if (params.threadChannel) return;
-	if (params.channelType === discord_exports.ChannelType.GuildForum || params.channelType === discord_exports.ChannelType.GuildMedia || params.channelType === discord_exports.ChannelType.GuildVoice || params.channelType === discord_exports.ChannelType.GuildStageVoice) return;
-	const messageChannelId = resolveTrimmedDiscordMessageChannelId(params);
-	if (!messageChannelId) return;
-	try {
-		try {
-			const existingThreadId = (await getChannelMessage(params.client.rest, messageChannelId, params.message.id))?.thread?.id;
-			if (existingThreadId) {
-				logVerbose(`discord: autoThread reusing existing thread ${existingThreadId} on ${messageChannelId}/${params.message.id}`);
-				return existingThreadId;
-			}
-		} catch {}
-		if (params.message.author?.bot) {
-			logVerbose(`discord: autoThread skipped for bot-authored message ${messageChannelId}/${params.message.id}`);
-			return;
-		}
-		const rawThreadSource = params.baseText || params.combinedBody || "Thread";
-		const threadName = sanitizeDiscordThreadName(rawThreadSource, params.message.id);
-		const archiveDuration = params.channelConfig?.autoArchiveDuration ? Number(params.channelConfig.autoArchiveDuration) : 60;
-		const createdId = (await createThread(params.client.rest, messageChannelId, { body: {
-			name: threadName,
-			auto_archive_duration: archiveDuration
-		} }, params.message.id))?.id || "";
-		if (createdId && params.channelConfig?.autoThreadName === "generated" && params.cfg && params.agentId) {
-			const modelRef = resolveDiscordThreadTitleModelRef({
-				cfg: params.cfg,
-				channel: params.channel,
-				agentId: params.agentId,
-				threadId: createdId,
-				messageChannelId,
-				channelName: params.channelName
-			});
-			maybeRenameDiscordAutoThread({
-				client: params.client,
-				threadId: createdId,
-				currentName: threadName,
-				fallbackId: params.message.id,
-				sourceText: rawThreadSource,
-				modelRef,
-				channelName: params.channelName,
-				channelDescription: params.channelDescription,
-				cfg: params.cfg,
-				agentId: params.agentId
-			});
-		}
-		return createdId || void 0;
-	} catch (err) {
-		logVerbose(`discord: autoThread creation failed for ${messageChannelId}/${params.message.id}: ${String(err)}`);
-		try {
-			const existingThreadId = (await getChannelMessage(params.client.rest, messageChannelId, params.message.id))?.thread?.id || "";
-			if (existingThreadId) {
-				logVerbose(`discord: autoThread reusing existing thread ${existingThreadId} on ${messageChannelId}/${params.message.id}`);
-				return existingThreadId;
-			}
-		} catch {}
-		return;
-	}
-}
-function resolveDiscordThreadTitleModelRef(params) {
-	const channel = params.channel?.trim();
-	if (!channel) return;
-	const parentSessionKey = buildAgentSessionKey({
-		agentId: params.agentId,
-		channel,
-		peer: {
-			kind: "channel",
-			id: params.messageChannelId
-		}
-	});
-	const channelLabel = params.channelName?.trim();
-	const groupChannel = channelLabel ? `#${channelLabel}` : void 0;
-	return resolveChannelModelOverride({
-		cfg: params.cfg,
-		channel,
-		groupId: params.threadId,
-		groupChatType: "channel",
-		groupChannel,
-		groupSubject: groupChannel,
-		parentSessionKey
-	})?.model;
-}
-async function maybeRenameDiscordAutoThread(params) {
-	try {
-		const fallbackName = sanitizeDiscordThreadName("", params.fallbackId);
-		const generated = await generateThreadTitle({
-			cfg: params.cfg,
-			agentId: params.agentId,
-			messageText: params.sourceText,
-			modelRef: params.modelRef,
-			channelName: params.channelName,
-			channelDescription: params.channelDescription
-		});
-		if (!generated) return;
-		const nextName = sanitizeDiscordThreadName(generated, params.fallbackId);
-		if (!nextName || nextName === params.currentName || nextName === fallbackName) return;
-		await editChannel(params.client.rest, params.threadId, { body: { name: nextName } });
-	} catch (err) {
-		logVerbose(`discord: autoThread rename failed for ${params.threadId}: ${String(err)}`);
-	}
-}
-//#endregion
-//#region extensions/discord/src/monitor/threading.ts
-var threading_exports = /* @__PURE__ */ __exportAll({
-	maybeCreateDiscordAutoThread: () => maybeCreateDiscordAutoThread,
-	resetDiscordThreadStarterCacheForTest: () => resetDiscordThreadStarterCacheForTest,
-	resolveDiscordAutoThreadContext: () => resolveDiscordAutoThreadContext,
-	resolveDiscordAutoThreadReplyPlan: () => resolveDiscordAutoThreadReplyPlan,
-	resolveDiscordReplyDeliveryPlan: () => resolveDiscordReplyDeliveryPlan,
-	resolveDiscordReplyTarget: () => resolveDiscordReplyTarget,
-	resolveDiscordThreadChannel: () => resolveDiscordThreadChannel,
-	resolveDiscordThreadParentInfo: () => resolveDiscordThreadParentInfo,
-	resolveDiscordThreadStarter: () => resolveDiscordThreadStarter,
-	sanitizeDiscordThreadName: () => sanitizeDiscordThreadName
-});
-//#endregion
-//#region extensions/discord/src/monitor/thread-channel-context.ts
-function isDiscordThreadChannelType(type) {
-	return type === discord_exports.ChannelType.PublicThread || type === discord_exports.ChannelType.PrivateThread || type === discord_exports.ChannelType.AnnouncementThread;
-}
-function buildFetchedChannelInfo(channel) {
-	const channelInfo = resolveDiscordChannelInfoSafe(channel);
-	if (channelInfo.type === void 0) return null;
-	return {
-		type: channelInfo.type,
-		name: channelInfo.name,
-		topic: channelInfo.topic,
-		parentId: channelInfo.parentId,
-		ownerId: channelInfo.ownerId
-	};
-}
-async function resolveDiscordThreadLikeChannelContext(params) {
-	const safeChannelInfo = resolveDiscordChannelInfoSafe(params.channel);
-	const channelId = resolveDiscordChannelIdSafe(params.channel) ?? params.channelIdFallback ?? "";
-	const channelInfo = params.channelInfo !== void 0 ? params.channelInfo : channelId ? await resolveDiscordChannelInfo(params.client, channelId) : null;
-	const channelType = safeChannelInfo.type ?? channelInfo?.type;
-	const channelName = safeChannelInfo.name ?? channelInfo?.name;
-	const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
-	const parentId = resolveDiscordChannelParentIdSafe(params.channel) ?? channelInfo?.parentId;
-	const isThreadChannel = isDiscordThreadChannelType(channelType);
-	let threadParentId;
-	let threadParentName;
-	let threadParentSlug = "";
-	if (channelId && isThreadChannel) {
-		const parentInfo = await resolveDiscordThreadParentInfo({
+async function resolveDiscordThreadLikeChannelContext(params) {
+	const safeChannelInfo = resolveDiscordChannelInfoSafe(params.channel);
+	const channelId = resolveDiscordChannelIdSafe(params.channel) ?? params.channelIdFallback ?? "";
+	const channelInfo = params.channelInfo !== void 0 ? params.channelInfo : channelId ? await resolveDiscordChannelInfo(params.client, channelId) : null;
+	const channelType = safeChannelInfo.type ?? channelInfo?.type;
+	const channelName = safeChannelInfo.name ?? channelInfo?.name;
+	const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
+	const parentId = resolveDiscordChannelParentIdSafe(params.channel) ?? channelInfo?.parentId;
+	const isThreadChannel = isDiscordThreadChannelType(channelType);
+	let threadParentId;
+	let threadParentName;
+	let threadParentSlug = "";
+	if (channelId && isThreadChannel) {
+		const parentInfo = await resolveDiscordThreadParentInfo({
 			client: params.client,
 			threadChannel: {
 				id: channelId,
@@ -1113,7 +830,7 @@ async function handleDiscordReactionEvent(params) {
 		const resolveReactionBase = () => {
 			if (reactionBase) return reactionBase;
 			const emojiLabel = formatDiscordReactionEmoji(data.emoji);
-			const actorLabel = formatDiscordUserTag(user);
+			const actorLabel = formatDiscordUserTag(user) || user.id;
 			const guildSlug = guildInfo?.slug || (data.guild?.name ? normalizeDiscordSlug(data.guild.name) : data.guild_id ?? (isGroupDm ? "group-dm" : "dm"));
 			const channelLabel = channelSlug ? `#${channelSlug}` : channelName ? `#${normalizeDiscordSlug(channelName)}` : `#${data.channel_id}`;
 			reactionBase = {
@@ -1124,24 +841,21 @@ async function handleDiscordReactionEvent(params) {
 		};
 		const emitReaction = (text, parentPeerId) => {
 			const { contextKey } = resolveReactionBase();
-			enqueueSystemEvent(text, {
-				sessionKey: resolveAgentRoute({
-					cfg: params.cfg,
-					channel: "discord",
-					accountId: params.accountId,
-					guildId: data.guild_id ?? void 0,
-					memberRoleIds,
-					peer: {
-						kind: isDirectMessage ? "direct" : isGroupDm ? "group" : "channel",
-						id: isDirectMessage ? user.id : data.channel_id
-					},
-					parentPeer: parentPeerId ? {
-						kind: "channel",
-						id: parentPeerId
-					} : void 0
-				}).sessionKey,
-				contextKey
-			});
+			enqueueRoutedSystemEvent(text, resolveAgentRoute({
+				cfg: params.cfg,
+				channel: "discord",
+				accountId: params.accountId,
+				guildId: data.guild_id ?? void 0,
+				memberRoleIds,
+				peer: {
+					kind: isDirectMessage ? "direct" : isGroupDm ? "group" : "channel",
+					id: isDirectMessage ? user.id : data.channel_id
+				},
+				parentPeer: parentPeerId ? {
+					kind: "channel",
+					id: parentPeerId
+				} : void 0
+			}), { contextKey });
 		};
 		const shouldNotifyReaction = (options) => shouldEmitDiscordReactionNotification({
 			mode: options.mode,
@@ -1222,232 +936,39 @@ async function handleDiscordReactionEvent(params) {
 	}
 }
 //#endregion
-//#region extensions/discord/src/monitor/presence-events.ts
-const DISCORD_PRESENCE_GREETING_COOLDOWN_MS = 480 * 60 * 1e3;
-function isDiscordOnlineStatus(status) {
-	return status === "online" || status === "idle" || status === "dnd";
-}
-function isDiscordOfflineStatus(status) {
-	return status === "offline";
-}
-function resolveDiscordOnlinePresenceEvent(params) {
-	const config = params.config;
-	const userId = params.data.user?.id?.trim();
-	if (!config || config.enabled === false || !userId || userId === params.botUserId || params.data.user.bot === true || !isDiscordOnlineStatus(params.data.status) || !params.availabilityKind) return null;
-	if (config.users !== void 0 && !config.users.includes(userId)) return null;
-	if (params.lastEmittedAtMs !== void 0 && params.nowMs - params.lastEmittedAtMs < 288e5) return null;
-	const lines = [
-		"Discord online-presence event:",
-		params.availabilityKind === "observed-offline" ? `A human member became available online after being observed offline in guild_id=${JSON.stringify(params.data.guild_id)} user_id=${JSON.stringify(userId)} status=${JSON.stringify(params.data.status)}.` : `A human member became newly visible online since the current guild snapshot in guild_id=${JSON.stringify(params.data.guild_id)} user_id=${JSON.stringify(userId)} status=${JSON.stringify(params.data.status)}. They may have come online or joined after the snapshot; do not claim an exact prior status.`,
-		`The authorized greeting target is channel_id=${JSON.stringify(config.channelId)}.`,
-		"Before greeting, retrieve relevant memory and wiki context for this immutable user_id, including a known timezone when available. Use their local time for the greeting; if their timezone is unknown, do not guess.",
-		"Send at most one short, natural greeting to the target channel. Do not reveal private memory. If no greeting is appropriate, stay silent."
-	];
-	return {
-		channelId: config.channelId,
-		userId,
-		text: lines.join("\n")
-	};
-}
-//#endregion
-//#region extensions/discord/src/monitor/presence-cooldown-store.ts
-const DISCORD_PRESENCE_COOLDOWN_MAX_ENTRIES = 25e3;
-function openDiscordPresenceCooldownStore() {
-	return getDiscordRuntime().state.openSyncKeyedStore({
-		namespace: "presence-greeting-cooldowns",
-		maxEntries: DISCORD_PRESENCE_COOLDOWN_MAX_ENTRIES,
-		overflowPolicy: "reject-new",
-		defaultTtlMs: DISCORD_PRESENCE_GREETING_COOLDOWN_MS
-	});
-}
-//#endregion
-//#region extensions/discord/src/monitor/presence-emission-gate.ts
-const DISCORD_PRESENCE_RECONNECT_SUPPRESS_MS = 300 * 1e3;
-const DISCORD_PRESENCE_BURST_LIMIT = 8;
-const DISCORD_PRESENCE_BURST_WINDOW_MS = 60 * 1e3;
-function resolveDiscordPresenceGateOptions(config) {
-	return {
-		reconnectSuppressMs: config?.reconnectSuppressSeconds !== void 0 ? config.reconnectSuppressSeconds * 1e3 : DISCORD_PRESENCE_RECONNECT_SUPPRESS_MS,
-		burstLimit: config?.burstLimit ?? DISCORD_PRESENCE_BURST_LIMIT,
-		burstWindowMs: config?.burstWindowSeconds !== void 0 ? config.burstWindowSeconds * 1e3 : DISCORD_PRESENCE_BURST_WINDOW_MS
-	};
+//#region extensions/discord/src/monitor/listeners.ts
+function registerDiscordListener(listeners, listener) {
+	if (listeners.some((existing) => existing.constructor === listener.constructor)) return false;
+	listeners.push(listener);
+	return true;
 }
-/**
-* Per-account lifecycle gate for online-presence events. Reconnect state belongs to the Gateway
-* session, while burst state follows the guild-owned configuration that supplies its limits.
-*/
-var DiscordPresenceEmissionGate = class {
-	constructor() {
-		this.reconnectLogged = false;
-		this.burstByGuild = /* @__PURE__ */ new Map();
-		this.nextReservationId = 0;
-	}
-	noteGatewaySessionReset(nowMs) {
-		this.lastSessionResetAtMs = nowMs;
-		this.reconnectLogged = false;
-	}
-	evaluateReconnectWindow(nowMs, options) {
-		if (this.lastSessionResetAtMs !== void 0 && options.reconnectSuppressMs > 0 && nowMs - this.lastSessionResetAtMs < options.reconnectSuppressMs) {
-			const shouldLog = !this.reconnectLogged;
-			this.reconnectLogged = true;
-			return {
-				allowed: false,
-				reason: "reconnect-window",
-				shouldLog
-			};
-		}
-		return { allowed: true };
+var DiscordMessageListener = class extends MessageCreateListener {
+	constructor(handler, logger, onEvent) {
+		super();
+		this.handler = handler;
+		this.logger = logger;
+		this.onEvent = onEvent;
 	}
-	reserveBurst(guildId, nowMs, options) {
-		const state = this.burstByGuild.get(guildId) ?? {
-			reservations: [],
-			logged: false
-		};
-		state.reservations = state.reservations.filter((reservation) => !reservation.committed || nowMs - reservation.atMs < options.burstWindowMs);
-		this.burstByGuild.set(guildId, state);
-		if (state.reservations.length >= options.burstLimit) {
-			const shouldLog = !state.logged;
-			state.logged = true;
-			return {
-				allowed: false,
-				reason: state.reservations.some((reservation) => !reservation.committed) ? "burst-pending" : "burst",
-				shouldLog
-			};
+	async handle(data, client) {
+		this.onEvent?.();
+		try {
+			await this.handler(data, client);
+		} catch (err) {
+			(this.logger ?? discordEventQueueLog).error(danger(`discord handler failed: ${String(err)}`));
 		}
-		state.logged = false;
-		const reservation = {
-			id: this.nextReservationId++,
-			atMs: nowMs,
-			committed: false
-		};
-		state.reservations.push(reservation);
-		return {
-			allowed: true,
-			reservation: reservation.id
-		};
 	}
-	commitBurst(guildId, reservation, nowMs) {
-		const entry = this.burstByGuild.get(guildId)?.reservations.find((candidate) => candidate.id === reservation);
-		if (!entry) return;
-		entry.atMs = nowMs;
-		entry.committed = true;
+};
+var DiscordInteractionListener = class extends InteractionCreateListener {
+	constructor(logger, onEvent) {
+		super();
+		this.logger = logger;
+		this.onEvent = onEvent;
 	}
-	releaseBurst(guildId, reservation) {
-		const state = this.burstByGuild.get(guildId);
-		if (!state) return;
-		state.reservations = state.reservations.filter((candidate) => candidate.id !== reservation);
-		if (state.reservations.length === 0 && !state.logged) this.burstByGuild.delete(guildId);
-	}
-};
-//#endregion
-//#region extensions/discord/src/monitor/presence-transition-cache.ts
-const DEFAULT_PRESENCE_BASELINE_MAX_ENTRIES = 75e3;
-var DiscordPresenceBaselineCache = class {
-	constructor(maxEntries = DEFAULT_PRESENCE_BASELINE_MAX_ENTRIES) {
-		this.maxEntries = maxEntries;
-		this.offlineByKey = /* @__PURE__ */ new Map();
-		this.onlineByKey = /* @__PURE__ */ new Map();
-	}
-	clear() {
-		this.offlineByKey.clear();
-		this.onlineByKey.clear();
-	}
-	clearScope(scope) {
-		for (const markers of [this.offlineByKey, this.onlineByKey]) for (const [key, markerScope] of markers) if (markerScope === scope) markers.delete(key);
-	}
-	isOffline(scope, key) {
-		return this.offlineByKey.get(key) === scope;
-	}
-	isOnline(scope, key) {
-		return this.onlineByKey.get(key) === scope;
-	}
-	observeOffline(scope, key) {
-		this.deleteMarker(this.onlineByKey, scope, key);
-		return this.observe(this.offlineByKey, scope, key);
-	}
-	observeOnline(scope, key) {
-		this.deleteMarker(this.offlineByKey, scope, key);
-		return this.observe(this.onlineByKey, scope, key);
-	}
-	deleteMarker(markers, scope, key) {
-		if (markers.get(key) === scope) markers.delete(key);
-	}
-	observe(markers, scope, key) {
-		markers.delete(key);
-		markers.set(key, scope);
-		let evictedScope;
-		while (markers.size > this.maxEntries) {
-			const oldestKey = markers.keys().next().value;
-			if (oldestKey === void 0) break;
-			evictedScope = markers.get(oldestKey);
-			markers.delete(oldestKey);
-		}
-		return evictedScope;
-	}
-};
-//#endregion
-//#region extensions/discord/src/monitor/thread-session-close.ts
-/**
-* 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;
-	const normalizedThreadId = normalizeOptionalLowercaseString(threadId) ?? "";
-	if (!normalizedThreadId) return 0;
-	const segmentRe = new RegExp(`:${normalizedThreadId}(?::|$)`, "i");
-	function sessionKeyContainsThreadId(key) {
-		return segmentRe.test(key);
-	}
-	const storePath = resolveStorePath(cfg.session?.store, { agentId: accountId });
-	let resetCount = 0;
-	for (const { sessionKey, entry } of listSessionEntries({ storePath })) {
-		if (!sessionKeyContainsThreadId(sessionKey)) continue;
-		if (await deleteSessionEntry({
-			archiveTranscript: true,
-			expectedSessionId: entry.sessionId ?? null,
-			expectedUpdatedAt: entry.updatedAt,
-			sessionKey,
-			storePath
-		})) resetCount += 1;
-	}
-	return resetCount;
-}
-//#endregion
-//#region extensions/discord/src/monitor/listeners.ts
-function registerDiscordListener(listeners, listener) {
-	if (listeners.some((existing) => existing.constructor === listener.constructor)) return false;
-	listeners.push(listener);
-	return true;
-}
-var DiscordMessageListener = class extends MessageCreateListener {
-	constructor(handler, logger, onEvent) {
-		super();
-		this.handler = handler;
-		this.logger = logger;
-		this.onEvent = onEvent;
-	}
-	async handle(data, client) {
-		this.onEvent?.();
-		try {
-			await this.handler(data, client);
-		} catch (err) {
-			(this.logger ?? discordEventQueueLog).error(danger(`discord handler failed: ${String(err)}`));
-		}
-	}
-};
-var DiscordInteractionListener = class extends InteractionCreateListener {
-	constructor(logger, onEvent) {
-		super();
-		this.logger = logger;
-		this.onEvent = onEvent;
-	}
-	async handle(data, client) {
-		this.onEvent?.();
-		Promise.resolve().then(() => client.handleInteraction(data, {})).catch((err) => {
-			(this.logger ?? discordEventQueueLog).error(danger(`discord interaction handler failed: ${String(err)}`));
-		});
+	async handle(data, client) {
+		this.onEvent?.();
+		Promise.resolve().then(() => client.handleInteraction(data, {})).catch((err) => {
+			(this.logger ?? discordEventQueueLog).error(danger(`discord interaction handler failed: ${String(err)}`));
+		});
 	}
 };
 var DiscordPresenceListener = class extends PresenceUpdateListener {
@@ -1612,8 +1133,7 @@ var DiscordPresenceListener = class extends PresenceUpdateListener {
 				(this.params.logger ?? discordEventQueueLog).warn(danger(`discord presence cooldown persistence failed: ${String(err)}`));
 				return;
 			}
-			if (!enqueueSystemEvent(presenceEvent.text, {
-				sessionKey: route.sessionKey,
+			if (!enqueueRoutedSystemEvent(presenceEvent.text, route, {
 				contextKey: `discord:presence-online:${this.params.accountId}:${data.guild_id}:${userId}`,
 				deliveryContext: {
 					channel: "discord",
@@ -1679,10 +1199,9 @@ var DiscordPresenceReadyListener = class extends ReadyListener {
 	}
 };
 var DiscordThreadUpdateListener = class extends ThreadUpdateListener {
-	constructor(cfg, accountId, logger) {
+	constructor(cfg, logger) {
 		super();
 		this.cfg = cfg;
-		this.accountId = accountId;
 		this.logger = logger;
 	}
 	async handle(data) {
@@ -1697,7 +1216,6 @@ var DiscordThreadUpdateListener = class extends ThreadUpdateListener {
 				const logger = this.logger ?? discordEventQueueLog;
 				const count = await closeDiscordThreadSessions({
 					cfg: this.cfg,
-					accountId: this.accountId,
 					threadId
 				});
 				if (count > 0) logger.info("Discord thread archived — reset sessions", {
@@ -1711,6 +1229,40 @@ var DiscordThreadUpdateListener = class extends ThreadUpdateListener {
 		});
 	}
 };
+var DiscordThreadDeleteListener = class extends ThreadDeleteListener {
+	constructor(cfg, accountId, logger) {
+		super();
+		this.cfg = cfg;
+		this.accountId = accountId;
+		this.logger = logger;
+	}
+	async handle(data) {
+		await runDiscordListenerWithSlowLog({
+			logger: this.logger,
+			listener: this.constructor.name,
+			event: this.type,
+			run: async () => {
+				const threadId = data.id;
+				getThreadBindingManager(this.accountId)?.unbindThread({
+					threadId,
+					reason: "thread-delete",
+					sendFarewell: false
+				});
+				const count = await closeDiscordThreadSessions({
+					cfg: this.cfg,
+					threadId
+				});
+				if (count > 0) (this.logger ?? discordEventQueueLog).info("Discord thread deleted — reset sessions", {
+					threadId,
+					count
+				});
+			},
+			onError: (err) => {
+				(this.logger ?? discordEventQueueLog).error(danger(`discord thread-delete handler failed: ${String(err)}`));
+			}
+		});
+	}
+};
 //#endregion
 //#region extensions/discord/src/internal/gateway-dispatch.ts
 function dispatchVoiceGatewayEvent(client, type, data) {
@@ -1808,11 +1360,16 @@ function isDiscordUnknownInteraction(error) {
 	if (/Unknown interaction/i.test(err.rawBody?.message ?? "")) return true;
 	return false;
 }
+function resolveDiscordInteractionMessageParts(payload) {
+	const { components, embeds } = payload.channelData?.discord ?? {};
+	return {
+		components: Array.isArray(components) && components.length > 0 ? components : void 0,
+		embeds: Array.isArray(embeds) && embeds.length > 0 ? embeds : void 0
+	};
+}
 function hasRenderableReplyPayload(payload) {
-	if (resolveSendableOutboundReplyParts(payload).hasContent) return true;
-	const discordData = payload.channelData?.discord;
-	if (Array.isArray(discordData?.components) && discordData.components.length > 0) return true;
-	return false;
+	const { components, embeds } = resolveDiscordInteractionMessageParts(payload);
+	return resolveSendableOutboundReplyParts(payload).hasContent || Boolean(components || embeds);
 }
 async function safeDiscordInteractionCall(label, fn) {
 	try {
@@ -1832,43 +1389,25 @@ async function settleDiscordInteractionWithoutVisibleReply(interaction) {
 async function deliverDiscordInteractionReply(params) {
 	const { interaction, payload, textLimit, maxLinesPerMessage, preferFollowUp, chunkMode } = params;
 	const reply = resolveSendableOutboundReplyParts(payload);
-	const discordData = payload.channelData?.discord;
-	let firstMessageComponents = Array.isArray(discordData?.components) && discordData.components.length > 0 ? discordData.components : void 0;
+	let { components: firstMessageComponents, embeds: firstMessageEmbeds } = resolveDiscordInteractionMessageParts(payload);
 	let payloadDelivered = false;
-	const sendMessage = async (content, files, components) => {
-		const contentPayload = content ? { content } : {};
-		const payloadLocal = files && files.length > 0 ? {
-			...contentPayload,
+	const sendMessage = async (content, files, components, embeds) => {
+		const hasV2 = hasDiscordV2Components(components);
+		const payloadLocal = {
+			...content && !hasV2 ? { content } : {},
 			...components ? { components } : {},
+			...embeds && !hasV2 ? { embeds } : {},
 			...params.responseEphemeral !== void 0 ? { ephemeral: params.responseEphemeral } : {},
-			files: files.map((file) => {
-				if (file.data instanceof Blob) return {
-					name: file.name,
-					data: file.data
-				};
-				const arrayBuffer = Uint8Array.from(file.data).buffer;
-				return {
-					name: file.name,
-					data: new Blob([arrayBuffer])
-				};
-			})
-		} : {
-			...contentPayload,
-			...components ? { components } : {},
-			...params.responseEphemeral !== void 0 ? { ephemeral: params.responseEphemeral } : {}
+			...files?.length ? { files } : {}
 		};
 		let result;
 		try {
 			result = await safeDiscordInteractionCall("interaction send", async () => {
-				if (!preferFollowUp && !payloadDelivered) {
-					await interaction.reply(payloadLocal);
-					payloadDelivered = true;
-					firstMessageComponents = void 0;
-					return;
-				}
-				await interaction.followUp(payloadLocal);
+				if (!preferFollowUp && !payloadDelivered) await interaction.reply(payloadLocal);
+				else await interaction.followUp(payloadLocal);
 				payloadDelivered = true;
 				firstMessageComponents = void 0;
+				firstMessageEmbeds = void 0;
 			});
 		} catch (error) {
 			if (!payloadDelivered) throw error;
@@ -1884,7 +1423,8 @@ async function deliverDiscordInteractionReply(params) {
 			const loaded = await loadWebMedia(url, { localRoots: params.mediaLocalRoots });
 			return {
 				name: loaded.fileName ?? "upload",
-				data: loaded.buffer
+				data: loaded.buffer,
+				contentType: loaded.contentType
 			};
 		}));
 		const chunks = resolveTextChunksWithFallback(reply.text, chunkDiscordTextWithMode(reply.text, {
@@ -1892,99 +1432,27 @@ async function deliverDiscordInteractionReply(params) {
 			maxLines: maxLinesPerMessage,
 			chunkMode
 		}));
-		await sendMessage(chunks[0] ?? "", media, firstMessageComponents);
+		await sendMessage(chunks[0] ?? "", media, firstMessageComponents, firstMessageEmbeds);
 		for (const chunk of chunks.slice(1)) {
 			if (!chunk.trim()) continue;
 			await sendMessage(chunk);
 		}
 		return payloadDelivered;
 	}
-	if (!reply.hasText && !firstMessageComponents) return false;
-	let chunks = reply.text || firstMessageComponents ? resolveTextChunksWithFallback(reply.text, chunkDiscordTextWithMode(reply.text, {
+	if (!reply.hasText && !firstMessageComponents && !firstMessageEmbeds) return false;
+	const chunks = resolveTextChunksWithFallback(reply.text, chunkDiscordTextWithMode(reply.text, {
 		maxChars: textLimit,
 		maxLines: maxLinesPerMessage,
 		chunkMode
-	})) : [];
-	if (chunks.length === 0 && firstMessageComponents) chunks = [""];
+	}));
+	if (chunks.length === 0) chunks.push("");
 	for (const chunk of chunks) {
-		if (!chunk.trim() && !firstMessageComponents) continue;
-		await sendMessage(chunk, void 0, firstMessageComponents);
+		if (!chunk.trim() && !firstMessageComponents && !firstMessageEmbeds) continue;
+		await sendMessage(chunk, void 0, firstMessageComponents, firstMessageEmbeds);
 	}
 	return payloadDelivered;
 }
 //#endregion
-//#region extensions/discord/src/monitor/route-resolution.ts
-function buildDiscordRoutePeer(params) {
-	return {
-		kind: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
-		id: params.isDirectMessage ? params.directUserId?.trim() || params.conversationId : params.conversationId
-	};
-}
-function resolveDiscordConversationRoute(params) {
-	return resolveAgentRoute({
-		cfg: params.cfg,
-		channel: "discord",
-		accountId: params.accountId,
-		guildId: params.guildId ?? void 0,
-		memberRoleIds: params.memberRoleIds,
-		peer: params.peer,
-		parentPeer: params.parentConversationId ? {
-			kind: "channel",
-			id: params.parentConversationId
-		} : void 0
-	});
-}
-function resolveDiscordBoundConversationRoute(params) {
-	return resolveDiscordEffectiveRoute({
-		route: resolveDiscordConversationRoute({
-			cfg: params.cfg,
-			accountId: params.accountId,
-			guildId: params.guildId,
-			memberRoleIds: params.memberRoleIds,
-			peer: buildDiscordRoutePeer({
-				isDirectMessage: params.isDirectMessage,
-				isGroupDm: params.isGroupDm,
-				directUserId: params.directUserId,
-				conversationId: params.conversationId
-			}),
-			parentConversationId: params.parentConversationId
-		}),
-		boundSessionKey: params.boundSessionKey,
-		configuredRoute: params.configuredRoute,
-		matchedBy: params.matchedBy
-	});
-}
-function resolveDiscordEffectiveRoute(params) {
-	const boundSessionKey = params.boundSessionKey?.trim();
-	if (!boundSessionKey) return params.configuredRoute?.route ?? params.route;
-	return {
-		...params.route,
-		sessionKey: boundSessionKey,
-		agentId: resolveAgentIdFromSessionKey(boundSessionKey),
-		lastRoutePolicy: deriveLastRoutePolicy({
-			sessionKey: boundSessionKey,
-			mainSessionKey: params.route.mainSessionKey
-		}),
-		...params.matchedBy ? { matchedBy: params.matchedBy } : {}
-	};
-}
-function hasExplicitRuntimeBindingIntent(record) {
-	if (record.targetKind === "subagent") return true;
-	if (isAcpSessionKey(record.targetSessionKey) || isSubagentSessionKey(record.targetSessionKey)) return true;
-	const metadata = record.metadata;
-	if (!metadata || typeof metadata !== "object") return false;
-	return typeof metadata.boundBy === "string" || typeof metadata.label === "string" || typeof metadata.threadName === "string" || metadata.pluginBindingOwner === "plugin";
-}
-function shouldIgnoreStaleDiscordRouteBinding(params) {
-	const bindingRecord = params.bindingRecord;
-	const boundSessionKey = bindingRecord?.targetSessionKey?.trim();
-	if (!bindingRecord || !boundSessionKey || hasExplicitRuntimeBindingIntent(bindingRecord)) return false;
-	const bound = parseAgentSessionKey(boundSessionKey);
-	const routed = parseAgentSessionKey(params.route.sessionKey);
-	if (!bound || !routed || bound.rest !== routed.rest) return false;
-	return bound.agentId !== params.route.agentId;
-}
-//#endregion
 //#region extensions/discord/src/monitor/native-command-route.ts
 async function resolveDiscordNativeInteractionRouteState(params) {
 	const route = resolveDiscordBoundConversationRoute({
@@ -2031,8 +1499,6 @@ async function resolveDiscordNativeInteractionRouteState(params) {
 //#endregion
 //#region extensions/discord/src/monitor/native-command.runtime.ts
 const nativeCommandRuntime = {
-	matchPluginCommand: pluginRuntime.matchPluginCommand,
-	executePluginCommand: pluginRuntime.executePluginCommand,
 	dispatchChannelInboundTurn,
 	resolveDirectStatusReplyForSession,
 	resolveDiscordNativeInteractionRouteState,
@@ -2043,7 +1509,8 @@ const nativeCommandRuntime = {
 async function dispatchDiscordNativeAgentReply(params) {
 	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(params.discordConfig);
 	let didReply = false;
-	let settledWithoutVisibleReply = false;
+	let finalReplyOutcome;
+	let hiddenFinalReply;
 	const turnResult = await nativeCommandRuntime.dispatchChannelInboundTurn({
 		cfg: params.cfg,
 		channel: "discord",
@@ -2079,14 +1546,17 @@ async function dispatchDiscordNativeAgentReply(params) {
 					suppression: { reason: "no_visible_result" }
 				};
 			},
-			onDelivered: (_payload, _info, result) => {
-				if (result?.visibleReplySent === false) settledWithoutVisibleReply = true;
+			onDelivered: (payload, info, result) => {
+				if (params.suppressReplies && info.kind === "final" && result?.suppression?.reason === "no_visible_result" && payload.text?.trim()) hiddenFinalReply = payload;
+				if (info.kind === "final" && result?.visibleReplySent !== void 0 && (result.visibleReplySent || finalReplyOutcome !== "failed")) finalReplyOutcome = result.visibleReplySent ? "accepted" : "suppressed";
 			},
 			onError: (err, info) => {
-				if (isChannelPartialDeliveryError(err)) {
+				const partialDelivery = isChannelPartialDeliveryError(err);
+				if (partialDelivery) {
 					didReply = true;
 					logVerbose("discord: interaction reply partially delivered before expiry");
 				}
+				if (info.kind === "final") finalReplyOutcome = partialDelivery ? "accepted" : "failed";
 				const message = err instanceof Error ? err.stack ?? err.message : String(err);
 				params.log.error(`discord slash ${info.kind} reply failed: ${message}`);
 			}
@@ -2095,14 +1565,20 @@ async function dispatchDiscordNativeAgentReply(params) {
 		dispatcherOptions: { humanDelay: resolveHumanDelayConfig(params.cfg, params.effectiveRoute.agentId) },
 		replyOptions: {
 			skillFilter: params.channelConfig?.skills,
+			[PLUGIN_COMMAND_DISPATCH]: params.pluginCommandDispatch,
 			disableBlockStreaming: typeof blockStreamingEnabled === "boolean" ? !blockStreamingEnabled : void 0
 		}
 	});
-	if (!didReply && (params.suppressReplies || settledWithoutVisibleReply)) {
+	const deliberateSilentTerminalReply = turnResult.dispatched && turnResult.dispatchResult.deliberateSilentTerminalReply === true;
+	const dispatchResult = {
+		dispatched: turnResult.dispatched,
+		...hiddenFinalReply ? { hiddenFinalReply } : {}
+	};
+	if (!didReply && (params.suppressReplies || finalReplyOutcome === "suppressed" || deliberateSilentTerminalReply)) {
 		await settleDiscordInteractionWithoutVisibleReply(params.interaction);
-		return;
+		return dispatchResult;
 	}
-	if (params.suppressReplies || didReply || settledWithoutVisibleReply || turnResult.dispatched && hasVisibleInboundReplyDispatch(turnResult.dispatchResult)) return;
+	if (didReply || turnResult.dispatched && hasVisibleInboundReplyDispatch(turnResult.dispatchResult)) return dispatchResult;
 	await safeDiscordInteractionCall("interaction empty fallback", async () => {
 		const payload = {
 			content: DISCORD_EMPTY_VISIBLE_REPLY_WARNING,
@@ -2114,6 +1590,7 @@ async function dispatchDiscordNativeAgentReply(params) {
 		}
 		await params.interaction.reply(payload);
 	});
+	return dispatchResult;
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-interaction-channel-context.ts
@@ -2391,11 +1868,11 @@ async function resolveDiscordNativeAutocompleteAuthorized(params) {
 //#endregion
 //#region extensions/discord/src/monitor/native-command-bypass.ts
 function shouldBypassConfiguredAcpEnsure(commandName) {
-	return normalizeLowercaseStringOrEmpty(commandName) === "acp";
+	return commandName.trim().toLowerCase() === "acp";
 }
 function shouldBypassConfiguredAcpGuildGuards(commandName) {
-	const normalized = normalizeLowercaseStringOrEmpty(commandName);
-	return normalized === "new" || normalized === "reset";
+	const command = commandName.trim().toLowerCase();
+	return command === "new" || command === "reset";
 }
 //#endregion
 //#region extensions/discord/src/monitor/inbound-context.ts
@@ -2474,6 +1951,14 @@ function buildDiscordNativeCommandContext(params) {
 		CommandTargetSessionKey: params.commandTargetSessionKey,
 		AccountId: params.accountId ?? void 0,
 		ChatType: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
+		...buildDiscordConversationRouteContext({
+			isDirectMessage: params.isDirectMessage,
+			isGroupDm: params.isGroupDm,
+			directUserId: params.user.id,
+			conversationId: params.channelId,
+			isThread: params.isThreadChannel,
+			parentConversationId: params.threadParentId
+		}),
 		ConversationLabel: conversationLabel,
 		GroupSubject: params.isGuild ? params.guildName : void 0,
 		GroupSpace: params.isGuild ? params.guildInfo?.id ?? params.guildInfo?.slug ?? params.guildId : void 0,
@@ -2489,7 +1974,6 @@ function buildDiscordNativeCommandContext(params) {
 		Surface: "discord",
 		WasMentioned: true,
 		MessageSid: params.interactionId,
-		MessageThreadId: params.isThreadChannel ? params.channelId : void 0,
 		Timestamp: params.timestampMs ?? Date.now(),
 		CommandAuthorized: params.commandAuthorized,
 		CommandTurn: {
@@ -2504,8 +1988,7 @@ function buildDiscordNativeCommandContext(params) {
 			isDirectMessage: params.isDirectMessage,
 			userId: params.user.id,
 			channelId: params.channelId
-		}) ?? (params.isDirectMessage ? `user:${params.user.id}` : `channel:${params.channelId}`),
-		ThreadParentId: params.isThreadChannel ? params.threadParentId : void 0
+		}) ?? (params.isDirectMessage ? `user:${params.user.id}` : `channel:${params.channelId}`)
 	});
 }
 //#endregion
@@ -2623,7 +2106,8 @@ async function handleDiscordCommandArgInteraction(params) {
 		sessionPrefix: ctx.sessionPrefix,
 		preferFollowUp: true,
 		threadBindings: ctx.threadBindings,
-		responseEphemeral: resolveDiscordSlashCommandConfig(ctx.discordConfig?.slashCommand).ephemeral
+		responseEphemeral: resolveDiscordSlashCommandConfig(ctx.discordConfig?.slashCommand).ephemeral,
+		pluginCommandDispatch: { kind: "non-plugin" }
 	});
 }
 async function runDiscordCommandArgButton(params) {
@@ -2730,10 +2214,10 @@ function timestampOrder(value) {
 	return value !== void 0 && value >= 0 ? value : 0;
 }
 function comparePreferenceEntries(left, right) {
-	return timestampMs(right.value.updatedAt) - timestampMs(left.value.updatedAt) || timestampOrder(right.value.updatedOrder) - timestampOrder(left.value.updatedOrder) || left.key.localeCompare(right.key);
+	return preferenceTimestampMs(right.value.updatedAt) - preferenceTimestampMs(left.value.updatedAt) || timestampOrder(right.value.updatedOrder) - timestampOrder(left.value.updatedOrder) || left.key.localeCompare(right.key);
 }
 function nextPreferenceTimestamp(existingEntries) {
-	const existingMaxTimestampMs = existingEntries.reduce((max, entry) => Math.max(max, timestampMs(entry.updatedAt)), 0);
+	const existingMaxTimestampMs = existingEntries.reduce((max, entry) => Math.max(max, preferenceTimestampMs(entry.updatedAt)), 0);
 	lastPreferenceTimestampMs = Math.min(Math.max(resolveDateTimestampMs(Date.now(), 0), lastPreferenceTimestampMs + 1, existingMaxTimestampMs + 1), MAX_DATE_TIMESTAMP_MS);
 	const existingMaxOrder = existingEntries.reduce((max, entry) => Math.max(max, timestampOrder(entry.updatedOrder)), 0);
 	lastPreferenceOrder = Math.max(lastPreferenceOrder + 1, existingMaxOrder + 1);
@@ -2782,8 +2266,6 @@ async function recordDiscordModelPickerRecentModel(params) {
 const DISCORD_MODEL_PICKER_CUSTOM_ID_KEY = "mdlpk";
 const DISCORD_CUSTOM_ID_MAX_CHARS = 100;
 const DISCORD_COMPONENT_MAX_SELECT_OPTIONS = 25;
-const DISCORD_MODEL_PICKER_PROVIDER_PAGE_SIZE = DISCORD_COMPONENT_MAX_SELECT_OPTIONS;
-const DISCORD_MODEL_PICKER_MODEL_PAGE_SIZE = DISCORD_COMPONENT_MAX_SELECT_OPTIONS;
 function compareBucketItems(left, right) {
 	const normalized = left.toLowerCase().localeCompare(right.toLowerCase());
 	return normalized === 0 ? left.localeCompare(right) : normalized;
@@ -2843,15 +2325,15 @@ function parseRawPage(value) {
 	}
 	return 1;
 }
-function parseRawPositiveInt(value) {
-	return parseStrictPositiveInteger(value);
-}
 function coerceString(value) {
 	return typeof value === "string" || typeof value === "number" ? String(value) : "";
 }
-function clampPageSize(rawPageSize, max, fallback) {
-	if (!Number.isFinite(rawPageSize)) return fallback;
-	return Math.min(max, Math.max(1, Math.floor(rawPageSize ?? fallback)));
+function clampPageSize(rawPageSize) {
+	if (!Number.isFinite(rawPageSize)) return DISCORD_COMPONENT_MAX_SELECT_OPTIONS;
+	return Math.min(DISCORD_COMPONENT_MAX_SELECT_OPTIONS, Math.max(1, Math.floor(rawPageSize ?? DISCORD_COMPONENT_MAX_SELECT_OPTIONS)));
+}
+function normalizeOptionalModelPickerIndex(value) {
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(1, Math.floor(value)) : void 0;
 }
 function paginateItems(params) {
 	const totalItems = params.items.length;
@@ -2877,10 +2359,10 @@ function buildDiscordModelPickerCustomId(params) {
 	const userId = params.userId.trim();
 	if (!userId) throw new Error("Discord model picker custom_id requires userId");
 	const page = normalizeModelPickerPage(params.page);
-	const providerPage = typeof params.providerPage === "number" && Number.isFinite(params.providerPage) ? Math.max(1, Math.floor(params.providerPage)) : void 0;
+	const providerPage = normalizeOptionalModelPickerIndex(params.providerPage);
 	const normalizedProvider = params.provider ? normalizeProviderId(params.provider) : void 0;
-	const modelIndex = typeof params.modelIndex === "number" && Number.isFinite(params.modelIndex) ? Math.max(1, Math.floor(params.modelIndex)) : void 0;
-	const recentSlot = typeof params.recentSlot === "number" && Number.isFinite(params.recentSlot) ? Math.max(1, Math.floor(params.recentSlot)) : void 0;
+	const modelIndex = normalizeOptionalModelPickerIndex(params.modelIndex);
+	const recentSlot = normalizeOptionalModelPickerIndex(params.recentSlot);
 	const modelToken = params.modelToken?.trim();
 	if (modelToken && !DISCORD_MODEL_PICKER_MODEL_TOKEN_PATTERN.test(modelToken)) throw new Error("Discord model picker model token is invalid");
 	const parts = [
@@ -2893,7 +2375,7 @@ function buildDiscordModelPickerCustomId(params) {
 	if (normalizedProvider) parts.push(`p=${encodeCustomIdComponent(normalizedProvider)}`);
 	const runtime = params.runtime?.trim();
 	if (runtime) parts.push(`r=${encodeCustomIdComponent(runtime)}`);
-	const runtimeIndex = typeof params.runtimeIndex === "number" && Number.isFinite(params.runtimeIndex) ? Math.max(1, Math.floor(params.runtimeIndex)) : void 0;
+	const runtimeIndex = normalizeOptionalModelPickerIndex(params.runtimeIndex);
 	if (runtimeIndex) parts.push(`ri=${String(runtimeIndex)}`);
 	if (providerPage) parts.push(`pp=${String(providerPage)}`);
 	if (modelToken) parts.push(`m=${modelToken}`);
@@ -2917,13 +2399,13 @@ function parseDiscordModelPickerData(data) {
 	const userId = decodeCustomIdComponent(coerceString(data.u));
 	const providerRaw = decodeCustomIdComponent(coerceString(data.p));
 	const runtimeRaw = decodeCustomIdComponent(coerceString(data.r));
-	const runtimeIndex = parseRawPositiveInt(data.ri);
+	const runtimeIndex = parseStrictPositiveInteger(data.ri);
 	const page = parseRawPage(data.g ?? data.pg);
-	const providerPage = parseRawPositiveInt(data.pp);
-	const modelIndex = parseRawPositiveInt(data.mi);
+	const providerPage = parseStrictPositiveInteger(data.pp);
+	const modelIndex = parseStrictPositiveInteger(data.mi);
 	const modelTokenRaw = coerceString(data.m).trim();
 	const modelToken = DISCORD_MODEL_PICKER_MODEL_TOKEN_PATTERN.test(modelTokenRaw) ? modelTokenRaw : void 0;
-	const recentSlot = parseRawPositiveInt(data.rs);
+	const recentSlot = parseStrictPositiveInteger(data.rs);
 	const providerBucketRaw = decodeCustomIdComponent(coerceString(data.pb)).trim().toLowerCase();
 	const modelBucketRaw = decodeCustomIdComponent(coerceString(data.mb)).trim().toLowerCase();
 	if (!isValidCommandContext(command) || !isValidPickerAction(action) || !isValidPickerView(view)) return null;
@@ -3039,17 +2521,7 @@ function findProviderBucketId(data, provider) {
 	return findProviderBucketLocation(data, provider)?.bucket;
 }
 function findProviderBucketLocation(data, provider) {
-	const normalized = normalizeProviderId(provider);
-	const sorted = [...data.providers].toSorted();
-	const idx = sorted.indexOf(normalized);
-	if (idx < 0) return;
-	const containing = computeAlphaBuckets(sorted).find((bucket) => idx >= bucket.start && idx < bucket.end);
-	if (!containing) return;
-	const page = Math.floor((idx - containing.start) / DISCORD_MODEL_PICKER_PROVIDER_PAGE_SIZE) + 1;
-	return {
-		...containing.id !== "all" ? { bucket: containing.id } : {},
-		page
-	};
+	return findModelPickerBucketLocation([...data.providers].toSorted(), normalizeProviderId(provider));
 }
 /**
 * Derive the alpha-bucket id that contains a given model id within the
@@ -3059,28 +2531,24 @@ function findProviderBucketLocation(data, provider) {
 */
 function findModelBucketId(data, provider, model) {
 	const modelSet = data.byProvider.get(normalizeProviderId(provider));
-	if (!modelSet) return;
-	const sorted = [...modelSet].toSorted(compareBucketItems);
-	const idx = sorted.indexOf(model);
-	if (idx < 0) return;
-	const containing = computeAlphaBuckets(sorted).find((bucket) => idx >= bucket.start && idx < bucket.end);
-	return containing && containing.id !== "all" ? containing.id : void 0;
-}
-function buildDiscordModelPickerProviderItems(data) {
-	return [...data.providers].toSorted().map((provider) => ({
-		id: provider,
-		count: data.byProvider.get(provider)?.size ?? 0
-	}));
-}
-function getDiscordModelPickerProviderPage(params) {
-	const allItems = buildDiscordModelPickerProviderItems(params.data);
-	const buckets = computeAlphaBuckets(allItems.map((item) => item.id));
+	return modelSet ? findModelPickerBucketLocation([...modelSet].toSorted(compareBucketItems), model)?.bucket : void 0;
+}
+function findModelPickerBucketLocation(sortedItems, item, pageSize = DISCORD_COMPONENT_MAX_SELECT_OPTIONS) {
+	const index = sortedItems.indexOf(item);
+	const bucket = index < 0 ? void 0 : computeAlphaBuckets(sortedItems).find((entry) => index >= entry.start && index < entry.end);
+	return bucket ? {
+		...bucket.id === "all" ? {} : { bucket: bucket.id },
+		page: Math.floor((index - bucket.start) / pageSize) + 1
+	} : void 0;
+}
+function paginateDiscordModelPickerBucket(params) {
+	const buckets = computeAlphaBuckets(params.itemLabels);
 	const bucket = resolveBucket(buckets, params.bucket);
-	const bucketItems = bucket ? allItems.slice(bucket.start, bucket.end) : allItems;
-	const pageSize = clampPageSize(params.pageSize, DISCORD_MODEL_PICKER_PROVIDER_PAGE_SIZE, DISCORD_MODEL_PICKER_PROVIDER_PAGE_SIZE);
+	const items = bucket ? params.items.slice(bucket.start, bucket.end) : params.items;
+	const pageSize = clampPageSize(params.pageSize);
 	return {
 		...paginateItems({
-			items: bucketItems,
+			items,
 			page: normalizeModelPickerPage(params.page),
 			pageSize
 		}),
@@ -3088,24 +2556,29 @@ function getDiscordModelPickerProviderPage(params) {
 		buckets
 	};
 }
+function getDiscordModelPickerProviderPage(params) {
+	const providers = [...params.data.providers].toSorted();
+	return paginateDiscordModelPickerBucket({
+		...params,
+		itemLabels: providers,
+		items: providers.map((provider) => ({
+			id: provider,
+			count: params.data.byProvider.get(provider)?.size ?? 0
+		}))
+	});
+}
 function getDiscordModelPickerModelPage(params) {
 	const provider = normalizeProviderId(params.provider);
 	const modelSet = params.data.byProvider.get(provider);
 	if (!modelSet) return null;
 	const allModels = [...modelSet].toSorted(compareBucketItems);
-	const buckets = computeAlphaBuckets(allModels);
-	const bucket = resolveBucket(buckets, params.bucket);
-	const bucketItems = bucket ? allModels.slice(bucket.start, bucket.end) : allModels;
-	const pageSize = clampPageSize(params.pageSize, DISCORD_MODEL_PICKER_MODEL_PAGE_SIZE, DISCORD_MODEL_PICKER_MODEL_PAGE_SIZE);
 	return {
-		...paginateItems({
-			items: bucketItems,
-			page: normalizeModelPickerPage(params.page),
-			pageSize
+		...paginateDiscordModelPickerBucket({
+			...params,
+			items: allModels,
+			itemLabels: allModels
 		}),
-		provider,
-		bucket,
-		buckets
+		provider
 	};
 }
 function resolveDiscordModelPickerPageForModel(params) {
@@ -3113,16 +2586,8 @@ function resolveDiscordModelPickerPageForModel(params) {
 	const modelSet = params.data.byProvider.get(provider);
 	if (!modelSet) return { page: 1 };
 	const sorted = [...modelSet].toSorted(compareBucketItems);
-	const index = sorted.indexOf(params.model);
-	if (index < 0) return { page: 1 };
-	const pageSize = clampPageSize(params.pageSize, DISCORD_MODEL_PICKER_MODEL_PAGE_SIZE, DISCORD_MODEL_PICKER_MODEL_PAGE_SIZE);
-	const containingBucket = computeAlphaBuckets(sorted).find((bucket) => index >= bucket.start && index < bucket.end);
-	if (!containingBucket) return { page: Math.floor(index / pageSize) + 1 };
-	const offsetInBucket = index - containingBucket.start;
-	return {
-		page: Math.floor(offsetInBucket / pageSize) + 1,
-		bucket: containingBucket.id === "all" ? void 0 : containingBucket.id
-	};
+	const pageSize = clampPageSize(params.pageSize);
+	return findModelPickerBucketLocation(sorted, params.model, pageSize) ?? { page: 1 };
 }
 //#endregion
 //#region extensions/discord/src/monitor/model-picker.view.ts
@@ -3302,53 +2767,25 @@ function buildProviderSelectRow(params) {
 }
 function buildPaginationRow(params) {
 	if (params.totalPages <= 1) return null;
-	return new Row([
-		createModelPickerButton({
-			label: "◀ Prev",
-			style: ButtonStyle.Secondary,
-			disabled: !params.hasPrev,
-			customId: buildDiscordModelPickerCustomId({
-				command: params.command,
-				action: "nav",
-				view: params.view,
-				provider: params.provider,
-				runtime: params.runtime,
-				runtimeIndex: params.runtimeIndex,
-				page: Math.max(1, params.page - 1),
-				providerPage: params.providerPage,
-				modelIndex: params.modelIndex,
-				modelToken: params.modelToken,
-				providerBucket: params.providerBucket,
-				modelBucket: params.modelBucket,
-				userId: params.userId
-			})
-		}),
-		createModelPickerButton({
-			label: `Page ${params.page}/${params.totalPages}`,
-			style: ButtonStyle.Secondary,
-			disabled: true,
-			customId: DISCORD_MODEL_PICKER_PAGE_INDICATOR_CUSTOM_ID
-		}),
-		createModelPickerButton({
-			label: "Next ▶",
-			style: ButtonStyle.Secondary,
-			disabled: !params.hasNext,
-			customId: buildDiscordModelPickerCustomId({
-				command: params.command,
-				action: "nav",
-				view: params.view,
-				provider: params.provider,
-				runtime: params.runtime,
-				runtimeIndex: params.runtimeIndex,
-				page: Math.min(params.totalPages, params.page + 1),
-				providerPage: params.providerPage,
-				modelIndex: params.modelIndex,
-				modelToken: params.modelToken,
-				providerBucket: params.providerBucket,
-				modelBucket: params.modelBucket,
-				userId: params.userId
-			})
+	const { page, totalPages, hasPrev, hasNext, ...navigationState } = params;
+	const createNavigationButton = (label, targetPage, enabled) => createModelPickerButton({
+		label,
+		disabled: !enabled,
+		customId: buildDiscordModelPickerCustomId({
+			...navigationState,
+			action: "nav",
+			page: targetPage
 		})
+	});
+	const indicatorButton = createModelPickerButton({
+		label: `Page ${page}/${totalPages}`,
+		disabled: true,
+		customId: DISCORD_MODEL_PICKER_PAGE_INDICATOR_CUSTOM_ID
+	});
+	return new Row([
+		createNavigationButton("◀ Prev", Math.max(1, page - 1), hasPrev),
+		indicatorButton,
+		createNavigationButton("Next ▶", Math.min(totalPages, page + 1), hasNext)
 	]);
 }
 function buildModelRows(params) {
@@ -3461,10 +2898,17 @@ function buildModelRows(params) {
 	const resolvedDefault = params.data.resolvedDefault;
 	const shouldDisableReset = Boolean(parsedCurrentModel) && parsedCurrentModel?.provider === resolvedDefault.provider && parsedCurrentModel?.model === resolvedDefault.model;
 	const hasPendingSelection = Boolean(parsedPendingModel) && parsedPendingModel?.provider === params.modelPage.provider && typeof params.pendingModelIndex === "number" && params.pendingModelIndex > 0;
+	const modelActionState = {
+		command: params.command,
+		provider: params.modelPage.provider,
+		...compactRuntime,
+		page: params.modelPage.page,
+		providerPage: providerPage.page,
+		userId: params.userId
+	};
 	const buttonRowItems = [
 		createModelPickerButton({
 			label: "Providers",
-			style: ButtonStyle.Secondary,
 			customId: buildDiscordModelPickerCustomId({
 				command: params.command,
 				action: "back",
@@ -3476,47 +2920,29 @@ function buildModelRows(params) {
 		}),
 		createModelPickerButton({
 			label: "Cancel",
-			style: ButtonStyle.Secondary,
 			customId: buildDiscordModelPickerCustomId({
-				command: params.command,
+				...modelActionState,
 				action: "cancel",
-				view: "models",
-				provider: params.modelPage.provider,
-				...compactRuntime,
-				page: params.modelPage.page,
-				providerPage: providerPage.page,
-				userId: params.userId
+				view: "models"
 			})
 		}),
 		createModelPickerButton({
 			label: "Reset to default",
-			style: ButtonStyle.Secondary,
 			disabled: shouldDisableReset,
 			customId: buildDiscordModelPickerCustomId({
-				command: params.command,
+				...modelActionState,
 				action: "reset",
-				view: "models",
-				provider: params.modelPage.provider,
-				...compactRuntime,
-				page: params.modelPage.page,
-				providerPage: providerPage.page,
-				userId: params.userId
+				view: "models"
 			})
 		})
 	];
 	if (hasQuickModels) buttonRowItems.push(createModelPickerButton({
 		label: "Recents",
-		style: ButtonStyle.Secondary,
 		customId: buildDiscordModelPickerCustomId({
-			command: params.command,
+			...modelActionState,
 			action: "recents",
 			view: "recents",
-			provider: params.modelPage.provider,
-			...compactRuntime,
-			page: params.modelPage.page,
-			providerPage: providerPage.page,
-			modelBucket: activeModelBucket,
-			userId: params.userId
+			modelBucket: activeModelBucket
 		})
 	}));
 	buttonRowItems.push(createModelPickerButton({
@@ -3524,16 +2950,11 @@ function buildModelRows(params) {
 		style: ButtonStyle.Primary,
 		disabled: !hasPendingSelection,
 		customId: buildDiscordModelPickerCustomId({
-			command: params.command,
+			...modelActionState,
 			action: "submit",
 			view: "models",
-			provider: params.modelPage.provider,
-			...compactRuntime,
-			page: params.modelPage.page,
-			providerPage: providerPage.page,
 			modelIndex: params.pendingModelIndex,
-			modelToken: pendingModelToken,
-			userId: params.userId
+			modelToken: pendingModelToken
 		})
 	}));
 	return {
@@ -3680,32 +3101,14 @@ function createModelRefToken(modelRef) {
 function renderDiscordModelPickerRecentsView(params) {
 	const defaultModelRef = `${params.data.resolvedDefault.provider}/${params.data.resolvedDefault.model}`;
 	const rows = [];
-	const dedupedQuickModels = params.quickModels.filter((modelRef) => modelRef !== defaultModelRef);
-	rows.push(new Row([createModelPickerButton({
-		label: formatRecentsButtonLabel(defaultModelRef, "(default)"),
-		style: ButtonStyle.Secondary,
-		customId: buildDiscordModelPickerCustomId({
-			command: params.command,
-			action: "submit",
-			view: "recents",
-			recentSlot: 1,
-			modelToken: createModelRefToken(defaultModelRef),
-			provider: params.provider,
-			runtime: params.runtime,
-			runtimeIndex: params.runtimeIndex,
-			page: params.page,
-			providerPage: params.providerPage,
-			userId: params.userId
-		})
-	})]));
-	for (const [i, modelRef] of dedupedQuickModels.entries()) rows.push(new Row([createModelPickerButton({
-		label: formatRecentsButtonLabel(modelRef),
-		style: ButtonStyle.Secondary,
+	const recentModels = [defaultModelRef, ...params.quickModels.filter((modelRef) => modelRef !== defaultModelRef)];
+	for (const [index, modelRef] of recentModels.entries()) rows.push(new Row([createModelPickerButton({
+		label: formatRecentsButtonLabel(modelRef, index === 0 ? "(default)" : void 0),
 		customId: buildDiscordModelPickerCustomId({
 			command: params.command,
 			action: "submit",
 			view: "recents",
-			recentSlot: i + 2,
+			recentSlot: index + 1,
 			modelToken: createModelRefToken(modelRef),
 			provider: params.provider,
 			runtime: params.runtime,
@@ -3717,7 +3120,6 @@ function renderDiscordModelPickerRecentsView(params) {
 	})]));
 	const backRow = new Row([createModelPickerButton({
 		label: "Back",
-		style: ButtonStyle.Secondary,
 		customId: buildDiscordModelPickerCustomId({
 			command: params.command,
 			action: "back",
@@ -3749,43 +3151,10 @@ function toDiscordModelPickerMessagePayload(view) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-command-model-picker-apply.ts
-async function persistDiscordModelPickerOverride(params) {
-	const storePath = resolveStorePath(params.cfg.session?.store, { agentId: params.route.agentId });
-	let persisted = false;
-	await patchSessionEntry({
-		storePath,
-		sessionKey: params.route.sessionKey,
-		fallbackEntry: {
-			sessionId: randomUUID(),
-			updatedAt: Date.now()
-		},
-		replaceEntry: true,
-		update: (entry) => {
-			persisted = applyModelOverrideToSessionEntry({
-				entry,
-				selection: {
-					provider: params.provider,
-					model: params.model,
-					isDefault: params.isDefault
-				},
-				markLiveSwitchPending: true
-			}).updated || persisted;
-			const runtime = params.runtime?.trim();
-			if (runtime && runtime !== "auto" && runtime !== "default") {
-				if (entry.agentRuntimeOverride !== runtime) {
-					entry.agentRuntimeOverride = runtime;
-					delete entry.agentHarnessId;
-					persisted = true;
-				}
-			} else if (runtime && entry.agentRuntimeOverride) {
-				delete entry.agentRuntimeOverride;
-				delete entry.agentHarnessId;
-				persisted = true;
-			}
-			return entry;
-		}
-	});
-	return persisted;
+function normalizeExpectedRuntime(value) {
+	const runtime = value?.trim();
+	if (!runtime) return;
+	return runtime === "auto" || runtime === "default" ? "auto" : runtime;
 }
 async function applyDiscordModelPickerSelection(params) {
 	try {
@@ -3800,79 +3169,42 @@ async function applyDiscordModelPickerSelection(params) {
 			sessionPrefix: params.sessionPrefix,
 			preferFollowUp: true,
 			threadBindings: params.threadBindings,
-			suppressReplies: true
+			suppressReplies: true,
+			pluginCommandDispatch: { kind: "non-plugin" }
 		}), 12e3);
 		if (!dispatchResult.accepted) return {
 			status: "rejected",
 			noticeMessage: `❌ Failed to apply ${params.resolvedModelRef}. Try /model ${params.resolvedModelRef} directly.`
 		};
-		const fallbackRoute = dispatchResult.effectiveRoute ?? params.route;
+		const hiddenFinalReply = dispatchResult.hiddenFinalReply;
+		const effectiveRoute = dispatchResult.effectiveRoute ?? params.route;
 		if (params.settleMs > 0) await new Promise((resolve) => {
 			setTimeout(resolve, params.settleMs);
 		});
-		let effectiveModelRef = params.resolveCurrentModel(fallbackRoute);
-		let persisted = effectiveModelRef === params.resolvedModelRef;
-		if (params.selectedRuntime?.trim()) {
-			await persistDiscordModelPickerOverride({
-				cfg: params.cfg,
-				route: fallbackRoute,
-				provider: params.selectedProvider,
-				model: params.selectedModel,
-				isDefault: params.selectedProvider === params.defaultProvider && params.selectedModel === params.defaultModel,
-				runtime: params.selectedRuntime
-			});
-			await new Promise((resolve) => {
-				setTimeout(resolve, 100);
-			});
-			effectiveModelRef = params.resolveCurrentModel(fallbackRoute);
-			persisted = effectiveModelRef === params.resolvedModelRef;
-		}
-		if (!persisted) {
-			logVerbose(`discord: model picker override mismatch — expected ${params.resolvedModelRef} but read ${effectiveModelRef} from session key ${fallbackRoute.sessionKey}; attempting direct session override persist`);
-			try {
-				const directlyPersisted = await persistDiscordModelPickerOverride({
-					cfg: params.cfg,
-					route: fallbackRoute,
-					provider: params.selectedProvider,
-					model: params.selectedModel,
-					isDefault: params.selectedProvider === params.defaultProvider && params.selectedModel === params.defaultModel,
-					runtime: params.selectedRuntime
-				});
-				await new Promise((resolve) => {
-					setTimeout(resolve, 100);
-				});
-				effectiveModelRef = params.resolveCurrentModel(fallbackRoute);
-				persisted = effectiveModelRef === params.resolvedModelRef;
-				if (!persisted) logVerbose(`discord: direct session override persist failed — expected ${params.resolvedModelRef} but read ${effectiveModelRef} from session key ${fallbackRoute.sessionKey}`);
-				else if (!directlyPersisted) logVerbose(`discord: direct session override persist became a no-op because ${params.resolvedModelRef} was already present on re-read for session key ${fallbackRoute.sessionKey}`);
-			} catch (error) {
-				if (error instanceof ModelSelectionLockedError) return {
-					status: "rejected",
-					noticeMessage: `❌ ${error.message}`
-				};
-				const message = error instanceof Error ? error.message : String(error);
-				logVerbose(`discord: direct session override persist threw for session key ${fallbackRoute.sessionKey}: ${message}`);
-			}
-		}
-		if (persisted) await recordDiscordModelPickerRecentModel({
+		const effectiveModelRef = params.resolveCurrentModel(effectiveRoute);
+		const effectiveRuntime = params.resolveCurrentRuntime(effectiveRoute);
+		const currentSelection = `Current selection: ${effectiveModelRef} with runtime ${effectiveRuntime}.`;
+		if (hiddenFinalReply?.isError) return {
+			status: "rejected",
+			noticeMessage: `${hiddenFinalReply.text?.trim()}\n${currentSelection}`
+		};
+		const expectedRuntime = normalizeExpectedRuntime(params.selectedRuntime);
+		const verified = effectiveModelRef === params.resolvedModelRef && (expectedRuntime === void 0 || effectiveRuntime === expectedRuntime);
+		if (verified) await recordDiscordModelPickerRecentModel({
 			scope: params.preferenceScope,
 			modelRef: params.resolvedModelRef,
 			limit: 5
 		}).catch(() => void 0);
-		return persisted ? {
+		return verified ? {
 			status: "success",
 			effectiveModelRef,
-			noticeMessage: `✅ Model set to ${params.resolvedModelRef}.`
+			noticeMessage: hiddenFinalReply?.text?.trim() || `✅ Model set to ${params.resolvedModelRef}.`
 		} : {
 			status: "mismatch",
 			effectiveModelRef,
-			noticeMessage: `⚠️ Tried to set ${params.resolvedModelRef}, but current model is ${effectiveModelRef}.`
+			noticeMessage: `⚠️ Tried to set ${params.resolvedModelRef}${expectedRuntime ? ` with runtime ${expectedRuntime}` : ""}, but current selection is ${effectiveModelRef} with runtime ${effectiveRuntime}.`
 		};
 	} catch (error) {
-		if (error instanceof ModelSelectionLockedError) return {
-			status: "rejected",
-			noticeMessage: `❌ ${error.message}`
-		};
 		if (error instanceof Error && error.message === "timeout") return {
 			status: "timeout",
 			noticeMessage: `⏳ Model change to ${params.resolvedModelRef} is still processing. Check /status in a few seconds.`
@@ -3902,9 +3234,6 @@ function shouldOpenDiscordModelPickerFromCommand(params) {
 	if (context === "model") return !resolveCommandArgStringValue(params.commandArgs, "model") && !serializedArgs ? context : null;
 	return serializedArgs ? null : context;
 }
-function buildDiscordModelPickerCurrentModel(defaultProvider, defaultModel) {
-	return `${defaultProvider}/${defaultModel}`;
-}
 function buildDiscordModelPickerAllowedModelRefs(data) {
 	const out = /* @__PURE__ */ new Set();
 	for (const provider of data.providers) {
@@ -4000,7 +3329,7 @@ async function resolveDiscordNativeChoiceContext(params) {
 	}
 }
 function resolveDiscordModelPickerCurrentModel(params) {
-	const fallback = buildDiscordModelPickerCurrentModel(params.data.resolvedDefault.provider, params.data.resolvedDefault.model);
+	const fallback = `${params.data.resolvedDefault.provider}/${params.data.resolvedDefault.model}`;
 	try {
 		const storePath = resolveStorePath(params.cfg.session?.store, { agentId: params.route.agentId });
 		const override = resolveStoredModelOverride({
@@ -4175,7 +3504,7 @@ function buildDiscordModelPickerSelectionCommand(params) {
 	if (!commandDefinition) return null;
 	const commandArgs = {
 		values: { model: params.modelRef },
-		raw: params.modelRef
+		raw: params.runtime ? `${params.modelRef} --runtime ${params.runtime}` : params.modelRef
 	};
 	return {
 		command: commandDefinition,
@@ -4186,7 +3515,7 @@ function buildDiscordModelPickerSelectionCommand(params) {
 function listDiscordModelPickerProviderModels(data, provider) {
 	const modelSet = data.byProvider.get(provider);
 	if (!modelSet) return [];
-	return [...modelSet].toSorted();
+	return [...modelSet].toSorted((left, right) => left < right ? -1 : left > right ? 1 : 0);
 }
 function resolveDiscordModelPickerModelRefByToken(data, modelToken) {
 	const matchingRefs = [];
@@ -4224,10 +3553,6 @@ function resolveDiscordModelPickerSubmissionRuntime(params) {
 		provider: params.provider,
 		runtime: params.parsedRuntime,
 		allowResetRuntime: true
-	}) ?? resolveDiscordModelPickerRuntimeForProvider({
-		data: params.data,
-		provider: params.provider,
-		runtime: params.currentRuntime
 	});
 }
 async function handleDiscordModelPickerInteraction(params) {
@@ -4277,6 +3602,22 @@ async function handleDiscordModelPickerInteraction(params) {
 	});
 	const updatePicker = async (payload) => await params.safeInteractionCall("model picker update", () => deferredUpdate ? interaction.editReply(payload) : interaction.update(payload));
 	const showNotice = async (message) => await updatePicker(buildDiscordModelPickerNoticePayload(message));
+	const updateModelsView = async (provider, state = {}) => {
+		const rendered = renderDiscordModelPickerModelsView({
+			command: parsed.command,
+			userId: parsed.userId,
+			data: pickerData,
+			provider,
+			page: parsed.page,
+			providerPage: parsed.providerPage ?? 1,
+			providerBucket: parsed.providerBucket ?? findProviderBucketId(pickerData, provider),
+			currentModel: currentModelRef,
+			currentRuntime,
+			quickModels,
+			...state
+		});
+		return await updatePicker(toDiscordModelPickerMessagePayload(rendered));
+	};
 	if (parsed.action === "recents") {
 		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerRecentsView({
 			command: parsed.command,
@@ -4293,35 +3634,14 @@ async function handleDiscordModelPickerInteraction(params) {
 		})));
 		return;
 	}
-	if (parsed.action === "back" && parsed.view === "providers") {
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerProvidersView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			page: parsed.page,
-			providerBucket: parsed.providerBucket,
-			currentModel: currentModelRef
-		})));
-		return;
-	}
-	if (parsed.action === "nav" && parsed.view === "providers") {
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerProvidersView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			page: parsed.page,
-			providerBucket: parsed.providerBucket,
-			currentModel: currentModelRef
-		})));
-		return;
-	}
-	if (parsed.action === "bucket" && parsed.view === "providers") {
+	if (parsed.view === "providers" && (parsed.action === "back" || parsed.action === "nav" || parsed.action === "bucket")) {
+		const selectingBucket = parsed.action === "bucket";
 		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerProvidersView({
 			command: parsed.command,
 			userId: parsed.userId,
 			data: pickerData,
-			page: 1,
-			providerBucket: resolveSelectedBucket(interaction),
+			page: selectingBucket ? 1 : parsed.page,
+			providerBucket: selectingBucket ? resolveSelectedBucket(interaction) : parsed.providerBucket,
 			currentModel: currentModelRef
 		})));
 		return;
@@ -4332,24 +3652,15 @@ async function handleDiscordModelPickerInteraction(params) {
 			currentModelRef,
 			data: pickerData
 		});
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			provider,
+		await updateModelsView(provider, {
 			page: 1,
-			providerPage: parsed.providerPage ?? 1,
-			providerBucket: parsed.providerBucket ?? findProviderBucketId(pickerData, provider),
 			modelBucket: resolveSelectedBucket(interaction),
-			currentModel: currentModelRef,
-			currentRuntime,
 			pendingRuntime: resolvePendingRuntime({
 				data: pickerData,
 				provider,
 				parsed
-			}),
-			quickModels
-		})));
+			})
+		});
 		return;
 	}
 	if (parsed.action === "nav" && parsed.view === "models") {
@@ -4374,26 +3685,16 @@ async function handleDiscordModelPickerInteraction(params) {
 			provider,
 			model: pendingModel
 		}) : void 0;
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			provider,
-			page: parsed.page,
-			providerPage: parsed.providerPage ?? 1,
-			providerBucket: parsed.providerBucket ?? findProviderBucketId(pickerData, provider),
+		await updateModelsView(provider, {
 			modelBucket: parsed.modelBucket,
-			currentModel: currentModelRef,
-			currentRuntime,
 			...pendingModel ? { pendingModel: `${provider}/${pendingModel}` } : {},
 			pendingModelIndex: pendingModelIndex ?? void 0,
 			pendingRuntime: resolvePendingRuntime({
 				data: pickerData,
 				provider,
 				parsed
-			}),
-			quickModels
-		})));
+			})
+		});
 		return;
 	}
 	if (parsed.action === "back" && parsed.view === "models") {
@@ -4402,24 +3703,14 @@ async function handleDiscordModelPickerInteraction(params) {
 			currentModelRef,
 			data: pickerData
 		});
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			provider,
-			page: parsed.page ?? 1,
-			providerPage: parsed.providerPage ?? 1,
-			providerBucket: parsed.providerBucket ?? findProviderBucketId(pickerData, provider),
+		await updateModelsView(provider, {
 			modelBucket: parsed.modelBucket,
-			currentModel: currentModelRef,
-			currentRuntime,
 			pendingRuntime: resolvePendingRuntime({
 				data: pickerData,
 				provider,
 				parsed
-			}),
-			quickModels
-		})));
+			})
+		});
 		return;
 	}
 	if (parsed.action === "provider") {
@@ -4428,18 +3719,10 @@ async function handleDiscordModelPickerInteraction(params) {
 			await showNotice("Sorry, that provider isn't available anymore.");
 			return;
 		}
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			provider: selectedProvider,
+		await updateModelsView(selectedProvider, {
 			page: 1,
-			providerPage: parsed.providerPage ?? parsed.page,
-			providerBucket: parsed.providerBucket ?? findProviderBucketId(pickerData, selectedProvider),
-			currentModel: currentModelRef,
-			currentRuntime,
-			quickModels
-		})));
+			providerPage: parsed.providerPage ?? parsed.page
+		});
 		return;
 	}
 	if (parsed.action === "model") {
@@ -4459,28 +3742,16 @@ async function handleDiscordModelPickerInteraction(params) {
 			return;
 		}
 		const modelRef = `${provider}/${selectedModel}`;
-		const derivedProviderBucket = parsed.providerBucket ?? findProviderBucketId(pickerData, provider);
-		const derivedModelBucket = parsed.modelBucket ?? findModelBucketId(pickerData, provider, selectedModel);
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			provider,
-			page: parsed.page,
-			providerPage: parsed.providerPage ?? 1,
-			providerBucket: derivedProviderBucket,
-			modelBucket: derivedModelBucket,
-			currentModel: currentModelRef,
-			currentRuntime,
+		await updateModelsView(provider, {
+			modelBucket: parsed.modelBucket ?? findModelBucketId(pickerData, provider, selectedModel),
 			pendingModel: modelRef,
 			pendingModelIndex: modelIndex,
 			pendingRuntime: resolvePendingRuntime({
 				data: pickerData,
 				provider,
 				parsed
-			}),
-			quickModels
-		})));
+			})
+		});
 		return;
 	}
 	if (parsed.action === "runtime") {
@@ -4507,25 +3778,13 @@ async function handleDiscordModelPickerInteraction(params) {
 			provider,
 			model: selectedModel
 		}) : void 0;
-		const derivedProviderBucket = parsed.providerBucket ?? findProviderBucketId(pickerData, provider);
 		const currentModelOnly = splitDiscordModelRef(currentModelRef ?? "");
-		const derivedModelBucket = parsed.modelBucket ?? (selectedModel ? findModelBucketId(pickerData, provider, selectedModel) : currentModelOnly && currentModelOnly.provider === provider ? findModelBucketId(pickerData, provider, currentModelOnly.model) : void 0);
-		await updatePicker(toDiscordModelPickerMessagePayload(renderDiscordModelPickerModelsView({
-			command: parsed.command,
-			userId: parsed.userId,
-			data: pickerData,
-			provider,
-			page: parsed.page,
-			providerPage: parsed.providerPage ?? 1,
-			providerBucket: derivedProviderBucket,
-			modelBucket: derivedModelBucket,
-			currentModel: currentModelRef,
-			currentRuntime,
+		await updateModelsView(provider, {
+			modelBucket: parsed.modelBucket ?? (selectedModel ? findModelBucketId(pickerData, provider, selectedModel) : currentModelOnly && currentModelOnly.provider === provider ? findModelBucketId(pickerData, provider, currentModelOnly.model) : void 0),
 			...pendingModel ? { pendingModel } : {},
 			pendingModelIndex: pendingModelIndex ?? void 0,
-			pendingRuntime: selectedRuntime,
-			quickModels
-		})));
+			pendingRuntime: selectedRuntime
+		});
 		return;
 	}
 	if (parsed.action === "submit" || parsed.action === "reset" || parsed.action === "quick") {
@@ -4548,10 +3807,12 @@ async function handleDiscordModelPickerInteraction(params) {
 				data: pickerData,
 				parsed,
 				selectedProvider: parsedModelRef.provider
-			}),
-			currentRuntime
+			})
+		});
+		const selectionCommand = buildDiscordModelPickerSelectionCommand({
+			modelRef: resolvedModelRef,
+			runtime: selectedRuntime
 		});
-		const selectionCommand = buildDiscordModelPickerSelectionCommand({ modelRef: resolvedModelRef });
 		if (!selectionCommand) {
 			await showNotice("Sorry, /model is unavailable right now.");
 			return;
@@ -4568,17 +3829,17 @@ async function handleDiscordModelPickerInteraction(params) {
 			threadBindings: ctx.threadBindings,
 			route,
 			resolvedModelRef,
-			selectedProvider: parsedModelRef.provider,
-			selectedModel: parsedModelRef.model,
 			selectedRuntime,
-			defaultProvider: pickerData.resolvedDefault.provider,
-			defaultModel: pickerData.resolvedDefault.model,
 			preferenceScope,
 			settleMs: ctx.postApplySettleMs ?? 250,
 			resolveCurrentModel: (currentRoute) => resolveDiscordModelPickerCurrentModel({
 				cfg,
 				route: currentRoute,
 				data: pickerData
+			}),
+			resolveCurrentRuntime: (currentRoute) => resolveDiscordModelPickerCurrentRuntime({
+				cfg,
+				route: currentRoute
 			})
 		});
 		await params.safeInteractionCall("model picker follow-up", () => interaction.followUp({
@@ -4661,7 +3922,7 @@ const DISCORD_COMMAND_DESCRIPTION_MAX = 100;
 function truncateDiscordCommandDescription(params) {
 	const { value, label } = params;
 	if (value.length <= DISCORD_COMMAND_DESCRIPTION_MAX) return value;
-	log$1.warn(`discord: truncating native command description (${label}) from ${value.length} to ${DISCORD_COMMAND_DESCRIPTION_MAX}: ${JSON.stringify(value)}`);
+	log$1.debug(`discord: truncating native command description (${label}) from ${value.length} to ${DISCORD_COMMAND_DESCRIPTION_MAX}: ${JSON.stringify(value)}`);
 	return truncateUtf16Safe(value, DISCORD_COMMAND_DESCRIPTION_MAX);
 }
 function truncateDiscordCommandDescriptionLocalizations(params) {
@@ -4756,12 +4017,13 @@ function buildDiscordCommandOptions(params) {
 //#endregion
 //#region extensions/discord/src/monitor/native-command.ts
 const log = createSubsystemLogger("discord/native-command");
+const NON_PLUGIN_COMMAND_DISPATCH = Object.freeze({ kind: "non-plugin" });
 function createDiscordNativeCommand(params) {
 	const { command, cfg, discordConfig, accountId, sessionPrefix, ephemeralDefault, threadBindings } = params;
 	const fallbackCommandDefinition = createNativeCommandDefinition(command);
-	const pluginCommandMatch = nativeCommandRuntime.matchPluginCommand(`/${command.name}`);
-	const commandDefinition = pluginCommandMatch !== null ? fallbackCommandDefinition : findCommandByNativeName$1(command.name, "discord", { includeBundledChannelFallback: false }) ?? fallbackCommandDefinition;
-	const argDefinitions = commandDefinition.args ?? command.args;
+	const pluginCommandCandidate = "prepareDispatch" in command ? command : void 0;
+	const commandDefinition = pluginCommandCandidate ? fallbackCommandDefinition : findCommandByNativeName$1(command.name, "discord", { includeBundledChannelFallback: false }) ?? fallbackCommandDefinition;
+	const argDefinitions = commandDefinition.args ?? ("args" in command ? command.args : void 0);
 	const resolveCurrentConfig = () => getRuntimeConfigSnapshot() ?? cfg;
 	const commandOptions = buildDiscordCommandOptions({
 		command: commandDefinition,
@@ -4772,7 +4034,7 @@ function createDiscordNativeCommand(params) {
 			cfg: resolveCurrentConfig(),
 			discordConfig,
 			accountId,
-			skipCommandOwnerAllowFrom: pluginCommandMatch !== null
+			skipCommandOwnerAllowFrom: pluginCommandCandidate !== void 0
 		}),
 		resolveChoiceContext: async (interaction) => resolveDiscordNativeChoiceContext({
 			interaction,
@@ -4810,9 +4072,11 @@ function createDiscordNativeCommand(params) {
 				...commandArgs,
 				raw: serializeCommandArgs$1(commandDefinition, commandArgs) ?? commandArgs.raw
 			} : void 0;
+			const prompt = buildCommandTextFromArgs$1(commandDefinition, commandArgsWithRaw);
+			const preparedPluginCommand = pluginCommandCandidate?.prepareDispatch(commandArgsWithRaw?.raw);
 			await dispatchDiscordCommandInteraction({
 				interaction,
-				prompt: buildCommandTextFromArgs$1(commandDefinition, commandArgsWithRaw),
+				prompt,
 				command: commandDefinition,
 				commandArgs: commandArgsWithRaw,
 				cfg,
@@ -4821,7 +4085,8 @@ function createDiscordNativeCommand(params) {
 				sessionPrefix,
 				preferFollowUp: true,
 				threadBindings,
-				responseEphemeral: ephemeralDefault
+				responseEphemeral: ephemeralDefault,
+				pluginCommandDispatch: preparedPluginCommand ?? NON_PLUGIN_COMMAND_DISPATCH
 			});
 		}
 	}();
@@ -4884,7 +4149,8 @@ async function dispatchDiscordCommandInteraction(params) {
 		allowNameMatching
 	});
 	const commandOwnerAllowAll = commandOwnerAllowFrom?.includes("*") === true;
-	const senderIsCommandOwner = commandOwnerOk || commandOwnerAllowAll;
+	const senderIsCommandOwner = commandOwnerOk;
+	const commandOwnerAccessAllowed = senderIsCommandOwner || commandOwnerAllowAll;
 	const ownerAllowListConfigured = discordOwnerAllowList != null;
 	const ownerOk = discordOwnerOk;
 	const { commandsAllowFromAccess, guildInfo, channelConfig } = resolveDiscordNativeCommandChannelAccessContext({
@@ -5024,8 +4290,7 @@ async function dispatchDiscordCommandInteraction(params) {
 			return { accepted: false };
 		}
 	}
-	const pluginMatch = nativeCommandRuntime.matchPluginCommand(prompt);
-	if (commandOwnerAllowFrom && !senderIsCommandOwner && !commandsAllowFromAccess.allowed && commandName !== "status" && !pluginMatch) {
+	if (commandOwnerAllowFrom && !commandOwnerAccessAllowed && !commandsAllowFromAccess.allowed && commandName !== "status" && params.pluginCommandDispatch.kind !== "plugin") {
 		await respond("You are not authorized to use this command.", { ephemeral: true });
 		return { accepted: false };
 	}
@@ -5085,7 +4350,7 @@ async function dispatchDiscordCommandInteraction(params) {
 		}));
 		return { accepted: true };
 	}
-	if (pluginMatch && commandName !== "status") {
+	if (params.pluginCommandDispatch.kind === "plugin" && commandName !== "status") {
 		if (suppressReplies) {
 			await settleDiscordInteractionWithoutVisibleReply(interaction);
 			return { accepted: true };
@@ -5099,9 +4364,7 @@ async function dispatchDiscordCommandInteraction(params) {
 			agentId: pluginCommandAgentId,
 			sessionKey: effectiveRoute.sessionKey
 		});
-		const pluginReply = await nativeCommandRuntime.executePluginCommand({
-			command: pluginMatch.command,
-			args: pluginMatch.args,
+		const pluginReply = await params.pluginCommandDispatch.execute({
 			senderId: sender.id,
 			channel: "discord",
 			channelId,
@@ -5242,7 +4505,7 @@ async function dispatchDiscordCommandInteraction(params) {
 		respond
 	});
 	if (directStatusResult) return directStatusResult;
-	await dispatchDiscordNativeAgentReply({
+	const { dispatched, hiddenFinalReply } = await dispatchDiscordNativeAgentReply({
 		cfg,
 		discordConfig,
 		accountId,
@@ -5254,11 +4517,13 @@ async function dispatchDiscordCommandInteraction(params) {
 		preferFollowUp,
 		responseEphemeral,
 		suppressReplies,
-		log
+		log,
+		pluginCommandDispatch: params.pluginCommandDispatch
 	});
 	return {
-		accepted: true,
-		effectiveRoute
+		accepted: dispatched,
+		effectiveRoute,
+		hiddenFinalReply
 	};
 }
 function createDiscordCommandArgFallbackButton(params) {
@@ -5516,7 +4781,7 @@ var DiscordGatewayVoiceStateCache = class {
 	}
 	listVoiceChannelStates(guildId, channelId) {
 		const states = this.statesByGuild.get(guildId);
-		if (!states) return [];
+		if (!states) return null;
 		const result = [];
 		for (const state of states.values()) if (state.channel_id === channelId) result.push({ ...state });
 		return result;
@@ -5729,7 +4994,10 @@ var GatewayPlugin = class extends Plugin {
 		if (payload.s !== null && payload.s !== void 0) this.sequence = payload.s;
 		switch (payload.op) {
 			case GatewayOpcodes.Hello: {
-				this.startHeartbeat(payload.d.heartbeat_interval ?? 45e3);
+				this.startHeartbeat(asSafeIntegerInRange(asOptionalRecord(payload.d)?.heartbeat_interval, {
+					min: 1,
+					max: MAX_TIMER_TIMEOUT_MS
+				}) ?? 45e3);
 				const resumeState = resume ? this.getResumeState() : null;
 				if (resumeState) this.send({
 					op: GatewayOpcodes.Resume,
@@ -5932,12 +5200,6 @@ var GatewayPlugin = class extends Plugin {
 	}
 };
 //#endregion
-//#region extensions/discord/src/voice/config.ts
-function resolveDiscordVoiceEnabled(voice) {
-	if (voice?.enabled !== void 0) return voice.enabled;
-	return voice !== void 0;
-}
-//#endregion
 //#region extensions/discord/src/monitor/presence.ts
 const DEFAULT_CUSTOM_ACTIVITY_TYPE$1 = 4;
 const CUSTOM_STATUS_NAME$1 = "Custom Status";
@@ -6429,8 +5691,7 @@ function readStringProperty(value, key) {
 	return typeof property === "string" && property ? property : void 0;
 }
 function readNumberProperty(value, key) {
-	const property = value[key];
-	return typeof property === "number" && Number.isFinite(property) ? property : void 0;
+	return asFiniteNumber(value[key]);
 }
 function describeDiscordGatewayTransportError(error) {
 	const code = readStringProperty(error, "code");
@@ -6480,7 +5741,8 @@ function resolveDiscordGatewayIntents(params) {
 	const intentsConfig = params?.intentsConfig;
 	const voiceEnabled = params?.voiceEnabled;
 	const voiceStatesEnabled = intentsConfig?.voiceStates ?? voiceEnabled ?? false;
-	let intents = GatewayIntents.Guilds | GatewayIntents.GuildMessages | GatewayIntents.MessageContent | GatewayIntents.DirectMessages | GatewayIntents.GuildMessageReactions | GatewayIntents.DirectMessageReactions;
+	let intents = GatewayIntents.Guilds | GatewayIntents.GuildMessages | GatewayIntents.DirectMessages | GatewayIntents.GuildMessageReactions | GatewayIntents.DirectMessageReactions;
+	if (intentsConfig?.messageContent !== false) intents |= GatewayIntents.MessageContent;
 	if (voiceStatesEnabled) intents |= GatewayIntents.GuildVoiceStates;
 	if (intentsConfig?.presence) intents |= GatewayIntents.GuildPresences;
 	if (intentsConfig?.guildMembers) intents |= GatewayIntents.GuildMembers;
@@ -6860,7 +6122,7 @@ async function waitForDiscordGatewayStop(params) {
 				gateway?.disconnect?.();
 			} finally {
 				cleanup();
-				reject(toLintErrorObject(err, "Non-Error rejection"));
+				reject(toErrorObject(err, "Non-Error rejection"));
 			}
 		};
 		const onAbort = () => {
@@ -6881,12 +6143,15 @@ async function waitForDiscordGatewayStop(params) {
 		params.registerForceStop?.(onForceStop);
 	});
 }
-function toLintErrorObject(value, fallbackMessage) {
-	if (value instanceof Error) return value;
-	if (typeof value === "string") return new Error(value);
-	const error = new Error(fallbackMessage, { cause: value });
-	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
-	return error;
+//#endregion
+//#region extensions/discord/src/monitor/status.ts
+/** READY proves a prior terminal failure was repaired, so the account is restartable again. */
+function createDiscordReadyStatusPatch(at = Date.now()) {
+	return channelReadyPatch({
+		lastConnectedAt: at,
+		lastEventAt: at,
+		lastDisconnect: null
+	});
 }
 //#endregion
 //#region extensions/discord/src/monitor/provider.lifecycle.ts
@@ -7018,11 +6283,7 @@ function createGatewayStatusObserver(params) {
 		queuedForceStopError = err;
 	};
 	const pushConnectedStatus = (at) => {
-		params.pushStatus({
-			...createConnectedChannelStatusPatch(at),
-			lastDisconnect: null,
-			lastError: null
-		});
+		params.pushStatus(createDiscordReadyStatusPatch(at));
 	};
 	const startReadyWatch = () => {
 		clearReadyWatch();
@@ -7046,6 +6307,7 @@ function createGatewayStatusObserver(params) {
 				const error = /* @__PURE__ */ new Error(`discord gateway opened but did not reach READY within ${params.runtimeReadyTimeoutMs}ms`);
 				params.pushStatus({
 					connected: false,
+					lifecycle: "recovering",
 					lastEventAt: at,
 					lastDisconnect: {
 						at,
@@ -7074,8 +6336,14 @@ function createGatewayStatusObserver(params) {
 		if (message.includes("Gateway websocket closed")) {
 			clearReadyWatch();
 			const code = parseGatewayCloseCode(message);
+			const terminalDisconnect = code !== void 0 && isFatalGatewayCloseCode(code);
 			params.pushStatus({
 				connected: false,
+				lifecycle: terminalDisconnect ? "blocked" : "recovering",
+				...terminalDisconnect ? {
+					terminalDisconnect: true,
+					lastError: message
+				} : {},
 				lastEventAt: at,
 				lastDisconnect: {
 					at,
@@ -7088,6 +6356,7 @@ function createGatewayStatusObserver(params) {
 			clearReadyWatch();
 			params.pushStatus({
 				connected: false,
+				lifecycle: "recovering",
 				lastEventAt: at,
 				lastError: message
 			});
@@ -7118,11 +6387,7 @@ async function waitForGatewayReady(params) {
 			if (await params.beforePoll?.() === "stop") return "stopped";
 			if (params.gateway?.isConnected === true) {
 				const at = Date.now();
-				params.pushStatus?.({
-					...createConnectedChannelStatusPatch(at),
-					lastDisconnect: null,
-					lastError: null
-				});
+				params.pushStatus?.(createDiscordReadyStatusPatch(at));
 				return "ready";
 			}
 			if (Date.now() >= deadlineAt) return "timeout";
@@ -7144,6 +6409,7 @@ async function waitForGatewayReady(params) {
 		params.runtime.error?.(danger(`discord: gateway READY wait timed out after ${params.readyTimeoutMs}ms; reconnecting with backoff (attempt ${attempt})`));
 		params.pushStatus?.({
 			connected: false,
+			lifecycle: "recovering",
 			lastEventAt: restartAt,
 			lastDisconnect: {
 				at: restartAt,
@@ -7252,7 +6518,7 @@ async function runDiscordGatewayLifecycle(params) {
 		gatewayEmitter?.removeListener(DISCORD_GATEWAY_TRANSPORT_ACTIVITY_EVENT, onGatewayTransportActivity);
 		if (params.voiceManager) {
 			await params.voiceManager.destroy();
-			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-DIKGsTGT.js").then((n) => n.n);
+			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-DeIMNbRh.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: params.accountId,
 				manager: null
@@ -7267,7 +6533,7 @@ async function runDiscordGatewayLifecycle(params) {
 let discordVoiceRuntimePromise;
 let discordProviderSessionRuntimePromise;
 async function loadDiscordVoiceRuntime() {
-	const promise = discordVoiceRuntimePromise ?? import("./manager.runtime-Bjav3pfC.js");
+	const promise = discordVoiceRuntimePromise ?? import("./voice-runtime-CjNFaynA.js");
 	discordVoiceRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7277,7 +6543,7 @@ async function loadDiscordVoiceRuntime() {
 	}
 }
 async function loadDiscordProviderSessionRuntime() {
-	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-Bo88k0pV.js");
+	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-CvvphHvs.js");
 	discordProviderSessionRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7287,13 +6553,12 @@ async function loadDiscordProviderSessionRuntime() {
 	}
 }
 const discordProviderRuntime = {
-	fetchDiscordApplicationId,
+	probeDiscordApplicationId,
 	createDiscordNativeCommand,
 	runDiscordGatewayLifecycle,
 	loadDiscordVoiceRuntime,
 	loadDiscordProviderSessionRuntime,
 	createClient: (...args) => new Client(...args),
-	getPluginCommandSpecs: void 0,
 	resolveDiscordAccount,
 	resolveNativeCommandsEnabled,
 	resolveNativeSkillsEnabled,
@@ -7639,80 +6904,303 @@ async function cleanupDiscordProviderStartup(params) {
 	if (!params.lifecycleStarted) params.threadBindings.stop();
 }
 //#endregion
-//#region extensions/discord/src/monitor/provider.commands.ts
-const loadPluginCommandSpecs = createLazyRuntimeNamedExport(() => import("openclaw/plugin-sdk/plugin-runtime"), "getPluginCommandSpecs");
-async function appendPluginCommandSpecs(params) {
-	const merged = [...params.commandSpecs];
-	const existingNames = new Set(normalizeStringEntriesLower(merged.map((spec) => spec.name)));
-	const getPluginCommandSpecs = params.getPluginCommandSpecs ?? await loadPluginCommandSpecs();
-	for (const pluginCommand of getPluginCommandSpecs("discord", { config: params.cfg })) {
-		const normalizedName = normalizeLowercaseStringOrEmpty(pluginCommand.name);
-		if (!normalizedName) continue;
-		if (existingNames.has(normalizedName)) {
-			params.runtime.error?.(danger(`discord: plugin command "/${normalizedName}" duplicates an existing native command. Skipping.`));
-			continue;
-		}
-		existingNames.add(normalizedName);
-		merged.push({
-			name: pluginCommand.name,
-			description: pluginCommand.description,
-			acceptsArgs: pluginCommand.acceptsArgs
-		});
-	}
-	return merged;
-}
-async function resolveDiscordProviderCommandSpecs(params) {
-	const listSkillCommands = params.listSkillCommandsForAgents ?? listSkillCommandsForAgents;
-	const listNativeCommandSpecs = params.listNativeCommandSpecsForConfig ?? listNativeCommandSpecsForConfig;
-	const maxDiscordCommands = params.maxDiscordCommands ?? 100;
-	let skillCommands = params.nativeEnabled && params.nativeSkillsEnabled ? listSkillCommands({ cfg: params.cfg }) : [];
-	let commandSpecs = params.nativeEnabled ? listNativeCommandSpecs(params.cfg, {
-		skillCommands,
-		provider: "discord"
-	}) : [];
-	if (params.nativeEnabled) commandSpecs = await appendPluginCommandSpecs({
-		commandSpecs,
-		runtime: params.runtime,
+//#region extensions/discord/src/voice/command.ts
+const VOICE_CHANNEL_TYPES = [ChannelType.GuildVoice, ChannelType.GuildStageVoice];
+const DISCORD_VOICE_COMMAND_SPEC = {
+	name: "vc",
+	description: "Voice channel controls",
+	acceptsArgs: false
+};
+async function authorizeVoiceCommand(interaction, params, options) {
+	const channelOverride = options?.channelOverride;
+	const channel = channelOverride ? void 0 : interaction.channel;
+	if (!interaction.guild) return {
+		ok: false,
+		message: "Voice commands are only available in guilds."
+	};
+	const user = interaction.user;
+	if (!user) return {
+		ok: false,
+		message: "Unable to resolve command user."
+	};
+	const channelId = channelOverride?.id ?? channel?.id ?? "";
+	const channelContext = await resolveDiscordThreadLikeChannelContext({
+		client: interaction.client,
+		channel: channelOverride ?? channel,
+		channelIdFallback: channelId
+	});
+	const channelName = channelOverride?.name ?? channelContext.channelName;
+	const memberRoleIds = Array.isArray(interaction.rawData.member?.roles) ? interaction.rawData.member.roles.map((roleId) => roleId) : [];
+	const sender = resolveDiscordSenderIdentity({
+		author: user,
+		member: interaction.rawData.member
+	});
+	const voiceAccess = resolveDiscordVoiceAccess(params);
+	const access = await authorizeDiscordVoiceIngress({
 		cfg: params.cfg,
-		getPluginCommandSpecs: params.getPluginCommandSpecs
+		discordConfig: params.discordConfig,
+		accountId: params.accountId,
+		groupPolicy: params.groupPolicy,
+		useAccessGroups: params.useAccessGroups,
+		guild: interaction.guild,
+		guildId: interaction.guild.id,
+		channelId,
+		channelName,
+		channelSlug: channelContext.channelSlug,
+		parentId: channelOverride?.parentId ?? channelContext.threadParentId,
+		parentName: channelContext.threadParentName,
+		parentSlug: channelContext.threadParentSlug,
+		scope: channelContext.isThreadChannel ? "thread" : "channel",
+		channelLabel: channelId ? formatMention({ channelId }) : "This channel",
+		memberRoleIds,
+		admissionAllowFrom: voiceAccess.admissionAllowFrom,
+		sender: {
+			id: sender.id,
+			name: sender.name,
+			tag: sender.tag
+		}
 	});
-	const initialCommandCount = commandSpecs.length;
-	if (params.nativeEnabled && params.nativeSkillsEnabled && commandSpecs.length > maxDiscordCommands) {
-		skillCommands = [];
-		commandSpecs = listNativeCommandSpecs(params.cfg, {
-			skillCommands: [],
-			provider: "discord"
+	if (!access.ok) return {
+		ok: false,
+		message: access.message
+	};
+	return {
+		ok: true,
+		guildId: interaction.guild.id
+	};
+}
+async function resolveVoiceCommandRuntimeContext(interaction, params) {
+	const guildId = interaction.guild?.id;
+	if (!guildId) {
+		await interaction.reply({
+			content: "Unable to resolve guild for this command.",
+			ephemeral: true
 		});
-		commandSpecs = await appendPluginCommandSpecs({
-			commandSpecs,
-			runtime: params.runtime,
-			cfg: params.cfg,
-			getPluginCommandSpecs: params.getPluginCommandSpecs
+		return null;
+	}
+	const manager = params.getManager();
+	if (!manager) {
+		await interaction.reply({
+			content: "Voice manager is not available yet.",
+			ephemeral: true
 		});
-		params.runtime.log?.(warn(`${initialCommandCount} commands exceed the ${maxDiscordCommands}-command Discord limit; removing per-skill commands and keeping /skill.`));
+		return null;
 	}
-	if (params.nativeEnabled && commandSpecs.length > maxDiscordCommands) params.runtime.log?.(warn(`${commandSpecs.length} commands exceed the ${maxDiscordCommands}-command Discord limit; some commands may fail to deploy.`));
 	return {
-		skillCommands,
-		commandSpecs
+		guildId,
+		manager
 	};
 }
-//#endregion
-//#region extensions/discord/src/monitor/provider.config-log.ts
-function formatThreadBindingDurationForConfigLabel(durationMs) {
-	const label = formatThreadBindingDurationLabel(durationMs);
-	return label === "disabled" ? "off" : label;
-}
-function logDiscordResolvedConfig(params) {
-	const allowFromSummary = summarizeStringEntries({
-		entries: params.allowFrom ?? [],
-		limit: 4,
-		emptyText: "any"
-	});
-	const groupDmChannelSummary = summarizeStringEntries({
-		entries: params.groupDmChannels ?? [],
-		limit: 4,
-		emptyText: "any"
+async function ensureVoiceCommandAccess(params) {
+	const access = await authorizeVoiceCommand(params.interaction, params.context, { channelOverride: params.channelOverride });
+	if (access.ok) return true;
+	await params.interaction.reply({
+		content: access.message ?? "Not authorized.",
+		ephemeral: true
+	});
+	return false;
+}
+function createDiscordVoiceCommand(params) {
+	const resolveSessionChannelId = (manager, guildId) => manager.status().find((entry) => entry.guildId === guildId)?.channelId;
+	class JoinCommand extends Command {
+		constructor(..._args) {
+			super(..._args);
+			this.name = "join";
+			this.description = "Join a voice channel";
+			this.defer = true;
+			this.ephemeral = params.ephemeralDefault;
+			this.options = [{
+				name: "channel",
+				description: "Voice channel to join",
+				type: ApplicationCommandOptionType.Channel,
+				required: true,
+				channel_types: VOICE_CHANNEL_TYPES
+			}];
+		}
+		async run(interaction) {
+			const channel = await interaction.options.getChannel("channel", true);
+			if (!channel || !("id" in channel)) {
+				await interaction.reply({
+					content: "Voice channel not found.",
+					ephemeral: true
+				});
+				return;
+			}
+			const access = await authorizeVoiceCommand(interaction, params, { channelOverride: {
+				id: channel.id,
+				name: resolveDiscordChannelNameSafe(channel)
+			} });
+			if (!access.ok) {
+				await interaction.reply({
+					content: access.message ?? "Not authorized.",
+					ephemeral: true
+				});
+				return;
+			}
+			if (!isVoiceChannelType(channel.type)) {
+				await interaction.reply({
+					content: "That is not a voice channel.",
+					ephemeral: true
+				});
+				return;
+			}
+			const guildId = access.guildId ?? ("guildId" in channel ? channel.guildId : void 0);
+			if (!guildId) {
+				await interaction.reply({
+					content: "Unable to resolve guild for this voice channel.",
+					ephemeral: true
+				});
+				return;
+			}
+			const manager = params.getManager();
+			if (!manager) {
+				await interaction.reply({
+					content: "Voice manager is not available yet.",
+					ephemeral: true
+				});
+				return;
+			}
+			const result = await manager.join({
+				guildId,
+				channelId: channel.id
+			});
+			await interaction.reply({
+				content: result.message,
+				ephemeral: true
+			});
+		}
+	}
+	class LeaveCommand extends Command {
+		constructor(..._args2) {
+			super(..._args2);
+			this.name = "leave";
+			this.description = "Leave the current voice channel";
+			this.defer = true;
+			this.ephemeral = params.ephemeralDefault;
+		}
+		async run(interaction) {
+			const runtimeContext = await resolveVoiceCommandRuntimeContext(interaction, params);
+			if (!runtimeContext) return;
+			const sessionChannelId = resolveSessionChannelId(runtimeContext.manager, runtimeContext.guildId);
+			if (!await ensureVoiceCommandAccess({
+				interaction,
+				context: params,
+				channelOverride: sessionChannelId ? { id: sessionChannelId } : void 0
+			})) return;
+			const result = await runtimeContext.manager.leave({ guildId: runtimeContext.guildId });
+			await interaction.reply({
+				content: result.message,
+				ephemeral: true
+			});
+		}
+	}
+	class StatusCommand extends Command {
+		constructor(..._args3) {
+			super(..._args3);
+			this.name = "status";
+			this.description = "Show active voice sessions";
+			this.defer = true;
+			this.ephemeral = params.ephemeralDefault;
+		}
+		async run(interaction) {
+			const runtimeContext = await resolveVoiceCommandRuntimeContext(interaction, params);
+			if (!runtimeContext) return;
+			const sessions = runtimeContext.manager.status().filter((entry) => entry.guildId === runtimeContext.guildId);
+			const sessionChannelId = sessions[0]?.channelId;
+			if (!await ensureVoiceCommandAccess({
+				interaction,
+				context: params,
+				channelOverride: sessionChannelId ? { id: sessionChannelId } : void 0
+			})) return;
+			if (sessions.length === 0) {
+				await interaction.reply({
+					content: "No active voice sessions.",
+					ephemeral: true
+				});
+				return;
+			}
+			const lines = sessions.map((entry) => `• ${formatMention({ channelId: entry.channelId })} (guild ${entry.guildId})`);
+			await interaction.reply({
+				content: lines.join("\n"),
+				ephemeral: true
+			});
+		}
+	}
+	return new class extends CommandWithSubcommands {
+		constructor(..._args4) {
+			super(..._args4);
+			this.name = DISCORD_VOICE_COMMAND_SPEC.name;
+			this.description = DISCORD_VOICE_COMMAND_SPEC.description;
+			this.subcommands = [
+				new JoinCommand(),
+				new LeaveCommand(),
+				new StatusCommand()
+			];
+		}
+	}();
+}
+function isVoiceChannelType(type) {
+	return type === ChannelType.GuildVoice || type === ChannelType.GuildStageVoice;
+}
+//#endregion
+//#region extensions/discord/src/monitor/provider.commands.ts
+const loadPluginCommandRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/plugin-command-runtime"));
+async function resolveDiscordProviderCommandSpecs(params) {
+	const listSkillCommands = params.listSkillCommandsForAgents ?? listSkillCommandsForAgents;
+	const listNativeCommandSpecs = params.listNativeCommandSpecsForConfig ?? listNativeCommandSpecsForConfig;
+	const maxDiscordCommands = params.maxDiscordCommands ?? 100;
+	let pluginCommandRuntime;
+	if (params.nativeEnabled) pluginCommandRuntime = (await loadPluginCommandRuntime()).createPluginCommandRuntime();
+	const pluginCommandSpecs = pluginCommandRuntime?.listNativeCandidates("discord") ?? [];
+	const onCollision = (normalizedName) => {
+		params.runtime.error?.(danger(`discord: plugin command "/${normalizedName}" duplicates an existing native command. Skipping.`));
+	};
+	const mergePluginCommandSpecs = (primary, collisionHandler) => mergeNativeCommandSpecs({
+		primary,
+		secondary: pluginCommandSpecs,
+		onCollision: collisionHandler
+	});
+	const listPrimaryCommandSpecs = (skillCommands) => {
+		const standardSpecs = listNativeCommandSpecs(params.cfg, {
+			skillCommands,
+			provider: "discord"
+		});
+		if (!params.voiceEnabled) return standardSpecs;
+		const voiceName = DISCORD_VOICE_COMMAND_SPEC.name;
+		return [...standardSpecs.filter((spec) => normalizeLowercaseStringOrEmpty(spec.name) !== voiceName), DISCORD_VOICE_COMMAND_SPEC];
+	};
+	const provisionalCollisions = [];
+	let skillCommands = params.nativeEnabled && params.nativeSkillsEnabled ? listSkillCommands({ cfg: params.cfg }) : [];
+	let commandSpecs = params.nativeEnabled ? mergePluginCommandSpecs(listPrimaryCommandSpecs(skillCommands), (normalizedName) => provisionalCollisions.push(normalizedName)) : [];
+	const initialCommandCount = commandSpecs.length;
+	if (params.nativeEnabled && params.nativeSkillsEnabled && commandSpecs.length > maxDiscordCommands) {
+		skillCommands = [];
+		commandSpecs = mergePluginCommandSpecs(listPrimaryCommandSpecs([]), onCollision);
+		params.runtime.log?.(warn(`${initialCommandCount} commands exceed the ${maxDiscordCommands}-command Discord limit; removing per-skill commands and keeping /skill.`));
+	} else for (const normalizedName of provisionalCollisions) onCollision(normalizedName);
+	if (params.nativeEnabled && commandSpecs.length > maxDiscordCommands) params.runtime.log?.(warn(`${commandSpecs.length} commands exceed the ${maxDiscordCommands}-command Discord limit; some commands may fail to deploy.`));
+	if (commandSpecs.some((command) => "prepareDispatch" in command)) pluginCommandRuntime?.retainNativeCatalog("discord");
+	return {
+		skillCommands,
+		commandSpecs
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/provider.config-log.ts
+function formatThreadBindingDurationForConfigLabel(durationMs) {
+	const label = formatThreadBindingDurationLabel(durationMs);
+	return label === "disabled" ? "off" : label;
+}
+function logDiscordResolvedConfig(params) {
+	const allowFromSummary = summarizeStringEntries({
+		entries: params.allowFrom ?? [],
+		limit: 4,
+		emptyText: "any"
+	});
+	const groupDmChannelSummary = summarizeStringEntries({
+		entries: params.groupDmChannels ?? [],
+		limit: 4,
+		emptyText: "any"
 	});
 	const guildSummary = summarizeStringEntries({
 		entries: Object.keys(params.guildEntries ?? {}),
@@ -7762,13 +7250,6 @@ function resolveDiscordRejectedDeployEntriesSource(rawBody) {
 function readDiscordDeployObjectField(value, field) {
 	return value && typeof value === "object" && field in value ? value[field] : void 0;
 }
-function readFiniteNumber(value) {
-	if (typeof value === "number" && Number.isFinite(value)) return value;
-	if (typeof value === "string" && value.trim().length > 0) return parseStrictFiniteNumber(value);
-}
-function readNonNegativeInteger(value) {
-	return parseStrictNonNegativeInteger(value);
-}
 function isAbortLikeError(err) {
 	if (!err || typeof err !== "object") return false;
 	const name = "name" in err && typeof err.name === "string" ? err.name : void 0;
@@ -7786,8 +7267,8 @@ function formatDiscordDeployRestOperation(err) {
 function formatDiscordDeployErrorMessage(err) {
 	if (!isAbortLikeError(err)) return formatErrorMessage$1(err);
 	const deployErr = err && typeof err === "object" ? err : {};
-	const requestMs = readFiniteNumber(deployErr.deployRequestMs);
-	const timeoutMs = readFiniteNumber(deployErr.deployTimeoutMs);
+	const requestMs = parseFiniteNumber$1(deployErr.deployRequestMs);
+	const timeoutMs = parseFiniteNumber$1(deployErr.deployTimeoutMs);
 	const operation = formatDiscordDeployRestOperation(deployErr);
 	if (!(requestMs !== void 0 || timeoutMs !== void 0 || deployErr.deployRestMethod !== void 0 || deployErr.deployRestPath !== void 0)) return "Discord REST request was aborted";
 	const timing = [];
@@ -7800,8 +7281,8 @@ function formatDiscordDeployErrorMessage(err) {
 function resolveDiscordDeployRateLimitDetails(err) {
 	if (!err || typeof err !== "object") return;
 	const deployErr = err;
-	const status = readNonNegativeInteger(deployErr.status) ?? readNonNegativeInteger(deployErr.statusCode);
-	const retryAfterSeconds = readFiniteNumber(deployErr.retryAfter) ?? readFiniteNumber(readDiscordDeployObjectField(deployErr.rawBody, "retry_after"));
+	const status = parseStrictNonNegativeInteger$1(deployErr.status) ?? parseStrictNonNegativeInteger$1(deployErr.statusCode);
+	const retryAfterSeconds = parseFiniteNumber$1(deployErr.retryAfter) ?? parseFiniteNumber$1(readDiscordDeployObjectField(deployErr.rawBody, "retry_after"));
 	if (!(err instanceof RateLimitError || status === 429 || retryAfterSeconds !== void 0)) return;
 	const rawGlobal = readDiscordDeployObjectField(deployErr.rawBody, "global");
 	const scope = typeof deployErr.scope === "string" && deployErr.scope.trim().length > 0 ? deployErr.scope : rawGlobal === true ? "global" : rawGlobal === false ? "route" : void 0;
@@ -7891,8 +7372,8 @@ function formatDiscordDeployErrorDetails(err) {
 function isDiscordDeployDailyCreateLimit(err) {
 	if (!err || typeof err !== "object") return false;
 	const deployErr = err;
-	const discordCode = readNonNegativeInteger(deployErr.discordCode);
-	const rawCode = readNonNegativeInteger(readDiscordDeployObjectField(deployErr.rawBody, "code"));
+	const discordCode = parseStrictNonNegativeInteger$1(deployErr.discordCode);
+	const rawCode = parseStrictNonNegativeInteger$1(readDiscordDeployObjectField(deployErr.rawBody, "code"));
 	return (discordCode === 30034 || rawCode === 30034) && /daily application command creates/i.test(formatErrorMessage$1(err));
 }
 //#endregion
@@ -8013,428 +7494,96 @@ function runDiscordCommandDeployInBackground(params) {
 	logDiscordStartupPhase$1({
 		runtime: params.runtime,
 		accountId: params.accountId,
-		phase: "deploy-commands:scheduled",
-		startAt: params.startupStartedAt,
-		details: "mode=reconcile background=true",
-		isVerbose: params.isVerbose
-	});
-	deployDiscordCommands(params).then(() => {
-		logDiscordStartupPhase$1({
-			runtime: params.runtime,
-			accountId: params.accountId,
-			phase: "deploy-commands:done",
-			startAt: params.startupStartedAt,
-			details: "background=true",
-			isVerbose: params.isVerbose
-		});
-	}).catch((err) => {
-		params.runtime.log?.(warn(`[${params.accountId}] slash command deploy failed in background (message send/receive unaffected): ${formatErrorMessage$1(err)}`));
-	});
-}
-//#endregion
-//#region extensions/discord/src/monitor/agent-components-reply.ts
-async function replySilently(interaction, params) {
-	try {
-		await interaction.reply(params);
-	} catch {}
-}
-//#endregion
-//#region extensions/discord/src/activities/interaction.ts
-const REGISTRATION_WIDGET_ID = "AAAAAAAAAAAAAAAAAAAAAA";
-const PENDING_LAUNCH_WRITE_BUDGET_MS = 250;
-var DiscordActivityButton = class extends Button {
-	constructor(ctx, deps) {
-		super();
-		this.ctx = ctx;
-		this.deps = deps;
-		this.label = "Open widget";
-		this.customId = buildDiscordActivityCustomId(REGISTRATION_WIDGET_ID);
-		this.customIdParser = parseDiscordActivityCustomIdForInteraction;
-		this.pendingLaunchFailureLogged = false;
-	}
-	logPendingLaunchFailure(error) {
-		if (this.pendingLaunchFailureLogged) return;
-		this.pendingLaunchFailureLogged = true;
-		this.deps.logError(`discord activity: failed to record pending launch: ${String(error)}`);
-	}
-	async run(interaction, data) {
-		if (typeof data.widgetId !== "string") {
-			await this.deps.reply(interaction, {
-				content: "This widget is no longer valid.",
-				ephemeral: true
-			});
-			return;
-		}
-		const runtime = getDiscordActivitiesRuntime();
-		const channelId = interaction.rawData.channel_id;
-		const discordUserId = interaction.userId;
-		if (!runtime || !channelId || !discordUserId) this.logPendingLaunchFailure(/* @__PURE__ */ new Error("missing activity runtime or interaction identity"));
-		else {
-			const write = runtime.store.recordPendingLaunch({
-				accountId: this.ctx.accountId,
-				channelId,
-				discordUserId,
-				widgetId: data.widgetId,
-				createdAt: Date.now()
-			}).then(() => "written").catch((error) => {
-				this.logPendingLaunchFailure(error);
-				return "failed";
-			});
-			let timer;
-			const timeout = new Promise((resolve) => {
-				timer = setTimeout(() => resolve("timeout"), PENDING_LAUNCH_WRITE_BUDGET_MS);
-				timer.unref?.();
-			});
-			try {
-				if (await Promise.race([write, timeout]) === "timeout") this.logPendingLaunchFailure(/* @__PURE__ */ new Error(`pending launch write exceeded ${PENDING_LAUNCH_WRITE_BUDGET_MS}ms`));
-			} finally {
-				if (timer) clearTimeout(timer);
-			}
-		}
-		await interaction.launchActivity();
-	}
-};
-function createDiscordActivityButton(ctx, applicationId, deps = {}) {
-	const runtime = getDiscordActivitiesRuntime();
-	if (!runtime || !runtime.isAccountEnabled(ctx.accountId, ctx.cfg)) return null;
-	if (applicationId) runtime.registerApplicationId(ctx.accountId, applicationId);
-	if (!runtime.resolveAccount(ctx.accountId, ctx.cfg)) return null;
-	return new DiscordActivityButton(ctx, {
-		reply: deps.reply ?? replySilently,
-		logError: deps.logError ?? logError
-	});
-}
-//#endregion
-//#region extensions/discord/src/voice/access.ts
-async function authorizeDiscordVoiceIngress(params) {
-	const groupPolicy = params.groupPolicy ?? resolveOpenProviderRuntimeGroupPolicy({
-		providerConfigPresent: params.cfg.channels?.discord !== void 0,
-		groupPolicy: params.discordConfig.groupPolicy,
-		defaultGroupPolicy: params.cfg.channels?.defaults?.groupPolicy
-	}).groupPolicy;
-	const guildInfo = resolveDiscordGuildEntry({
-		guild: params.guild ?? {
-			id: params.guildId,
-			...params.guildName ? { name: params.guildName } : {}
-		},
-		guildId: params.guildId,
-		guildEntries: params.discordConfig.guilds
-	});
-	const channelConfig = params.channelId ? resolveDiscordChannelConfigWithFallback({
-		guildInfo,
-		channelId: params.channelId,
-		channelName: params.channelName,
-		channelSlug: params.channelSlug,
-		parentId: params.parentId,
-		parentName: params.parentName,
-		parentSlug: params.parentSlug,
-		scope: params.scope
-	}) : null;
-	if (channelConfig?.enabled === false) return {
-		ok: false,
-		message: "This channel is disabled."
-	};
-	const channelAllowlistConfigured = Boolean(guildInfo?.channels) && Object.keys(guildInfo?.channels ?? {}).length > 0;
-	if (!params.channelId && groupPolicy === "allowlist" && channelAllowlistConfigured) return {
-		ok: false,
-		message: `${params.channelLabel ?? "This channel"} is not allowlisted for voice commands.`
-	};
-	const channelAllowed = channelConfig ? channelConfig.allowed : !channelAllowlistConfigured;
-	if (!isDiscordGroupAllowedByPolicy({
-		groupPolicy,
-		guildAllowlisted: Boolean(guildInfo),
-		channelAllowlistConfigured,
-		channelAllowed
-	}) || channelConfig?.allowed === false) return {
-		ok: false,
-		message: `${params.channelLabel ?? "This channel"} is not allowlisted for voice commands.`
-	};
-	const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
-		channelConfig,
-		guildInfo,
-		memberRoleIds: params.memberRoleIds,
-		sender: params.sender,
-		allowNameMatching: false
-	});
-	const admissionAllowList = normalizeDiscordAllowList(params.admissionAllowFrom ?? params.discordConfig.allowFrom ?? params.discordConfig.allowFrom, [
-		"discord:",
-		"user:",
-		"pk:"
-	]);
-	const admissionAllowed = admissionAllowList ? allowListMatches(admissionAllowList, params.sender, { allowNameMatching: false }) : false;
-	const useAccessGroups = params.useAccessGroups ?? true;
-	return resolveCommandAuthorizedFromAuthorizers({
-		useAccessGroups,
-		authorizers: useAccessGroups ? [{
-			configured: admissionAllowList != null,
-			allowed: admissionAllowed
-		}, {
-			configured: hasAccessRestrictions,
-			allowed: memberAllowed
-		}] : [{
-			configured: hasAccessRestrictions,
-			allowed: memberAllowed
-		}],
-		modeWhenAccessGroupsOff: "configured"
-	}) ? {
-		ok: true,
-		channelConfig
-	} : {
-		ok: false,
-		message: "You are not authorized to use this command."
-	};
-}
-//#endregion
-//#region extensions/discord/src/voice/owner-access.ts
-function resolveDiscordVoiceAccess(params) {
-	const commandOwnerAllowFrom = resolveDiscordCommandOwnerAllowFrom(params.cfg);
-	if (commandOwnerAllowFrom) return {
-		admissionAllowFrom: commandOwnerAllowFrom,
-		ownerAllowFrom: commandOwnerAllowFrom,
-		ownerAllowAll: commandOwnerAllowFrom.includes("*")
-	};
-	return {
-		admissionAllowFrom: resolveDiscordAccountAllowFrom({
-			cfg: params.cfg,
-			accountId: params.accountId
-		}) ?? params.discordConfig.allowFrom ?? params.discordConfig.allowFrom ?? [],
-		ownerAllowFrom: [],
-		ownerAllowAll: false
-	};
-}
-//#endregion
-//#region extensions/discord/src/voice/command.ts
-const VOICE_CHANNEL_TYPES = [ChannelType.GuildVoice, ChannelType.GuildStageVoice];
-async function authorizeVoiceCommand(interaction, params, options) {
-	const channelOverride = options?.channelOverride;
-	const channel = channelOverride ? void 0 : interaction.channel;
-	if (!interaction.guild) return {
-		ok: false,
-		message: "Voice commands are only available in guilds."
-	};
-	const user = interaction.user;
-	if (!user) return {
-		ok: false,
-		message: "Unable to resolve command user."
-	};
-	const channelId = channelOverride?.id ?? channel?.id ?? "";
-	const channelContext = await resolveDiscordThreadLikeChannelContext({
-		client: interaction.client,
-		channel: channelOverride ?? channel,
-		channelIdFallback: channelId
-	});
-	const channelName = channelOverride?.name ?? channelContext.channelName;
-	const memberRoleIds = Array.isArray(interaction.rawData.member?.roles) ? interaction.rawData.member.roles.map((roleId) => roleId) : [];
-	const sender = resolveDiscordSenderIdentity({
-		author: user,
-		member: interaction.rawData.member
-	});
-	const voiceAccess = resolveDiscordVoiceAccess(params);
-	const access = await authorizeDiscordVoiceIngress({
-		cfg: params.cfg,
-		discordConfig: params.discordConfig,
-		accountId: params.accountId,
-		groupPolicy: params.groupPolicy,
-		useAccessGroups: params.useAccessGroups,
-		guild: interaction.guild,
-		guildId: interaction.guild.id,
-		channelId,
-		channelName,
-		channelSlug: channelContext.channelSlug,
-		parentId: channelOverride?.parentId ?? channelContext.threadParentId,
-		parentName: channelContext.threadParentName,
-		parentSlug: channelContext.threadParentSlug,
-		scope: channelContext.isThreadChannel ? "thread" : "channel",
-		channelLabel: channelId ? formatMention({ channelId }) : "This channel",
-		memberRoleIds,
-		admissionAllowFrom: voiceAccess.admissionAllowFrom,
-		sender: {
-			id: sender.id,
-			name: sender.name,
-			tag: sender.tag
-		}
-	});
-	if (!access.ok) return {
-		ok: false,
-		message: access.message
-	};
-	return {
-		ok: true,
-		guildId: interaction.guild.id
-	};
-}
-async function resolveVoiceCommandRuntimeContext(interaction, params) {
-	const guildId = interaction.guild?.id;
-	if (!guildId) {
-		await interaction.reply({
-			content: "Unable to resolve guild for this command.",
-			ephemeral: true
-		});
-		return null;
-	}
-	const manager = params.getManager();
-	if (!manager) {
-		await interaction.reply({
-			content: "Voice manager is not available yet.",
-			ephemeral: true
-		});
-		return null;
-	}
-	return {
-		guildId,
-		manager
-	};
-}
-async function ensureVoiceCommandAccess(params) {
-	const access = await authorizeVoiceCommand(params.interaction, params.context, { channelOverride: params.channelOverride });
-	if (access.ok) return true;
-	await params.interaction.reply({
-		content: access.message ?? "Not authorized.",
-		ephemeral: true
-	});
-	return false;
-}
-function createDiscordVoiceCommand(params) {
-	const resolveSessionChannelId = (manager, guildId) => manager.status().find((entry) => entry.guildId === guildId)?.channelId;
-	class JoinCommand extends Command {
-		constructor(..._args) {
-			super(..._args);
-			this.name = "join";
-			this.description = "Join a voice channel";
-			this.defer = true;
-			this.ephemeral = params.ephemeralDefault;
-			this.options = [{
-				name: "channel",
-				description: "Voice channel to join",
-				type: ApplicationCommandOptionType.Channel,
-				required: true,
-				channel_types: VOICE_CHANNEL_TYPES
-			}];
-		}
-		async run(interaction) {
-			const channel = await interaction.options.getChannel("channel", true);
-			if (!channel || !("id" in channel)) {
-				await interaction.reply({
-					content: "Voice channel not found.",
-					ephemeral: true
-				});
-				return;
-			}
-			const access = await authorizeVoiceCommand(interaction, params, { channelOverride: {
-				id: channel.id,
-				name: resolveDiscordChannelNameSafe(channel)
-			} });
-			if (!access.ok) {
-				await interaction.reply({
-					content: access.message ?? "Not authorized.",
-					ephemeral: true
-				});
-				return;
-			}
-			if (!isVoiceChannelType(channel.type)) {
-				await interaction.reply({
-					content: "That is not a voice channel.",
-					ephemeral: true
-				});
-				return;
-			}
-			const guildId = access.guildId ?? ("guildId" in channel ? channel.guildId : void 0);
-			if (!guildId) {
-				await interaction.reply({
-					content: "Unable to resolve guild for this voice channel.",
-					ephemeral: true
-				});
-				return;
-			}
-			const manager = params.getManager();
-			if (!manager) {
-				await interaction.reply({
-					content: "Voice manager is not available yet.",
-					ephemeral: true
-				});
-				return;
-			}
-			const result = await manager.join({
-				guildId,
-				channelId: channel.id
-			});
-			await interaction.reply({
-				content: result.message,
-				ephemeral: true
-			});
-		}
+		phase: "deploy-commands:scheduled",
+		startAt: params.startupStartedAt,
+		details: "mode=reconcile background=true",
+		isVerbose: params.isVerbose
+	});
+	deployDiscordCommands(params).then(() => {
+		logDiscordStartupPhase$1({
+			runtime: params.runtime,
+			accountId: params.accountId,
+			phase: "deploy-commands:done",
+			startAt: params.startupStartedAt,
+			details: "background=true",
+			isVerbose: params.isVerbose
+		});
+	}).catch((err) => {
+		params.runtime.log?.(warn(`[${params.accountId}] slash command deploy failed in background (message send/receive unaffected): ${formatErrorMessage$1(err)}`));
+	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/agent-components-reply.ts
+async function replySilently(interaction, params) {
+	try {
+		await interaction.reply(params);
+	} catch {}
+}
+//#endregion
+//#region extensions/discord/src/activities/interaction.ts
+const REGISTRATION_WIDGET_ID = "AAAAAAAAAAAAAAAAAAAAAA";
+const PENDING_LAUNCH_WRITE_BUDGET_MS = 250;
+var DiscordActivityButton = class extends Button {
+	constructor(ctx, deps) {
+		super();
+		this.ctx = ctx;
+		this.deps = deps;
+		this.label = "Open widget";
+		this.customId = buildDiscordActivityCustomId(REGISTRATION_WIDGET_ID);
+		this.customIdParser = parseDiscordActivityCustomIdForInteraction;
+		this.pendingLaunchFailureLogged = false;
 	}
-	class LeaveCommand extends Command {
-		constructor(..._args2) {
-			super(..._args2);
-			this.name = "leave";
-			this.description = "Leave the current voice channel";
-			this.defer = true;
-			this.ephemeral = params.ephemeralDefault;
-		}
-		async run(interaction) {
-			const runtimeContext = await resolveVoiceCommandRuntimeContext(interaction, params);
-			if (!runtimeContext) return;
-			const sessionChannelId = resolveSessionChannelId(runtimeContext.manager, runtimeContext.guildId);
-			if (!await ensureVoiceCommandAccess({
-				interaction,
-				context: params,
-				channelOverride: sessionChannelId ? { id: sessionChannelId } : void 0
-			})) return;
-			const result = await runtimeContext.manager.leave({ guildId: runtimeContext.guildId });
-			await interaction.reply({
-				content: result.message,
+	logPendingLaunchFailure(error) {
+		if (this.pendingLaunchFailureLogged) return;
+		this.pendingLaunchFailureLogged = true;
+		this.deps.logError(`discord activity: failed to record pending launch: ${String(error)}`);
+	}
+	async run(interaction, data) {
+		if (typeof data.widgetId !== "string") {
+			await this.deps.reply(interaction, {
+				content: "This widget is no longer valid.",
 				ephemeral: true
 			});
+			return;
 		}
-	}
-	class StatusCommand extends Command {
-		constructor(..._args3) {
-			super(..._args3);
-			this.name = "status";
-			this.description = "Show active voice sessions";
-			this.defer = true;
-			this.ephemeral = params.ephemeralDefault;
-		}
-		async run(interaction) {
-			const runtimeContext = await resolveVoiceCommandRuntimeContext(interaction, params);
-			if (!runtimeContext) return;
-			const sessions = runtimeContext.manager.status().filter((entry) => entry.guildId === runtimeContext.guildId);
-			const sessionChannelId = sessions[0]?.channelId;
-			if (!await ensureVoiceCommandAccess({
-				interaction,
-				context: params,
-				channelOverride: sessionChannelId ? { id: sessionChannelId } : void 0
-			})) return;
-			if (sessions.length === 0) {
-				await interaction.reply({
-					content: "No active voice sessions.",
-					ephemeral: true
-				});
-				return;
-			}
-			const lines = sessions.map((entry) => `• ${formatMention({ channelId: entry.channelId })} (guild ${entry.guildId})`);
-			await interaction.reply({
-				content: lines.join("\n"),
-				ephemeral: true
+		const runtime = getDiscordActivitiesRuntime();
+		const channelId = interaction.rawData.channel_id;
+		const discordUserId = interaction.userId;
+		if (!runtime || !channelId || !discordUserId) this.logPendingLaunchFailure(/* @__PURE__ */ new Error("missing activity runtime or interaction identity"));
+		else {
+			const write = runtime.store.recordPendingLaunch({
+				accountId: this.ctx.accountId,
+				channelId,
+				discordUserId,
+				widgetId: data.widgetId,
+				createdAt: Date.now()
+			}).then(() => "written").catch((error) => {
+				this.logPendingLaunchFailure(error);
+				return "failed";
 			});
+			let timer;
+			const timeout = new Promise((resolve) => {
+				timer = setTimeout(() => resolve("timeout"), PENDING_LAUNCH_WRITE_BUDGET_MS);
+				timer.unref?.();
+			});
+			try {
+				if (await Promise.race([write, timeout]) === "timeout") this.logPendingLaunchFailure(/* @__PURE__ */ new Error(`pending launch write exceeded ${PENDING_LAUNCH_WRITE_BUDGET_MS}ms`));
+			} finally {
+				if (timer) clearTimeout(timer);
+			}
 		}
+		await interaction.launchActivity();
 	}
-	return new class extends CommandWithSubcommands {
-		constructor(..._args4) {
-			super(..._args4);
-			this.name = "vc";
-			this.description = "Voice channel controls";
-			this.subcommands = [
-				new JoinCommand(),
-				new LeaveCommand(),
-				new StatusCommand()
-			];
-		}
-	}();
-}
-function isVoiceChannelType(type) {
-	return type === ChannelType.GuildVoice || type === ChannelType.GuildStageVoice;
+};
+function createDiscordActivityButton(ctx, applicationId, deps = {}) {
+	const runtime = getDiscordActivitiesRuntime();
+	if (!runtime || !runtime.isAccountEnabled(ctx.accountId, ctx.cfg)) return null;
+	if (applicationId) runtime.registerApplicationId(ctx.accountId, applicationId);
+	if (!runtime.resolveAccount(ctx.accountId, ctx.cfg)) return null;
+	return new DiscordActivityButton(ctx, {
+		reply: deps.reply ?? replySilently,
+		logError: deps.logError ?? logError
+	});
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components-context.ts
@@ -8472,6 +7621,14 @@ async function ackComponentInteraction(params) {
 		logError(`${params.label}: failed to acknowledge interaction: ${String(err)}`);
 	}
 }
+async function replyUnavailableComponentInteraction(interaction, content) {
+	try {
+		await interaction.reply({
+			content,
+			ephemeral: true
+		});
+	} catch {}
+}
 function resolveDiscordChannelContext(interaction) {
 	const channel = interaction.channel;
 	const channelInfo = resolveDiscordChannelInfoSafe(channel);
@@ -8967,12 +8124,6 @@ function formatModalSubmissionText(entry, interaction) {
 	if (lines.length === 1) lines.push("- (no values)");
 	return lines.join("\n");
 }
-function resolveDiscordInteractionId(interaction) {
-	const rawId = interaction.rawData && typeof interaction.rawData === "object" && "id" in interaction.rawData ? interaction.rawData.id : void 0;
-	if (typeof rawId === "string" && rawId.trim()) return rawId.trim();
-	if (typeof rawId === "number" && Number.isFinite(rawId)) return String(rawId);
-	return `discord-interaction:${Date.now()}`;
-}
 //#endregion
 //#region extensions/discord/src/monitor/agent-components-helpers.ts
 const AGENT_BUTTON_KEY = "agent";
@@ -8983,7 +8134,8 @@ function resolveReplyContext(message, resolveDiscordMessageText) {
 	const referenced = message.referencedMessage;
 	if (!referenced?.author) return null;
 	const referencedText = resolveDiscordMessageText(referenced, { includeForwarded: true });
-	if (!referencedText) return null;
+	const hasVisibleMedia = referenced.attachments.length > 0 || !referencedText && resolveDiscordMessageStickers(referenced).length > 0;
+	if (!referencedText && !hasVisibleMedia) return null;
 	const sender = resolveDiscordSenderIdentity({
 		author: referenced.author,
 		pluralkitInfo: null
@@ -8999,7 +8151,7 @@ function resolveReplyContext(message, resolveDiscordMessageText) {
 			const roles = referenced.member?.roles;
 			return Array.isArray(roles) ? roles.map((roleId) => roleId) : void 0;
 		})(),
-		body: referencedText,
+		...referencedText ? { body: referencedText } : {},
 		timestamp: resolveTimestampMs(referenced.timestamp)
 	};
 }
@@ -9046,7 +8198,7 @@ function stripDiscordInternalChannelLines(text) {
 	return kept.join("\n");
 }
 function sanitizeDiscordFrontChannelText(text) {
-	return collapseExcessBlankLines(stripDiscordInternalChannelLines(stripPlainTextToolCallBlocks(sanitizeAssistantVisibleText(stripPlainTextToolCallBlocks(text))))).trim();
+	return collapseExcessBlankLines(stripDiscordInternalChannelLines(stripPlainTextToolCallBlocks(sanitizeAssistantVisibleText(stripPlainTextToolCallBlocks(text, { resolveProtectedRanges: findCodeRegions })), { resolveProtectedRanges: findCodeRegions }))).trim();
 }
 function sanitizeDiscordFrontChannelReplyPayloads(payloads, options = {}) {
 	const preserveVerboseToolProgress = options.kind === "tool";
@@ -9143,7 +8295,7 @@ function formatDiscordReasoningPayload(payload) {
 async function deliverDiscordReply(params) {
 	params.runtime;
 	const delivery = resolveDiscordDeliveryOptions(params);
-	const payloads = sanitizeDiscordFrontChannelReplyPayloads(params.replies, { kind: params.kind }).map(formatDiscordReasoningPayload);
+	const payloads = sanitizeDiscordFrontChannelReplyPayloads(params.replies, { kind: params.kind }).map(formatDiscordReasoningPayload).map((payload) => params.bindPendingFinalDelivery?.(payload) ?? payload);
 	if (payloads.length === 0) return {
 		visibleReplySent: false,
 		suppression: { reason: "no_visible_result" }
@@ -9173,7 +8325,7 @@ async function deliverDiscordReply(params) {
 			requesterAccountId: params.accountId
 		})
 	});
-	if (send.status === "failed" || send.status === "partial_failed") throw send.error;
+	if (send.status === "failed") throw send.error;
 	if (send.status === "suppressed") {
 		const hookEffect = send.payloadOutcomes?.find((outcome) => outcome.status === "suppressed")?.hookEffect;
 		return {
@@ -9185,17 +8337,19 @@ async function deliverDiscordReply(params) {
 			}
 		};
 	}
-	const results = send.results;
-	if (results.length === 0) throw new Error(`discord final reply produced no delivered message for ${delivery.to}`);
-	return {
-		messageIds: results.flatMap((result) => result.messageId ? [result.messageId] : []),
+	if (send.results.length === 0) throw new Error(`discord final reply produced no delivered message for ${delivery.to}`);
+	const deliveryResult = {
+		messageIds: listMessageReceiptPlatformIds(send.receipt),
+		receipt: send.receipt,
 		visibleReplySent: true
 	};
+	if (send.status === "partial_failed") throw createChannelPartialDeliveryError(send.error, deliveryResult);
+	return deliveryResult;
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.dispatch.ts
 const loadConversationRuntime$1 = createLazyRuntimeModule(() => import("./agent-components.runtime-CEPrf2SY.js"));
-const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing--Mzo2kM7.js").then((n) => n.n));
+const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing-oLiS5Z13.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}`;
@@ -9317,6 +8471,14 @@ async function dispatchDiscordComponentEvent(params) {
 		SessionKey: sessionKey,
 		AccountId: accountId,
 		ChatType: chatType,
+		...buildDiscordConversationRouteContext({
+			isDirectMessage: interactionCtx.isDirectMessage,
+			isGroupDm: interactionCtx.isGroupDm,
+			directUserId: interactionCtx.userId,
+			conversationId: interactionCtx.channelId,
+			isThread: channelCtx.isThread,
+			parentConversationId: channelCtx.parentId
+		}),
 		ConversationLabel: fromLabel,
 		SenderName: senderName,
 		SenderId: interactionCtx.userId,
@@ -9385,6 +8547,7 @@ async function dispatchDiscordComponentEvent(params) {
 					sessionKey
 				},
 				ctxPayload,
+				dispatchReplyFromConfig: ctx.channelRuntime?.reply?.dispatchReplyFromConfig,
 				record: {
 					updateLastRoute: interactionCtx.isDirectMessage ? {
 						sessionKey: inboundLastRouteSessionKey,
@@ -9425,7 +8588,8 @@ async function dispatchDiscordComponentEvent(params) {
 							tableMode,
 							chunkMode: resolveChunkMode(ctx.cfg, "discord", accountId),
 							mediaLocalRoots,
-							kind: info.kind
+							kind: info.kind,
+							bindPendingFinalDelivery: info.bindPendingFinalDelivery
 						});
 						if (result.visibleReplySent) replyReference.markSent();
 						return result;
@@ -9455,33 +8619,14 @@ async function dispatchDiscordComponentEvent(params) {
 }
 //#endregion
 //#region extensions/discord/src/interactive-dispatch.ts
+const dispatchDiscordInteractive = createChannelInteractiveDispatcher({
+	channel: "discord",
+	interactiveKey: "interaction"
+});
 async function dispatchDiscordPluginInteractiveHandler(params) {
-	return await dispatchPluginInteractiveHandler({
-		channel: "discord",
-		data: params.data,
-		dedupeId: params.interactionId,
-		onMatched: params.onMatched,
-		invoke: ({ registration, namespace, payload }) => registration.handler({
-			...params.ctx,
-			channel: "discord",
-			interaction: {
-				...params.ctx.interaction,
-				data: params.data,
-				namespace,
-				payload
-			},
-			respond: params.respond,
-			...createInteractiveConversationBindingHelpers({
-				registration,
-				senderId: params.ctx.senderId,
-				conversation: {
-					channel: "discord",
-					accountId: params.ctx.accountId,
-					conversationId: params.ctx.conversationId,
-					parentConversationId: params.ctx.parentConversationId
-				}
-			})
-		})
+	return await dispatchDiscordInteractive({
+		...params,
+		dedupeId: params.interactionId
 	});
 }
 //#endregion
@@ -9512,10 +8657,11 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 		},
 		reply: async ({ text, ephemeral = true }) => {
 			responded = true;
-			await params.interaction.reply({
+			const payload = {
 				content: text,
 				ephemeral
-			});
+			};
+			await (acknowledged ? params.interaction.followUp(payload) : params.interaction.reply(payload));
 		},
 		followUp: async ({ text, ephemeral = true }) => {
 			responded = true;
@@ -9573,10 +8719,10 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 	}
 	const dispatched = await dispatchDiscordPluginInteractiveHandler({
 		data: params.data,
-		interactionId: resolveDiscordInteractionId(params.interaction),
+		interactionId: params.interaction.id,
 		ctx: {
 			accountId: params.ctx.accountId,
-			interactionId: resolveDiscordInteractionId(params.interaction),
+			interactionId: params.interaction.id,
 			conversationId: normalizedConversationId,
 			parentConversationId: params.channelCtx.parentId,
 			guildId: params.interactionCtx.rawGuildId,
@@ -9608,17 +8754,12 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.handlers.ts
-const loadComponentsRuntime = createLazyRuntimeModule(() => import("./outbound-session-route-H-HoyH5U.js").then((n) => n.n));
+const loadComponentsRuntime = createLazyRuntimeModule(() => import("./components-ezGKo_Yh.js").then((n) => n.t));
 async function handleDiscordComponentEvent(params) {
 	const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
 	if (!parsed) {
 		logError(`${params.label}: failed to parse component data`);
-		try {
-			await params.interaction.reply({
-				content: "This component is no longer valid.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This component is no longer valid.");
 		return;
 	}
 	const entry = await resolveDiscordComponentEntryWithPersistence({
@@ -9626,12 +8767,7 @@ async function handleDiscordComponentEvent(params) {
 		consume: false
 	});
 	if (!entry) {
-		try {
-			await params.interaction.reply({
-				content: "This component has expired.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This component has expired.");
 		return;
 	}
 	const unauthorizedReply = `You are not authorized to use this ${params.componentLabel}.`;
@@ -9659,21 +8795,11 @@ async function handleDiscordComponentEvent(params) {
 		consume: !entry.reusable
 	});
 	if (!consumed) {
-		try {
-			await params.interaction.reply({
-				content: "This component has expired.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This component has expired.");
 		return;
 	}
 	if (consumed.kind === "modal-trigger") {
-		try {
-			await params.interaction.reply({
-				content: "This form is no longer available.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This form is no longer available.");
 		return;
 	}
 	const values = params.values ? mapSelectValues(consumed, params.values) : void 0;
@@ -9726,12 +8852,7 @@ async function handleDiscordModalTrigger(params) {
 	const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
 	if (!parsed) {
 		logError(`${params.label}: failed to parse modal trigger data`);
-		try {
-			await params.interaction.reply({
-				content: "This button is no longer valid.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This button is no longer valid.");
 		return;
 	}
 	const entry = await resolveDiscordComponentEntryWithPersistence({
@@ -9739,22 +8860,12 @@ async function handleDiscordModalTrigger(params) {
 		consume: false
 	});
 	if (!entry || entry.kind !== "modal-trigger") {
-		try {
-			await params.interaction.reply({
-				content: "This button has expired.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This button has expired.");
 		return;
 	}
 	const modalId = entry.modalId ?? parsed.modalId;
 	if (!modalId) {
-		try {
-			await params.interaction.reply({
-				content: "This form is no longer available.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This form is no longer available.");
 		return;
 	}
 	const unauthorizedReply = "You are not authorized to use this form.";
@@ -9782,12 +8893,7 @@ async function handleDiscordModalTrigger(params) {
 		consume: !entry.reusable
 	});
 	if (!consumed) {
-		try {
-			await params.interaction.reply({
-				content: "This form has expired.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This form has expired.");
 		return;
 	}
 	const modalEntry = await resolveDiscordModalEntryWithPersistence({
@@ -9795,18 +8901,14 @@ async function handleDiscordModalTrigger(params) {
 		consume: false
 	});
 	if (!modalEntry) {
-		try {
-			await params.interaction.reply({
-				content: "This form has expired.",
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, "This form has expired.");
 		return;
 	}
 	try {
 		await params.interaction.showModal((await loadComponentsRuntime()).createDiscordFormModal(modalEntry));
 	} catch (err) {
 		logError(`${params.label}: failed to show modal: ${String(err)}`);
+		await replyUnavailableComponentInteraction(params.interaction, "Could not open this form. Request a new form and try again.");
 	}
 }
 const discordComponentControlHandlers = {
@@ -9828,12 +8930,7 @@ var DiscordComponentModal = class extends Modal {
 		const modalId = parseDiscordModalId(data, resolveInteractionCustomId(interaction));
 		if (!modalId) {
 			logError("discord component modal: missing modal id");
-			try {
-				await interaction.reply({
-					content: "This form is no longer valid.",
-					ephemeral: true
-				});
-			} catch {}
+			await replyUnavailableComponentInteraction(interaction, "This form is no longer valid.");
 			return;
 		}
 		const modalEntry = await resolveDiscordModalEntryWithPersistence({
@@ -9841,12 +8938,7 @@ var DiscordComponentModal = class extends Modal {
 			consume: false
 		});
 		if (!modalEntry) {
-			try {
-				await interaction.reply({
-					content: "This form has expired.",
-					ephemeral: true
-				});
-			} catch {}
+			await replyUnavailableComponentInteraction(interaction, "This form has expired.");
 			return;
 		}
 		const unauthorizedReply = "You are not authorized to use this form.";
@@ -9879,12 +8971,7 @@ var DiscordComponentModal = class extends Modal {
 			consume: !modalEntry.reusable
 		});
 		if (!consumed) {
-			try {
-				await interaction.reply({
-					content: "This form has expired.",
-					ephemeral: true
-				});
-			} catch {}
+			await replyUnavailableComponentInteraction(interaction, "This form has expired.");
 			return;
 		}
 		if (consumed.callbackData) {
@@ -9933,12 +9020,7 @@ async function runAgentSystemControlInteraction(params) {
 	const parsed = parseAgentComponentData(params.data);
 	if (!parsed) {
 		logError(`${params.label}: failed to parse component data`);
-		try {
-			await params.interaction.reply({
-				content: params.invalidReply,
-				ephemeral: true
-			});
-		} catch {}
+		await replyUnavailableComponentInteraction(params.interaction, params.invalidReply);
 		return;
 	}
 	const { componentId } = parsed;
@@ -9979,10 +9061,7 @@ async function runAgentSystemControlInteraction(params) {
 		userId
 	});
 	logDebug(`${params.label}: enqueuing event for channel ${channelId}: ${eventText}`);
-	enqueueSystemEvent$1(eventText, {
-		sessionKey: route.sessionKey,
-		contextKey: `${params.contextKeyPrefix}:${channelId}:${componentId}:${userId}`
-	});
+	enqueueRoutedSystemEvent$1(eventText, route, { contextKey: `${params.contextKeyPrefix}:${channelId}:${componentId}:${userId}:${params.interaction.id}` });
 	await ackComponentInteraction({
 		interaction: params.interaction,
 		replyOpts,
@@ -10237,7 +9316,7 @@ var ExecApprovalButton = class extends Button {
 		try {
 			await interaction.acknowledge();
 		} catch {}
-		const result = await this.ctx.resolveApproval(parsed.approvalId, parsed.approvalKind, parsed.action);
+		const result = await this.ctx.resolveApproval(parsed.approvalId, parsed.approvalKind, parsed.action, userId);
 		if (!result.ok) {
 			try {
 				await interaction.followUp({
@@ -10274,7 +9353,7 @@ function createDiscordExecApprovalButtonContext(params) {
 			accountId: params.accountId,
 			configOverride: params.config
 		}),
-		resolveApproval: async (approvalId, approvalKind, decision) => {
+		resolveApproval: async (approvalId, approvalKind, decision, senderId) => {
 			try {
 				return {
 					ok: true,
@@ -10283,8 +9362,10 @@ function createDiscordExecApprovalButtonContext(params) {
 						approvalId,
 						approvalKind,
 						decision,
-						gatewayUrl: params.gatewayUrl,
-						clientDisplayName: `Discord approval (${params.accountId})`
+						channel: "discord",
+						accountId: params.accountId,
+						senderId,
+						gatewayUrl: params.gatewayUrl
 					})
 				};
 			} catch (err) {
@@ -10368,24 +9449,26 @@ function createDiscordQuestionButton(params) {
 //#region extensions/discord/src/monitor/provider.interactions.ts
 function createDiscordProviderInteractionSurface(params) {
 	const createNativeCommand = params.createNativeCommand ?? createDiscordNativeCommand;
-	const commands = params.commandSpecs.map((spec) => createNativeCommand({
-		command: spec,
-		cfg: params.cfg,
-		discordConfig: params.discordConfig,
-		accountId: params.accountId,
-		sessionPrefix: params.sessionPrefix,
-		ephemeralDefault: params.ephemeralDefault,
-		threadBindings: params.threadBindings
-	}));
-	if (params.nativeEnabled && params.voiceEnabled) commands.push(createDiscordVoiceCommand({
-		cfg: params.cfg,
-		discordConfig: params.discordConfig,
-		accountId: params.accountId,
-		groupPolicy: params.groupPolicy,
-		useAccessGroups: params.useAccessGroups,
-		getManager: () => params.voiceManagerRef.current,
-		ephemeralDefault: params.ephemeralDefault
-	}));
+	const commands = params.commandSpecs.map((spec) => {
+		if (params.nativeEnabled && params.voiceEnabled && spec.name === DISCORD_VOICE_COMMAND_SPEC.name) return createDiscordVoiceCommand({
+			cfg: params.cfg,
+			discordConfig: params.discordConfig,
+			accountId: params.accountId,
+			groupPolicy: params.groupPolicy,
+			useAccessGroups: params.useAccessGroups,
+			getManager: () => params.voiceManagerRef.current,
+			ephemeralDefault: params.ephemeralDefault
+		});
+		return createNativeCommand({
+			command: spec,
+			cfg: params.cfg,
+			discordConfig: params.discordConfig,
+			accountId: params.accountId,
+			sessionPrefix: params.sessionPrefix,
+			ephemeralDefault: params.ephemeralDefault,
+			threadBindings: params.threadBindings
+		});
+	});
 	const execApprovalsConfig = params.discordConfig.execApprovals ?? {};
 	const execApprovalsEnabled = isDiscordExecApprovalClientEnabled({
 		cfg: params.cfg,
@@ -10453,6 +9536,7 @@ function createDiscordProviderInteractionSurface(params) {
 		allowFrom: params.allowFrom,
 		dmPolicy: params.dmPolicy,
 		runtime: params.runtime,
+		channelRuntime: params.channelRuntime,
 		token: params.token
 	}, params.applicationId);
 	if (activityButton) components.push(activityButton);
@@ -10665,7 +9749,8 @@ function registerDiscordMonitorListeners(params) {
 		registerDiscordListener(params.client.listeners, new DiscordReactionListener(reactionListenerOptions));
 		registerDiscordListener(params.client.listeners, new DiscordReactionRemoveListener(reactionListenerOptions));
 	}
-	registerDiscordListener(params.client.listeners, new DiscordThreadUpdateListener(params.cfg, params.accountId, params.logger));
+	registerDiscordListener(params.client.listeners, new DiscordThreadUpdateListener(params.cfg, params.logger));
+	registerDiscordListener(params.client.listeners, new DiscordThreadDeleteListener(params.cfg, params.accountId, params.logger));
 	if (params.discordConfig.intents?.presence) {
 		const presenceListener = new DiscordPresenceListener({
 			cfg: params.cfg,
@@ -10866,8 +9951,31 @@ async function monitorDiscordProvider(opts = {}) {
 		phase: "fetch-application-id:start",
 		startAt: startupStartedAt
 	});
-	const applicationId = (typeof discordCfg.applicationId === "string" && discordCfg.applicationId.trim() ? discordCfg.applicationId.trim() : void 0) ?? parseApplicationIdFromToken(token) ?? await discordProviderRuntime.fetchDiscordApplicationId(token, 4e3, discordRestFetch);
-	if (!applicationId) throw new Error("Failed to resolve Discord application id");
+	const parsedApplicationId = (typeof discordCfg.applicationId === "string" && discordCfg.applicationId.trim() ? discordCfg.applicationId.trim() : void 0) ?? parseApplicationIdFromToken(token);
+	const applicationIdProbe = parsedApplicationId ? {
+		kind: "resolved",
+		applicationId: parsedApplicationId
+	} : await discordProviderRuntime.probeDiscordApplicationId(token, 4e3, discordRestFetch);
+	if (applicationIdProbe.kind !== "resolved") {
+		const at = Date.now();
+		const terminal = applicationIdProbe.kind === "rejected";
+		const probeError = formatErrorMessage$1(applicationIdProbe.error);
+		const message = `Failed to resolve Discord application id: ${probeError}`;
+		opts.setStatus?.({
+			connected: false,
+			lifecycle: terminal ? "blocked" : "recovering",
+			terminalDisconnect: terminal ? true : void 0,
+			lastEventAt: at,
+			lastDisconnect: {
+				at,
+				...applicationIdProbe.status !== null ? { status: applicationIdProbe.status } : {},
+				error: probeError
+			},
+			lastError: message
+		});
+		throw new Error(message, { cause: applicationIdProbe.error });
+	}
+	const applicationId = applicationIdProbe.applicationId;
 	logDiscordStartupPhase({
 		runtime,
 		accountId: account.accountId,
@@ -10880,9 +9988,9 @@ async function monitorDiscordProvider(opts = {}) {
 		runtime,
 		nativeEnabled,
 		nativeSkillsEnabled,
+		voiceEnabled,
 		listSkillCommandsForAgents: discordProviderRuntime.listSkillCommandsForAgents,
-		listNativeCommandSpecsForConfig: discordProviderRuntime.listNativeCommandSpecsForConfig,
-		getPluginCommandSpecs: discordProviderRuntime.getPluginCommandSpecs
+		listNativeCommandSpecsForConfig: discordProviderRuntime.listNativeCommandSpecsForConfig
 	});
 	const voiceManagerRef = { current: null };
 	const threadBindings = threadBindingsEnabled ? discordProviderSessionRuntime.createThreadBindingManager({
@@ -10921,6 +10029,7 @@ async function monitorDiscordProvider(opts = {}) {
 	let earlyGatewayEmitter = gatewaySupervisor?.emitter;
 	let onEarlyGatewayDebug;
 	try {
+		const pluginChannelRuntime = opts.channelRuntime;
 		const { commands, components, modals } = createDiscordProviderInteractionSurface({
 			cfg,
 			discordConfig: discordCfg,
@@ -10940,7 +10049,7 @@ async function monitorDiscordProvider(opts = {}) {
 			allowFrom,
 			dmPolicy,
 			runtime,
-			channelRuntime: opts.channelRuntime,
+			channelRuntime: pluginChannelRuntime,
 			abortSignal: opts.abortSignal,
 			createNativeCommand: discordProviderRuntime.createDiscordNativeCommand
 		});
@@ -11014,7 +10123,7 @@ async function monitorDiscordProvider(opts = {}) {
 				runtime,
 				botUserId
 			});
-			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-DIKGsTGT.js").then((n) => n.n);
+			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-DeIMNbRh.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: account.accountId,
 				manager: voiceManager
@@ -11032,6 +10141,7 @@ async function monitorDiscordProvider(opts = {}) {
 			accountId: account.accountId,
 			token,
 			runtime,
+			buildContext: pluginChannelRuntime?.inbound.buildContext,
 			setStatus: opts.setStatus,
 			abortSignal: opts.abortSignal,
 			botUserId,
@@ -11087,7 +10197,7 @@ async function monitorDiscordProvider(opts = {}) {
 			gatewayReady: lifecycleGateway?.isConnected === true,
 			botIdentity: botIdentity || void 0
 		}));
-		if (lifecycleGateway?.isConnected) opts.setStatus?.(createConnectedChannelStatusPatch());
+		if (lifecycleGateway?.isConnected) opts.setStatus?.(createDiscordReadyStatusPatch());
 		lifecycleStarted = true;
 		earlyGatewayEmitter?.removeListener("debug", onEarlyGatewayDebug);
 		onEarlyGatewayDebug = void 0;
@@ -11119,4 +10229,4 @@ async function monitorDiscordProvider(opts = {}) {
 	}
 }
 //#endregion
-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 };
+export { mapGatewayDispatchData as _, sanitizeDiscordFrontChannelReplyPayloads as a, resolveDiscordDmCommandAccess as b, resolveReplyContext as c, waitForDiscordGatewayPluginRegistration as d, createDiscordNativeCommand as f, handleDiscordDmCommandDecision as g, createDiscordSupplementalContextAccessChecker as h, formatDiscordReplySkip as i, createDiscordGatewayPlugin as l, buildDiscordInboundAccessContext as m, deliverDiscordReply as n, buildDirectLabel as o, buildDiscordGroupSystemPrompt as p, formatDiscordReplyDeliveryFailure as r, buildGuildLabel as s, monitorDiscordProvider as t, resolveDiscordGatewayIntents as u, registerDiscordListener as v, resolveDiscordTextCommandAccess as x, resolveFetchedDiscordThreadLikeChannelContext as y };