@openclaw/discord 2026.8.1-beta.2 → 2026.8.1

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

@@ -1,39 +1,44 @@
-import { B as Message, C as ReadyListener, Ct as editChannel, E as ThreadUpdateListener, Et as getChannelMessage, K as Modal, L as Command, M as RateLimitError, O as Client, R as CommandWithSubcommands, S as PresenceUpdateListener, T as ThreadDeleteListener, V as User, Y as Button, Z as Container, _ as GuildDeleteListener, a as chunkDiscordTextWithMode, at as Separator, b as MessageReactionAddListener, bt as createThread, g as GuildCreateListener, h as discord_exports, k as Plugin, ot as StringSelectMenu, rt as Row, st as TextDisplay, tn as __exportAll, ut as BaseMessageInteractiveComponent, v as InteractionCreateListener, x as MessageReactionRemoveListener, y as MessageCreateListener, z as Guild } from "./retry-CLpJcXXf.js";
-import { c as resolveDiscordAccountAllowFrom, d as resolveDiscordAccountDmPolicy, f as resolveDiscordMaxLinesPerMessage, p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-DJTf1LtA.js";
-import { n as getDiscordActivitiesRuntime } from "./runtime-DoHjckYm.js";
-import { C as parseDiscordActivityCustomIdForInteraction, D as parseDiscordModalCustomIdForInteraction, E as parseDiscordModalCustomId, O as decodeCustomIdComponent, T as parseDiscordComponentCustomIdForInteraction, k as encodeCustomIdComponent, l as parseExecApprovalData, s as parseDiscordQuestionData, w as parseDiscordComponentCustomId, y as buildDiscordActivityCustomId } from "./outbound-session-route-DxLkrgKQ.js";
-import { D as canViewDiscordGuildChannel, F as createDiscordRestClient, H as registerGateway, K as validateDiscordProxyUrl, U as unregisterGateway, q as withValidatedDiscordProxy, z as DISCORD_REST_TIMEOUT_MS } from "./send.shared-BmwFjW6T.js";
-import { _ as resolveDiscordModalEntryWithPersistence, g as resolveDiscordComponentEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-iJyFXw9L.js";
+import { A as ThreadUpdateListener, C as MessageCreateListener, D as ReadyListener, E as PresenceUpdateListener, G as User, H as CommandWithSubcommands, I as RateLimitError, K as hasDiscordV2Components, M as Client, N as Plugin, S as InteractionCreateListener, T as MessageReactionRemoveListener, U as Guild, V as Command, W as Message, Z as Modal, a as chunkDiscordTextWithMode, b as GuildCreateListener, ct as Row, dt as StringSelectMenu, et as Button, ft as TextDisplay, ht as BaseMessageInteractiveComponent, k as ThreadDeleteListener, nt as Container, ut as Separator, w as MessageReactionAddListener, x as GuildDeleteListener, y as discord_exports } from "./retry-DqHCW6PV.js";
+import { C as parseDiscordActivityCustomIdForInteraction, D as parseDiscordModalCustomIdForInteraction, E as parseDiscordModalCustomId, O as decodeCustomIdComponent, T as parseDiscordComponentCustomIdForInteraction, c as parseExecApprovalData, k as encodeCustomIdComponent, o as parseDiscordQuestionData, w as parseDiscordComponentCustomId, y as buildDiscordActivityCustomId } from "./components-Dk35LTf_.js";
+import { c as resolveDiscordAccount, f as resolveDiscordAccountDmPolicy, l as resolveDiscordAccountAllowFrom, m as normalizeDiscordToken, p as resolveDiscordMaxLinesPerMessage } from "./accounts-CfQ-vSyf.js";
+import { a as resolveDiscordComponentEntryWithPersistence, o as resolveDiscordModalEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-CrBJpGT_.js";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
 import { a as isDiscordRateLimitResponseBody, o as summarizeDiscordResponseBody } from "./api-DNVbJyEy.js";
-import { C as resolveTimestampMs, a as normalizeDiscordSlug, b as formatDiscordReactionEmoji, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordCommandOwnerAllowFrom, f as resolveDiscordGuildEntry, g as resolveDiscordOwnerAllowFrom, h as resolveDiscordOwnerAccess, i as normalizeDiscordDisplaySlug, l as resolveDiscordChannelPolicyCommandAuthorizer, m as resolveDiscordMemberAllowed, n as isDiscordGroupAllowedByPolicy, o as resolveDiscordAllowListMatch, p as resolveDiscordMemberAccessState, r as normalizeDiscordAllowList, t as allowListMatches, v as resolveGroupDmAllow, x as formatDiscordUserTag, y as shouldEmitDiscordReactionNotification } from "./allow-list-DnxIlPP2.js";
-import { a as formatMention, t as sendMessageDiscord } from "./send.outbound-DS5tHwfR.js";
+import { 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, s as resolveDiscordChannelConfig, v as resolveGroupDmAllow, x as formatDiscordUserTag, y as shouldEmitDiscordReactionNotification } from "./allow-list-BDMimASD.js";
+import { B as validateDiscordProxyUrl, G as unregisterGateway, P as createDiscordRestClient, R as DISCORD_REST_TIMEOUT_MS, V as withValidatedDiscordProxy, W as registerGateway, b as canViewDiscordGuildChannel, w as hasAnyChannelPermissionDiscord } from "./send.shared-DZJ1akvQ.js";
+import { a as formatMention, t as sendMessageDiscord } from "./send.outbound-D7JYmfm9.js";
+import { t as isDiscordThreadChannelType } from "./channel-type-CVLZyGYS.js";
+import { n as getDiscordActivitiesRuntime } from "./runtime-DrxVBTtp.js";
+import { n as resolveDiscordVoiceEnabled, r as authorizeDiscordVoiceIngress, t as resolveDiscordVoiceAccess } from "./owner-access-UlYi9t0M.js";
 import { i as setPresence, t as clearPresences } from "./presence-cache-z1N8MbJ3.js";
-import { r as sendVoiceMessageDiscord } from "./send-B7Q6Oc1I.js";
+import { _ as readMessagesDiscord, s as sendVoiceMessageDiscord } from "./send-UJHiAm4C.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-AcIxvrf3.js";
-import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-Dm7jEeg6.js";
-import { t as resolveDiscordUserAllowlist } from "./resolve-users-bktrCUUU.js";
-import { a as isThreadArchived, c as resolveDiscordChannelInfoSafe, d as resolveDiscordChannelParentSafe, f as resolveDiscordChannelTopicSafe, h as formatThreadBindingDurationLabel, l as resolveDiscordChannelNameSafe, r as getThreadBindingManager, s as resolveDiscordChannelIdSafe, u as resolveDiscordChannelParentIdSafe } from "./thread-bindings.manager-DCIH6WDC.js";
-import { a as probeDiscordApplicationId, r as parseApplicationIdFromToken } from "./probe-Bl-k5_Ku.js";
+import { S as isDiscordExecApprovalClientEnabled, b as getDiscordExecApprovalApprovers, c as resolveDiscordEffectiveRoute, i as buildDiscordConversationRouteContext, n as DISCORD_APPROVAL_ALLOWED_MENTIONS, o as resolveDiscordBoundConversationRoute, r as formatDiscordApprovalDisplayValue, u as resolveDiscordConversationIdentity } from "./outbound-session-route-Bn4uXaoE.js";
+import { t as discordIngressIdentity } from "./ingress-identity-CzZKcPK8.js";
+import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-D2yl_2CN.js";
+import { t as resolveDiscordUserAllowlist } from "./resolve-users-BLxfqajZ.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-Clm77DBM.js";
+import { a as probeDiscordApplicationId, r as parseApplicationIdFromToken } from "./probe-n6ZXxK8V.js";
 import { i as sanitizeRecentModels, n as normalizeModelRef, r as preferenceTimestampMs, t as buildPreferenceModelKey } from "./model-picker-preference-primitives-BHT1LkR_.js";
-import { a as formatDiscordMediaText, d as resolveDiscordChannelInfo, f as resolveDiscordMessageChannelId, n as resolveDiscordForwardedMessagesTextFromSnapshots, t as resolveDiscordEmbedText } from "./message-utils-BSCPVgy0.js";
-import { t as resolveDiscordSenderIdentity } from "./sender-identity-QtalnCYv.js";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import { buildAgentSessionKey, deriveLastRoutePolicy, isAcpSessionKey, isSubagentSessionKey, parseAgentSessionKey, resolveAgentIdFromSessionKey, resolveAgentRoute } from "openclaw/plugin-sdk/routing";
-import { asFiniteNumber, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeOptionalStringifiedId, normalizeStringEntries, parseFiniteNumber, parseStrictNonNegativeInteger, summarizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { getRuntimeConfig, getRuntimeConfigSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
+import { f as resolveDiscordChannelInfo, u as resolveDiscordMessageStickers } from "./message-text-Ca8M6TU8.js";
+import { i as resolveDiscordThreadParentInfo } from "./threading-CXuu_7o9.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 as parseFiniteNumber$1, parseStrictInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { ApplicationCommandOptionType, ButtonStyle, ChannelType, ComponentType, GatewayCloseCodes, GatewayCloseCodes as GatewayCloseCodes$1, GatewayDispatchEvents, GatewayIntentBits, GatewayOpcodes, PermissionFlagsBits } from "discord-api-types/v10";
 import { Type } from "typebox";
 import { Check, Errors } from "typebox/value";
+import { createHash, randomUUID } from "node:crypto";
+import { MAX_DATE_TIMESTAMP_MS, MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, asSafeIntegerInRange, parseFiniteNumber, parseStrictInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
+import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { inspect } from "node:util";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 import { PlatformMessageNotDispatchedError, formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { fetchWithSsrFGuard, formatErrorMessage as formatErrorMessage$1 } from "openclaw/plugin-sdk/ssrf-runtime";
+import { 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 { resolveSendableOutboundReplyParts, resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
 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";
@@ -41,33 +46,30 @@ import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
 import { chunkItems, findCodeRegions, sanitizeAssistantVisibleText, sanitizeAssistantVisibleTextWithProfile } from "openclaw/plugin-sdk/text-chunking";
-import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
 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 } from "openclaw/plugin-sdk/lazy-runtime";
-import { resolvePinnedMainDmOwnerFromAllowlist as resolvePinnedMainDmOwnerFromAllowlist$1 } from "openclaw/plugin-sdk/security-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 * as conversationRuntime from "openclaw/plugin-sdk/conversation-binding-runtime";
+import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
+import { createChannelIngressResolver, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { clearExpiredCooldowns, ensureAuthProfileStore, formatReasoningMessage, getPreparedModelCatalogSnapshot, isProfileInCooldown, listAgentIds, loadPreparedModelCatalog, resolveAgentAvatar, resolveAgentDir, resolveDefaultModelForAgent, resolveHumanDelayConfig, resolveProfilesUnavailableReason } from "openclaw/plugin-sdk/agent-runtime";
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { resolveNativeCommandsEnabled, resolveNativeSkillsEnabled } from "openclaw/plugin-sdk/native-command-config-runtime";
 import { requestHeartbeat } from "openclaw/plugin-sdk/heartbeat-runtime";
 import { enqueueRoutedSystemEvent, enqueueRoutedSystemEvent as enqueueRoutedSystemEvent$1 } from "openclaw/plugin-sdk/system-event-runtime";
-import { 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 { resolveChannelModelOverride } from "openclaw/plugin-sdk/model-session-runtime";
-import { finalizeInboundContext, generateConversationLabel } from "openclaw/plugin-sdk/reply-dispatch-runtime";
 import { deleteSessionEntry, getSessionEntry, listSessionEntries, readSessionUpdatedAt as readSessionUpdatedAt$1, resolveStorePath, resolveStorePath as resolveStorePath$1 } from "openclaw/plugin-sdk/session-store-runtime";
-import { buildCommandTextFromArgs, findCommandByNativeName, formatCommandArgMenuTitle, listChatCommands, listNativeCommandSpecsForConfig, listSkillCommandsForAgents, resolveCommandAuthorizedFromAuthorizers, resolveEffectiveAgentRuntime, resolveNativeCommandSessionTargets, resolveStoredModelOverride, serializeCommandArgs } from "openclaw/plugin-sdk/command-auth-native";
+import { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-runtime";
+import { createChannelPartialDeliveryError, dispatchChannelInboundTurn, formatInboundEnvelope, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, resolveEnvelopeFormatOptions, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent } from "openclaw/plugin-sdk/channel-inbound";
 import { buildCommandTextFromArgs as buildCommandTextFromArgs$1, findCommandByNativeName as findCommandByNativeName$1, mergeNativeCommandSpecs, parseCommandArgs, resolveCommandArgChoices, resolveCommandArgMenu, serializeCommandArgs as serializeCommandArgs$1 } from "openclaw/plugin-sdk/native-command-registry";
 import { PLUGIN_COMMAND_DISPATCH } from "openclaw/plugin-sdk/plugin-command-runtime";
 import { resolveDirectStatusReplyForSession } from "openclaw/plugin-sdk/command-status-runtime";
-import * as conversationRuntime from "openclaw/plugin-sdk/conversation-binding-runtime";
 import { normalizeProviderId } from "openclaw/plugin-sdk/provider-model-shared";
 import { EventEmitter } from "node:events";
 import * as ws from "ws";
@@ -79,6 +81,7 @@ import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runti
 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 { reportChannelRoomJoin } from "openclaw/plugin-sdk/channel-join-intro-runtime";
 import { resolveRequestUrl } from "openclaw/plugin-sdk/request-url";
 import { fetchWithRuntimeDispatcher } from "openclaw/plugin-sdk/runtime-fetch";
 import { Agent as Agent$1 } from "undici";
@@ -140,56 +143,216 @@ 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:",
-	"user:",
-	"pk:"
-];
 const DISCORD_CHANNEL_ID = "discord";
-const DISCORD_USER_ID_KIND = "stable-id";
-const DISCORD_USER_NAME_KIND = "username";
-function normalizeDiscordIdEntry(entry) {
-	const text = entry.trim();
-	if (!text) return null;
-	const maybeId = text.replace(/^<@!?/, "").replace(/>$/, "");
-	if (/^\d+$/.test(maybeId)) return maybeId;
-	const prefix = DISCORD_ALLOW_LIST_PREFIXES.find((entryPrefix) => text.startsWith(entryPrefix));
-	if (prefix) return text.slice(prefix.length).trim() || null;
-	return null;
-}
-function normalizeDiscordNameEntry(entry) {
-	const text = entry.trim();
-	if (!text || text === "*" || normalizeDiscordIdEntry(text)) return null;
-	const nameSlug = normalizeDiscordAllowList([text], DISCORD_ALLOW_LIST_PREFIXES)?.names.values().next().value;
-	return typeof nameSlug === "string" && nameSlug ? nameSlug : null;
-}
-function normalizeDiscordNameSubject(value) {
-	const nameSlug = normalizeDiscordAllowList([value], DISCORD_ALLOW_LIST_PREFIXES)?.names.values().next().value;
-	return typeof nameSlug === "string" && nameSlug ? nameSlug : null;
-}
-const discordIngressIdentity = defineStableChannelIngressIdentity({
-	key: "discordUserId",
-	kind: DISCORD_USER_ID_KIND,
-	normalizeEntry: normalizeDiscordIdEntry,
-	normalizeSubject: (value) => value.trim() || null,
-	sensitivity: "pii",
-	aliases: [["discordUserName", normalizeDiscordNameEntry], ["discordUserTag", () => null]].map(([key, normalizeEntry]) => ({
-		key,
-		kind: DISCORD_USER_NAME_KIND,
-		normalizeEntry,
-		normalizeSubject: normalizeDiscordNameSubject,
-		dangerous: true,
-		sensitivity: "pii"
-	}))
-});
 function createDiscordDmIngressSubject(sender) {
 	return {
 		stableId: sender.id,
 		aliases: {
 			discordUserName: sender.name,
-			discordUserTag: sender.tag
-		}
+			discordUserTag: sender.tag,
+			participantKind: sender.isPluralKit ? "pluralkit-member" : sender.authorKind
+		},
+		...sender.isPluralKit ? { authentication: { discordUserId: "asserted" } } : {}
 	};
 }
 function createDiscordDynamicAccessGroupResolver(params) {
@@ -264,7 +427,10 @@ async function resolveDiscordDmCommandAccess(params) {
 		},
 		dmPolicy: params.dmPolicy,
 		groupPolicy: "disabled",
-		policy: { mutableIdentifierMatching: params.allowNameMatching ? "enabled" : "disabled" },
+		policy: {
+			mutableIdentifierMatching: params.allowNameMatching ? "enabled" : "disabled",
+			...params.minIdentifierAuthentication ? { minIdentifierAuthentication: params.minIdentifierAuthentication } : {}
+		},
 		allowFrom: params.configuredAllowFrom,
 		command: {
 			hasControlCommand: false,
@@ -294,7 +460,10 @@ async function resolveDiscordTextCommandAccess(params) {
 		accessGroupMembership,
 		dmPolicy: "allowlist",
 		groupPolicy: "allowlist",
-		policy: { mutableIdentifierMatching: params.allowNameMatching ? "enabled" : "disabled" },
+		policy: {
+			mutableIdentifierMatching: params.allowNameMatching ? "enabled" : "disabled",
+			...params.minIdentifierAuthentication ? { minIdentifierAuthentication: params.minIdentifierAuthentication } : {}
+		},
 		allowFrom: ownerAllowFrom,
 		groupAllowFrom: commandGroup,
 		command: {
@@ -305,474 +474,16 @@ async function resolveDiscordTextCommandAccess(params) {
 	});
 }
 //#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_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;
-	try {
-		const userMessage = buildThreadTitleCompletionUserMessage({
-			sourceText,
-			channelName: params.channelName,
-			channelDescription: params.channelDescription
-		});
-		const timeoutMs = resolveThreadTitleTimeoutMs(params.timeoutMs);
-		const generated = await generateConversationLabel({
-			cfg: params.cfg,
-			agentId: params.agentId,
-			userMessage,
-			prompt: DISCORD_THREAD_TITLE_SYSTEM_PROMPT,
-			...params.modelRef ? { modelRef: params.modelRef } : {},
-			timeoutMs,
-			maxLength: MAX_THREAD_TITLE_SOURCE_CHARS
-		});
-		return generated ? normalizeGeneratedThreadTitle(generated) : null;
-	} catch (err) {
-		logVerbose(`thread-title: title generation failed for agent ${params.agentId}: ${String(err)}`);
-		return null;
-	}
-}
-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) {
-	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;
+//#region extensions/discord/src/monitor/thread-channel-context.ts
+function buildFetchedChannelInfo(channel) {
+	const channelInfo = resolveDiscordChannelInfoSafe(channel);
+	if (channelInfo.type === void 0) return null;
 	return {
-		id: parentId,
-		name: parentName,
-		type: parentType
-	};
-}
-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
+		type: channelInfo.type,
+		name: channelInfo.name,
+		topic: channelInfo.topic,
+		parentId: channelInfo.parentId,
+		ownerId: channelInfo.ownerId
 	};
 }
 async function resolveDiscordThreadLikeChannelContext(params) {
@@ -1090,305 +801,106 @@ async function handleDiscordReactionEvent(params) {
 			const guildSlug = guildInfo?.slug || (data.guild?.name ? normalizeDiscordSlug(data.guild.name) : data.guild_id ?? (isGroupDm ? "group-dm" : "dm"));
 			const channelLabel = channelSlug ? `#${channelSlug}` : channelName ? `#${normalizeDiscordSlug(channelName)}` : `#${data.channel_id}`;
 			reactionBase = {
-				baseText: `Discord reaction ${action}: ${emojiLabel} by ${actorLabel} on ${guildSlug} ${channelLabel} msg ${data.message_id}`,
-				contextKey: `discord:reaction:${action}:${data.message_id}:${user.id}:${emojiLabel}`
-			};
-			return reactionBase;
-		};
-		const emitReaction = (text, parentPeerId) => {
-			const { contextKey } = resolveReactionBase();
-			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,
-			botId: botUserId,
-			messageAuthorId: options.messageAuthorId,
-			userId: user.id,
-			userName: user.username,
-			userTag: formatDiscordUserTag(user),
-			channelConfig: options.channelConfig,
-			guildInfo,
-			memberRoleIds,
-			allowNameMatching: params.allowNameMatching
-		});
-		const emitReactionWithAuthor = (message) => {
-			const { baseText } = resolveReactionBase();
-			const authorLabel = message?.author ? formatDiscordUserTag(message.author) : void 0;
-			const text = authorLabel ? `${baseText} from ${authorLabel}` : baseText;
-			emitReaction(text, parentId);
-		};
-		const resolveThreadChannelConfig = () => resolveDiscordChannelConfigWithFallback({
-			guildInfo,
-			channelId: data.channel_id,
-			channelName,
-			channelSlug,
-			parentId,
-			parentName,
-			parentSlug,
-			scope: "thread"
-		});
-		const authorizeReactionIngressForChannel = async (channelConfig) => await authorizeDiscordReactionIngress({
-			...reactionIngressBase,
-			channelConfig
-		});
-		const resolveThreadChannelAccess = async () => {
-			const channelConfig = resolveThreadChannelConfig();
-			return {
-				access: await authorizeReactionIngressForChannel(channelConfig),
-				channelConfig
-			};
-		};
-		if (isThreadChannel) {
-			await handleDiscordThreadReactionNotification({
-				reactionMode,
-				message: data.message,
-				parentId,
-				resolveThreadChannelAccess,
-				shouldNotifyReaction,
-				resolveReactionBase,
-				emitReaction,
-				emitReactionWithAuthor
-			});
-			return;
-		}
-		const channelConfig = resolveDiscordChannelConfigWithFallback({
-			guildInfo,
-			channelId: data.channel_id,
-			channelName,
-			channelSlug,
-			parentId,
-			parentName,
-			parentSlug,
-			scope: "channel"
-		});
-		await handleDiscordChannelReactionNotification({
-			isGuildMessage,
-			reactionMode,
-			message: data.message,
-			channelConfig,
-			parentId,
-			authorizeReactionIngressForChannel,
-			shouldNotifyReaction,
-			resolveReactionBase,
-			emitReaction,
-			emitReactionWithAuthor
-		});
-	} catch (err) {
-		params.logger.error(danger(`discord reaction handler failed: ${String(err)}`));
-	}
-}
-//#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;
+				baseText: `Discord ${data.burst ? "super " : ""}reaction ${action}: ${emojiLabel} by ${actorLabel} on ${guildSlug} ${channelLabel} msg ${data.message_id}`,
+				contextKey: `discord:reaction:${action}:${data.message_id}:${user.id}:${emojiLabel}${data.burst ? ":burst" : ""}`
+			};
+			return reactionBase;
+		};
+		const emitReaction = (text, parentPeerId) => {
+			const { contextKey } = resolveReactionBase();
+			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,
+			botId: botUserId,
+			messageAuthorId: options.messageAuthorId,
+			userId: user.id,
+			userName: user.username,
+			userTag: formatDiscordUserTag(user),
+			channelConfig: options.channelConfig,
+			guildInfo,
+			memberRoleIds,
+			allowNameMatching: params.allowNameMatching
+		});
+		const emitReactionWithAuthor = (message) => {
+			const { baseText } = resolveReactionBase();
+			const authorLabel = message?.author ? formatDiscordUserTag(message.author) : void 0;
+			const text = authorLabel ? `${baseText} from ${authorLabel}` : baseText;
+			emitReaction(text, parentId);
+		};
+		const resolveThreadChannelConfig = () => resolveDiscordChannelConfigWithFallback({
+			guildInfo,
+			channelId: data.channel_id,
+			channelName,
+			channelSlug,
+			parentId,
+			parentName,
+			parentSlug,
+			scope: "thread"
+		});
+		const authorizeReactionIngressForChannel = async (channelConfig) => await authorizeDiscordReactionIngress({
+			...reactionIngressBase,
+			channelConfig
+		});
+		const resolveThreadChannelAccess = async () => {
+			const channelConfig = resolveThreadChannelConfig();
+			return {
+				access: await authorizeReactionIngressForChannel(channelConfig),
+				channelConfig
+			};
+		};
+		if (isThreadChannel) {
+			await handleDiscordThreadReactionNotification({
+				reactionMode,
+				message: data.message,
+				parentId,
+				resolveThreadChannelAccess,
+				shouldNotifyReaction,
+				resolveReactionBase,
+				emitReaction,
+				emitReactionWithAuthor
+			});
+			return;
 		}
+		const channelConfig = resolveDiscordChannelConfigWithFallback({
+			guildInfo,
+			channelId: data.channel_id,
+			channelName,
+			channelSlug,
+			parentId,
+			parentName,
+			parentSlug,
+			scope: "channel"
+		});
+		await handleDiscordChannelReactionNotification({
+			isGuildMessage,
+			reactionMode,
+			message: data.message,
+			channelConfig,
+			parentId,
+			authorizeReactionIngressForChannel,
+			shouldNotifyReaction,
+			resolveReactionBase,
+			emitReaction,
+			emitReactionWithAuthor
+		});
+	} catch (err) {
+		params.logger.error(danger(`discord reaction handler failed: ${String(err)}`));
 	}
-	return resetCount;
 }
 //#endregion
 //#region extensions/discord/src/monitor/listeners.ts
@@ -1815,11 +1327,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 {
@@ -1839,33 +1356,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
-		} : {
-			...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;
@@ -1890,99 +1399,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({
@@ -2050,6 +1487,7 @@ async function dispatchDiscordNativeAgentReply(params) {
 			sessionKey: params.ctxPayload.SessionKey ?? params.effectiveRoute.sessionKey
 		},
 		ctxPayload: params.ctxPayload,
+		dispatchReplyFromConfig: params.dispatchReplyFromConfig,
 		delivery: {
 			deliver: async (payload) => {
 				if (params.suppressReplies) return {
@@ -2099,28 +1537,171 @@ async function dispatchDiscordNativeAgentReply(params) {
 			disableBlockStreaming: typeof blockStreamingEnabled === "boolean" ? !blockStreamingEnabled : void 0
 		}
 	});
-	const deliberateSilentTerminalReply = turnResult.dispatched && turnResult.dispatchResult.deliberateSilentTerminalReply === true;
-	const dispatchResult = {
-		dispatched: turnResult.dispatched,
-		...hiddenFinalReply ? { hiddenFinalReply } : {}
+	const shouldSettleWithoutVisibleReply = params.suppressReplies || finalReplyOutcome === "suppressed" || turnResult.dispatched && (turnResult.dispatchResult.deliberateSilentTerminalReply === true || turnResult.dispatchResult.deferredToActiveRun !== void 0);
+	const dispatchResult = {
+		dispatched: turnResult.dispatched,
+		...hiddenFinalReply ? { hiddenFinalReply } : {}
+	};
+	if (!didReply && shouldSettleWithoutVisibleReply) {
+		await settleDiscordInteractionWithoutVisibleReply(params.interaction);
+		return dispatchResult;
+	}
+	if (didReply || turnResult.dispatched && hasVisibleInboundReplyDispatch(turnResult.dispatchResult)) return dispatchResult;
+	await safeDiscordInteractionCall("interaction empty fallback", async () => {
+		const payload = {
+			content: DISCORD_EMPTY_VISIBLE_REPLY_WARNING,
+			ephemeral: true
+		};
+		if (params.preferFollowUp) {
+			await params.interaction.followUp(payload);
+			return;
+		}
+		await params.interaction.reply(payload);
+	});
+	return dispatchResult;
+}
+//#endregion
+//#region extensions/discord/src/monitor/commands.ts
+function resolveDiscordSlashCommandConfig(raw) {
+	return { ephemeral: raw?.ephemeral !== false };
+}
+//#endregion
+//#region extensions/discord/src/monitor/native-command-arg-ui.ts
+const DISCORD_COMMAND_ARG_CUSTOM_ID_KEY = "cmdarg";
+function createCommandArgsWithValue(params) {
+	return { values: { [params.argName]: params.value } };
+}
+function buildDiscordCommandArgCustomId(params) {
+	return [
+		`${DISCORD_COMMAND_ARG_CUSTOM_ID_KEY}:command=${encodeCustomIdComponent(params.command)}`,
+		`arg=${encodeCustomIdComponent(params.arg)}`,
+		`value=${encodeCustomIdComponent(params.value)}`,
+		`user=${encodeCustomIdComponent(params.userId)}`
+	].join(";");
+}
+function parseDiscordCommandArgData(data) {
+	if (!data || typeof data !== "object") return null;
+	const coerce = (value) => typeof value === "string" || typeof value === "number" ? String(value) : "";
+	const rawCommand = coerce(data.command);
+	const rawArg = coerce(data.arg);
+	const rawValue = coerce(data.value);
+	const rawUser = coerce(data.user);
+	if (!rawCommand || !rawArg || !rawValue || !rawUser) return null;
+	return {
+		command: decodeCustomIdComponent(rawCommand),
+		arg: decodeCustomIdComponent(rawArg),
+		value: decodeCustomIdComponent(rawValue),
+		userId: decodeCustomIdComponent(rawUser)
+	};
+}
+async function handleDiscordCommandArgInteraction(params) {
+	const { interaction, data, ctx } = params;
+	const clearWithMessage = async (content) => await params.safeInteractionCall("command arg update", () => interaction.update({
+		content,
+		components: []
+	}));
+	const parsed = parseDiscordCommandArgData(data);
+	if (!parsed) {
+		await clearWithMessage("Sorry, that selection is no longer available.");
+		return;
+	}
+	if (interaction.user?.id && interaction.user.id !== parsed.userId) {
+		await params.safeInteractionCall("command arg ack", () => interaction.acknowledge());
+		return;
+	}
+	const commandDefinition = findCommandByNativeName(parsed.command, "discord") ?? listChatCommands().find((entry) => entry.key === parsed.command);
+	if (!commandDefinition) {
+		await clearWithMessage("Sorry, that command is no longer available.");
+		return;
+	}
+	if (await clearWithMessage(`⏳ Applying ${parsed.value}...`) === null) return;
+	const commandArgs = createCommandArgsWithValue({
+		argName: parsed.arg,
+		value: parsed.value
+	});
+	const commandArgsWithRaw = {
+		...commandArgs,
+		raw: serializeCommandArgs(commandDefinition, commandArgs)
+	};
+	const prompt = buildCommandTextFromArgs(commandDefinition, commandArgsWithRaw);
+	await params.dispatchCommandInteraction({
+		interaction,
+		prompt,
+		command: commandDefinition,
+		commandArgs: commandArgsWithRaw,
+		cfg: ctx.cfg,
+		discordConfig: ctx.discordConfig,
+		accountId: ctx.accountId,
+		sessionPrefix: ctx.sessionPrefix,
+		preferFollowUp: true,
+		threadBindings: ctx.threadBindings,
+		responseEphemeral: resolveDiscordSlashCommandConfig(ctx.discordConfig?.slashCommand).ephemeral,
+		dispatchReplyFromConfig: ctx.dispatchReplyFromConfig,
+		pluginCommandDispatch: { kind: "non-plugin" }
+	});
+}
+async function runDiscordCommandArgButton(params) {
+	await handleDiscordCommandArgInteraction(params);
+}
+var DiscordCommandArgButton = class extends Button {
+	constructor(params) {
+		super();
+		this.style = ButtonStyle.Secondary;
+		this.label = params.label;
+		this.customId = params.customId;
+		this.params = params;
+	}
+	async run(interaction, data) {
+		await runDiscordCommandArgButton({
+			...this.params,
+			interaction,
+			data
+		});
+	}
+};
+function buildDiscordCommandArgMenu(params) {
+	const { command, menu, interaction } = params;
+	const commandLabel = command.nativeName ?? command.key;
+	const userId = interaction.user?.id ?? "";
+	const rows = chunkItems(menu.choices, 4).map((choices) => {
+		return new Row(choices.map((choice) => new DiscordCommandArgButton({
+			label: choice.label,
+			customId: buildDiscordCommandArgCustomId({
+				command: commandLabel,
+				arg: menu.arg.name,
+				value: choice.value,
+				userId
+			}),
+			ctx: params.ctx,
+			safeInteractionCall: params.safeInteractionCall,
+			dispatchCommandInteraction: params.dispatchCommandInteraction
+		})));
+	});
+	return {
+		content: formatCommandArgMenuTitle({
+			command,
+			menu
+		}),
+		components: rows
 	};
-	if (!didReply && (params.suppressReplies || finalReplyOutcome === "suppressed" || deliberateSilentTerminalReply)) {
-		await settleDiscordInteractionWithoutVisibleReply(params.interaction);
-		return dispatchResult;
+}
+var DiscordCommandArgFallbackButton = class extends Button {
+	constructor(params) {
+		super();
+		this.params = params;
+		this.label = "cmdarg";
+		this.customId = "cmdarg:seed=1";
 	}
-	if (didReply || turnResult.dispatched && hasVisibleInboundReplyDispatch(turnResult.dispatchResult)) return dispatchResult;
-	await safeDiscordInteractionCall("interaction empty fallback", async () => {
-		const payload = {
-			content: DISCORD_EMPTY_VISIBLE_REPLY_WARNING,
-			ephemeral: true
-		};
-		if (params.preferFollowUp) {
-			await params.interaction.followUp(payload);
-			return;
-		}
-		await params.interaction.reply(payload);
-	});
-	return dispatchResult;
+	async run(interaction, data) {
+		await runDiscordCommandArgButton({
+			...this.params,
+			interaction,
+			data
+		});
+	}
+};
+function createDiscordCommandArgFallbackButton$1(params) {
+	return new DiscordCommandArgFallbackButton(params);
 }
 //#endregion
 //#region extensions/discord/src/monitor/native-interaction-channel-context.ts
@@ -2398,11 +1979,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
@@ -2465,237 +2046,61 @@ function buildDiscordNativeCommandContext(params) {
 		channelConfig: params.channelConfig,
 		guildInfo: params.guildInfo,
 		sender: params.sender,
-		allowNameMatching: params.allowNameMatching,
-		isGuild: params.isGuild,
-		channelTopic: params.channelTopic
-	});
-	return finalizeInboundContext({
-		Body: params.prompt,
-		BodyForAgent: params.prompt,
-		RawBody: params.prompt,
-		CommandBody: params.prompt,
-		CommandArgs: params.commandArgs,
-		From: params.isDirectMessage ? `discord:${params.user.id}` : params.isGroupDm ? `discord:group:${params.channelId}` : `discord:channel:${params.channelId}`,
-		To: `slash:${params.user.id}`,
-		SessionKey: params.sessionKey,
-		CommandTargetSessionKey: params.commandTargetSessionKey,
-		AccountId: params.accountId ?? void 0,
-		ChatType: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
-		ConversationLabel: conversationLabel,
-		GroupSubject: params.isGuild ? params.guildName : void 0,
-		GroupSpace: params.isGuild ? params.guildInfo?.id ?? params.guildInfo?.slug ?? params.guildId : void 0,
-		MemberRoleIds: params.memberRoleIds,
-		GroupSystemPrompt: groupSystemPrompt,
-		ChannelStructuredContext: channelStructuredContext,
-		OwnerAllowFrom: ownerAllowFrom,
-		SenderName: params.user.globalName ?? params.user.username,
-		SenderId: params.user.id,
-		SenderUsername: params.user.username,
-		SenderTag: params.sender.tag,
-		Provider: "discord",
-		Surface: "discord",
-		WasMentioned: true,
-		MessageSid: params.interactionId,
-		MessageThreadId: params.isThreadChannel ? params.channelId : void 0,
-		Timestamp: params.timestampMs ?? Date.now(),
-		CommandAuthorized: params.commandAuthorized,
-		CommandTurn: {
-			kind: "native",
-			source: "native",
-			authorized: params.commandAuthorized,
-			body: params.prompt
-		},
-		CommandSource: "native",
-		OriginatingChannel: "discord",
-		OriginatingTo: resolveDiscordConversationIdentity({
-			isDirectMessage: params.isDirectMessage,
-			userId: params.user.id,
-			channelId: params.channelId
-		}) ?? (params.isDirectMessage ? `user:${params.user.id}` : `channel:${params.channelId}`),
-		ThreadParentId: params.isThreadChannel ? params.threadParentId : void 0
-	});
-}
-//#endregion
-//#region extensions/discord/src/monitor/native-command-status.ts
-async function maybeDeliverDiscordDirectStatus(params) {
-	if (params.suppressReplies || params.commandName !== "status") return null;
-	const statusReply = await params.resolveDirectStatusReplyForSession({
-		cfg: params.cfg,
-		sessionKey: params.commandTargetSessionKey?.trim() || params.sessionKey,
-		channel: params.channel,
-		senderId: params.senderId,
-		senderIsOwner: params.senderIsOwner,
-		isAuthorizedSender: params.isAuthorizedSender,
-		isGroup: params.isGroup,
-		defaultGroupActivation: params.defaultGroupActivation
-	});
-	if (statusReply && hasRenderableReplyPayload(statusReply)) {
-		await deliverDiscordInteractionReply({
-			interaction: params.interaction,
-			payload: statusReply,
-			mediaLocalRoots: params.mediaLocalRoots,
-			textLimit: resolveTextChunkLimit(params.cfg, "discord", params.accountId, { fallbackLimit: 2e3 }),
-			maxLinesPerMessage: resolveDiscordMaxLinesPerMessage({
-				cfg: params.cfg,
-				discordConfig: params.discordConfig,
-				accountId: params.accountId
-			}),
-			preferFollowUp: params.preferFollowUp,
-			responseEphemeral: params.responseEphemeral,
-			chunkMode: resolveChunkMode(params.cfg, "discord", params.accountId)
-		});
-		return {
-			accepted: true,
-			effectiveRoute: params.effectiveRoute
-		};
-	}
-	await params.respond("Status unavailable.");
-	return {
-		accepted: true,
-		effectiveRoute: params.effectiveRoute
-	};
-}
-//#endregion
-//#region extensions/discord/src/monitor/commands.ts
-function resolveDiscordSlashCommandConfig(raw) {
-	return { ephemeral: raw?.ephemeral !== false };
-}
-//#endregion
-//#region extensions/discord/src/monitor/native-command-arg-ui.ts
-const DISCORD_COMMAND_ARG_CUSTOM_ID_KEY = "cmdarg";
-function createCommandArgsWithValue(params) {
-	return { values: { [params.argName]: params.value } };
-}
-function buildDiscordCommandArgCustomId(params) {
-	return [
-		`${DISCORD_COMMAND_ARG_CUSTOM_ID_KEY}:command=${encodeCustomIdComponent(params.command)}`,
-		`arg=${encodeCustomIdComponent(params.arg)}`,
-		`value=${encodeCustomIdComponent(params.value)}`,
-		`user=${encodeCustomIdComponent(params.userId)}`
-	].join(";");
-}
-function parseDiscordCommandArgData(data) {
-	if (!data || typeof data !== "object") return null;
-	const coerce = (value) => typeof value === "string" || typeof value === "number" ? String(value) : "";
-	const rawCommand = coerce(data.command);
-	const rawArg = coerce(data.arg);
-	const rawValue = coerce(data.value);
-	const rawUser = coerce(data.user);
-	if (!rawCommand || !rawArg || !rawValue || !rawUser) return null;
-	return {
-		command: decodeCustomIdComponent(rawCommand),
-		arg: decodeCustomIdComponent(rawArg),
-		value: decodeCustomIdComponent(rawValue),
-		userId: decodeCustomIdComponent(rawUser)
-	};
-}
-async function handleDiscordCommandArgInteraction(params) {
-	const { interaction, data, ctx } = params;
-	const clearWithMessage = async (content) => await params.safeInteractionCall("command arg update", () => interaction.update({
-		content,
-		components: []
-	}));
-	const parsed = parseDiscordCommandArgData(data);
-	if (!parsed) {
-		await clearWithMessage("Sorry, that selection is no longer available.");
-		return;
-	}
-	if (interaction.user?.id && interaction.user.id !== parsed.userId) {
-		await params.safeInteractionCall("command arg ack", () => interaction.acknowledge());
-		return;
-	}
-	const commandDefinition = findCommandByNativeName(parsed.command, "discord") ?? listChatCommands().find((entry) => entry.key === parsed.command);
-	if (!commandDefinition) {
-		await clearWithMessage("Sorry, that command is no longer available.");
-		return;
-	}
-	if (await clearWithMessage(`⏳ Applying ${parsed.value}...`) === null) return;
-	const commandArgs = createCommandArgsWithValue({
-		argName: parsed.arg,
-		value: parsed.value
-	});
-	const commandArgsWithRaw = {
-		...commandArgs,
-		raw: serializeCommandArgs(commandDefinition, commandArgs)
-	};
-	const prompt = buildCommandTextFromArgs(commandDefinition, commandArgsWithRaw);
-	await params.dispatchCommandInteraction({
-		interaction,
-		prompt,
-		command: commandDefinition,
-		commandArgs: commandArgsWithRaw,
-		cfg: ctx.cfg,
-		discordConfig: ctx.discordConfig,
-		accountId: ctx.accountId,
-		sessionPrefix: ctx.sessionPrefix,
-		preferFollowUp: true,
-		threadBindings: ctx.threadBindings,
-		responseEphemeral: resolveDiscordSlashCommandConfig(ctx.discordConfig?.slashCommand).ephemeral,
-		pluginCommandDispatch: { kind: "non-plugin" }
-	});
-}
-async function runDiscordCommandArgButton(params) {
-	await handleDiscordCommandArgInteraction(params);
-}
-var DiscordCommandArgButton = class extends Button {
-	constructor(params) {
-		super();
-		this.style = ButtonStyle.Secondary;
-		this.label = params.label;
-		this.customId = params.customId;
-		this.params = params;
-	}
-	async run(interaction, data) {
-		await runDiscordCommandArgButton({
-			...this.params,
-			interaction,
-			data
-		});
-	}
-};
-function buildDiscordCommandArgMenu(params) {
-	const { command, menu, interaction } = params;
-	const commandLabel = command.nativeName ?? command.key;
-	const userId = interaction.user?.id ?? "";
-	const rows = chunkItems(menu.choices, 4).map((choices) => {
-		return new Row(choices.map((choice) => new DiscordCommandArgButton({
-			label: choice.label,
-			customId: buildDiscordCommandArgCustomId({
-				command: commandLabel,
-				arg: menu.arg.name,
-				value: choice.value,
-				userId
-			}),
-			ctx: params.ctx,
-			safeInteractionCall: params.safeInteractionCall,
-			dispatchCommandInteraction: params.dispatchCommandInteraction
-		})));
+		allowNameMatching: params.allowNameMatching,
+		isGuild: params.isGuild,
+		channelTopic: params.channelTopic
 	});
-	return {
-		content: formatCommandArgMenuTitle({
-			command,
-			menu
+	return finalizeInboundContext({
+		Body: params.prompt,
+		BodyForAgent: params.prompt,
+		RawBody: params.prompt,
+		CommandBody: params.prompt,
+		CommandArgs: params.commandArgs,
+		From: params.isDirectMessage ? `discord:${params.user.id}` : params.isGroupDm ? `discord:group:${params.channelId}` : `discord:channel:${params.channelId}`,
+		To: `slash:${params.user.id}`,
+		SessionKey: params.sessionKey,
+		CommandTargetSessionKey: params.commandTargetSessionKey,
+		AccountId: params.accountId ?? void 0,
+		ChatType: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
+		...buildDiscordConversationRouteContext({
+			isDirectMessage: params.isDirectMessage,
+			isGroupDm: params.isGroupDm,
+			directUserId: params.user.id,
+			conversationId: params.channelId,
+			isThread: params.isThreadChannel,
+			parentConversationId: params.threadParentId
 		}),
-		components: rows
-	};
-}
-var DiscordCommandArgFallbackButton = class extends Button {
-	constructor(params) {
-		super();
-		this.params = params;
-		this.label = "cmdarg";
-		this.customId = "cmdarg:seed=1";
-	}
-	async run(interaction, data) {
-		await runDiscordCommandArgButton({
-			...this.params,
-			interaction,
-			data
-		});
-	}
-};
-function createDiscordCommandArgFallbackButton$1(params) {
-	return new DiscordCommandArgFallbackButton(params);
+		ConversationLabel: conversationLabel,
+		GroupSubject: params.isGuild ? params.guildName : void 0,
+		GroupSpace: params.isGuild ? params.guildInfo?.id ?? params.guildInfo?.slug ?? params.guildId : void 0,
+		MemberRoleIds: params.memberRoleIds,
+		GroupSystemPrompt: groupSystemPrompt,
+		ChannelStructuredContext: channelStructuredContext,
+		OwnerAllowFrom: ownerAllowFrom,
+		SenderName: params.user.globalName ?? params.user.username,
+		SenderId: params.user.id,
+		SenderUsername: params.user.username,
+		SenderTag: params.sender.tag,
+		Provider: "discord",
+		Surface: "discord",
+		WasMentioned: true,
+		MessageSid: params.interactionId,
+		Timestamp: params.timestampMs ?? Date.now(),
+		CommandAuthorized: params.commandAuthorized,
+		CommandTurn: {
+			kind: "native",
+			source: "native",
+			authorized: params.commandAuthorized,
+			body: params.prompt
+		},
+		CommandSource: "native",
+		OriginatingChannel: "discord",
+		OriginatingTo: resolveDiscordConversationIdentity({
+			isDirectMessage: params.isDirectMessage,
+			userId: params.user.id,
+			channelId: params.channelId
+		}) ?? (params.isDirectMessage ? `user:${params.user.id}` : `channel:${params.channelId}`)
+	});
 }
 //#endregion
 //#region extensions/discord/src/monitor/model-picker-preferences.ts
@@ -2876,8 +2281,8 @@ function paginateItems(params) {
 	};
 }
 async function loadDiscordModelPickerData(cfg, agentId) {
-	const { buildModelsProviderData } = await loadModelsProviderRuntime();
-	return buildModelsProviderData(cfg, agentId);
+	const { buildPreparedModelsProviderData } = await loadModelsProviderRuntime();
+	return buildPreparedModelsProviderData(cfg, agentId);
 }
 function buildDiscordModelPickerCustomId(params) {
 	const userId = params.userId.trim();
@@ -3694,6 +3099,7 @@ async function applyDiscordModelPickerSelection(params) {
 			preferFollowUp: true,
 			threadBindings: params.threadBindings,
 			suppressReplies: true,
+			dispatchReplyFromConfig: params.dispatchReplyFromConfig,
 			pluginCommandDispatch: { kind: "non-plugin" }
 		}), 12e3);
 		if (!dispatchResult.accepted) return {
@@ -4351,6 +3757,7 @@ async function handleDiscordModelPickerInteraction(params) {
 			accountId: ctx.accountId,
 			sessionPrefix: ctx.sessionPrefix,
 			threadBindings: ctx.threadBindings,
+			dispatchReplyFromConfig: ctx.dispatchReplyFromConfig,
 			route,
 			resolvedModelRef,
 			selectedRuntime,
@@ -4414,6 +3821,46 @@ function createDiscordModelPickerFallbackSelect$1(params) {
 	return new DiscordModelPickerFallbackSelect(params);
 }
 //#endregion
+//#region extensions/discord/src/monitor/native-command-status.ts
+async function maybeDeliverDiscordDirectStatus(params) {
+	if (params.suppressReplies || params.commandName !== "status") return null;
+	const statusReply = await params.resolveDirectStatusReplyForSession({
+		cfg: params.cfg,
+		sessionKey: params.commandTargetSessionKey?.trim() || params.sessionKey,
+		channel: params.channel,
+		senderId: params.senderId,
+		senderIsOwner: params.senderIsOwner,
+		isAuthorizedSender: params.isAuthorizedSender,
+		isGroup: params.isGroup,
+		defaultGroupActivation: params.defaultGroupActivation
+	});
+	if (statusReply && hasRenderableReplyPayload(statusReply)) {
+		await deliverDiscordInteractionReply({
+			interaction: params.interaction,
+			payload: statusReply,
+			mediaLocalRoots: params.mediaLocalRoots,
+			textLimit: resolveTextChunkLimit(params.cfg, "discord", params.accountId, { fallbackLimit: 2e3 }),
+			maxLinesPerMessage: resolveDiscordMaxLinesPerMessage({
+				cfg: params.cfg,
+				discordConfig: params.discordConfig,
+				accountId: params.accountId
+			}),
+			preferFollowUp: params.preferFollowUp,
+			responseEphemeral: params.responseEphemeral,
+			chunkMode: resolveChunkMode(params.cfg, "discord", params.accountId)
+		});
+		return {
+			accepted: true,
+			effectiveRoute: params.effectiveRoute
+		};
+	}
+	await params.respond("Status unavailable.");
+	return {
+		accepted: true,
+		effectiveRoute: params.effectiveRoute
+	};
+}
+//#endregion
 //#region extensions/discord/src/monitor/native-command.args.ts
 function readDiscordCommandArgs(interaction, definitions) {
 	if (!definitions || definitions.length === 0) return;
@@ -4446,7 +3893,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) {
@@ -4543,7 +3990,7 @@ function buildDiscordCommandOptions(params) {
 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 { command, cfg, discordConfig, accountId, sessionPrefix, ephemeralDefault, threadBindings, dispatchReplyFromConfig } = params;
 	const fallbackCommandDefinition = createNativeCommandDefinition(command);
 	const pluginCommandCandidate = "prepareDispatch" in command ? command : void 0;
 	const commandDefinition = pluginCommandCandidate ? fallbackCommandDefinition : findCommandByNativeName$1(command.name, "discord", { includeBundledChannelFallback: false }) ?? fallbackCommandDefinition;
@@ -4610,13 +4057,14 @@ function createDiscordNativeCommand(params) {
 				preferFollowUp: true,
 				threadBindings,
 				responseEphemeral: ephemeralDefault,
+				dispatchReplyFromConfig,
 				pluginCommandDispatch: preparedPluginCommand ?? NON_PLUGIN_COMMAND_DISPATCH
 			});
 		}
 	}();
 }
 async function dispatchDiscordCommandInteraction(params) {
-	const { interaction, prompt, command, commandArgs, cfg: inputConfig, discordConfig, accountId, sessionPrefix, preferFollowUp, threadBindings, responseEphemeral, suppressReplies } = params;
+	const { interaction, prompt, command, commandArgs, cfg: inputConfig, discordConfig, accountId, sessionPrefix, preferFollowUp, threadBindings, responseEphemeral, suppressReplies, dispatchReplyFromConfig } = params;
 	const cfg = getRuntimeConfigSnapshot() ?? inputConfig;
 	const commandName = command.nativeName ?? command.key;
 	const respond = async (content, options) => {
@@ -4854,7 +4302,8 @@ async function dispatchDiscordCommandInteraction(params) {
 				discordConfig,
 				accountId,
 				sessionPrefix,
-				threadBindings
+				threadBindings,
+				dispatchReplyFromConfig
 			},
 			safeInteractionCall: safeDiscordInteractionCall,
 			dispatchCommandInteraction: dispatchDiscordCommandInteraction
@@ -5041,6 +4490,7 @@ async function dispatchDiscordCommandInteraction(params) {
 		preferFollowUp,
 		responseEphemeral,
 		suppressReplies,
+		dispatchReplyFromConfig,
 		log,
 		pluginCommandDispatch: params.pluginCommandDispatch
 	});
@@ -5097,7 +4547,7 @@ function canResumeAfterGatewayClose(code) {
 //#region extensions/discord/src/internal/gateway-identify-limiter.ts
 const IDENTIFY_WINDOW_MS = 5e3;
 function normalizeMaxConcurrency(value) {
-	const parsed = parseFiniteNumber$1(value);
+	const parsed = parseFiniteNumber(value);
 	return parsed === void 0 ? 1 : Math.max(1, Math.floor(parsed));
 }
 var GatewayIdentifyLimiter = class {
@@ -5305,7 +4755,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;
@@ -5375,7 +4825,10 @@ const GatewayIntents = GatewayIntentBits;
 const READY_STATE_OPEN = 1;
 const DEFAULT_GATEWAY_URL = "wss://gateway.discord.gg/";
 const DISCORD_GATEWAY_PAYLOAD_LIMIT_BYTES = 4096;
-const DISCORD_GATEWAY_WS_CLIENT_OPTIONS = Object.freeze({ maxPayload: 16 * 1024 * 1024 });
+const DISCORD_GATEWAY_WS_CLIENT_OPTIONS = Object.freeze({
+	maxPayload: 16 * 1024 * 1024,
+	handshakeTimeout: 3e4
+});
 const INVALID_SESSION_MIN_DELAY_MS = 1e3;
 const INVALID_SESSION_JITTER_MS = 4e3;
 const RESUME_FAILURE_THRESHOLD = 3;
@@ -5415,6 +4868,9 @@ var GatewayPlugin = class extends Plugin {
 	listVoiceChannelStates(guildId, channelId) {
 		return this.voiceStateCache.listVoiceChannelStates(guildId, channelId);
 	}
+	async fetchGuildEmojis(guildId, fetcher) {
+		return this.client ? await this.client.fetchGuildEmojis(guildId, fetcher) : await fetcher();
+	}
 	takeVoiceStateTransition(state) {
 		return this.voiceStateCache.takeTransition(state);
 	}
@@ -5518,7 +4974,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,
@@ -5721,12 +5180,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";
@@ -6200,7 +5653,6 @@ async function fetchDiscordGatewayMetadataGuarded(input, init, options) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/gateway-plugin.ts
-const DISCORD_GATEWAY_HANDSHAKE_TIMEOUT_MS = 3e4;
 const DISCORD_GATEWAY_POLICY_VIOLATION_CLOSE_CODE = 1008;
 const DISCORD_GATEWAY_WS_RECEIVER_LIMIT_CODE = "WS_ERR_TOO_MANY_BUFFERED_PARTS";
 const DISCORD_GATEWAY_CLOSE_REASON_LOG_MAX_CHARS = 240;
@@ -6268,7 +5720,7 @@ function resolveDiscordGatewayIntents(params) {
 	const intentsConfig = params?.intentsConfig;
 	const voiceEnabled = params?.voiceEnabled;
 	const voiceStatesEnabled = intentsConfig?.voiceStates ?? voiceEnabled ?? false;
-	let intents = GatewayIntents.Guilds | GatewayIntents.GuildMessages | GatewayIntents.DirectMessages | GatewayIntents.GuildMessageReactions | GatewayIntents.DirectMessageReactions;
+	let intents = GatewayIntents.Guilds | GatewayIntents.GuildExpressions | 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;
@@ -6317,7 +5769,6 @@ function createGatewayPlugin(params) {
 			const wsFlowId = randomUUID();
 			const socket = new ((params.testing?.webSocketCtor) ?? ws.default)(url, {
 				...DISCORD_GATEWAY_WS_CLIENT_OPTIONS,
-				handshakeTimeout: DISCORD_GATEWAY_HANDSHAKE_TIMEOUT_MS,
 				...params.wsAgent ? { agent: params.wsAgent } : {}
 			});
 			let lastTransportError;
@@ -7045,7 +6496,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-CfFMexGt.js").then((n) => n.n);
+			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-BLEMH_yi.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: params.accountId,
 				manager: null
@@ -7060,7 +6511,7 @@ async function runDiscordGatewayLifecycle(params) {
 let discordVoiceRuntimePromise;
 let discordProviderSessionRuntimePromise;
 async function loadDiscordVoiceRuntime() {
-	const promise = discordVoiceRuntimePromise ?? import("./voice-runtime-BEdqNcST.js");
+	const promise = discordVoiceRuntimePromise ?? import("./voice-runtime-DY6_o73o.js");
 	discordVoiceRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7070,7 +6521,7 @@ async function loadDiscordVoiceRuntime() {
 	}
 }
 async function loadDiscordProviderSessionRuntime() {
-	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-BUEqD0rA.js");
+	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-DSNe7r2W.js");
 	discordProviderSessionRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7431,102 +6882,6 @@ async function cleanupDiscordProviderStartup(params) {
 	if (!params.lifecycleStarted) params.threadBindings.stop();
 }
 //#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
-	};
-	return {
-		admissionAllowFrom: resolveDiscordAccountAllowFrom({
-			cfg: params.cfg,
-			accountId: params.accountId
-		}) ?? params.discordConfig.allowFrom ?? [],
-		ownerAllowFrom: []
-	};
-}
-//#endregion
 //#region extensions/discord/src/voice/command.ts
 const VOICE_CHANNEL_TYPES = [ChannelType.GuildVoice, ChannelType.GuildStageVoice];
 const DISCORD_VOICE_COMMAND_SPEC = {
@@ -7890,8 +7245,8 @@ function formatDiscordDeployRestOperation(err) {
 function formatDiscordDeployErrorMessage(err) {
 	if (!isAbortLikeError(err)) return formatErrorMessage$1(err);
 	const deployErr = err && typeof err === "object" ? err : {};
-	const requestMs = parseFiniteNumber(deployErr.deployRequestMs);
-	const timeoutMs = parseFiniteNumber(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 = [];
@@ -7904,8 +7259,8 @@ function formatDiscordDeployErrorMessage(err) {
 function resolveDiscordDeployRateLimitDetails(err) {
 	if (!err || typeof err !== "object") return;
 	const deployErr = err;
-	const status = parseStrictNonNegativeInteger(deployErr.status) ?? parseStrictNonNegativeInteger(deployErr.statusCode);
-	const retryAfterSeconds = parseFiniteNumber(deployErr.retryAfter) ?? parseFiniteNumber(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;
@@ -7995,8 +7350,8 @@ function formatDiscordDeployErrorDetails(err) {
 function isDiscordDeployDailyCreateLimit(err) {
 	if (!err || typeof err !== "object") return false;
 	const deployErr = err;
-	const discordCode = parseStrictNonNegativeInteger(deployErr.discordCode);
-	const rawCode = parseStrictNonNegativeInteger(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
@@ -8214,9 +7569,6 @@ function formatUsername(user) {
 	if (user.discriminator && user.discriminator !== "0") return `${user.username}#${user.discriminator}`;
 	return user.username;
 }
-function isThreadChannelType(channelType) {
-	return channelType === ChannelType.PublicThread || channelType === ChannelType.PrivateThread || channelType === ChannelType.AnnouncementThread;
-}
 function resolveAgentComponentRoute(params) {
 	return resolveAgentRoute({
 		cfg: params.ctx.cfg,
@@ -8259,7 +7611,7 @@ function resolveDiscordChannelContext(interaction) {
 	const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
 	const displayChannelSlug = channelName ? normalizeDiscordDisplaySlug(channelName) : "";
 	const channelType = channelInfo.type;
-	const isThread = isThreadChannelType(channelType);
+	const isThread = isDiscordThreadChannelType(channelType);
 	let parentId;
 	let parentName;
 	let parentSlug = "";
@@ -8757,7 +8109,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
@@ -8773,7 +8126,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)
 	};
 }
@@ -8933,6 +8286,7 @@ async function deliverDiscordReply(params) {
 		formatting: delivery.formatting,
 		threadId: delivery.threadId,
 		identity: delivery.identity,
+		onPlatformSendDispatch: params.onPlatformSendDispatch,
 		deps: createDiscordDeliveryDeps({
 			cfg: params.cfg,
 			token: params.token,
@@ -8971,7 +8325,7 @@ async function deliverDiscordReply(params) {
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.dispatch.ts
 const loadConversationRuntime$1 = createLazyRuntimeModule(() => import("./agent-components.runtime-CEPrf2SY.js"));
-const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing-CS-nNVoe.js").then((n) => n.n));
+const loadTypingRuntime = createLazyRuntimeModule(() => import("./typing-B9snnwMe.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}`;
@@ -9093,6 +8447,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,
@@ -9161,6 +8523,7 @@ async function dispatchDiscordComponentEvent(params) {
 					sessionKey
 				},
 				ctxPayload,
+				dispatchReplyFromConfig: ctx.channelRuntime?.reply?.dispatchReplyFromConfig,
 				record: {
 					updateLastRoute: interactionCtx.isDirectMessage ? {
 						sessionKey: inboundLastRouteSessionKey,
@@ -9202,7 +8565,8 @@ async function dispatchDiscordComponentEvent(params) {
 							chunkMode: resolveChunkMode(ctx.cfg, "discord", accountId),
 							mediaLocalRoots,
 							kind: info.kind,
-							bindPendingFinalDelivery: info.bindPendingFinalDelivery
+							bindPendingFinalDelivery: info.bindPendingFinalDelivery,
+							onPlatformSendDispatch: info.onPlatformSendDispatch
 						});
 						if (result.visibleReplySent) replyReference.markSent();
 						return result;
@@ -9367,7 +8731,7 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/agent-components.handlers.ts
-const loadComponentsRuntime = createLazyRuntimeModule(() => import("./outbound-session-route-DxLkrgKQ.js").then((n) => n.n));
+const loadComponentsRuntime = createLazyRuntimeModule(() => import("./components-Dk35LTf_.js").then((n) => n.t));
 async function handleDiscordComponentEvent(params) {
 	const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
 	if (!parsed) {
@@ -10013,29 +9377,24 @@ var QuestionButton = class extends Button {
 		try {
 			await interaction.acknowledge();
 		} catch {}
-		let result;
+		let content;
 		try {
-			result = await this.ctx.resolveQuestion({
+			content = (await this.ctx.resolveQuestion({
 				cfg: this.ctx.cfg,
 				questionId: callback.questionId,
 				optionIndex: callback.optionIndex,
 				senderId: interaction.userId,
 				clientDisplayName: `Discord question (${this.ctx.accountId})`
-			});
+			})).status === "answered" ? "Answer submitted." : "This question was already answered.";
 		} catch {
-			try {
-				await interaction.followUp({
-					content: "Could not submit this answer.",
-					ephemeral: true
-				});
-			} catch {}
-			return;
+			content = "Could not submit this answer.";
 		}
 		try {
-			await interaction.followUp({
-				content: result.status === "answered" ? "Answer submitted." : "This question was already answered.",
+			const feedback = {
+				content,
 				ephemeral: true
-			});
+			};
+			await (interaction.responseState === "unacknowledged" ? interaction.reply(feedback) : interaction.followUp(feedback));
 		} catch {}
 	}
 };
@@ -10079,7 +9438,8 @@ function createDiscordProviderInteractionSurface(params) {
 			accountId: params.accountId,
 			sessionPrefix: params.sessionPrefix,
 			ephemeralDefault: params.ephemeralDefault,
-			threadBindings: params.threadBindings
+			threadBindings: params.threadBindings,
+			dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
 		});
 	});
 	const execApprovalsConfig = params.discordConfig.execApprovals ?? {};
@@ -10124,21 +9484,24 @@ function createDiscordProviderInteractionSurface(params) {
 			discordConfig: params.discordConfig,
 			accountId: params.accountId,
 			sessionPrefix: params.sessionPrefix,
-			threadBindings: params.threadBindings
+			threadBindings: params.threadBindings,
+			dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
 		}),
 		createDiscordModelPickerFallbackButton({
 			cfg: params.cfg,
 			discordConfig: params.discordConfig,
 			accountId: params.accountId,
 			sessionPrefix: params.sessionPrefix,
-			threadBindings: params.threadBindings
+			threadBindings: params.threadBindings,
+			dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
 		}),
 		createDiscordModelPickerFallbackSelect({
 			cfg: params.cfg,
 			discordConfig: params.discordConfig,
 			accountId: params.accountId,
 			sessionPrefix: params.sessionPrefix,
-			threadBindings: params.threadBindings
+			threadBindings: params.threadBindings,
+			dispatchReplyFromConfig: params.channelRuntime?.reply?.dispatchReplyFromConfig
 		})
 	];
 	const activityButton = createDiscordActivityButton({
@@ -10149,6 +9512,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);
@@ -10217,6 +9581,170 @@ var VoicePlugin = class extends Plugin {
 	}
 };
 //#endregion
+//#region extensions/discord/src/monitor/message-handler.preflight-channel-access.ts
+function resolveDiscordPreflightChannelAccess(params) {
+	if (params.isGuildMessage && params.channelConfig?.enabled === false) {
+		logDebug(`[discord-preflight] drop: channel disabled`);
+		logVerbose(`Blocked discord channel ${params.messageChannelId} (channel disabled, ${params.channelMatchMeta})`);
+		return {
+			allowed: false,
+			channelAllowlistConfigured: false,
+			channelAllowed: false
+		};
+	}
+	const groupDmAllowed = params.isGroupDm && resolveGroupDmAllow({
+		channels: params.groupDmChannels,
+		channelId: params.messageChannelId,
+		channelName: params.displayChannelName,
+		channelSlug: params.displayChannelSlug
+	});
+	if (params.isGroupDm && !groupDmAllowed) return {
+		allowed: false,
+		channelAllowlistConfigured: false,
+		channelAllowed: false
+	};
+	const channelAllowlistConfigured = Boolean(params.guildInfo?.channels) && Object.keys(params.guildInfo?.channels ?? {}).length > 0;
+	const channelAllowed = params.channelConfig?.allowed !== false;
+	if (params.isGuildMessage && !isDiscordGroupAllowedByPolicy({
+		groupPolicy: params.groupPolicy,
+		guildAllowlisted: Boolean(params.guildInfo),
+		channelAllowlistConfigured,
+		channelAllowed
+	})) {
+		if (params.groupPolicy === "disabled") {
+			logDebug(`[discord-preflight] drop: groupPolicy disabled`);
+			logVerbose(`discord: drop guild message (groupPolicy: disabled, ${params.channelMatchMeta})`);
+		} else if (!channelAllowlistConfigured) {
+			logDebug(`[discord-preflight] drop: groupPolicy allowlist, no channel allowlist configured`);
+			logVerbose(`discord: drop guild message (groupPolicy: allowlist, no channel allowlist, ${params.channelMatchMeta})`);
+		} else {
+			logDebug(`[discord] Ignored message from channel ${params.messageChannelId} (not in guild allowlist). Add to guilds.<guildId>.channels to enable.`);
+			logVerbose(`Blocked discord channel ${params.messageChannelId} not in guild channel allowlist (groupPolicy: allowlist, ${params.channelMatchMeta})`);
+		}
+		return {
+			allowed: false,
+			channelAllowlistConfigured,
+			channelAllowed
+		};
+	}
+	if (params.isGuildMessage && params.channelConfig?.allowed === false) {
+		logDebug(`[discord-preflight] drop: channelConfig.allowed===false`);
+		logVerbose(`Blocked discord channel ${params.messageChannelId} not in guild channel allowlist (${params.channelMatchMeta})`);
+		return {
+			allowed: false,
+			channelAllowlistConfigured,
+			channelAllowed
+		};
+	}
+	if (params.isGuildMessage) {
+		logDebug(`[discord-preflight] pass: channel allowed`);
+		logVerbose(`discord: allow channel ${params.messageChannelId} (${params.channelMatchMeta})`);
+	}
+	return {
+		allowed: true,
+		channelAllowlistConfigured,
+		channelAllowed
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/listeners.guild-join.ts
+const DISCORD_GUILD_JOIN_INTRO_MAX_AGE_MS = 300 * 1e3;
+var DiscordGuildJoinIntroductionListener = class extends GuildCreateListener {
+	constructor(params) {
+		super();
+		this.params = params;
+	}
+	async handle(data, client) {
+		if (!("joined_at" in data) || data.unavailable || !this.params.botUserId) return;
+		const joinAgeMs = Date.now() - Date.parse(data.joined_at);
+		if (!Number.isFinite(joinAgeMs) || joinAgeMs < 0 || joinAgeMs > DISCORD_GUILD_JOIN_INTRO_MAX_AGE_MS) return;
+		const textChannels = data.channels.filter((channel) => channel.type === ChannelType.GuildText);
+		const systemChannel = textChannels.find((channel) => channel.id === data.system_channel_id);
+		const candidateChannels = systemChannel ? [systemChannel, ...textChannels.filter((channel) => channel !== systemChannel)] : textChannels;
+		const discordOptions = {
+			cfg: this.params.cfg,
+			accountId: this.params.accountId,
+			rest: client.rest
+		};
+		const guildInfo = resolveDiscordGuildEntry({
+			guild: new Guild(client, data),
+			guildId: data.id,
+			guildEntries: this.params.guildEntries
+		});
+		const guildConfigured = !this.params.guildEntries || Object.keys(this.params.guildEntries).length === 0 || Boolean(guildInfo);
+		let targetChannel;
+		let roomAllowed = false;
+		for (const channel of candidateChannels) if (await canViewDiscordGuildChannel(data.id, channel.id, this.params.botUserId, discordOptions) && await hasAnyChannelPermissionDiscord(data.id, channel.id, this.params.botUserId, [PermissionFlagsBits.SendMessages], discordOptions)) {
+			targetChannel ??= channel;
+			const channelConfig = resolveDiscordChannelConfig({
+				guildInfo,
+				channelId: channel.id,
+				channelName: channel.name,
+				channelSlug: normalizeDiscordSlug(channel.name)
+			});
+			roomAllowed = guildConfigured && resolveDiscordPreflightChannelAccess({
+				isGuildMessage: true,
+				isGroupDm: false,
+				groupPolicy: this.params.groupPolicy,
+				messageChannelId: channel.id,
+				displayChannelName: channel.name,
+				displayChannelSlug: normalizeDiscordDisplaySlug(channel.name),
+				guildInfo,
+				channelConfig,
+				channelMatchMeta: `guild=${data.id} channel=${channel.id}`
+			}).allowed;
+			if (roomAllowed) {
+				targetChannel = channel;
+				break;
+			}
+		}
+		if (!targetChannel) {
+			this.params.logger?.info("Discord guild join introduction skipped: no writable text channel", {
+				guildId: data.id,
+				accountId: this.params.accountId
+			});
+			return;
+		}
+		const selectedChannel = targetChannel;
+		await reportChannelRoomJoin({
+			cfg: this.params.cfg,
+			channel: "discord",
+			accountId: this.params.accountId,
+			conversationId: data.id,
+			deliverTo: `channel:${selectedChannel.id}`,
+			route: resolveAgentRoute({
+				cfg: this.params.cfg,
+				channel: "discord",
+				accountId: this.params.accountId,
+				guildId: data.id,
+				peer: {
+					kind: "channel",
+					id: selectedChannel.id
+				}
+			}),
+			roomAllowed,
+			resolveRoomContext: async ({ messageLimit }) => {
+				const roomContext = {
+					title: `#${selectedChannel.name}`,
+					purpose: selectedChannel.topic ?? void 0
+				};
+				try {
+					const messages = await readMessagesDiscord(selectedChannel.id, { limit: messageLimit }, discordOptions);
+					return {
+						...roomContext,
+						recentMessages: messages.toReversed().flatMap(({ author, content }) => content.trim() ? [{
+							sender: author.global_name ?? author.username,
+							text: content
+						}] : [])
+					};
+				} catch {
+					return roomContext;
+				}
+			}
+		});
+	}
+};
+//#endregion
 //#region extensions/discord/src/monitor/provider.startup.ts
 function registerLatePlugin(client, plugin) {
 	plugin.registerClient?.(client);
@@ -10341,6 +9869,14 @@ async function fetchDiscordBotIdentity(params) {
 function registerDiscordMonitorListeners(params) {
 	registerDiscordListener(params.client.listeners, new DiscordInteractionListener(params.logger, params.trackInboundEvent));
 	registerDiscordListener(params.client.listeners, new DiscordMessageListener(params.messageHandler, params.logger, params.trackInboundEvent));
+	registerDiscordListener(params.client.listeners, new DiscordGuildJoinIntroductionListener({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		botUserId: params.botUserId,
+		groupPolicy: params.groupPolicy,
+		guildEntries: params.guildEntries,
+		logger: params.logger
+	}));
 	if (shouldRegisterDiscordReactionListeners(params)) {
 		const reactionListenerOptions = {
 			cfg: params.cfg,
@@ -10641,6 +10177,7 @@ async function monitorDiscordProvider(opts = {}) {
 	let earlyGatewayEmitter = gatewaySupervisor?.emitter;
 	let onEarlyGatewayDebug;
 	try {
+		const pluginChannelRuntime = opts.channelRuntime;
 		const { commands, components, modals } = createDiscordProviderInteractionSurface({
 			cfg,
 			discordConfig: discordCfg,
@@ -10660,7 +10197,7 @@ async function monitorDiscordProvider(opts = {}) {
 			allowFrom,
 			dmPolicy,
 			runtime,
-			channelRuntime: opts.channelRuntime,
+			channelRuntime: pluginChannelRuntime,
 			abortSignal: opts.abortSignal,
 			createNativeCommand: discordProviderRuntime.createDiscordNativeCommand
 		});
@@ -10734,7 +10271,7 @@ async function monitorDiscordProvider(opts = {}) {
 				runtime,
 				botUserId
 			});
-			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-CfFMexGt.js").then((n) => n.n);
+			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-BLEMH_yi.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: account.accountId,
 				manager: voiceManager
@@ -10752,7 +10289,7 @@ async function monitorDiscordProvider(opts = {}) {
 			accountId: account.accountId,
 			token,
 			runtime,
-			buildContext: opts.channelRuntime?.inbound.buildContext,
+			buildContext: pluginChannelRuntime?.inbound.buildContext,
 			setStatus: opts.setStatus,
 			abortSignal: opts.abortSignal,
 			botUserId,
@@ -10840,4 +10377,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 { resolveDiscordTextCommandAccess as S, handleDiscordDmCommandDecision as _, formatDiscordReplySkip as a, resolveFetchedDiscordThreadLikeChannelContext as b, buildGuildLabel as c, resolveDiscordGatewayIntents as d, waitForDiscordGatewayPluginRegistration as f, createDiscordSupplementalContextAccessChecker as g, buildDiscordInboundAccessContext as h, formatDiscordReplyDeliveryFailure as i, resolveReplyContext as l, buildDiscordGroupSystemPrompt as m, resolveDiscordPreflightChannelAccess as n, sanitizeDiscordFrontChannelReplyPayloads as o, createDiscordNativeCommand as p, deliverDiscordReply as r, buildDirectLabel as s, monitorDiscordProvider as t, createDiscordGatewayPlugin as u, mapGatewayDispatchData as v, resolveDiscordDmCommandAccess as x, registerDiscordListener as y };