@openclaw/discord 2026.5.12 → 2026.5.14-beta.2

package/dist/{provider-DABvNRT0.js → provider-nzJg2k5t.js}

@@ -1,35 +1,26 @@
-import { C as Message, H as StringSelectMenu, K as BaseMessageInteractiveComponent, N as Container, O as Modal, S as Guild, U as TextDisplay, V as Separator, a as MessageReactionRemoveListener, b as Command, f as Client, g as RateLimitError, i as MessageReactionAddListener, j as Button, l as ThreadUpdateListener, n as InteractionCreateListener, o as PresenceUpdateListener, p as Plugin, r as MessageCreateListener, s as ReadyListener, t as discord_exports, w as User, x as CommandWithSubcommands, z as Row } from "./discord-BqYcwxvG.js";
-import { t as normalizeDiscordToken } from "./token-BZtonk7d.js";
-import { c as resolveDiscordAccountAllowFrom, d as resolveDiscordAccountDmPolicy, f as resolveDiscordMaxLinesPerMessage, s as resolveDiscordAccount } from "./accounts-BcwyaFd-.js";
-import { a as resolveDiscordComponentEntryWithPersistence, o as resolveDiscordModalEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-DxDqPJZQ.js";
-import { c as setPresence, i as unregisterGateway, r as registerGateway } from "./gateway-registry-BKG4KIVC.js";
-import { t as chunkDiscordTextWithMode } from "./chunk-DYl-_5RL.js";
-import { F as DISCORD_REST_TIMEOUT_MS, I as validateDiscordProxyUrl, L as withValidatedDiscordProxy, j as createDiscordRestClient } from "./send.shared-Dza0jdso.js";
-import { a as summarizeDiscordResponseBody, i as isDiscordRateLimitResponseBody } from "./api-DzNBVTto.js";
-import { n as formatDiscordUserTag, t as formatDiscordReactionEmoji } from "./format-D8TsaXxW.js";
-import { _ as resolveGroupDmAllow, a as normalizeDiscordSlug, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordGuildEntry, f as resolveDiscordMemberAccessState, i as normalizeDiscordDisplaySlug, l as resolveDiscordChannelPolicyCommandAuthorizer, m as resolveDiscordOwnerAccess, n as isDiscordGroupAllowedByPolicy, o as resolveDiscordAllowListMatch, r as normalizeDiscordAllowList, v as shouldEmitDiscordReactionNotification } from "./allow-list-n8Ki-Rt3.js";
-import { t as formatMention } from "./mentions-BZoGn0ul.js";
-import { _ as parseDiscordModalCustomIdForInteraction, g as parseDiscordModalCustomId, h as parseDiscordComponentCustomIdForInteraction, m as parseDiscordComponentCustomId } from "./components-Dxq2mU57.js";
-import { i as isDiscordExecApprovalClientEnabled, n as getDiscordExecApprovalApprovers } from "./approval-shared-BFnWKSQD.js";
-import "./approval-native-Gtqpyfdj.js";
-import { t as resolveDiscordConversationIdentity } from "./conversation-identity-CvIx6J7M.js";
-import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-JNt3Ak6P.js";
-import { t as resolveDiscordUserAllowlist } from "./resolve-users-CrjbUxrL.js";
-import { a as isThreadArchived, d as formatThreadBindingDurationLabel } from "./thread-bindings.discord-api-BAw15EQb.js";
-import { i as resolveDiscordChannelParentIdSafe, n as resolveDiscordChannelInfoSafe, o as resolveDiscordChannelTopicSafe, r as resolveDiscordChannelNameSafe, t as resolveDiscordChannelIdSafe } from "./channel-access-BL-wemES.js";
-import { r as parseApplicationIdFromToken, t as fetchDiscordApplicationId } from "./probe-BZtr8qle.js";
-import { o as raceWithTimeout, s as withAbortTimeout } from "./timeouts-C3FYXWJX.js";
-import { i as resolveDiscordEffectiveRoute, n as resolveDiscordBoundConversationRoute, o as handleDiscordDmCommandDecision, s as resolveDiscordDmCommandAccess } from "./route-resolution-BFfF9xmG.js";
-import { c as resolveDiscordChannelInfo } from "./message-utils-ByofKwPe.js";
-import { i as resolveDiscordThreadParentInfo } from "./threading-CLZ3v7-y.js";
-import { t as resolveDiscordSenderIdentity } from "./sender-identity-w9rSI-nD.js";
-import { n as buildDiscordInboundAccessContext, t as buildDiscordGroupSystemPrompt } from "./inbound-context-jtKcY9on.js";
-import { n as resolveDiscordVoiceEnabled, t as authorizeDiscordVoiceIngress } from "./access-Dxmzr0ix.js";
-import { n as buildDirectLabel, r as buildGuildLabel, t as deliverDiscordReply } from "./reply-delivery-CUSK6SA_.js";
-import "./approval-handler.runtime-S-ircYcz.js";
+import { $ as BaseMessageInteractiveComponent, A as Message, B as Container, C as RateLimitError, D as Command, F as Modal, J as Separator, K as Row, O as CommandWithSubcommands, R as Button, Wt as __exportAll, X as TextDisplay, Y as StringSelectMenu, b as Plugin, c as discord_exports, ct as createThread, d as MessageReactionAddListener, dt as editChannel, f as MessageReactionRemoveListener, g as ThreadUpdateListener, j as User, k as Guild, l as InteractionCreateListener, m as ReadyListener, mt as getChannelMessage, p as PresenceUpdateListener, s as chunkDiscordTextWithMode, u as MessageCreateListener, y as Client } from "./send.receipt-nKLxvA1s.js";
+import { c as resolveDiscordAccountAllowFrom, d as resolveDiscordAccountDmPolicy, f as resolveDiscordMaxLinesPerMessage, p as normalizeDiscordToken, s as resolveDiscordAccount } from "./accounts-DnNVBDfc.js";
+import { _ as parseDiscordComponentCustomId, b as parseDiscordModalCustomIdForInteraction, v as parseDiscordComponentCustomIdForInteraction, y as parseDiscordModalCustomId } from "./components-Cgm7XT8-.js";
+import { a as resolveDiscordComponentEntryWithPersistence, o as resolveDiscordModalEntryWithPersistence, t as editDiscordComponentMessage } from "./send.components-D6pXHVrU.js";
+import { c as setPresence, i as unregisterGateway, r as registerGateway } from "./gateway-registry-BKSpa4GB.js";
+import { I as DISCORD_REST_TIMEOUT_MS, L as validateDiscordProxyUrl, M as createDiscordRestClient, R as withValidatedDiscordProxy, w as canViewDiscordGuildChannel } from "./send.shared-DSpva7uA.js";
+import { a as summarizeDiscordResponseBody, i as isDiscordRateLimitResponseBody } from "./api-DgQLz1wq.js";
+import { S as resolveTimestampMs, _ as resolveGroupDmAllow, a as normalizeDiscordSlug, b as formatDiscordUserTag, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordGuildEntry, f as resolveDiscordMemberAccessState, i as normalizeDiscordDisplaySlug, l as resolveDiscordChannelPolicyCommandAuthorizer, m as resolveDiscordOwnerAccess, n as isDiscordGroupAllowedByPolicy, o as resolveDiscordAllowListMatch, r as normalizeDiscordAllowList, v as shouldEmitDiscordReactionNotification, y as formatDiscordReactionEmoji } from "./allow-list-CBI-M84K.js";
+import { s as sendVoiceMessageDiscord } from "./send-BqzTEkt9.js";
+import { i as formatMention, t as sendMessageDiscord } from "./send.outbound-D8o8BW6q.js";
+import { a as getDiscordExecApprovalApprovers, s as isDiscordExecApprovalClientEnabled, t as resolveDiscordConversationIdentity } from "./conversation-identity-C3AI-1tz.js";
+import { t as resolveDiscordChannelAllowlist } from "./resolve-channels-u7_agBcm.js";
+import { t as resolveDiscordUserAllowlist } from "./resolve-users-Bc25I6OP.js";
+import { _ as formatThreadBindingDurationLabel, a as isThreadArchived, d as resolveDiscordChannelNameSafe, f as resolveDiscordChannelParentIdSafe, l as resolveDiscordChannelIdSafe, m as resolveDiscordChannelTopicSafe, p as resolveDiscordChannelParentSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-DJACBZJ1.js";
+import { r as parseApplicationIdFromToken, t as fetchDiscordApplicationId } from "./probe-CiBYm-vD.js";
+import { o as raceWithTimeout, s as withAbortTimeout } from "./timeouts-snXNwR4m.js";
+import { c as resolveDiscordChannelInfo, l as resolveDiscordMessageChannelId, n as resolveDiscordForwardedMessagesTextFromSnapshots, t as resolveDiscordEmbedText } from "./message-utils-N5UTOXQ2.js";
+import { t as resolveDiscordSenderIdentity } from "./sender-identity-BTGL3VbF.js";
+import { n as buildDiscordInboundAccessContext, t as buildDiscordGroupSystemPrompt } from "./inbound-context-DD7n3Q6U.js";
+import "./approval-handler.runtime-Uco62pII.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries, summarizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeOptionalStringifiedId, normalizeStringEntries, summarizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { buildAgentSessionKey, deriveLastRoutePolicy, isAcpSessionKey, isSubagentSessionKey, parseAgentSessionKey, resolveAgentIdFromSessionKey, resolveAgentRoute } from "openclaw/plugin-sdk/routing";
 import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { ApplicationCommandOptionType, ButtonStyle, ChannelType, ComponentType, GatewayCloseCodes, GatewayCloseCodes as GatewayCloseCodes$1, GatewayDispatchEvents, GatewayIntentBits, GatewayOpcodes } from "discord-api-types/v10";
 import { randomUUID } from "node:crypto";
@@ -46,24 +37,27 @@ import { wrapFetchWithAbortSignal } from "openclaw/plugin-sdk/fetch-runtime";
 import { createNonExitingRuntime, createSubsystemLogger, danger, formatDurationSeconds, isVerbose, logVerbose, shouldLogVerbose, warn } from "openclaw/plugin-sdk/runtime-env";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
-import { chunkItems } from "openclaw/plugin-sdk/text-chunking";
-import { createChannelMessageReplyPipeline } from "openclaw/plugin-sdk/channel-message";
+import { chunkItems, sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
+import { createChannelMessageReplyPipeline, sendDurableMessageBatch } from "openclaw/plugin-sdk/channel-message";
 import { fetchWithSsrFGuard, formatErrorMessage as formatErrorMessage$1 } from "openclaw/plugin-sdk/ssrf-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 { readJsonFileWithFallback, writeJsonFileAtomically } from "openclaw/plugin-sdk/json-store";
 import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
+import { buildOutboundSessionContext } from "openclaw/plugin-sdk/outbound-runtime";
 import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, canonicalizeAllowlistWithResolvedIds, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
 import { resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-streaming";
-import { buildPairingReply, upsertChannelPairingRequest as upsertChannelPairingRequest$1 } from "openclaw/plugin-sdk/conversation-runtime";
-import { clearExpiredCooldowns, ensureAuthProfileStore, isProfileInCooldown, resolveDefaultModelForAgent, resolveHumanDelayConfig, resolveProfilesUnavailableReason } from "openclaw/plugin-sdk/agent-runtime";
+import { buildPairingReply, upsertChannelPairingRequest, upsertChannelPairingRequest as upsertChannelPairingRequest$1 } from "openclaw/plugin-sdk/conversation-runtime";
+import { clearExpiredCooldowns, ensureAuthProfileStore, isProfileInCooldown, resolveAgentAvatar, resolveDefaultModelForAgent, resolveHumanDelayConfig, resolveProfilesUnavailableReason } from "openclaw/plugin-sdk/agent-runtime";
 import { GROUP_POLICY_BLOCKED_LABEL, resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
-import { withTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
+import { truncateUtf16Safe, withTimeout } from "openclaw/plugin-sdk/text-utility-runtime";
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { resolveNativeCommandsEnabled, resolveNativeSkillsEnabled } from "openclaw/plugin-sdk/native-command-config-runtime";
 import { enqueueSystemEvent, enqueueSystemEvent as enqueueSystemEvent$1 } from "openclaw/plugin-sdk/system-event-runtime";
-import { readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
-import { applyModelOverrideToSessionEntry } from "openclaw/plugin-sdk/model-session-runtime";
+import { createChannelIngressResolver, defineStableChannelIngressIdentity, readChannelIngressStoreAllowFromForDmPolicy } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { applyModelOverrideToSessionEntry, resolveChannelModelOverride } from "openclaw/plugin-sdk/model-session-runtime";
+import { completeWithPreparedSimpleCompletionModel, extractAssistantText, prepareSimpleCompletionModelForAgent } from "openclaw/plugin-sdk/simple-completion-runtime";
+import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
 import { loadSessionStore, readSessionUpdatedAt as readSessionUpdatedAt$1, resolveStorePath, resolveStorePath as resolveStorePath$1, updateSessionStore } from "openclaw/plugin-sdk/session-store-runtime";
 import { formatInboundEnvelope, resolveEnvelopeFormatOptions } from "openclaw/plugin-sdk/channel-inbound";
 import { buildCommandTextFromArgs, findCommandByNativeName, formatCommandArgMenuTitle, listChatCommands, listNativeCommandSpecsForConfig, listSkillCommandsForAgents, resolveCommandAuthorizedFromAuthorizers, resolveNativeCommandSessionTargets, resolveStoredModelOverride, serializeCommandArgs } from "openclaw/plugin-sdk/command-auth-native";
@@ -147,6 +141,628 @@ async function runDiscordListenerWithSlowLog(params) {
 	}
 }
 //#endregion
+//#region extensions/discord/src/monitor/dm-command-auth.ts
+const DISCORD_ALLOW_LIST_PREFIXES = [
+	"discord:",
+	"user:",
+	"pk:"
+];
+const DISCORD_CHANNEL_ID = "discord";
+const DISCORD_USER_ID_KIND = "stable-id";
+const DISCORD_USER_NAME_KIND = "username";
+function normalizeDiscordIdEntry(entry) {
+	const text = entry.trim();
+	if (!text) return null;
+	const maybeId = text.replace(/^<@!?/, "").replace(/>$/, "");
+	if (/^\d+$/.test(maybeId)) return maybeId;
+	const prefix = DISCORD_ALLOW_LIST_PREFIXES.find((entryPrefix) => text.startsWith(entryPrefix));
+	if (prefix) return text.slice(prefix.length).trim() || null;
+	return null;
+}
+function normalizeDiscordNameEntry(entry) {
+	const text = entry.trim();
+	if (!text || text === "*" || normalizeDiscordIdEntry(text)) return null;
+	const nameSlug = normalizeDiscordAllowList([text], DISCORD_ALLOW_LIST_PREFIXES)?.names.values().next().value;
+	return typeof nameSlug === "string" && nameSlug ? nameSlug : null;
+}
+function normalizeDiscordNameSubject(value) {
+	const nameSlug = normalizeDiscordAllowList([value], DISCORD_ALLOW_LIST_PREFIXES)?.names.values().next().value;
+	return typeof nameSlug === "string" && nameSlug ? nameSlug : null;
+}
+const discordIngressIdentity = defineStableChannelIngressIdentity({
+	key: "discordUserId",
+	kind: DISCORD_USER_ID_KIND,
+	normalizeEntry: normalizeDiscordIdEntry,
+	normalizeSubject: (value) => value.trim() || null,
+	sensitivity: "pii",
+	aliases: [["discordUserName", normalizeDiscordNameEntry], ["discordUserTag", () => null]].map(([key, normalizeEntry]) => ({
+		key,
+		kind: DISCORD_USER_NAME_KIND,
+		normalizeEntry,
+		normalizeSubject: normalizeDiscordNameSubject,
+		dangerous: true,
+		sensitivity: "pii"
+	}))
+});
+function createDiscordDmIngressSubject(sender) {
+	return {
+		stableId: sender.id,
+		aliases: {
+			discordUserName: sender.name,
+			discordUserTag: sender.tag
+		}
+	};
+}
+function createDiscordDynamicAccessGroupResolver(params) {
+	if (!params.cfg) return;
+	const cfg = params.cfg;
+	return async ({ name, group, accountId, subject }) => {
+		if (group.type !== "discord.channelAudience") return false;
+		const senderId = String(subject.stableId ?? "").trim();
+		if (!senderId) return false;
+		if ((group.membership ?? "canViewChannel") !== "canViewChannel") return false;
+		try {
+			return await canViewDiscordGuildChannel(group.guildId, group.channelId, senderId, {
+				cfg,
+				accountId,
+				token: params.token,
+				rest: params.rest
+			});
+		} catch (err) {
+			logVerbose(`discord: accessGroup:${name} lookup failed for user ${senderId}: ${String(err)}`);
+			throw err;
+		}
+	};
+}
+function createDiscordIngressResolver(params) {
+	return createChannelIngressResolver({
+		channelId: DISCORD_CHANNEL_ID,
+		accountId: params.accountId,
+		identity: discordIngressIdentity,
+		cfg: params.cfg,
+		resolveAccessGroupMembership: createDiscordDynamicAccessGroupResolver({
+			cfg: params.cfg,
+			token: params.token,
+			rest: params.rest
+		}),
+		...params.readStoreAllowFrom ? { readStoreAllowFrom: params.readStoreAllowFrom } : {},
+		...params.useDefaultPairingStore !== void 0 ? { useDefaultPairingStore: params.useDefaultPairingStore } : {}
+	});
+}
+function syntheticAccessGroupMembership(groupName, allowed) {
+	return allowed ? {
+		kind: "matched",
+		groupName,
+		source: "dynamic",
+		matchedEntryIds: [groupName]
+	} : {
+		kind: "not-matched",
+		groupName,
+		source: "dynamic"
+	};
+}
+async function resolveDiscordDmCommandAccess(params) {
+	return await createDiscordIngressResolver({
+		accountId: params.accountId,
+		cfg: params.cfg,
+		token: params.token,
+		rest: params.rest,
+		readStoreAllowFrom: params.readStoreAllowFrom,
+		useDefaultPairingStore: params.readStoreAllowFrom == null
+	}).message({
+		subject: createDiscordDmIngressSubject(params.sender),
+		conversation: {
+			kind: "direct",
+			id: params.sender.id
+		},
+		event: {
+			kind: params.eventKind ?? "native-command",
+			authMode: "inbound",
+			mayPair: true
+		},
+		dmPolicy: params.dmPolicy,
+		groupPolicy: "disabled",
+		policy: { mutableIdentifierMatching: params.allowNameMatching ? "enabled" : "disabled" },
+		allowFrom: params.configuredAllowFrom,
+		command: {
+			hasControlCommand: false,
+			modeWhenAccessGroupsOff: "configured"
+		}
+	});
+}
+async function resolveDiscordTextCommandAccess(params) {
+	const ownerAllowFrom = (params.ownerAllowFrom ?? []).filter((entry) => entry.trim() !== "*");
+	const memberAccessGroup = "discord-member-access";
+	const commandGroup = params.memberAccessConfigured ? [`accessGroup:${memberAccessGroup}`] : [];
+	const accessGroupMembership = params.memberAccessConfigured ? [syntheticAccessGroupMembership(memberAccessGroup, params.memberAllowed)] : [];
+	return (await createDiscordIngressResolver({
+		accountId: params.accountId,
+		cfg: params.cfg,
+		token: params.token,
+		rest: params.rest
+	}).command({
+		subject: createDiscordDmIngressSubject(params.sender),
+		conversation: {
+			kind: "group",
+			id: "discord-command"
+		},
+		accessGroupMembership,
+		dmPolicy: "allowlist",
+		groupPolicy: "allowlist",
+		policy: { mutableIdentifierMatching: params.allowNameMatching ? "enabled" : "disabled" },
+		allowFrom: ownerAllowFrom,
+		groupAllowFrom: commandGroup,
+		command: {
+			allowTextCommands: params.allowTextCommands,
+			hasControlCommand: params.hasControlCommand,
+			modeWhenAccessGroupsOff: "configured"
+		}
+	})).commandAccess;
+}
+//#endregion
+//#region extensions/discord/src/monitor/thread-title.ts
+const DEFAULT_THREAD_TITLE_TIMEOUT_MS = 1e4;
+const MAX_THREAD_TITLE_SOURCE_CHARS = 600;
+const MAX_THREAD_TITLE_CHANNEL_NAME_CHARS = 120;
+const MAX_THREAD_TITLE_CHANNEL_DESCRIPTION_CHARS = 320;
+const DISCORD_THREAD_TITLE_MAX_TOKENS = 512;
+const DISCORD_THREAD_TITLE_SYSTEM_PROMPT = "Generate a concise Discord thread title (3-6 words). Return only the title. Use channel context when provided and avoid redundant channel-name words unless needed for clarity.";
+async function generateThreadTitle(params) {
+	const sourceText = params.messageText.trim();
+	if (!sourceText) return null;
+	const prepared = await prepareSimpleCompletionModelForAgent({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		...params.modelRef ? { modelRef: params.modelRef } : {},
+		allowMissingApiKeyModes: ["aws-sdk"]
+	});
+	if ("error" in prepared) {
+		const modelLabel = prepared.selection ? `${prepared.selection.provider}/${prepared.selection.modelId}` : "unknown";
+		logVerbose(`thread-title: ${prepared.error} (agent=${params.agentId}, model=${modelLabel})`);
+		return null;
+	}
+	try {
+		const userMessage = buildThreadTitleUserMessage({
+			sourceText: truncateThreadTitleSourceText(sourceText),
+			channelName: params.channelName,
+			channelDescription: params.channelDescription
+		});
+		const timeoutMs = resolveThreadTitleTimeoutMs(params.timeoutMs);
+		return normalizeGeneratedThreadTitle(extractAssistantText(await completeThreadTitle({
+			model: prepared.model,
+			auth: prepared.auth,
+			userMessage,
+			timeoutMs
+		}))) || null;
+	} catch (err) {
+		logVerbose(`thread-title: title generation failed for agent ${params.agentId}: ${String(err)}`);
+		return null;
+	}
+}
+async function completeThreadTitle(params) {
+	return await withAbortTimeout({
+		timeoutMs: params.timeoutMs,
+		createTimeoutError: () => /* @__PURE__ */ new Error(`thread-title timed out after ${params.timeoutMs}ms`),
+		run: async (signal) => await completeWithPreparedSimpleCompletionModel({
+			model: params.model,
+			auth: params.auth,
+			context: {
+				systemPrompt: DISCORD_THREAD_TITLE_SYSTEM_PROMPT,
+				messages: [{
+					role: "user",
+					content: params.userMessage,
+					timestamp: Date.now()
+				}]
+			},
+			options: {
+				maxTokens: DISCORD_THREAD_TITLE_MAX_TOKENS,
+				signal
+			}
+		})
+	});
+}
+function buildThreadTitleUserMessage(params) {
+	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${params.sourceText}`);
+	return messageLines.join("\n\n");
+}
+function truncateThreadTitleSourceText(sourceText) {
+	if (sourceText.length <= MAX_THREAD_TITLE_SOURCE_CHARS) return sourceText;
+	return `${sourceText.slice(0, 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 = current.replace(/^\*\*(.+)\*\*$/u, "$1").trim();
+		current = current.replace(/^__(.+)__$/u, "$1").trim();
+		current = current.replace(/^\*(.+)\*$/u, "$1").trim();
+		current = current.replace(/^_(.+)_$/u, "$1").trim();
+		current = current.replace(/^~~(.+)~~$/u, "$1").trim();
+	}
+	return current;
+}
+function normalizeTitleContextField(raw, maxChars) {
+	const value = raw?.trim();
+	if (!value) return;
+	const singleLine = value.replace(/\s+/g, " ");
+	if (singleLine.length <= maxChars) return singleLine;
+	return `${singleLine.slice(0, 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;
+}
+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 {
+		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({
+	__resetDiscordThreadStarterCacheForTest: () => __resetDiscordThreadStarterCacheForTest,
+	maybeCreateDiscordAutoThread: () => maybeCreateDiscordAutoThread,
+	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;
@@ -694,6 +1310,35 @@ var DiscordThreadUpdateListener = class extends ThreadUpdateListener {
 	}
 };
 //#endregion
+//#region extensions/discord/src/monitor/dm-command-decision.ts
+async function handleDiscordDmCommandDecision(params) {
+	if (params.senderAccess.decision === "allow") return true;
+	if (params.senderAccess.decision === "pairing") {
+		const upsertPairingRequest = params.upsertPairingRequest ?? upsertChannelPairingRequest;
+		const result = await createChannelPairingChallengeIssuer({
+			channel: "discord",
+			upsertPairingRequest: async ({ id, meta }) => await upsertPairingRequest({
+				channel: "discord",
+				id,
+				accountId: params.accountId,
+				meta
+			})
+		})({
+			senderId: params.sender.id,
+			senderIdLine: `Your Discord user id: ${params.sender.id}`,
+			meta: {
+				tag: params.sender.tag,
+				name: params.sender.name
+			},
+			sendPairingReply: async () => {}
+		});
+		if (result.created && result.code) await params.onPairingCreated(result.code);
+		return false;
+	}
+	await params.onUnauthorized();
+	return false;
+}
+//#endregion
 //#region extensions/discord/src/monitor/native-command-reply.ts
 const DISCORD_EMPTY_VISIBLE_REPLY_WARNING = "⚠️ Command produced no visible reply.";
 function isDiscordUnknownInteraction(error) {
@@ -794,6 +1439,78 @@ async function deliverDiscordInteractionReply(params) {
 	}
 }
 //#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({
@@ -1205,6 +1922,12 @@ function buildDiscordNativeCommandContext(params) {
 		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({
@@ -3778,6 +4501,12 @@ 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";
@@ -5258,6 +5987,85 @@ function runDiscordCommandDeployInBackground(params) {
 	});
 }
 //#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 { ownerAllowList, ownerAllowed } = resolveDiscordOwnerAccess({
+		allowFrom: params.ownerAllowFrom ?? params.discordConfig.allowFrom ?? params.discordConfig.dm?.allowFrom,
+		sender: params.sender,
+		allowNameMatching: false
+	});
+	const useAccessGroups = params.useAccessGroups ?? params.cfg.commands?.useAccessGroups !== false;
+	return resolveCommandAuthorizedFromAuthorizers({
+		useAccessGroups,
+		authorizers: useAccessGroups ? [{
+			configured: ownerAllowList != null,
+			allowed: ownerAllowed
+		}, {
+			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/command.ts
 const VOICE_CHANNEL_TYPES = [ChannelType.GuildVoice, ChannelType.GuildStageVoice];
 async function authorizeVoiceCommand(interaction, params, options) {
@@ -6054,15 +6862,195 @@ function resolveDiscordInteractionId(interaction) {
 const AGENT_BUTTON_KEY = "agent";
 const AGENT_SELECT_KEY = "agentsel";
 //#endregion
+//#region extensions/discord/src/monitor/reply-context.ts
+function resolveReplyContext(message, resolveDiscordMessageText) {
+	const referenced = message.referencedMessage;
+	if (!referenced?.author) return null;
+	const referencedText = resolveDiscordMessageText(referenced, { includeForwarded: true });
+	if (!referencedText) return null;
+	const sender = resolveDiscordSenderIdentity({
+		author: referenced.author,
+		pluralkitInfo: null
+	});
+	return {
+		id: referenced.id,
+		channelId: referenced.channelId,
+		sender: sender.tag ?? sender.label ?? "unknown",
+		senderId: referenced.author.id,
+		senderName: referenced.author.username ?? void 0,
+		senderTag: sender.tag ?? void 0,
+		memberRoleIds: (() => {
+			const roles = referenced.member?.roles;
+			return Array.isArray(roles) ? roles.map((roleId) => roleId) : void 0;
+		})(),
+		body: referencedText,
+		timestamp: resolveTimestampMs(referenced.timestamp)
+	};
+}
+function buildDirectLabel(author, tagOverride) {
+	return `${(tagOverride?.trim() || resolveDiscordSenderIdentity({
+		author,
+		pluralkitInfo: null
+	}).tag) ?? "unknown"} user id:${author.id}`;
+}
+function buildGuildLabel(params) {
+	const { guild, channelName, channelId } = params;
+	return `${guild?.name ?? "Guild"} #${channelName} channel id:${channelId}`;
+}
+//#endregion
+//#region extensions/discord/src/monitor/reply-safety.ts
+const DISCORD_INTERNAL_TRACE_LINE_RE = /^(?:>\s*)?(?:📊|🛠️|📖|📝|🔍|🔎|⚙️)\s*(?:Session Status|Exec|Read|Edit|Write|Patch|Search|Open|Click|Find|Screenshot|Update Plan|Tool Call|Tool Result|Function Call|Shell|Command)\s*:/i;
+const DISCORD_INTERNAL_COMPACT_COMMAND_TRACE_LINE_RE = /^(?:>\s*)?🛠️\s*(?:(?:(?:elevated|pty)\b\s*(?:·|,)\s*)+)?(?:`{1,2}\s*\S|(?:run|check|fetch|pull|push|view|show|list|switch|create|merge|rebase|stage|restore|reset|stash|search|find|print|copy|move|remove|install|start|cd|git|pnpm|npm|yarn|bun|node|python|python3|bash|sh)\b)/i;
+const DISCORD_INTERNAL_CHANNEL_LINE_RE = /^(?:>\s*)?(?:analysis|commentary|tool[-_ ]?call|tool[-_ ]?result|function[-_ ]?call|thinking|reasoning)\s*[:=]/i;
+function hasNonEmptyRecord(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0);
+}
+function hasInteractiveOrPresentationBlocks(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const record = value;
+	if (typeof record.title === "string" && record.title.trim().length > 0) return true;
+	return Array.isArray(record.blocks) && record.blocks.length > 0;
+}
+function hasNonTextReplyPayloadContent(payload) {
+	return payload.audioAsVoice === true || hasNonEmptyRecord(payload.channelData) || hasInteractiveOrPresentationBlocks(payload.interactive) || hasInteractiveOrPresentationBlocks(payload.presentation);
+}
+function stripDiscordInternalTraceLines(text) {
+	let inFence = false;
+	const kept = [];
+	for (const line of text.split(/\r?\n/)) {
+		if (/^\s*```/.test(line)) {
+			inFence = !inFence;
+			kept.push(line);
+			continue;
+		}
+		if (!inFence) {
+			const trimmed = line.trim();
+			if (DISCORD_INTERNAL_TRACE_LINE_RE.test(trimmed) || DISCORD_INTERNAL_COMPACT_COMMAND_TRACE_LINE_RE.test(trimmed) || DISCORD_INTERNAL_CHANNEL_LINE_RE.test(trimmed)) continue;
+		}
+		kept.push(line);
+	}
+	return kept.join("\n");
+}
+function collapseExcessBlankLines(text) {
+	return text.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n");
+}
+function sanitizeDiscordFrontChannelText(text) {
+	return collapseExcessBlankLines(stripDiscordInternalTraceLines(sanitizeAssistantVisibleText(text))).trim();
+}
+function sanitizeDiscordFrontChannelReplyPayloads(payloads) {
+	const safePayloads = [];
+	for (const payload of payloads) {
+		const safeText = typeof payload.text === "string" ? sanitizeDiscordFrontChannelText(payload.text) : payload.text;
+		const nextPayload = safeText === payload.text ? payload : {
+			...payload,
+			text: safeText || void 0
+		};
+		if (!resolveSendableOutboundReplyParts(nextPayload).hasContent && !hasNonTextReplyPayloadContent(nextPayload)) continue;
+		safePayloads.push(nextPayload);
+	}
+	return safePayloads;
+}
+//#endregion
+//#region extensions/discord/src/monitor/reply-delivery.ts
+function resolveTargetChannelId(target) {
+	if (!target.startsWith("channel:")) return;
+	return target.slice(8).trim() || void 0;
+}
+function resolveBoundThreadBinding(params) {
+	const sessionKey = params.sessionKey?.trim();
+	if (!params.threadBindings || !sessionKey) return;
+	const targetChannelId = resolveTargetChannelId(params.target);
+	if (!targetChannelId) return;
+	return params.threadBindings.listBySessionKey(sessionKey).find((entry) => entry.threadId === targetChannelId);
+}
+function resolveBindingIdentity(cfg, binding) {
+	if (!binding) return;
+	const identity = { name: (`🤖 ${binding.label?.trim() || binding.agentId}`.trim() || "🤖 agent").slice(0, 80) };
+	try {
+		const avatar = resolveAgentAvatar(cfg, binding.agentId);
+		if (avatar.kind === "remote") identity.avatarUrl = avatar.url;
+	} catch {}
+	return identity;
+}
+function createDiscordDeliveryDeps(params) {
+	return {
+		discord: (to, text, opts) => sendMessageDiscord(to, text, {
+			...opts,
+			cfg: opts?.cfg ?? params.cfg,
+			token: params.token,
+			rest: params.rest
+		}),
+		discordVoice: (to, audioPath, opts) => sendVoiceMessageDiscord(to, audioPath, {
+			...opts,
+			cfg: opts?.cfg ?? params.cfg,
+			token: params.token,
+			rest: params.rest
+		})
+	};
+}
+function resolveDiscordDeliveryOptions(params) {
+	const binding = resolveBoundThreadBinding({
+		threadBindings: params.threadBindings,
+		sessionKey: params.sessionKey,
+		target: params.target
+	});
+	return {
+		to: binding ? `channel:${binding.channelId}` : params.target,
+		threadId: binding?.threadId,
+		agentId: binding?.agentId,
+		identity: resolveBindingIdentity(params.cfg, binding),
+		mediaAccess: params.mediaLocalRoots?.length ? { localRoots: params.mediaLocalRoots } : void 0,
+		replyToMode: params.replyToMode ?? "all",
+		formatting: {
+			textLimit: params.textLimit,
+			maxLinesPerMessage: params.maxLinesPerMessage,
+			tableMode: params.tableMode,
+			chunkMode: params.chunkMode
+		}
+	};
+}
+async function deliverDiscordReply(params) {
+	params.runtime;
+	const delivery = resolveDiscordDeliveryOptions(params);
+	const payloads = sanitizeDiscordFrontChannelReplyPayloads(params.replies);
+	if (payloads.length === 0) return;
+	const send = await sendDurableMessageBatch({
+		cfg: params.cfg,
+		channel: "discord",
+		to: delivery.to,
+		accountId: params.accountId,
+		payloads,
+		replyToId: normalizeOptionalString(params.replyToId),
+		replyToMode: delivery.replyToMode,
+		formatting: delivery.formatting,
+		threadId: delivery.threadId,
+		identity: delivery.identity,
+		deps: createDiscordDeliveryDeps({
+			cfg: params.cfg,
+			token: params.token,
+			rest: params.rest
+		}),
+		mediaAccess: delivery.mediaAccess,
+		session: buildOutboundSessionContext({
+			cfg: params.cfg,
+			sessionKey: params.sessionKey,
+			agentId: delivery.agentId,
+			requesterAccountId: params.accountId
+		})
+	});
+	if (send.status === "failed" || send.status === "partial_failed") throw send.error;
+	if ((send.status === "sent" ? send.results : []).length === 0) throw new Error(`discord final reply produced no delivered message for ${delivery.to}`);
+}
+//#endregion
 //#region extensions/discord/src/monitor/agent-components.dispatch.ts
 let conversationRuntimePromise$1;
 let typingRuntimePromise;
 async function loadConversationRuntime$1() {
-	conversationRuntimePromise$1 ??= import("./agent-components.runtime-zT8qPsnM.js");
+	conversationRuntimePromise$1 ??= import("./agent-components.runtime-CEMbMQcQ.js");
 	return await conversationRuntimePromise$1;
 }
 async function loadTypingRuntime() {
-	typingRuntimePromise ??= import("./typing-_jePdFIw.js").then((n) => n.n);
+	typingRuntimePromise ??= import("./typing-C_8U8J7E.js").then((n) => n.n);
 	return await typingRuntimePromise;
 }
 function buildDiscordComponentConversationLabel(params) {
@@ -6200,6 +7188,12 @@ async function dispatchDiscordComponentEvent(params) {
 		Surface: "discord",
 		WasMentioned: true,
 		CommandAuthorized: commandAuthorized,
+		CommandTurn: {
+			kind: "text-slash",
+			source: "text",
+			authorized: commandAuthorized,
+			body: eventText
+		},
 		CommandSource: "text",
 		MessageSid: interaction.rawData.id,
 		Timestamp: timestamp,
@@ -6349,7 +7343,7 @@ async function dispatchDiscordPluginInteractiveHandler(params) {
 //#region extensions/discord/src/monitor/agent-components.plugin-interactive.ts
 let conversationRuntimePromise;
 async function loadConversationRuntime() {
-	conversationRuntimePromise ??= import("./agent-components.runtime-zT8qPsnM.js");
+	conversationRuntimePromise ??= import("./agent-components.runtime-CEMbMQcQ.js");
 	return await conversationRuntimePromise;
 }
 async function dispatchPluginDiscordInteractiveEvent(params) {
@@ -6475,7 +7469,7 @@ async function dispatchPluginDiscordInteractiveEvent(params) {
 //#region extensions/discord/src/monitor/agent-components.handlers.ts
 let componentsRuntimePromise;
 async function loadComponentsRuntime() {
-	componentsRuntimePromise ??= import("./components-Dxq2mU57.js").then((n) => n.t);
+	componentsRuntimePromise ??= import("./components-Cgm7XT8-.js").then((n) => n.t);
 	return await componentsRuntimePromise;
 }
 async function handleDiscordComponentEvent(params) {
@@ -7982,7 +8976,7 @@ function logDiscordStartupPhase(params) {
 	});
 }
 async function loadDiscordVoiceRuntime() {
-	const promise = discordVoiceRuntimePromise ?? import("./manager.runtime-DqMGETqp.js");
+	const promise = discordVoiceRuntimePromise ?? import("./manager.runtime-DauS2xA3.js");
 	discordVoiceRuntimePromise = promise;
 	try {
 		return await promise;
@@ -7992,7 +8986,7 @@ async function loadDiscordVoiceRuntime() {
 	}
 }
 async function loadDiscordProviderSessionRuntime() {
-	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-BZyP90-i.js");
+	const promise = discordProviderSessionRuntimePromise ?? import("./provider-session.runtime-DMxaLPB3.js");
 	discordProviderSessionRuntimePromise = promise;
 	try {
 		return await promise;
@@ -8362,4 +9356,4 @@ async function monitorDiscordProvider(opts = {}) {
 	}
 }
 //#endregion
-export { createDiscordNativeCommand as a, waitForDiscordGatewayPluginRegistration as i, createDiscordGatewayPlugin as n, registerDiscordListener as o, resolveDiscordGatewayIntents as r, monitorDiscordProvider as t };
+export { resolveDiscordDmCommandAccess as C, sanitizeDiscordThreadName as S, registerDiscordListener as _, resolveReplyContext as a, resolveDiscordReplyTarget as b, resolveDiscordGatewayIntents as c, createDiscordNativeCommand as d, buildDiscordRoutePeer as f, handleDiscordDmCommandDecision as g, shouldIgnoreStaleDiscordRouteBinding as h, buildGuildLabel as i, waitForDiscordGatewayPluginRegistration as l, resolveDiscordEffectiveRoute as m, deliverDiscordReply as n, authorizeDiscordVoiceIngress as o, resolveDiscordConversationRoute as p, buildDirectLabel as r, createDiscordGatewayPlugin as s, monitorDiscordProvider as t, resolveDiscordVoiceEnabled as u, threading_exports as v, resolveDiscordTextCommandAccess as w, resolveDiscordThreadStarter as x, resolveDiscordAutoThreadReplyPlan as y };