@openclaw/discord 2026.8.1-beta.2 → 2026.9.1-beta.1

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

@@ -1,39 +1,42 @@
-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-Cv4jCU5Z.js";
+import { C as parseDiscordComponentCustomId, D as decodeCustomIdComponent, E as parseDiscordModalCustomIdForInteraction, O as encodeCustomIdComponent, S as parseDiscordActivityCustomIdForInteraction, T as parseDiscordModalCustomId, c as parseExecApprovalData, o as parseDiscordQuestionData, v as buildDiscordActivityCustomId, w as parseDiscordComponentCustomIdForInteraction } from "./components-B9V5o361.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-DKKAw5VX.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, 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 } from "./send.shared-JjljcV4O.js";
+import { a as formatMention, t as sendMessageDiscord } from "./send.outbound-zam0TrZx.js";
+import { t as isDiscordThreadChannelType } from "./channel-type-CVLZyGYS.js";
+import { n as getDiscordActivitiesRuntime } from "./runtime-CY4PRMF-.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 { s as sendVoiceMessageDiscord } from "./send-C49MFF9j.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-Cg15ZFJd.js";
+import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-C2sT_n67.js";
+import { t as resolveDiscordUserAllowlist } from "./resolve-users-CzpjLwjy.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-ByOtwjo_.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-aiwO5R2F.js";
+import { i as resolveDiscordThreadParentInfo } from "./threading-agH1T_6s.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 { 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 { 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 +44,31 @@ 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 { 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 { deleteSessionEntry, getSessionEntry, listSessionEntries, readSessionUpdatedAt as readSessionUpdatedAt$1, resolveStorePath, resolveStorePath as resolveStorePath$1 } from "openclaw/plugin-sdk/session-store-runtime";
 import { createChannelIngressResolver, defineStableChannelIngressIdentity, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-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 { 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";
@@ -140,6 +141,205 @@ async function runDiscordListenerWithSlowLog(params) {
 	}
 }
 //#endregion
+//#region extensions/discord/src/monitor/presence-events.ts
+const DISCORD_PRESENCE_GREETING_COOLDOWN_MS = 480 * 60 * 1e3;
+function isDiscordOnlineStatus(status) {
+	return status === "online" || status === "idle" || status === "dnd";
+}
+function isDiscordOfflineStatus(status) {
+	return status === "offline";
+}
+function resolveDiscordOnlinePresenceEvent(params) {
+	const config = params.config;
+	const userId = params.data.user?.id?.trim();
+	if (!config || config.enabled === false || !userId || userId === params.botUserId || params.data.user.bot === true || !isDiscordOnlineStatus(params.data.status) || !params.availabilityKind) return null;
+	if (config.users !== void 0 && !config.users.includes(userId)) return null;
+	if (params.lastEmittedAtMs !== void 0 && params.nowMs - params.lastEmittedAtMs < 288e5) return null;
+	const lines = [
+		"Discord online-presence event:",
+		params.availabilityKind === "observed-offline" ? `A human member became available online after being observed offline in guild_id=${JSON.stringify(params.data.guild_id)} user_id=${JSON.stringify(userId)} status=${JSON.stringify(params.data.status)}.` : `A human member became newly visible online since the current guild snapshot in guild_id=${JSON.stringify(params.data.guild_id)} user_id=${JSON.stringify(userId)} status=${JSON.stringify(params.data.status)}. They may have come online or joined after the snapshot; do not claim an exact prior status.`,
+		`The authorized greeting target is channel_id=${JSON.stringify(config.channelId)}.`,
+		"Before greeting, retrieve relevant memory and wiki context for this immutable user_id, including a known timezone when available. Use their local time for the greeting; if their timezone is unknown, do not guess.",
+		"Send at most one short, natural greeting to the target channel. Do not reveal private memory. If no greeting is appropriate, stay silent."
+	];
+	return {
+		channelId: config.channelId,
+		userId,
+		text: lines.join("\n")
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/presence-cooldown-store.ts
+const DISCORD_PRESENCE_COOLDOWN_MAX_ENTRIES = 25e3;
+function openDiscordPresenceCooldownStore() {
+	return getDiscordRuntime().state.openSyncKeyedStore({
+		namespace: "presence-greeting-cooldowns",
+		maxEntries: DISCORD_PRESENCE_COOLDOWN_MAX_ENTRIES,
+		overflowPolicy: "reject-new",
+		defaultTtlMs: DISCORD_PRESENCE_GREETING_COOLDOWN_MS
+	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/presence-emission-gate.ts
+const DISCORD_PRESENCE_RECONNECT_SUPPRESS_MS = 300 * 1e3;
+const DISCORD_PRESENCE_BURST_LIMIT = 8;
+const DISCORD_PRESENCE_BURST_WINDOW_MS = 60 * 1e3;
+function resolveDiscordPresenceGateOptions(config) {
+	return {
+		reconnectSuppressMs: config?.reconnectSuppressSeconds !== void 0 ? config.reconnectSuppressSeconds * 1e3 : DISCORD_PRESENCE_RECONNECT_SUPPRESS_MS,
+		burstLimit: config?.burstLimit ?? DISCORD_PRESENCE_BURST_LIMIT,
+		burstWindowMs: config?.burstWindowSeconds !== void 0 ? config.burstWindowSeconds * 1e3 : DISCORD_PRESENCE_BURST_WINDOW_MS
+	};
+}
+/**
+* Per-account lifecycle gate for online-presence events. Reconnect state belongs to the Gateway
+* session, while burst state follows the guild-owned configuration that supplies its limits.
+*/
+var DiscordPresenceEmissionGate = class {
+	constructor() {
+		this.reconnectLogged = false;
+		this.burstByGuild = /* @__PURE__ */ new Map();
+		this.nextReservationId = 0;
+	}
+	noteGatewaySessionReset(nowMs) {
+		this.lastSessionResetAtMs = nowMs;
+		this.reconnectLogged = false;
+	}
+	evaluateReconnectWindow(nowMs, options) {
+		if (this.lastSessionResetAtMs !== void 0 && options.reconnectSuppressMs > 0 && nowMs - this.lastSessionResetAtMs < options.reconnectSuppressMs) {
+			const shouldLog = !this.reconnectLogged;
+			this.reconnectLogged = true;
+			return {
+				allowed: false,
+				reason: "reconnect-window",
+				shouldLog
+			};
+		}
+		return { allowed: true };
+	}
+	reserveBurst(guildId, nowMs, options) {
+		const state = this.burstByGuild.get(guildId) ?? {
+			reservations: [],
+			logged: false
+		};
+		state.reservations = state.reservations.filter((reservation) => !reservation.committed || nowMs - reservation.atMs < options.burstWindowMs);
+		this.burstByGuild.set(guildId, state);
+		if (state.reservations.length >= options.burstLimit) {
+			const shouldLog = !state.logged;
+			state.logged = true;
+			return {
+				allowed: false,
+				reason: state.reservations.some((reservation) => !reservation.committed) ? "burst-pending" : "burst",
+				shouldLog
+			};
+		}
+		state.logged = false;
+		const reservation = {
+			id: this.nextReservationId++,
+			atMs: nowMs,
+			committed: false
+		};
+		state.reservations.push(reservation);
+		return {
+			allowed: true,
+			reservation: reservation.id
+		};
+	}
+	commitBurst(guildId, reservation, nowMs) {
+		const entry = this.burstByGuild.get(guildId)?.reservations.find((candidate) => candidate.id === reservation);
+		if (!entry) return;
+		entry.atMs = nowMs;
+		entry.committed = true;
+	}
+	releaseBurst(guildId, reservation) {
+		const state = this.burstByGuild.get(guildId);
+		if (!state) return;
+		state.reservations = state.reservations.filter((candidate) => candidate.id !== reservation);
+		if (state.reservations.length === 0 && !state.logged) this.burstByGuild.delete(guildId);
+	}
+};
+//#endregion
+//#region extensions/discord/src/monitor/presence-transition-cache.ts
+const DEFAULT_PRESENCE_BASELINE_MAX_ENTRIES = 75e3;
+var DiscordPresenceBaselineCache = class {
+	constructor(maxEntries = DEFAULT_PRESENCE_BASELINE_MAX_ENTRIES) {
+		this.maxEntries = maxEntries;
+		this.offlineByKey = /* @__PURE__ */ new Map();
+		this.onlineByKey = /* @__PURE__ */ new Map();
+	}
+	clear() {
+		this.offlineByKey.clear();
+		this.onlineByKey.clear();
+	}
+	clearScope(scope) {
+		for (const markers of [this.offlineByKey, this.onlineByKey]) for (const [key, markerScope] of markers) if (markerScope === scope) markers.delete(key);
+	}
+	isOffline(scope, key) {
+		return this.offlineByKey.get(key) === scope;
+	}
+	isOnline(scope, key) {
+		return this.onlineByKey.get(key) === scope;
+	}
+	observeOffline(scope, key) {
+		this.deleteMarker(this.onlineByKey, scope, key);
+		return this.observe(this.offlineByKey, scope, key);
+	}
+	observeOnline(scope, key) {
+		this.deleteMarker(this.offlineByKey, scope, key);
+		return this.observe(this.onlineByKey, scope, key);
+	}
+	deleteMarker(markers, scope, key) {
+		if (markers.get(key) === scope) markers.delete(key);
+	}
+	observe(markers, scope, key) {
+		markers.delete(key);
+		markers.set(key, scope);
+		let evictedScope;
+		while (markers.size > this.maxEntries) {
+			const oldestKey = markers.keys().next().value;
+			if (oldestKey === void 0) break;
+			evictedScope = markers.get(oldestKey);
+			markers.delete(oldestKey);
+		}
+		return evictedScope;
+	}
+};
+//#endregion
+//#region extensions/discord/src/monitor/thread-session-close.ts
+/**
+* Closes every session entry in the store whose key contains {@link threadId}.
+* The explicit lifecycle deletion archives the old transcript and guarantees
+* that a later inbound message starts a fresh session in every reset mode.
+*/
+async function closeDiscordThreadSessions(params) {
+	const { cfg, threadId } = params;
+	const normalizedThreadId = normalizeOptionalLowercaseString(threadId) ?? "";
+	if (!normalizedThreadId) return 0;
+	const segmentRe = new RegExp(`:${normalizedThreadId}(?::|$)`, "i");
+	function sessionKeyContainsThreadId(key) {
+		return segmentRe.test(key);
+	}
+	let resetCount = 0;
+	for (const agentId of listAgentIds(cfg)) {
+		const storePath = resolveStorePath(cfg.session?.store, { agentId });
+		for (const { sessionKey, entry } of listSessionEntries({
+			agentId,
+			storePath,
+			readOnly: true
+		})) {
+			if (!sessionKeyContainsThreadId(sessionKey)) continue;
+			if (await deleteSessionEntry({
+				archiveTranscript: true,
+				expectedSessionId: entry.sessionId ?? null,
+				expectedUpdatedAt: entry.updatedAt,
+				sessionKey,
+				storePath
+			})) resetCount += 1;
+		}
+	}
+	return resetCount;
+}
+//#endregion
 //#region extensions/discord/src/monitor/dm-command-auth.ts
 const DISCORD_ALLOW_LIST_PREFIXES = [
 	"discord:",
@@ -305,474 +505,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,8 +832,8 @@ 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}`
+				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;
 		};
@@ -1101,294 +843,95 @@ async function handleDiscordReactionEvent(params) {
 				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;
+				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 +1358,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 +1387,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 +1430,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 +1518,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 +1568,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 deliberateSilentTerminalReply = turnResult.dispatched && turnResult.dispatchResult.deliberateSilentTerminalReply === true;
+	const dispatchResult = {
+		dispatched: turnResult.dispatched,
+		...hiddenFinalReply ? { hiddenFinalReply } : {}
+	};
+	if (!didReply && (params.suppressReplies || finalReplyOutcome === "suppressed" || deliberateSilentTerminalReply)) {
+		await settleDiscordInteractionWithoutVisibleReply(params.interaction);
+		return 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 +2010,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
@@ -2423,279 +2035,103 @@ function createDiscordSupplementalContextAccessChecker(params) {
 				userName: sender.name,
 				userTag: sender.tag,
 				allowNameMatching: params.allowNameMatching
-			})
-		});
-	};
-}
-function buildDiscordGroupSystemPrompt(channelConfig) {
-	const systemPromptParts = [channelConfig?.systemPrompt?.trim() || null].filter((entry) => Boolean(entry));
-	return systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : void 0;
-}
-function buildDiscordChannelStructuredContext(params) {
-	if (!params.isGuild) return;
-	const entries = [];
-	if (typeof params.channelTopic === "string" && params.channelTopic.trim().length > 0) entries.push({
-		label: "Discord channel metadata",
-		source: "discord",
-		type: "channel_metadata",
-		payload: { topic: params.channelTopic.trim() }
-	});
-	return entries.length > 0 ? entries : void 0;
-}
-function buildDiscordInboundAccessContext(params) {
-	return {
-		groupSystemPrompt: params.isGuild ? buildDiscordGroupSystemPrompt(params.channelConfig) : void 0,
-		channelStructuredContext: buildDiscordChannelStructuredContext({
-			isGuild: params.isGuild,
-			channelTopic: params.channelTopic
-		}),
-		ownerAllowFrom: resolveDiscordOwnerAllowFrom({
-			channelConfig: params.channelConfig,
-			guildInfo: params.guildInfo,
-			sender: params.sender,
-			allowNameMatching: params.allowNameMatching
-		})
-	};
-}
-//#endregion
-//#region extensions/discord/src/monitor/native-command-context.ts
-function buildDiscordNativeCommandContext(params) {
-	const conversationLabel = params.isDirectMessage ? params.user.globalName ?? params.user.username : params.channelId;
-	const { groupSystemPrompt, ownerAllowFrom, channelStructuredContext } = buildDiscordInboundAccessContext({
-		channelConfig: params.channelConfig,
-		guildInfo: params.guildInfo,
-		sender: params.sender,
-		allowNameMatching: params.allowNameMatching,
-		isGuild: params.isGuild,
-		channelTopic: params.channelTopic
-	});
-	return finalizeInboundContext({
-		Body: params.prompt,
-		BodyForAgent: params.prompt,
-		RawBody: params.prompt,
-		CommandBody: params.prompt,
-		CommandArgs: params.commandArgs,
-		From: params.isDirectMessage ? `discord:${params.user.id}` : params.isGroupDm ? `discord:group:${params.channelId}` : `discord:channel:${params.channelId}`,
-		To: `slash:${params.user.id}`,
-		SessionKey: params.sessionKey,
-		CommandTargetSessionKey: params.commandTargetSessionKey,
-		AccountId: params.accountId ?? void 0,
-		ChatType: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
-		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);
+function buildDiscordGroupSystemPrompt(channelConfig) {
+	const systemPromptParts = [channelConfig?.systemPrompt?.trim() || null].filter((entry) => Boolean(entry));
+	return systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : void 0;
 }
-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
-		})));
+function buildDiscordChannelStructuredContext(params) {
+	if (!params.isGuild) return;
+	const entries = [];
+	if (typeof params.channelTopic === "string" && params.channelTopic.trim().length > 0) entries.push({
+		label: "Discord channel metadata",
+		source: "discord",
+		type: "channel_metadata",
+		payload: { topic: params.channelTopic.trim() }
 	});
+	return entries.length > 0 ? entries : void 0;
+}
+function buildDiscordInboundAccessContext(params) {
 	return {
-		content: formatCommandArgMenuTitle({
-			command,
-			menu
+		groupSystemPrompt: params.isGuild ? buildDiscordGroupSystemPrompt(params.channelConfig) : void 0,
+		channelStructuredContext: buildDiscordChannelStructuredContext({
+			isGuild: params.isGuild,
+			channelTopic: params.channelTopic
 		}),
-		components: rows
+		ownerAllowFrom: resolveDiscordOwnerAllowFrom({
+			channelConfig: params.channelConfig,
+			guildInfo: params.guildInfo,
+			sender: params.sender,
+			allowNameMatching: params.allowNameMatching
+		})
 	};
 }
-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);
+//#endregion
+//#region extensions/discord/src/monitor/native-command-context.ts
+function buildDiscordNativeCommandContext(params) {
+	const conversationLabel = params.isDirectMessage ? params.user.globalName ?? params.user.username : params.channelId;
+	const { groupSystemPrompt, ownerAllowFrom, channelStructuredContext } = buildDiscordInboundAccessContext({
+		channelConfig: params.channelConfig,
+		guildInfo: params.guildInfo,
+		sender: params.sender,
+		allowNameMatching: params.allowNameMatching,
+		isGuild: params.isGuild,
+		channelTopic: params.channelTopic
+	});
+	return finalizeInboundContext({
+		Body: params.prompt,
+		BodyForAgent: params.prompt,
+		RawBody: params.prompt,
+		CommandBody: params.prompt,
+		CommandArgs: params.commandArgs,
+		From: params.isDirectMessage ? `discord:${params.user.id}` : params.isGroupDm ? `discord:group:${params.channelId}` : `discord:channel:${params.channelId}`,
+		To: `slash:${params.user.id}`,
+		SessionKey: params.sessionKey,
+		CommandTargetSessionKey: params.commandTargetSessionKey,
+		AccountId: params.accountId ?? void 0,
+		ChatType: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
+		...buildDiscordConversationRouteContext({
+			isDirectMessage: params.isDirectMessage,
+			isGroupDm: params.isGroupDm,
+			directUserId: params.user.id,
+			conversationId: params.channelId,
+			isThread: params.isThreadChannel,
+			parentConversationId: params.threadParentId
+		}),
+		ConversationLabel: conversationLabel,
+		GroupSubject: params.isGuild ? params.guildName : void 0,
+		GroupSpace: params.isGuild ? params.guildInfo?.id ?? params.guildInfo?.slug ?? params.guildId : void 0,
+		MemberRoleIds: params.memberRoleIds,
+		GroupSystemPrompt: groupSystemPrompt,
+		ChannelStructuredContext: channelStructuredContext,
+		OwnerAllowFrom: ownerAllowFrom,
+		SenderName: params.user.globalName ?? params.user.username,
+		SenderId: params.user.id,
+		SenderUsername: params.user.username,
+		SenderTag: params.sender.tag,
+		Provider: "discord",
+		Surface: "discord",
+		WasMentioned: true,
+		MessageSid: params.interactionId,
+		Timestamp: params.timestampMs ?? Date.now(),
+		CommandAuthorized: params.commandAuthorized,
+		CommandTurn: {
+			kind: "native",
+			source: "native",
+			authorized: params.commandAuthorized,
+			body: params.prompt
+		},
+		CommandSource: "native",
+		OriginatingChannel: "discord",
+		OriginatingTo: resolveDiscordConversationIdentity({
+			isDirectMessage: params.isDirectMessage,
+			userId: params.user.id,
+			channelId: params.channelId
+		}) ?? (params.isDirectMessage ? `user:${params.user.id}` : `channel:${params.channelId}`)
+	});
 }
 //#endregion
 //#region extensions/discord/src/monitor/model-picker-preferences.ts
@@ -3694,6 +3130,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 +3788,7 @@ async function handleDiscordModelPickerInteraction(params) {
 			accountId: ctx.accountId,
 			sessionPrefix: ctx.sessionPrefix,
 			threadBindings: ctx.threadBindings,
+			dispatchReplyFromConfig: ctx.dispatchReplyFromConfig,
 			route,
 			resolvedModelRef,
 			selectedRuntime,
@@ -4414,6 +3852,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 +3924,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 +4021,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 +4088,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 +4333,8 @@ async function dispatchDiscordCommandInteraction(params) {
 				discordConfig,
 				accountId,
 				sessionPrefix,
-				threadBindings
+				threadBindings,
+				dispatchReplyFromConfig
 			},
 			safeInteractionCall: safeDiscordInteractionCall,
 			dispatchCommandInteraction: dispatchDiscordCommandInteraction
@@ -5041,6 +4521,7 @@ async function dispatchDiscordCommandInteraction(params) {
 		preferFollowUp,
 		responseEphemeral,
 		suppressReplies,
+		dispatchReplyFromConfig,
 		log,
 		pluginCommandDispatch: params.pluginCommandDispatch
 	});
@@ -5097,7 +4578,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 +4786,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;
@@ -5415,6 +4896,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 +5002,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 +5208,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";
@@ -6268,7 +5749,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;
@@ -7045,7 +6526,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-BR11iHA4.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: params.accountId,
 				manager: null
@@ -7060,7 +6541,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-DIeaa8fJ.js");
 	discordVoiceRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7070,7 +6551,7 @@ async function loadDiscordVoiceRuntime() {
 	}
 }
 async function loadDiscordProviderSessionRuntime() {
-	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-BUEqD0rA.js");
+	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-B9xe-Qaf.js");
 	discordProviderSessionRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7431,102 +6912,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 +7275,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 +7289,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 +7380,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 +7599,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 +7641,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 +8139,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 +8156,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 +8316,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 +8355,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-Dc_YMY2e.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 +8477,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 +8553,7 @@ async function dispatchDiscordComponentEvent(params) {
 					sessionKey
 				},
 				ctxPayload,
+				dispatchReplyFromConfig: ctx.channelRuntime?.reply?.dispatchReplyFromConfig,
 				record: {
 					updateLastRoute: interactionCtx.isDirectMessage ? {
 						sessionKey: inboundLastRouteSessionKey,
@@ -9202,7 +8595,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 +8761,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-B9V5o361.js").then((n) => n.t));
 async function handleDiscordComponentEvent(params) {
 	const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
 	if (!parsed) {
@@ -10013,29 +9407,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 +9468,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 +9514,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 +9542,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);
@@ -10641,6 +10035,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 +10055,7 @@ async function monitorDiscordProvider(opts = {}) {
 			allowFrom,
 			dmPolicy,
 			runtime,
-			channelRuntime: opts.channelRuntime,
+			channelRuntime: pluginChannelRuntime,
 			abortSignal: opts.abortSignal,
 			createNativeCommand: discordProviderRuntime.createDiscordNativeCommand
 		});
@@ -10734,7 +10129,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-BR11iHA4.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: account.accountId,
 				manager: voiceManager
@@ -10752,7 +10147,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 +10235,4 @@ async function monitorDiscordProvider(opts = {}) {
 	}
 }
 //#endregion
-export { sanitizeDiscordThreadName as A, handleDiscordDmCommandDecision as C, resolveDiscordAutoThreadReplyPlan as D, threading_exports as E, resolveDiscordTextCommandAccess as M, resolveDiscordReplyTarget as O, shouldIgnoreStaleDiscordRouteBinding as S, registerDiscordListener as T, buildDiscordInboundAccessContext as _, sanitizeDiscordFrontChannelReplyPayloads as a, resolveDiscordConversationRoute as b, resolveReplyContext as c, createDiscordGatewayPlugin as d, resolveDiscordGatewayIntents as f, buildDiscordGroupSystemPrompt as g, createDiscordNativeCommand as h, formatDiscordReplySkip as i, resolveDiscordDmCommandAccess as j, resolveDiscordThreadStarter as k, resolveDiscordVoiceAccess as l, resolveDiscordVoiceEnabled as m, deliverDiscordReply as n, buildDirectLabel as o, waitForDiscordGatewayPluginRegistration as p, formatDiscordReplyDeliveryFailure as r, buildGuildLabel as s, monitorDiscordProvider as t, authorizeDiscordVoiceIngress as u, createDiscordSupplementalContextAccessChecker as v, mapGatewayDispatchData as w, resolveDiscordEffectiveRoute as x, buildDiscordRoutePeer as y };
+export { mapGatewayDispatchData as _, sanitizeDiscordFrontChannelReplyPayloads as a, resolveDiscordDmCommandAccess as b, resolveReplyContext as c, waitForDiscordGatewayPluginRegistration as d, createDiscordNativeCommand as f, handleDiscordDmCommandDecision as g, createDiscordSupplementalContextAccessChecker as h, formatDiscordReplySkip as i, createDiscordGatewayPlugin as l, buildDiscordInboundAccessContext as m, deliverDiscordReply as n, buildDirectLabel as o, buildDiscordGroupSystemPrompt as p, formatDiscordReplyDeliveryFailure as r, buildGuildLabel as s, monitorDiscordProvider as t, resolveDiscordGatewayIntents as u, registerDiscordListener as v, resolveDiscordTextCommandAccess as x, resolveFetchedDiscordThreadLikeChannelContext as y };