@openclaw/discord 2026.8.1-beta.2 → 2026.8.1

package/dist/{voice-runtime-BEdqNcST.js → voice-runtime-DY6_o73o.js}

@@ -1,19 +1,20 @@
-import { C as ReadyListener, D as VoiceStateUpdateListener, N as isUnknownDiscordVoiceStateError, Wt as getGuildVoiceState, h as discord_exports, p as parseDiscordTarget, w as ResumedListener } from "./retry-CLpJcXXf.js";
+import { D as ReadyListener, L as isUnknownDiscordVoiceStateError, O as ResumedListener, Yt as getGuildVoiceState, _ as parseDiscordTarget, j as VoiceStateUpdateListener, y as discord_exports } from "./retry-DqHCW6PV.js";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
-import { a as normalizeDiscordSlug, h as resolveDiscordOwnerAccess, x as formatDiscordUserTag } from "./allow-list-DnxIlPP2.js";
-import { a as formatMention } from "./send.outbound-DS5tHwfR.js";
-import { g as buildDiscordGroupSystemPrompt, l as resolveDiscordVoiceAccess, m as resolveDiscordVoiceEnabled, u as authorizeDiscordVoiceIngress } from "./provider-DvSNb-2v.js";
-import { S as formatVoiceLogPreview, _ as decodeOpusStream, a as SPEAKING_READY_TIMEOUT_MS, b as formatVoiceIngressPrompt, c as isDiscordRealtimeVoiceMode, d as resolveDiscordVoiceMode, f as resolveVoiceTimeoutMs, g as createDiscordOpusPlaybackStream, i as PLAYBACK_READY_TIMEOUT_MS, l as isVoiceChannel, n as CAPTURE_FINALIZE_GRACE_MS, o as VOICE_CONNECT_READY_TIMEOUT_MS, s as VOICE_RECONNECT_GRACE_MS, t as loadDiscordVoiceSdk, u as logVoiceVerbose, v as decodeOpusStreamChunks, x as maybeControlDiscordVoiceAgentRun, y as writeVoiceWavFile } from "./sdk-runtime-QpY8PvCh.js";
-import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { a as normalizeDiscordSlug, h as resolveDiscordOwnerAccess, x as formatDiscordUserTag } from "./allow-list-BDMimASD.js";
+import { a as formatMention } from "./send.outbound-D7JYmfm9.js";
+import { n as resolveDiscordVoiceEnabled, r as authorizeDiscordVoiceIngress, t as resolveDiscordVoiceAccess } from "./owner-access-UlYi9t0M.js";
+import { b as resolveFetchedDiscordThreadLikeChannelContext, m as buildDiscordGroupSystemPrompt } from "./provider-LXiOcJrH.js";
+import { _ as decodeOpusStreamChunks, a as VOICE_CONNECT_READY_TIMEOUT_MS, b as maybeControlDiscordVoiceAgentRun, c as isVoiceChannel, d as resolveVoiceTimeoutMs, g as decodeOpusStream, h as createDiscordOpusPlaybackStream, i as PLAYBACK_READY_TIMEOUT_MS, l as logVoiceVerbose, n as CAPTURE_FINALIZE_GRACE_MS, o as VOICE_RECONNECT_GRACE_MS, s as isDiscordRealtimeVoiceMode, t as loadDiscordVoiceSdk, u as resolveDiscordVoiceMode, v as writeVoiceWavFile, x as formatVoiceLogPreview, y as formatVoiceIngressPrompt } from "./sdk-runtime-6tfgYDjY.js";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/ssrf-runtime";
+import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
 import { escapeRegExp, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { stripInlineDirectiveTagsForDisplay } from "openclaw/plugin-sdk/text-chunking";
-import path from "node:path";
-import { agentCommandFromIngress, resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
+import { unlinkIfExists } from "openclaw/plugin-sdk/media-runtime";
+import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
 import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
 import { Readable } from "node:stream";
 import { OpusError } from "libopus-wasm";
@@ -82,12 +83,13 @@ async function runDiscordVoiceAgentTurn(params) {
 	});
 	if (!context) return null;
 	const voiceModel = normalizeOptionalString(params.discordConfig.voice?.model);
-	const payloads = (await agentCommandFromIngress({
+	const payloads = (await getDiscordRuntime().agent.runCommandFromIngress({
 		message: params.message,
 		sessionKey: params.entry.route.sessionKey,
 		agentId: params.entry.route.agentId,
 		messageChannel: "discord",
 		messageProvider: DISCORD_VOICE_MESSAGE_PROVIDER,
+		accountId: params.accountId,
 		extraSystemPrompt: context.extraSystemPrompt,
 		senderIsOwner: context.senderIsOwner,
 		allowModelOverride: Boolean(voiceModel),
@@ -193,7 +195,7 @@ function countDiscordVoiceHumanParticipants(params) {
 		const userId = state.user_id?.trim();
 		if (!userId || userId === params.botUserId || knownUserIds.has(userId)) continue;
 		knownUserIds.add(userId);
-		if (state.member?.user?.bot !== true) count += 1;
+		if (state.member?.user && state.member.user.bot !== true) count += 1;
 	}
 	for (const rawUserId of params.additionalUserIds ?? []) {
 		const userId = rawUserId.trim();
@@ -654,7 +656,8 @@ function normalizeVoiceChannelResidencies(entries) {
 		const channelId = entry.channelId?.trim();
 		if (guildId && channelId) normalized.push({
 			guildId,
-			channelId
+			channelId,
+			...entry.whenOccupied === true ? { whenOccupied: true } : {}
 		});
 	}
 	return normalized;
@@ -1017,6 +1020,7 @@ var DiscordVoiceFollowing = class {
 	}
 	resolveVoiceResidencyTarget(guildId) {
 		const autoJoinTarget = this.params.autoJoinChannels.toReversed().find((entry) => entry.guildId === guildId);
+		if (autoJoinTarget?.whenOccupied) return null;
 		if (autoJoinTarget && this.params.isAllowedVoiceChannel(autoJoinTarget)) return autoJoinTarget;
 		if (this.params.allowedChannels === null) return null;
 		const guildAllowed = this.params.allowedChannels.filter((entry) => entry.guildId === guildId);
@@ -1142,6 +1146,7 @@ async function synthesizeVoiceReplyAudio(params) {
 		release: streamResult.release,
 		speakText
 	};
+	const streamFailure = streamResult && !streamResult.success ? streamResult.attempts?.findLast((attempt) => attempt.outcome === "failed") : void 0;
 	const result = await runtime.tts.textToSpeech({
 		text: speakText,
 		cfg: prepared.cfg,
@@ -1156,7 +1161,11 @@ async function synthesizeVoiceReplyAudio(params) {
 		status: "ok",
 		mode: "file",
 		audioPath: result.audioPath,
-		speakText
+		speakText,
+		...streamFailure ? { streamFailure: {
+			provider: streamFailure.provider,
+			reasonCode: streamFailure.reasonCode
+		} } : {}
 	};
 }
 //#endregion
@@ -1190,6 +1199,7 @@ async function processDiscordVoiceSegment(params) {
 	logVoiceVerbose(`transcription ok (${transcript.length} chars): guild ${entry.guildId} channel ${entry.channelId}`);
 	logVoiceVerbose(`transcript from ${ingress.speakerLabel} (${userId}) in guild ${entry.guildId} channel ${entry.channelId}: ${formatVoiceLogPreview(transcript)}`);
 	if (params.transcripts) {
+		if (entry.sessionLifecycle.status === "stopped" || entry.transcripts !== params.transcripts) return;
 		await params.transcripts.onUtterance({
 			sessionId: params.transcripts.sessionId,
 			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1219,10 +1229,12 @@ async function processDiscordVoiceSegment(params) {
 		logger$4.info(`discord voice: active-run control handled mode=${control.result.mode} ok=${control.result.ok} active=${control.result.active} reason=${control.result.reason ?? "none"} session=${entry.route.sessionKey}`);
 		replyText = control.speakText ?? "";
 	} else {
+		const prompt = formatVoiceIngressPrompt(transcript, ingress.speakerLabel);
 		const turn = await runDiscordVoiceAgentTurn({
 			entry,
+			accountId: params.accountId,
 			userId,
-			message: formatVoiceIngressPrompt(transcript, ingress.speakerLabel),
+			message: prompt,
 			cfg: params.cfg,
 			discordConfig: params.discordConfig,
 			runtime: params.runtime,
@@ -1256,26 +1268,38 @@ async function processDiscordVoiceSegment(params) {
 		logger$4.warn(`discord voice: TTS failed: ${voiceReplyAudio.error ?? "unknown error"}`);
 		return;
 	}
+	const streamFailure = voiceReplyAudio.mode === "file" ? voiceReplyAudio.streamFailure : void 0;
+	if (streamFailure && !entry.ttsStreamFallbackWarned) {
+		entry.ttsStreamFallbackWarned = true;
+		logger$4.warn(`discord voice: streaming TTS failed provider=${streamFailure.provider} reasonCode=${streamFailure.reasonCode}; using file fallback`);
+	}
 	logVoiceVerbose(`tts ok (${voiceReplyAudio.speakText.length} chars): guild ${entry.guildId} channel ${entry.channelId}`);
+	const releaseAudio = voiceReplyAudio.mode === "stream" ? voiceReplyAudio.release : () => unlinkIfExists(voiceReplyAudio.audioPath);
+	if (entry.sessionLifecycle.status === "stopped") {
+		await releaseAudio?.();
+		return;
+	}
 	params.enqueuePlayback(entry, async () => {
 		const voiceSdk = loadDiscordVoiceSdk();
-		const releaseAudioStream = voiceReplyAudio.mode === "stream" ? voiceReplyAudio.release : void 0;
+		const playbackLifecycle = new AbortController();
+		let playbackStarted = false;
+		const cancelStoppedPlayback = () => (!playbackStarted || entry.sessionLifecycle.status === "stopped") && playbackLifecycle.abort();
 		try {
-			if (voiceReplyAudio.mode === "stream") {
-				logVoiceVerbose(`playback start: guild ${entry.guildId} channel ${entry.channelId} stream`);
-				const nodeStream = Readable.fromWeb(voiceReplyAudio.audioStream);
-				const resource = voiceSdk.createAudioResource(createDiscordOpusPlaybackStream(nodeStream), { inputType: voiceSdk.StreamType.Opus });
-				entry.player.play(resource);
-			} else {
-				logVoiceVerbose(`playback start: guild ${entry.guildId} channel ${entry.channelId} file ${path.basename(voiceReplyAudio.audioPath)}`);
-				const resource = voiceSdk.createAudioResource(createDiscordOpusPlaybackStream(voiceReplyAudio.audioPath), { inputType: voiceSdk.StreamType.Opus });
-				entry.player.play(resource);
-			}
-			await voiceSdk.entersState(entry.player, voiceSdk.AudioPlayerStatus.Playing, PLAYBACK_READY_TIMEOUT_MS).catch(() => void 0);
-			await voiceSdk.entersState(entry.player, voiceSdk.AudioPlayerStatus.Idle, SPEAKING_READY_TIMEOUT_MS).catch(() => void 0);
+			if (entry.sessionLifecycle.status === "stopped") return;
+			entry.player.on(voiceSdk.AudioPlayerStatus.Idle, cancelStoppedPlayback);
+			const input = voiceReplyAudio.mode === "stream" ? Readable.fromWeb(voiceReplyAudio.audioStream) : voiceReplyAudio.audioPath;
+			logVoiceVerbose(`playback start: guild ${entry.guildId} channel ${entry.channelId} ${voiceReplyAudio.mode}`);
+			const resource = voiceSdk.createAudioResource(createDiscordOpusPlaybackStream(input), { inputType: voiceSdk.StreamType.Opus });
+			entry.player.play(resource);
+			await voiceSdk.entersState(entry.player, voiceSdk.AudioPlayerStatus.Playing, AbortSignal.any([AbortSignal.timeout(PLAYBACK_READY_TIMEOUT_MS), playbackLifecycle.signal]));
+			playbackStarted = true;
+			await voiceSdk.entersState(entry.player, voiceSdk.AudioPlayerStatus.Idle, playbackLifecycle.signal);
 			logVoiceVerbose(`playback done: guild ${entry.guildId} channel ${entry.channelId}`);
+		} catch (error) {
+			if (entry.sessionLifecycle.status !== "stopped") throw error;
 		} finally {
-			await releaseAudioStream?.();
+			entry.player.off(voiceSdk.AudioPlayerStatus.Idle, cancelStoppedPlayback);
+			await releaseAudio?.();
 		}
 	});
 }
@@ -1320,6 +1344,7 @@ var DiscordVoiceReceive = class {
 		}
 		logVoiceVerbose(`capture start: guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
 		const voiceSdk = loadDiscordVoiceSdk();
+		const transcripts = entry.transcripts;
 		const voiceMode = resolveDiscordVoiceMode(this.params.discordConfig.voice);
 		const realtime = entry.realtimeLifecycle.status === "active" && isDiscordRealtimeVoiceMode(voiceMode) ? entry.realtimeLifecycle.instance : void 0;
 		if (entry.player.state.status === voiceSdk.AudioPlayerStatus.Playing && !realtime) {
@@ -1397,6 +1422,7 @@ var DiscordVoiceReceive = class {
 			logVoiceVerbose(`capture ready (${durationSeconds.toFixed(2)}s): guild ${entry.guildId} channel ${entry.channelId} user ${userId}`);
 			entry.processingQueue = entry.processingQueue.then(async () => {
 				if (!this.params.isEntryCurrent(entry)) return;
+				if (entry.transcripts !== transcripts) return;
 				await this.processSegment({
 					entry,
 					wavPath,
@@ -1415,6 +1441,7 @@ var DiscordVoiceReceive = class {
 	async processSegment(params) {
 		await processDiscordVoiceSegment({
 			...params,
+			accountId: this.params.accountId,
 			cfg: this.params.cfg,
 			discordConfig: this.params.discordConfig,
 			admissionAllowFrom: this.params.admissionAllowFrom,
@@ -1515,6 +1542,7 @@ var DiscordVoiceReceive = class {
 		logger$3.info(`discord voice: agent turn start guild=${entry.guildId} channel=${entry.channelId} voiceSession=${entry.voiceSessionKey} supervisorSession=${entry.route.sessionKey} agent=${entry.route.agentId} user=${userId} speaker=${context.speakerLabel} owner=${context.senderIsOwner} model=${this.params.discordConfig.voice?.model ?? "route-default"} message=${formatVoiceLogPreview(message)}`);
 		const turn = await runDiscordVoiceAgentTurn({
 			entry,
+			accountId: this.params.accountId,
 			userId,
 			message,
 			cfg: this.params.cfg,
@@ -1574,16 +1602,31 @@ var DiscordVoiceReceive = class {
 		const result = await this.params.join({
 			guildId: entry.guildId,
 			channelId: entry.channelId
-		}, { preserveFollowState });
+		}, {
+			preserveFollowState,
+			autoJoinWhenOccupied: entry.autoJoinWhenOccupied
+		});
 		if (!result.ok) logger$3.warn(`discord voice: rejoin after decrypt failures failed: ${result.message}`);
 	}
 };
 //#endregion
 //#region extensions/discord/src/voice/voice-session.ts
 const logger$2 = createSubsystemLogger("discord/voice");
+const REALTIME_PLAYBACK_MAX_MISSED_FRAMES = 100;
 function isVoiceSessionStopped(entry) {
 	return entry.sessionLifecycle.status === "stopped";
 }
+function retireTranscripts(entry) {
+	const transcripts = entry.transcripts;
+	entry.transcripts = void 0;
+	try {
+		Promise.resolve(transcripts?.onStop?.()).catch((error) => {
+			logger$2.warn(`discord voice: transcripts retirement failed: ${formatErrorMessage(error)}`);
+		});
+	} catch (error) {
+		logger$2.warn(`discord voice: transcripts retirement failed: ${formatErrorMessage(error)}`);
+	}
+}
 function isVoiceConnectionDestroyed(connection, voiceSdk) {
 	return connection.state.status === voiceSdk.VoiceConnectionStatus.Destroyed;
 }
@@ -1660,10 +1703,20 @@ var DiscordVoiceSessions = class {
 		const { guildId, channelId } = params;
 		const voiceConfig = this.params.discordConfig.voice;
 		const voiceMode = resolveDiscordVoiceMode(voiceConfig);
+		const cancelledJoinResult = () => ({
+			ok: false,
+			message: "Discord voice join was cancelled.",
+			guildId,
+			channelId
+		});
 		const existing = this.params.sessions.get(guildId);
 		if (existing && existing.channelId === channelId) {
+			existing.autoJoinWhenOccupied = options?.autoJoinWhenOccupied === true;
 			if (authority) existing.generation = authority.generation;
-			if (options?.transcripts) existing.transcripts = options.transcripts;
+			if (options?.transcripts) {
+				retireTranscripts(existing);
+				existing.transcripts = options.transcripts;
+			}
 			if (!options?.transcripts && isDiscordRealtimeVoiceMode(voiceMode) && existing.realtimeLifecycle.status !== "active" && existing.realtimeLifecycle.status !== "starting") {
 				const realtimeResult = await this.attachRealtimeSession(existing, voiceMode, {
 					requireLiveEntry: true,
@@ -1688,14 +1741,20 @@ var DiscordVoiceSessions = class {
 			logVoiceVerbose(`join: replacing existing session for guild ${guildId}`);
 			await this.leave({ guildId }, { preserveFollowState: options?.preserveFollowState });
 		}
-		const channelInfo = await this.params.client.fetchChannel(channelId).catch(() => null);
-		if (authority && !authority.isCurrent()) return {
-			ok: false,
-			message: "Discord voice join was cancelled.",
-			guildId,
-			channelId
-		};
-		if (!channelInfo || "type" in channelInfo && !isVoiceChannel(channelInfo.type)) return {
+		let channelInfo;
+		try {
+			channelInfo = await this.params.client.fetchChannel(channelId);
+		} catch (err) {
+			if (authority && !authority.isCurrent()) return cancelledJoinResult();
+			return {
+				ok: false,
+				message: `Failed to resolve Discord channel ${channelId}: ${formatErrorMessage(err)}`,
+				guildId,
+				channelId
+			};
+		}
+		if (authority && !authority.isCurrent()) return cancelledJoinResult();
+		if (!isVoiceChannel(channelInfo.type)) return {
 			ok: false,
 			message: `Channel ${channelId} is not a voice channel.`
 		};
@@ -1717,10 +1776,7 @@ var DiscordVoiceSessions = class {
 		logVoiceVerbose(`join: DAVE settings encryption=${daveEncryption === false ? "off" : "on"} tolerance=${decryptionFailureTolerance ?? "default"} connectTimeout=${connectReadyTimeoutMs}ms reconnectGrace=${reconnectGraceMs}ms`);
 		const voiceSdk = loadDiscordVoiceSdk();
 		const existingEntry = this.params.sessions.get(guildId);
-		if (existingEntry) {
-			existingEntry.stop();
-			this.params.sessions.delete(guildId);
-		}
+		if (existingEntry) existingEntry.stop();
 		const voiceConnectionGroup = resolveVoiceConnectionGroup(this.params.accountId);
 		const staleConnection = voiceSdk.getVoiceConnection(guildId, voiceConnectionGroup);
 		if (staleConnection) destroyVoiceConnectionSafely({
@@ -1774,12 +1830,7 @@ var DiscordVoiceSessions = class {
 				voiceSdk,
 				reason: `cancelled join guild ${guildId} channel ${channelId}`
 			});
-			return {
-				ok: false,
-				message: "Discord voice join was cancelled.",
-				guildId,
-				channelId
-			};
+			return cancelledJoinResult();
 		}
 		if (this.params.destroyed()) {
 			destroyVoiceConnectionSafely({
@@ -1820,24 +1871,23 @@ var DiscordVoiceSessions = class {
 		}
 		const { route, voiceRoute, agentSessionMode, agentSessionTarget } = routeInfo;
 		logger$2.info(`discord voice: joining guild=${guildId} channel=${channelId} mode=${voiceMode} agent=${route.agentId} voiceSession=${voiceRoute.sessionKey} supervisorSession=${route.sessionKey} agentSessionMode=${agentSessionMode}${agentSessionTarget ? ` agentSessionTarget=${agentSessionTarget}` : ""} voiceModel=${voiceConfig?.model ?? "route-default"} realtimeProvider=${voiceConfig?.realtime?.provider ?? "auto"} realtimeModel=${voiceConfig?.realtime?.model ?? "provider-default"} realtimeVoice=${voiceConfig?.realtime?.speakerVoice ?? voiceConfig?.realtime?.speakerVoiceId ?? "provider-default"}`);
-		const player = voiceSdk.createAudioPlayer();
+		const player = isDiscordRealtimeVoiceMode(voiceMode) ? voiceSdk.createAudioPlayer({ behaviors: { maxMissedFrames: REALTIME_PLAYBACK_MAX_MISSED_FRAMES } }) : voiceSdk.createAudioPlayer();
 		connection.subscribe(player);
-		const clearSessionIfCurrent = () => {
-			if (this.params.sessions.get(guildId)?.connection === connection) this.params.sessions.delete(guildId);
-		};
-		const stopEntry = (entry, optionsLocal) => {
+		const stopEntry = (optionsLocal) => {
 			if (entry.sessionLifecycle.status === "stopped") return;
 			entry.sessionLifecycle = {
 				status: "stopped",
 				reason: optionsLocal.reason
 			};
+			retireTranscripts(entry);
+			if (this.params.sessions.get(guildId) === entry) this.params.sessions.delete(guildId);
 			this.params.membership.deactivate(entry);
-			if (speakingHandler) connection.receiver.speaking.off("start", speakingHandler);
-			if (speakingEndHandler) connection.receiver.speaking.off("end", speakingEndHandler);
+			connection.receiver.speaking.off("start", speakingHandler);
+			connection.receiver.speaking.off("end", speakingEndHandler);
 			stopVoiceCaptureState(entry.capture);
-			if (disconnectedHandler) connection.off(voiceSdk.VoiceConnectionStatus.Disconnected, disconnectedHandler);
-			if (destroyedHandler) connection.off(voiceSdk.VoiceConnectionStatus.Destroyed, destroyedHandler);
-			if (playerErrorHandler) player.off("error", playerErrorHandler);
+			connection.off(voiceSdk.VoiceConnectionStatus.Disconnected, disconnectedHandler);
+			connection.off(voiceSdk.VoiceConnectionStatus.Destroyed, destroyedHandler);
+			player.off("error", playerErrorHandler);
 			const realtimeLifecycle = entry.realtimeLifecycle;
 			if (realtimeLifecycle.status === "starting" || realtimeLifecycle.status === "active") realtimeLifecycle.instance.close();
 			entry.realtimeLifecycle = {
@@ -1845,7 +1895,7 @@ var DiscordVoiceSessions = class {
 				generation: realtimeLifecycle.generation,
 				reason: optionsLocal.reason
 			};
-			player.stop();
+			player.stop(true);
 			if (optionsLocal.destroyConnection) destroyVoiceConnectionSafely({
 				connection,
 				voiceSdk,
@@ -1855,6 +1905,7 @@ var DiscordVoiceSessions = class {
 		};
 		const entry = {
 			generation: authority?.generation ?? 0,
+			autoJoinWhenOccupied: options?.autoJoinWhenOccupied === true,
 			sessionLifecycle: { status: "active" },
 			guildId,
 			guildName: channelInfo && "guild" in channelInfo && channelInfo.guild && typeof channelInfo.guild.name === "string" ? channelInfo.guild.name : void 0,
@@ -1867,6 +1918,7 @@ var DiscordVoiceSessions = class {
 			player,
 			playbackQueue: Promise.resolve(),
 			processingQueue: Promise.resolve(),
+			ttsStreamFallbackWarned: false,
 			capture: createVoiceCaptureState(),
 			transcripts: options?.transcripts,
 			receiveRecovery: createVoiceReceiveRecoveryState(),
@@ -1875,41 +1927,12 @@ var DiscordVoiceSessions = class {
 				generation: 0
 			},
 			stop(reason) {
-				clearSessionIfCurrent();
-				stopEntry(entry, {
+				stopEntry({
 					destroyConnection: true,
 					reason: reason ?? `stop guild ${guildId} channel ${channelId}`
 				});
 			}
 		};
-		if (!options?.transcripts && isDiscordRealtimeVoiceMode(voiceMode)) {
-			const realtimeResult = await this.attachRealtimeSession(entry, voiceMode, { isCurrent: authority?.isCurrent });
-			if (!realtimeResult.ok) {
-				destroyVoiceConnectionSafely({
-					connection,
-					voiceSdk,
-					reason: `realtime setup failed guild ${guildId} channel ${channelId}`
-				});
-				return {
-					ok: false,
-					message: realtimeResult.message,
-					guildId,
-					channelId
-				};
-			}
-		}
-		if (this.params.destroyed() || authority && !authority.isCurrent()) {
-			stopEntry(entry, {
-				destroyConnection: true,
-				reason: `${this.params.destroyed() ? "manager stopped" : "join cancelled"} during setup guild ${guildId} channel ${channelId}`
-			});
-			return {
-				ok: false,
-				message: this.params.destroyed() ? "Discord voice manager is stopped." : "Discord voice join was cancelled.",
-				guildId,
-				channelId
-			};
-		}
 		const speakingHandler = (userId) => {
 			this.params.receive.handleSpeakingStart(entry, userId).catch((err) => {
 				logger$2.warn(`discord voice: capture failed: ${formatErrorMessage(err)}`);
@@ -1926,8 +1949,7 @@ var DiscordVoiceSessions = class {
 					logVoiceVerbose(`disconnected: recovery started guild ${guildId} channel ${channelId}`);
 				} catch (err) {
 					logger$2.warn(`discord voice: disconnect recovery failed: guild ${guildId} channel ${channelId} timeout=${reconnectGraceMs}ms error=${formatErrorMessage(err)}; destroying connection`);
-					clearSessionIfCurrent();
-					stopEntry(entry, {
+					stopEntry({
 						destroyConnection: true,
 						reason: `disconnect recovery failed guild ${guildId} channel ${channelId}`
 					});
@@ -1935,8 +1957,7 @@ var DiscordVoiceSessions = class {
 			})();
 		};
 		const destroyedHandler = () => {
-			clearSessionIfCurrent();
-			stopEntry(entry, {
+			stopEntry({
 				destroyConnection: false,
 				reason: `destroyed guild ${guildId} channel ${channelId}`
 			});
@@ -1944,12 +1965,33 @@ var DiscordVoiceSessions = class {
 		const playerErrorHandler = (err) => {
 			logger$2.warn(`discord voice: playback error: ${formatErrorMessage(err)}`);
 		};
-		this.params.receive.enableDaveReceivePassthrough(entry, "post-join warmup", 30);
-		connection.receiver.speaking.on("start", speakingHandler);
-		connection.receiver.speaking.on("end", speakingEndHandler);
 		connection.on(voiceSdk.VoiceConnectionStatus.Disconnected, disconnectedHandler);
 		connection.on(voiceSdk.VoiceConnectionStatus.Destroyed, destroyedHandler);
 		player.on("error", playerErrorHandler);
+		if (!options?.transcripts && isDiscordRealtimeVoiceMode(voiceMode)) {
+			const realtimeResult = await this.attachRealtimeSession(entry, voiceMode, { isCurrent: authority?.isCurrent });
+			if (!realtimeResult.ok) {
+				entry.stop(`realtime setup failed guild ${guildId} channel ${channelId}`);
+				return {
+					ok: false,
+					message: realtimeResult.message,
+					guildId,
+					channelId
+				};
+			}
+		}
+		if (isVoiceSessionStopped(entry) || this.params.destroyed() || authority && !authority.isCurrent()) {
+			entry.stop(`${this.params.destroyed() ? "manager stopped" : "join cancelled"} during setup guild ${guildId} channel ${channelId}`);
+			return {
+				ok: false,
+				message: this.params.destroyed() ? "Discord voice manager is stopped." : "Discord voice join was cancelled.",
+				guildId,
+				channelId
+			};
+		}
+		this.params.receive.enableDaveReceivePassthrough(entry, "post-join warmup", 30);
+		connection.receiver.speaking.on("start", speakingHandler);
+		connection.receiver.speaking.on("end", speakingEndHandler);
 		this.params.sessions.set(guildId, entry);
 		this.params.membership.activate(entry, this.params.botUserId());
 		logger$2.info(`discord voice: joined guild=${guildId} channel=${channelId} mode=${voiceMode} agent=${route.agentId} voiceSession=${voiceRoute.sessionKey} supervisorSession=${route.sessionKey} voiceModel=${voiceConfig?.model ?? "route-default"}`);
@@ -1980,7 +2022,7 @@ var DiscordVoiceSessions = class {
 				channelId: entry.channelId
 			};
 			if (entry.realtimeLifecycle.status === "active" || entry.realtimeLifecycle.status === "starting") {
-				entry.transcripts = void 0;
+				retireTranscripts(entry);
 				return {
 					ok: true,
 					message: `Stopped transcripts for ${formatMention({ channelId: entry.channelId })}.`,
@@ -1990,7 +2032,6 @@ var DiscordVoiceSessions = class {
 			}
 		}
 		entry.stop();
-		this.params.sessions.delete(guildId);
 		if (!entry.receiveRecovery.decryptRecoveryInFlight) this.params.receive.deleteRecoveryAttempt(guildId);
 		if (!options?.preserveFollowState) this.params.onLeaveFollowState(guildId);
 		logVoiceVerbose(`leave: disconnected from guild ${guildId} channel ${entry.channelId}`);
@@ -2011,8 +2052,9 @@ var DiscordVoiceSessions = class {
 			ok: false,
 			message: "Discord realtime voice session stopped before startup completed."
 		};
-		const { DiscordRealtimeVoiceSession } = await import("./realtime-session.runtime-C7wen-aF.js");
+		const { DiscordRealtimeVoiceSession } = await import("./realtime-session.runtime-DOViOIjY.js");
 		const realtime = new DiscordRealtimeVoiceSession({
+			accountId: this.params.accountId,
 			bootstrapContextInstructions,
 			cfg: this.params.cfg,
 			discordConfig: this.params.discordConfig,
@@ -2069,8 +2111,8 @@ var DiscordVoiceSessions = class {
 //#endregion
 //#region extensions/discord/src/voice/listeners.ts
 const logger$1 = createSubsystemLogger("discord/voice");
-function startAutoJoin(manager) {
-	manager.autoJoin().catch((err) => logger$1.warn(`discord voice: autoJoin failed: ${formatErrorMessage(err)}`));
+function startAutoJoin(operation, context = "") {
+	operation().catch((err) => logger$1.warn(`discord voice: autoJoin${context} failed: ${formatErrorMessage(err)}`));
 }
 var DiscordVoiceReadyListener = class extends ReadyListener {
 	constructor(manager) {
@@ -2078,7 +2120,7 @@ var DiscordVoiceReadyListener = class extends ReadyListener {
 		this.manager = manager;
 	}
 	async handle(_data, _client) {
-		startAutoJoin(this.manager);
+		startAutoJoin(() => this.manager.autoJoin());
 	}
 };
 var DiscordVoiceResumedListener = class extends ResumedListener {
@@ -2087,7 +2129,7 @@ var DiscordVoiceResumedListener = class extends ResumedListener {
 		this.manager = manager;
 	}
 	async handle(_data, _client) {
-		startAutoJoin(this.manager);
+		startAutoJoin(() => this.manager.autoJoin());
 	}
 };
 var DiscordVoiceGuildCreateListener = class {
@@ -2096,7 +2138,10 @@ var DiscordVoiceGuildCreateListener = class {
 		this.type = discord_exports.GatewayDispatchEvents.GuildCreate;
 	}
 	async handle(data, _client) {
-		if (!data.unavailable) this.manager.refreshGuildRoster(data.id);
+		if (!data.unavailable) {
+			this.manager.refreshGuildRoster(data.id);
+			startAutoJoin(() => this.manager.reconcileAutoJoinGuild(data.id), ` occupancy reconciliation guild=${data.id}`);
+		}
 	}
 };
 var DiscordVoiceStateUpdateListener = class extends VoiceStateUpdateListener {
@@ -2137,9 +2182,10 @@ var DiscordVoiceManager = class {
 		this.guildLifecycles = /* @__PURE__ */ new Map();
 		this.nextGuildGeneration = 0;
 		this.joinTasks = /* @__PURE__ */ new Map();
-		this.autoJoinTask = null;
+		this.autoJoinTasks = /* @__PURE__ */ new Map();
 		this.fatalAutoJoinFailures = /* @__PURE__ */ new Map();
 		this.destroyed = false;
+		this.client = params.client;
 		this.botUserId = params.botUserId;
 		this.voiceEnabled = resolveDiscordVoiceEnabled(params.discordConfig.voice);
 		const voiceAccess = resolveDiscordVoiceAccess(params);
@@ -2153,6 +2199,7 @@ var DiscordVoiceManager = class {
 		});
 		this.membership = new DiscordVoiceMembershipTracker(params.client, this.speakerContext, params.accountId);
 		this.receive = new DiscordVoiceReceive({
+			accountId: params.accountId,
 			admissionAllowFrom: this.admissionAllowFrom,
 			botUserId: () => this.botUserId,
 			cfg: params.cfg,
@@ -2218,51 +2265,24 @@ var DiscordVoiceManager = class {
 	}
 	async autoJoin() {
 		if (!this.voiceEnabled || this.destroyed) return;
-		if (this.autoJoinTask) return this.autoJoinTask;
-		this.autoJoinTask = (async () => {
-			const entries = this.autoJoinChannels;
-			const entriesByGuild = /* @__PURE__ */ new Map();
-			const duplicateGuilds = /* @__PURE__ */ new Set();
-			for (const entry of entries) {
-				const guildId = entry.guildId.trim();
-				const channelId = entry.channelId.trim();
-				if (!guildId || !channelId) continue;
-				if (entriesByGuild.has(guildId)) duplicateGuilds.add(guildId);
-				entriesByGuild.set(guildId, {
-					guildId,
-					channelId
-				});
-			}
-			logVoiceVerbose(`autoJoin: ${entries.length} entries, ${entriesByGuild.size} guilds`);
-			for (const guildId of duplicateGuilds) {
-				const selected = entriesByGuild.get(guildId);
-				if (selected) logger.warn(`discord voice: autoJoin has multiple entries for guild ${guildId}; using channel ${selected.channelId}`);
-			}
-			for (const entry of entriesByGuild.values()) {
-				const failureKey = formatAutoJoinFailureKey(entry);
-				const fatalFailure = this.fatalAutoJoinFailures.get(failureKey);
-				if (fatalFailure) {
-					if (!fatalFailure.skipLogged) {
-						logger.warn(`discord voice: autoJoin suppressed guild=${entry.guildId} channel=${entry.channelId} after fatal startup failure; retry with /vc join or reload config after fixing credentials: ${fatalFailure.message}`);
-						fatalFailure.skipLogged = true;
-					}
-					continue;
-				}
-				logVoiceVerbose(`autoJoin: joining guild ${entry.guildId} channel ${entry.channelId}`);
-				const result = await this.join(entry);
-				if (!result.ok) {
-					logger.warn(`discord voice: autoJoin skipped guild=${entry.guildId} channel=${entry.channelId}: ${result.message}`);
-					if (isFatalAutoJoinFailure(result.message)) this.fatalAutoJoinFailures.set(failureKey, {
-						message: result.message,
-						skipLogged: false
-					});
-				}
-			}
-			await this.following.startReconciliation();
-		})().finally(() => {
-			this.autoJoinTask = null;
-		});
-		return this.autoJoinTask;
+		const entriesByGuild = /* @__PURE__ */ new Map();
+		const duplicateGuilds = /* @__PURE__ */ new Set();
+		for (const entry of this.autoJoinChannels) {
+			if (entriesByGuild.has(entry.guildId)) duplicateGuilds.add(entry.guildId);
+			entriesByGuild.set(entry.guildId, entry);
+		}
+		logVoiceVerbose(`autoJoin: ${this.autoJoinChannels.length} entries, ${entriesByGuild.size} guilds`);
+		for (const guildId of duplicateGuilds) {
+			const selected = entriesByGuild.get(guildId);
+			if (selected) logger.warn(`discord voice: autoJoin has multiple entries for guild ${guildId}; using channel ${selected.channelId}`);
+		}
+		for (const entry of entriesByGuild.values()) await this.enqueueAutoJoin(entry);
+		await this.following.startReconciliation();
+	}
+	async reconcileAutoJoinGuild(guildId) {
+		const entry = this.resolveAutoJoinTarget(guildId);
+		if (!entry?.whenOccupied || !this.voiceEnabled || this.destroyed) return;
+		await this.enqueueAutoJoin(entry);
 	}
 	status() {
 		return Array.from(this.guildLifecycles.values()).filter((lifecycle) => lifecycle.status === "active").map(({ instance: session }) => ({
@@ -2279,6 +2299,24 @@ var DiscordVoiceManager = class {
 			channelId: params.channelId.trim()
 		});
 	}
+	async resolveAccessTarget(params) {
+		const [guild, channel] = await Promise.all([this.client.fetchGuild(params.guildId).catch(() => null), this.client.fetchChannel(params.channelId).catch(() => null)]);
+		if (!guild || !channel) return;
+		const context = await resolveFetchedDiscordThreadLikeChannelContext({
+			client: this.client,
+			channel,
+			channelIdFallback: params.channelId
+		});
+		return {
+			guild,
+			...context.channelName ? { channelName: context.channelName } : {},
+			channelSlug: context.channelSlug,
+			...context.parentId ? { parentId: context.parentId } : {},
+			...context.threadParentName ? { parentName: context.threadParentName } : {},
+			...context.threadParentSlug ? { parentSlug: context.threadParentSlug } : {},
+			scope: context.isThreadChannel ? "thread" : "channel"
+		};
+	}
 	async join(params, options) {
 		if (this.destroyed) return {
 			ok: false,
@@ -2429,6 +2467,7 @@ var DiscordVoiceManager = class {
 				guildId,
 				channelId
 			});
+			await this.reconcileAutoJoinGuild(guildId);
 			return;
 		}
 		this.membership.track(this.sessions.get(guildId), data, previousVoiceState);
@@ -2437,6 +2476,8 @@ var DiscordVoiceManager = class {
 			channelId,
 			userId
 		});
+		const autoJoinTarget = this.resolveAutoJoinTarget(guildId);
+		if (autoJoinTarget?.whenOccupied) await this.enqueueAutoJoin(autoJoinTarget);
 	}
 	async destroy() {
 		this.destroyed = true;
@@ -2454,6 +2495,65 @@ var DiscordVoiceManager = class {
 		const lifecycle = this.guildLifecycles.get(entry.guildId);
 		return lifecycle?.status === "active" && lifecycle.generation === entry.generation && lifecycle.instance === entry && entry.sessionLifecycle.status === "active";
 	}
+	resolveAutoJoinTarget(guildId) {
+		return this.autoJoinChannels.toReversed().find((entry) => entry.guildId === guildId.trim());
+	}
+	enqueueAutoJoin(entry) {
+		const task = (this.autoJoinTasks.get(entry.guildId) ?? Promise.resolve()).catch(() => void 0).then(async () => await this.reconcileAutoJoinEntry(entry)).finally(() => {
+			if (this.autoJoinTasks.get(entry.guildId) === task) this.autoJoinTasks.delete(entry.guildId);
+		});
+		this.autoJoinTasks.set(entry.guildId, task);
+		return task;
+	}
+	async reconcileAutoJoinEntry(entry) {
+		if (this.destroyed) return;
+		const failureKey = formatAutoJoinFailureKey(entry);
+		const fatalFailure = this.fatalAutoJoinFailures.get(failureKey);
+		if (fatalFailure) {
+			if (!fatalFailure.skipLogged) {
+				logger.warn(`discord voice: autoJoin suppressed guild=${entry.guildId} channel=${entry.channelId} after fatal startup failure; retry with /vc join or reload config after fixing credentials: ${fatalFailure.message}`);
+				fatalFailure.skipLogged = true;
+			}
+			return;
+		}
+		if (entry.whenOccupied) {
+			const states = listDiscordVoiceParticipantStates({
+				client: this.client,
+				guildId: entry.guildId,
+				channelId: entry.channelId
+			});
+			if (states === null) {
+				logVoiceVerbose(`autoJoin waiting for guild voice snapshot guild=${entry.guildId} channel=${entry.channelId}`);
+				return;
+			}
+			const humanCount = countDiscordVoiceHumanParticipants({
+				states,
+				botUserId: this.botUserId
+			});
+			const existing = this.sessions.get(entry.guildId);
+			if (humanCount === 0) {
+				if (!existing?.autoJoinWhenOccupied || existing.channelId !== entry.channelId) return;
+				logger.info(`discord voice: occupied autoJoin leaving empty channel guild=${entry.guildId} channel=${entry.channelId}`);
+				const result = await this.leave({
+					guildId: entry.guildId,
+					channelId: entry.channelId
+				});
+				if (!result.ok) logger.warn(`discord voice: occupied autoJoin failed to leave guild=${entry.guildId} channel=${entry.channelId}: ${result.message}`);
+				return;
+			}
+			const lifecycle = this.guildLifecycles.get(entry.guildId);
+			if (existing || lifecycle?.status === "starting" || lifecycle?.status === "active") return;
+			logger.info(`discord voice: occupied autoJoin joining guild=${entry.guildId} channel=${entry.channelId} humans=${humanCount}`);
+		} else logVoiceVerbose(`autoJoin: joining guild ${entry.guildId} channel ${entry.channelId}`);
+		const result = await this.join(entry, { autoJoinWhenOccupied: entry.whenOccupied === true });
+		if (!result.ok) {
+			logger.warn(`discord voice: autoJoin skipped guild=${entry.guildId} channel=${entry.channelId}: ${result.message}`);
+			if (isFatalAutoJoinFailure(result.message)) this.fatalAutoJoinFailures.set(failureKey, {
+				message: result.message,
+				skipLogged: false
+			});
+		}
+	}
 };
 //#endregion
 export { DiscordVoiceGuildCreateListener, DiscordVoiceManager, DiscordVoiceReadyListener, DiscordVoiceResumedListener, DiscordVoiceStateUpdateListener };