@openclaw/discord 2026.8.1-beta.2 → 2026.8.1-beta.3

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

@@ -1,32 +1,30 @@
-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 RateLimitError, B as hasDiscordV2Components, C as ThreadDeleteListener, D as Plugin, E as Client, F as Command, G as Modal, I as CommandWithSubcommands, J as Button, L as Guild, R as Message, X as Container, _ as MessageCreateListener, a as chunkDiscordTextWithMode, at as StringSelectMenu, b as PresenceUpdateListener, g as InteractionCreateListener, h as GuildDeleteListener, it as Separator, lt as BaseMessageInteractiveComponent, m as GuildCreateListener, nt as Row, ot as TextDisplay, p as discord_exports, v as MessageReactionAddListener, w as ThreadUpdateListener, x as ReadyListener, y as MessageReactionRemoveListener, z as User } from "./retry-DNsVTeTo.js";
+import { C as parseDiscordComponentCustomId, D as decodeCustomIdComponent, E as parseDiscordModalCustomIdForInteraction, O as encodeCustomIdComponent, S as parseDiscordActivityCustomIdForInteraction, T as parseDiscordModalCustomId, c as parseExecApprovalData, o as parseDiscordQuestionData, v as buildDiscordActivityCustomId, w as parseDiscordComponentCustomIdForInteraction } from "./components-ezGKo_Yh.js";
+import { c as resolveDiscordAccount, f as resolveDiscordAccountDmPolicy, l as resolveDiscordAccountAllowFrom, m as normalizeDiscordToken, p as resolveDiscordMaxLinesPerMessage } from "./accounts-DNl-oCEw.js";
+import { a as resolveDiscordComponentEntryWithPersistence, o as resolveDiscordModalEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-ChK1wS7w.js";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
 import { a as isDiscordRateLimitResponseBody, o as summarizeDiscordResponseBody } from "./api-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 { F as createDiscordRestClient, G as registerGateway, H as withValidatedDiscordProxy, K as unregisterGateway, V as validateDiscordProxyUrl, b as canViewDiscordGuildChannel, z as DISCORD_REST_TIMEOUT_MS } from "./send.shared-B3fpaLWJ.js";
+import { a as formatMention, t as sendMessageDiscord } from "./send.outbound-HIkgji_7.js";
+import { n as getDiscordActivitiesRuntime } from "./runtime-CQovMsH3.js";
+import { n as resolveDiscordVoiceEnabled, r as authorizeDiscordVoiceIngress, t as resolveDiscordVoiceAccess } from "./owner-access-Bg41VzAf.js";
 import { i as setPresence, t as clearPresences } from "./presence-cache-z1N8MbJ3.js";
-import { r as sendVoiceMessageDiscord } from "./send-B7Q6Oc1I.js";
+import { r as sendVoiceMessageDiscord } from "./send-rQIffSYu.js";
 import { c as raceWithTimeout, u as withAbortTimeout } from "./timeouts-B9cy6RvQ.js";
-import { a as getDiscordExecApprovalApprovers, n as formatDiscordApprovalDisplayValue, r as resolveDiscordConversationIdentity, s as isDiscordExecApprovalClientEnabled, t as DISCORD_APPROVAL_ALLOWED_MENTIONS } from "./approval-message-safety-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 { a as resolveDiscordBoundConversationRoute, f as getDiscordExecApprovalApprovers, l as resolveDiscordConversationIdentity, m as isDiscordExecApprovalClientEnabled, n as formatDiscordApprovalDisplayValue, r as buildDiscordConversationRouteContext, s as resolveDiscordEffectiveRoute, t as DISCORD_APPROVAL_ALLOWED_MENTIONS } from "./approval-message-safety-XGFPbDoI.js";
+import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-CGeUoIqb.js";
+import { t as resolveDiscordUserAllowlist } from "./resolve-users-BtKxLUZv.js";
+import { a as isThreadArchived, c as resolveDiscordChannelInfoSafe, f as resolveDiscordChannelTopicSafe, h as formatThreadBindingDurationLabel, l as resolveDiscordChannelNameSafe, r as getThreadBindingManager, s as resolveDiscordChannelIdSafe, u as resolveDiscordChannelParentIdSafe } from "./thread-bindings.manager-CngsgErq.js";
+import { a as probeDiscordApplicationId, r as parseApplicationIdFromToken } from "./probe-BTdtVRwU.js";
 import { i as sanitizeRecentModels, n as normalizeModelRef, r as preferenceTimestampMs, t as buildPreferenceModelKey } from "./model-picker-preference-primitives-BHT1LkR_.js";
-import { 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 { d as resolveDiscordMessageStickers, f as resolveDiscordChannelInfo } from "./message-utils-BXLLnFl6.js";
+import { i as resolveDiscordThreadParentInfo } from "./threading-DU6pgeGm.js";
+import { t as resolveDiscordSenderIdentity } from "./sender-identity-BJtfyise.js";
 import { logDebug, logError } from "openclaw/plugin-sdk/logging-core";
 import { ApplicationCommandOptionType, ButtonStyle, ChannelType, ComponentType, GatewayCloseCodes, GatewayCloseCodes as GatewayCloseCodes$1, GatewayDispatchEvents, GatewayIntentBits, GatewayOpcodes } from "discord-api-types/v10";
 import { createHash, randomUUID } from "node:crypto";
-import { MAX_DATE_TIMESTAMP_MS, asDateTimestampMs, parseFiniteNumber as parseFiniteNumber$1, parseStrictInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
+import { MAX_DATE_TIMESTAMP_MS, MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, asSafeIntegerInRange, parseFiniteNumber, parseStrictInteger, parseStrictPositiveInteger, resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { Type } from "typebox";
 import { Check, Errors } from "typebox/value";
@@ -34,6 +32,10 @@ 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 +43,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 { createChannelPartialDeliveryError, dispatchChannelInboundTurn, formatInboundEnvelope, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, resolveEnvelopeFormatOptions, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent } from "openclaw/plugin-sdk/channel-inbound";
-import { resolveChannelModelOverride } from "openclaw/plugin-sdk/model-session-runtime";
-import { finalizeInboundContext, generateConversationLabel } from "openclaw/plugin-sdk/reply-dispatch-runtime";
-import { deleteSessionEntry, getSessionEntry, listSessionEntries, readSessionUpdatedAt as readSessionUpdatedAt$1, resolveStorePath, resolveStorePath as resolveStorePath$1 } from "openclaw/plugin-sdk/session-store-runtime";
-import { buildCommandTextFromArgs, findCommandByNativeName, formatCommandArgMenuTitle, listChatCommands, listNativeCommandSpecsForConfig, listSkillCommandsForAgents, resolveCommandAuthorizedFromAuthorizers, resolveEffectiveAgentRuntime, resolveNativeCommandSessionTargets, resolveStoredModelOverride, serializeCommandArgs } from "openclaw/plugin-sdk/command-auth-native";
+import { finalizeInboundContext } from "openclaw/plugin-sdk/reply-dispatch-runtime";
 import { 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 +140,205 @@ async function runDiscordListenerWithSlowLog(params) {
 	}
 }
 //#endregion
+//#region extensions/discord/src/monitor/presence-events.ts
+const DISCORD_PRESENCE_GREETING_COOLDOWN_MS = 480 * 60 * 1e3;
+function isDiscordOnlineStatus(status) {
+	return status === "online" || status === "idle" || status === "dnd";
+}
+function isDiscordOfflineStatus(status) {
+	return status === "offline";
+}
+function resolveDiscordOnlinePresenceEvent(params) {
+	const config = params.config;
+	const userId = params.data.user?.id?.trim();
+	if (!config || config.enabled === false || !userId || userId === params.botUserId || params.data.user.bot === true || !isDiscordOnlineStatus(params.data.status) || !params.availabilityKind) return null;
+	if (config.users !== void 0 && !config.users.includes(userId)) return null;
+	if (params.lastEmittedAtMs !== void 0 && params.nowMs - params.lastEmittedAtMs < 288e5) return null;
+	const lines = [
+		"Discord online-presence event:",
+		params.availabilityKind === "observed-offline" ? `A human member became available online after being observed offline in guild_id=${JSON.stringify(params.data.guild_id)} user_id=${JSON.stringify(userId)} status=${JSON.stringify(params.data.status)}.` : `A human member became newly visible online since the current guild snapshot in guild_id=${JSON.stringify(params.data.guild_id)} user_id=${JSON.stringify(userId)} status=${JSON.stringify(params.data.status)}. They may have come online or joined after the snapshot; do not claim an exact prior status.`,
+		`The authorized greeting target is channel_id=${JSON.stringify(config.channelId)}.`,
+		"Before greeting, retrieve relevant memory and wiki context for this immutable user_id, including a known timezone when available. Use their local time for the greeting; if their timezone is unknown, do not guess.",
+		"Send at most one short, natural greeting to the target channel. Do not reveal private memory. If no greeting is appropriate, stay silent."
+	];
+	return {
+		channelId: config.channelId,
+		userId,
+		text: lines.join("\n")
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/presence-cooldown-store.ts
+const DISCORD_PRESENCE_COOLDOWN_MAX_ENTRIES = 25e3;
+function openDiscordPresenceCooldownStore() {
+	return getDiscordRuntime().state.openSyncKeyedStore({
+		namespace: "presence-greeting-cooldowns",
+		maxEntries: DISCORD_PRESENCE_COOLDOWN_MAX_ENTRIES,
+		overflowPolicy: "reject-new",
+		defaultTtlMs: DISCORD_PRESENCE_GREETING_COOLDOWN_MS
+	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/presence-emission-gate.ts
+const DISCORD_PRESENCE_RECONNECT_SUPPRESS_MS = 300 * 1e3;
+const DISCORD_PRESENCE_BURST_LIMIT = 8;
+const DISCORD_PRESENCE_BURST_WINDOW_MS = 60 * 1e3;
+function resolveDiscordPresenceGateOptions(config) {
+	return {
+		reconnectSuppressMs: config?.reconnectSuppressSeconds !== void 0 ? config.reconnectSuppressSeconds * 1e3 : DISCORD_PRESENCE_RECONNECT_SUPPRESS_MS,
+		burstLimit: config?.burstLimit ?? DISCORD_PRESENCE_BURST_LIMIT,
+		burstWindowMs: config?.burstWindowSeconds !== void 0 ? config.burstWindowSeconds * 1e3 : DISCORD_PRESENCE_BURST_WINDOW_MS
+	};
+}
+/**
+* Per-account lifecycle gate for online-presence events. Reconnect state belongs to the Gateway
+* session, while burst state follows the guild-owned configuration that supplies its limits.
+*/
+var DiscordPresenceEmissionGate = class {
+	constructor() {
+		this.reconnectLogged = false;
+		this.burstByGuild = /* @__PURE__ */ new Map();
+		this.nextReservationId = 0;
+	}
+	noteGatewaySessionReset(nowMs) {
+		this.lastSessionResetAtMs = nowMs;
+		this.reconnectLogged = false;
+	}
+	evaluateReconnectWindow(nowMs, options) {
+		if (this.lastSessionResetAtMs !== void 0 && options.reconnectSuppressMs > 0 && nowMs - this.lastSessionResetAtMs < options.reconnectSuppressMs) {
+			const shouldLog = !this.reconnectLogged;
+			this.reconnectLogged = true;
+			return {
+				allowed: false,
+				reason: "reconnect-window",
+				shouldLog
+			};
+		}
+		return { allowed: true };
+	}
+	reserveBurst(guildId, nowMs, options) {
+		const state = this.burstByGuild.get(guildId) ?? {
+			reservations: [],
+			logged: false
+		};
+		state.reservations = state.reservations.filter((reservation) => !reservation.committed || nowMs - reservation.atMs < options.burstWindowMs);
+		this.burstByGuild.set(guildId, state);
+		if (state.reservations.length >= options.burstLimit) {
+			const shouldLog = !state.logged;
+			state.logged = true;
+			return {
+				allowed: false,
+				reason: state.reservations.some((reservation) => !reservation.committed) ? "burst-pending" : "burst",
+				shouldLog
+			};
+		}
+		state.logged = false;
+		const reservation = {
+			id: this.nextReservationId++,
+			atMs: nowMs,
+			committed: false
+		};
+		state.reservations.push(reservation);
+		return {
+			allowed: true,
+			reservation: reservation.id
+		};
+	}
+	commitBurst(guildId, reservation, nowMs) {
+		const entry = this.burstByGuild.get(guildId)?.reservations.find((candidate) => candidate.id === reservation);
+		if (!entry) return;
+		entry.atMs = nowMs;
+		entry.committed = true;
+	}
+	releaseBurst(guildId, reservation) {
+		const state = this.burstByGuild.get(guildId);
+		if (!state) return;
+		state.reservations = state.reservations.filter((candidate) => candidate.id !== reservation);
+		if (state.reservations.length === 0 && !state.logged) this.burstByGuild.delete(guildId);
+	}
+};
+//#endregion
+//#region extensions/discord/src/monitor/presence-transition-cache.ts
+const DEFAULT_PRESENCE_BASELINE_MAX_ENTRIES = 75e3;
+var DiscordPresenceBaselineCache = class {
+	constructor(maxEntries = DEFAULT_PRESENCE_BASELINE_MAX_ENTRIES) {
+		this.maxEntries = maxEntries;
+		this.offlineByKey = /* @__PURE__ */ new Map();
+		this.onlineByKey = /* @__PURE__ */ new Map();
+	}
+	clear() {
+		this.offlineByKey.clear();
+		this.onlineByKey.clear();
+	}
+	clearScope(scope) {
+		for (const markers of [this.offlineByKey, this.onlineByKey]) for (const [key, markerScope] of markers) if (markerScope === scope) markers.delete(key);
+	}
+	isOffline(scope, key) {
+		return this.offlineByKey.get(key) === scope;
+	}
+	isOnline(scope, key) {
+		return this.onlineByKey.get(key) === scope;
+	}
+	observeOffline(scope, key) {
+		this.deleteMarker(this.onlineByKey, scope, key);
+		return this.observe(this.offlineByKey, scope, key);
+	}
+	observeOnline(scope, key) {
+		this.deleteMarker(this.offlineByKey, scope, key);
+		return this.observe(this.onlineByKey, scope, key);
+	}
+	deleteMarker(markers, scope, key) {
+		if (markers.get(key) === scope) markers.delete(key);
+	}
+	observe(markers, scope, key) {
+		markers.delete(key);
+		markers.set(key, scope);
+		let evictedScope;
+		while (markers.size > this.maxEntries) {
+			const oldestKey = markers.keys().next().value;
+			if (oldestKey === void 0) break;
+			evictedScope = markers.get(oldestKey);
+			markers.delete(oldestKey);
+		}
+		return evictedScope;
+	}
+};
+//#endregion
+//#region extensions/discord/src/monitor/thread-session-close.ts
+/**
+* Closes every session entry in the store whose key contains {@link threadId}.
+* The explicit lifecycle deletion archives the old transcript and guarantees
+* that a later inbound message starts a fresh session in every reset mode.
+*/
+async function closeDiscordThreadSessions(params) {
+	const { cfg, threadId } = params;
+	const normalizedThreadId = normalizeOptionalLowercaseString(threadId) ?? "";
+	if (!normalizedThreadId) return 0;
+	const segmentRe = new RegExp(`:${normalizedThreadId}(?::|$)`, "i");
+	function sessionKeyContainsThreadId(key) {
+		return segmentRe.test(key);
+	}
+	let resetCount = 0;
+	for (const agentId of listAgentIds(cfg)) {
+		const storePath = resolveStorePath(cfg.session?.store, { agentId });
+		for (const { sessionKey, entry } of listSessionEntries({
+			agentId,
+			storePath,
+			readOnly: true
+		})) {
+			if (!sessionKeyContainsThreadId(sessionKey)) continue;
+			if (await deleteSessionEntry({
+				archiveTranscript: true,
+				expectedSessionId: entry.sessionId ?? null,
+				expectedUpdatedAt: entry.updatedAt,
+				sessionKey,
+				storePath
+			})) resetCount += 1;
+		}
+	}
+	return resetCount;
+}
+//#endregion
 //#region extensions/discord/src/monitor/dm-command-auth.ts
 const DISCORD_ALLOW_LIST_PREFIXES = [
 	"discord:",
@@ -305,461 +504,6 @@ 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;
-	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;
@@ -1131,264 +875,65 @@ async function handleDiscordReactionEvent(params) {
 			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;
+		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 {
-				allowed: false,
-				reason: state.reservations.some((reservation) => !reservation.committed) ? "burst-pending" : "burst",
-				shouldLog
+				access: await authorizeReactionIngressForChannel(channelConfig),
+				channelConfig
 			};
-		}
-		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;
+		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 +1360,16 @@ function isDiscordUnknownInteraction(error) {
 	if (/Unknown interaction/i.test(err.rawBody?.message ?? "")) return true;
 	return false;
 }
+function resolveDiscordInteractionMessageParts(payload) {
+	const { components, embeds } = payload.channelData?.discord ?? {};
+	return {
+		components: Array.isArray(components) && components.length > 0 ? components : void 0,
+		embeds: Array.isArray(embeds) && embeds.length > 0 ? embeds : void 0
+	};
+}
 function hasRenderableReplyPayload(payload) {
-	if (resolveSendableOutboundReplyParts(payload).hasContent) return true;
-	const discordData = payload.channelData?.discord;
-	if (Array.isArray(discordData?.components) && discordData.components.length > 0) return true;
-	return false;
+	const { components, embeds } = resolveDiscordInteractionMessageParts(payload);
+	return resolveSendableOutboundReplyParts(payload).hasContent || Boolean(components || embeds);
 }
 async function safeDiscordInteractionCall(label, fn) {
 	try {
@@ -1839,33 +1389,25 @@ async function settleDiscordInteractionWithoutVisibleReply(interaction) {
 async function deliverDiscordInteractionReply(params) {
 	const { interaction, payload, textLimit, maxLinesPerMessage, preferFollowUp, chunkMode } = params;
 	const reply = resolveSendableOutboundReplyParts(payload);
-	const discordData = payload.channelData?.discord;
-	let firstMessageComponents = Array.isArray(discordData?.components) && discordData.components.length > 0 ? discordData.components : void 0;
+	let { components: firstMessageComponents, embeds: firstMessageEmbeds } = resolveDiscordInteractionMessageParts(payload);
 	let payloadDelivered = false;
-	const sendMessage = async (content, files, components) => {
-		const contentPayload = content ? { content } : {};
-		const payloadLocal = files && files.length > 0 ? {
-			...contentPayload,
+	const sendMessage = async (content, files, components, embeds) => {
+		const hasV2 = hasDiscordV2Components(components);
+		const payloadLocal = {
+			...content && !hasV2 ? { content } : {},
 			...components ? { components } : {},
+			...embeds && !hasV2 ? { embeds } : {},
 			...params.responseEphemeral !== void 0 ? { ephemeral: params.responseEphemeral } : {},
-			files
-		} : {
-			...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 +1432,27 @@ async function deliverDiscordInteractionReply(params) {
 			maxLines: maxLinesPerMessage,
 			chunkMode
 		}));
-		await sendMessage(chunks[0] ?? "", media, firstMessageComponents);
+		await sendMessage(chunks[0] ?? "", media, firstMessageComponents, firstMessageEmbeds);
 		for (const chunk of chunks.slice(1)) {
 			if (!chunk.trim()) continue;
 			await sendMessage(chunk);
 		}
 		return payloadDelivered;
 	}
-	if (!reply.hasText && !firstMessageComponents) return false;
-	let chunks = reply.text || firstMessageComponents ? resolveTextChunksWithFallback(reply.text, chunkDiscordTextWithMode(reply.text, {
+	if (!reply.hasText && !firstMessageComponents && !firstMessageEmbeds) return false;
+	const chunks = resolveTextChunksWithFallback(reply.text, chunkDiscordTextWithMode(reply.text, {
 		maxChars: textLimit,
 		maxLines: maxLinesPerMessage,
 		chunkMode
-	})) : [];
-	if (chunks.length === 0 && firstMessageComponents) chunks = [""];
+	}));
+	if (chunks.length === 0) chunks.push("");
 	for (const chunk of chunks) {
-		if (!chunk.trim() && !firstMessageComponents) continue;
-		await sendMessage(chunk, void 0, firstMessageComponents);
+		if (!chunk.trim() && !firstMessageComponents && !firstMessageEmbeds) continue;
+		await sendMessage(chunk, void 0, firstMessageComponents, firstMessageEmbeds);
 	}
 	return payloadDelivered;
 }
 //#endregion
-//#region extensions/discord/src/monitor/route-resolution.ts
-function buildDiscordRoutePeer(params) {
-	return {
-		kind: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
-		id: params.isDirectMessage ? params.directUserId?.trim() || params.conversationId : params.conversationId
-	};
-}
-function resolveDiscordConversationRoute(params) {
-	return resolveAgentRoute({
-		cfg: params.cfg,
-		channel: "discord",
-		accountId: params.accountId,
-		guildId: params.guildId ?? void 0,
-		memberRoleIds: params.memberRoleIds,
-		peer: params.peer,
-		parentPeer: params.parentConversationId ? {
-			kind: "channel",
-			id: params.parentConversationId
-		} : void 0
-	});
-}
-function resolveDiscordBoundConversationRoute(params) {
-	return resolveDiscordEffectiveRoute({
-		route: resolveDiscordConversationRoute({
-			cfg: params.cfg,
-			accountId: params.accountId,
-			guildId: params.guildId,
-			memberRoleIds: params.memberRoleIds,
-			peer: buildDiscordRoutePeer({
-				isDirectMessage: params.isDirectMessage,
-				isGroupDm: params.isGroupDm,
-				directUserId: params.directUserId,
-				conversationId: params.conversationId
-			}),
-			parentConversationId: params.parentConversationId
-		}),
-		boundSessionKey: params.boundSessionKey,
-		configuredRoute: params.configuredRoute,
-		matchedBy: params.matchedBy
-	});
-}
-function resolveDiscordEffectiveRoute(params) {
-	const boundSessionKey = params.boundSessionKey?.trim();
-	if (!boundSessionKey) return params.configuredRoute?.route ?? params.route;
-	return {
-		...params.route,
-		sessionKey: boundSessionKey,
-		agentId: resolveAgentIdFromSessionKey(boundSessionKey),
-		lastRoutePolicy: deriveLastRoutePolicy({
-			sessionKey: boundSessionKey,
-			mainSessionKey: params.route.mainSessionKey
-		}),
-		...params.matchedBy ? { matchedBy: params.matchedBy } : {}
-	};
-}
-function hasExplicitRuntimeBindingIntent(record) {
-	if (record.targetKind === "subagent") return true;
-	if (isAcpSessionKey(record.targetSessionKey) || isSubagentSessionKey(record.targetSessionKey)) return true;
-	const metadata = record.metadata;
-	if (!metadata || typeof metadata !== "object") return false;
-	return typeof metadata.boundBy === "string" || typeof metadata.label === "string" || typeof metadata.threadName === "string" || metadata.pluginBindingOwner === "plugin";
-}
-function shouldIgnoreStaleDiscordRouteBinding(params) {
-	const bindingRecord = params.bindingRecord;
-	const boundSessionKey = bindingRecord?.targetSessionKey?.trim();
-	if (!bindingRecord || !boundSessionKey || hasExplicitRuntimeBindingIntent(bindingRecord)) return false;
-	const bound = parseAgentSessionKey(boundSessionKey);
-	const routed = parseAgentSessionKey(params.route.sessionKey);
-	if (!bound || !routed || bound.rest !== routed.rest) return false;
-	return bound.agentId !== params.route.agentId;
-}
-//#endregion
 //#region extensions/discord/src/monitor/native-command-route.ts
 async function resolveDiscordNativeInteractionRouteState(params) {
 	const route = resolveDiscordBoundConversationRoute({
@@ -2398,11 +1868,11 @@ async function resolveDiscordNativeAutocompleteAuthorized(params) {
 //#endregion
 //#region extensions/discord/src/monitor/native-command-bypass.ts
 function shouldBypassConfiguredAcpEnsure(commandName) {
-	return normalizeLowercaseStringOrEmpty(commandName) === "acp";
+	return commandName.trim().toLowerCase() === "acp";
 }
 function shouldBypassConfiguredAcpGuildGuards(commandName) {
-	const normalized = normalizeLowercaseStringOrEmpty(commandName);
-	return normalized === "new" || normalized === "reset";
+	const command = commandName.trim().toLowerCase();
+	return command === "new" || command === "reset";
 }
 //#endregion
 //#region extensions/discord/src/monitor/inbound-context.ts
@@ -2481,6 +1951,14 @@ function buildDiscordNativeCommandContext(params) {
 		CommandTargetSessionKey: params.commandTargetSessionKey,
 		AccountId: params.accountId ?? void 0,
 		ChatType: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
+		...buildDiscordConversationRouteContext({
+			isDirectMessage: params.isDirectMessage,
+			isGroupDm: params.isGroupDm,
+			directUserId: params.user.id,
+			conversationId: params.channelId,
+			isThread: params.isThreadChannel,
+			parentConversationId: params.threadParentId
+		}),
 		ConversationLabel: conversationLabel,
 		GroupSubject: params.isGuild ? params.guildName : void 0,
 		GroupSpace: params.isGuild ? params.guildInfo?.id ?? params.guildInfo?.slug ?? params.guildId : void 0,
@@ -2496,7 +1974,6 @@ function buildDiscordNativeCommandContext(params) {
 		Surface: "discord",
 		WasMentioned: true,
 		MessageSid: params.interactionId,
-		MessageThreadId: params.isThreadChannel ? params.channelId : void 0,
 		Timestamp: params.timestampMs ?? Date.now(),
 		CommandAuthorized: params.commandAuthorized,
 		CommandTurn: {
@@ -2511,8 +1988,7 @@ function buildDiscordNativeCommandContext(params) {
 			isDirectMessage: params.isDirectMessage,
 			userId: params.user.id,
 			channelId: params.channelId
-		}) ?? (params.isDirectMessage ? `user:${params.user.id}` : `channel:${params.channelId}`),
-		ThreadParentId: params.isThreadChannel ? params.threadParentId : void 0
+		}) ?? (params.isDirectMessage ? `user:${params.user.id}` : `channel:${params.channelId}`)
 	});
 }
 //#endregion
@@ -4446,7 +3922,7 @@ const DISCORD_COMMAND_DESCRIPTION_MAX = 100;
 function truncateDiscordCommandDescription(params) {
 	const { value, label } = params;
 	if (value.length <= DISCORD_COMMAND_DESCRIPTION_MAX) return value;
-	log$1.warn(`discord: truncating native command description (${label}) from ${value.length} to ${DISCORD_COMMAND_DESCRIPTION_MAX}: ${JSON.stringify(value)}`);
+	log$1.debug(`discord: truncating native command description (${label}) from ${value.length} to ${DISCORD_COMMAND_DESCRIPTION_MAX}: ${JSON.stringify(value)}`);
 	return truncateUtf16Safe(value, DISCORD_COMMAND_DESCRIPTION_MAX);
 }
 function truncateDiscordCommandDescriptionLocalizations(params) {
@@ -5097,7 +4573,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 +4781,7 @@ var DiscordGatewayVoiceStateCache = class {
 	}
 	listVoiceChannelStates(guildId, channelId) {
 		const states = this.statesByGuild.get(guildId);
-		if (!states) return [];
+		if (!states) return null;
 		const result = [];
 		for (const state of states.values()) if (state.channel_id === channelId) result.push({ ...state });
 		return result;
@@ -5518,7 +4994,10 @@ var GatewayPlugin = class extends Plugin {
 		if (payload.s !== null && payload.s !== void 0) this.sequence = payload.s;
 		switch (payload.op) {
 			case GatewayOpcodes.Hello: {
-				this.startHeartbeat(payload.d.heartbeat_interval ?? 45e3);
+				this.startHeartbeat(asSafeIntegerInRange(asOptionalRecord(payload.d)?.heartbeat_interval, {
+					min: 1,
+					max: MAX_TIMER_TIMEOUT_MS
+				}) ?? 45e3);
 				const resumeState = resume ? this.getResumeState() : null;
 				if (resumeState) this.send({
 					op: GatewayOpcodes.Resume,
@@ -5721,12 +5200,6 @@ var GatewayPlugin = class extends Plugin {
 	}
 };
 //#endregion
-//#region extensions/discord/src/voice/config.ts
-function resolveDiscordVoiceEnabled(voice) {
-	if (voice?.enabled !== void 0) return voice.enabled;
-	return voice !== void 0;
-}
-//#endregion
 //#region extensions/discord/src/monitor/presence.ts
 const DEFAULT_CUSTOM_ACTIVITY_TYPE$1 = 4;
 const CUSTOM_STATUS_NAME$1 = "Custom Status";
@@ -7045,7 +6518,7 @@ async function runDiscordGatewayLifecycle(params) {
 		gatewayEmitter?.removeListener(DISCORD_GATEWAY_TRANSPORT_ACTIVITY_EVENT, onGatewayTransportActivity);
 		if (params.voiceManager) {
 			await params.voiceManager.destroy();
-			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-CfFMexGt.js").then((n) => n.n);
+			const { setDiscordTranscriptsVoiceManager } = await import("./transcripts-source-DeIMNbRh.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: params.accountId,
 				manager: null
@@ -7060,7 +6533,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-CjNFaynA.js");
 	discordVoiceRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7070,7 +6543,7 @@ async function loadDiscordVoiceRuntime() {
 	}
 }
 async function loadDiscordProviderSessionRuntime() {
-	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-BUEqD0rA.js");
+	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-CvvphHvs.js");
 	discordProviderSessionRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7431,102 +6904,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 +7267,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 +7281,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 +7372,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
@@ -8757,7 +8134,8 @@ function resolveReplyContext(message, resolveDiscordMessageText) {
 	const referenced = message.referencedMessage;
 	if (!referenced?.author) return null;
 	const referencedText = resolveDiscordMessageText(referenced, { includeForwarded: true });
-	if (!referencedText) return null;
+	const hasVisibleMedia = referenced.attachments.length > 0 || !referencedText && resolveDiscordMessageStickers(referenced).length > 0;
+	if (!referencedText && !hasVisibleMedia) return null;
 	const sender = resolveDiscordSenderIdentity({
 		author: referenced.author,
 		pluralkitInfo: null
@@ -8773,7 +8151,7 @@ function resolveReplyContext(message, resolveDiscordMessageText) {
 			const roles = referenced.member?.roles;
 			return Array.isArray(roles) ? roles.map((roleId) => roleId) : void 0;
 		})(),
-		body: referencedText,
+		...referencedText ? { body: referencedText } : {},
 		timestamp: resolveTimestampMs(referenced.timestamp)
 	};
 }
@@ -8971,7 +8349,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-oLiS5Z13.js").then((n) => n.n));
 function buildDiscordComponentConversationLabel(params) {
 	if (params.interactionCtx.isDirectMessage) return buildDirectLabel(params.interactionCtx.user);
 	if (params.interactionCtx.isGroupDm) return `Group DM #${params.channelCtx.channelName ?? params.interactionCtx.channelId} channel id:${params.interactionCtx.channelId}`;
@@ -9093,6 +8471,14 @@ async function dispatchDiscordComponentEvent(params) {
 		SessionKey: sessionKey,
 		AccountId: accountId,
 		ChatType: chatType,
+		...buildDiscordConversationRouteContext({
+			isDirectMessage: interactionCtx.isDirectMessage,
+			isGroupDm: interactionCtx.isGroupDm,
+			directUserId: interactionCtx.userId,
+			conversationId: interactionCtx.channelId,
+			isThread: channelCtx.isThread,
+			parentConversationId: channelCtx.parentId
+		}),
 		ConversationLabel: fromLabel,
 		SenderName: senderName,
 		SenderId: interactionCtx.userId,
@@ -9161,6 +8547,7 @@ async function dispatchDiscordComponentEvent(params) {
 					sessionKey
 				},
 				ctxPayload,
+				dispatchReplyFromConfig: ctx.channelRuntime?.reply?.dispatchReplyFromConfig,
 				record: {
 					updateLastRoute: interactionCtx.isDirectMessage ? {
 						sessionKey: inboundLastRouteSessionKey,
@@ -9367,7 +8754,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-ezGKo_Yh.js").then((n) => n.t));
 async function handleDiscordComponentEvent(params) {
 	const parsed = parseDiscordComponentData(params.data, resolveInteractionCustomId(params.interaction));
 	if (!parsed) {
@@ -10149,6 +9536,7 @@ function createDiscordProviderInteractionSurface(params) {
 		allowFrom: params.allowFrom,
 		dmPolicy: params.dmPolicy,
 		runtime: params.runtime,
+		channelRuntime: params.channelRuntime,
 		token: params.token
 	}, params.applicationId);
 	if (activityButton) components.push(activityButton);
@@ -10641,6 +10029,7 @@ async function monitorDiscordProvider(opts = {}) {
 	let earlyGatewayEmitter = gatewaySupervisor?.emitter;
 	let onEarlyGatewayDebug;
 	try {
+		const pluginChannelRuntime = opts.channelRuntime;
 		const { commands, components, modals } = createDiscordProviderInteractionSurface({
 			cfg,
 			discordConfig: discordCfg,
@@ -10660,7 +10049,7 @@ async function monitorDiscordProvider(opts = {}) {
 			allowFrom,
 			dmPolicy,
 			runtime,
-			channelRuntime: opts.channelRuntime,
+			channelRuntime: pluginChannelRuntime,
 			abortSignal: opts.abortSignal,
 			createNativeCommand: discordProviderRuntime.createDiscordNativeCommand
 		});
@@ -10734,7 +10123,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-DeIMNbRh.js").then((n) => n.n);
 			setDiscordTranscriptsVoiceManager({
 				accountId: account.accountId,
 				manager: voiceManager
@@ -10752,7 +10141,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 +10229,4 @@ async function monitorDiscordProvider(opts = {}) {
 	}
 }
 //#endregion
-export { sanitizeDiscordThreadName as A, handleDiscordDmCommandDecision as C, resolveDiscordAutoThreadReplyPlan as D, threading_exports as E, resolveDiscordTextCommandAccess as M, resolveDiscordReplyTarget as O, shouldIgnoreStaleDiscordRouteBinding as S, registerDiscordListener as T, buildDiscordInboundAccessContext as _, sanitizeDiscordFrontChannelReplyPayloads as a, resolveDiscordConversationRoute as b, resolveReplyContext as c, createDiscordGatewayPlugin as d, resolveDiscordGatewayIntents as f, buildDiscordGroupSystemPrompt as g, createDiscordNativeCommand as h, formatDiscordReplySkip as i, resolveDiscordDmCommandAccess as j, resolveDiscordThreadStarter as k, resolveDiscordVoiceAccess as l, resolveDiscordVoiceEnabled as m, deliverDiscordReply as n, buildDirectLabel as o, waitForDiscordGatewayPluginRegistration as p, formatDiscordReplyDeliveryFailure as r, buildGuildLabel as s, monitorDiscordProvider as t, authorizeDiscordVoiceIngress as u, createDiscordSupplementalContextAccessChecker as v, mapGatewayDispatchData as w, resolveDiscordEffectiveRoute as x, buildDiscordRoutePeer as y };
+export { mapGatewayDispatchData as _, sanitizeDiscordFrontChannelReplyPayloads as a, resolveDiscordDmCommandAccess as b, resolveReplyContext as c, waitForDiscordGatewayPluginRegistration as d, createDiscordNativeCommand as f, handleDiscordDmCommandDecision as g, createDiscordSupplementalContextAccessChecker as h, formatDiscordReplySkip as i, createDiscordGatewayPlugin as l, buildDiscordInboundAccessContext as m, deliverDiscordReply as n, buildDirectLabel as o, buildDiscordGroupSystemPrompt as p, formatDiscordReplyDeliveryFailure as r, buildGuildLabel as s, monitorDiscordProvider as t, resolveDiscordGatewayIntents as u, registerDiscordListener as v, resolveDiscordTextCommandAccess as x, resolveFetchedDiscordThreadLikeChannelContext as y };