@openclaw/discord 2026.9.1-beta.1 → 2026.9.2

package/dist/{realtime-session.runtime-CU8IQUS-.js → realtime-session.runtime-CGYm1t_0.js}

@@ -1,23 +1,107 @@
-import { n as discordRealtimeVoiceSecretOwnerId } from "./secret-config-contract-B3i6WxV5.js";
-import { b as maybeControlDiscordVoiceAgentRun, f as convertDiscordPcm48kStereoToRealtimePcm24kMono, l as logVoiceVerbose, m as createDiscordOpusEncodeStream, p as convertRealtimePcm24kMonoToDiscordPcm48kStereo, t as loadDiscordVoiceSdk, x as formatVoiceLogPreview, y as formatVoiceIngressPrompt } from "./sdk-runtime-4geQHtXc.js";
+import { n as discordRealtimeVoiceSecretOwnerId } from "./secret-config-contract-DFu9hfU8.js";
+import { a as createDiscordOpusEncodeStream, c as formatVoiceLogPreview, i as convertRealtimePcm24kMonoToDiscordPcm48kStereo, l as loadDiscordVoiceSdk, n as logVoiceVerbose, o as formatVoiceIngressPrompt, r as convertDiscordPcm48kStereoToRealtimePcm24kMono, s as maybeControlDiscordVoiceAgentRun } from "./voice-runtime-BQnILUbG.js";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/ssrf-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
 import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { assertSecretOwnerAvailable, isSecretOwnerAvailable } from "openclaw/plugin-sdk/channel-secret-owner-runtime";
-import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AGENT_CONTROL_TOOL, REALTIME_VOICE_AGENT_CONTROL_TOOL_NAME, REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ, buildRealtimeVoiceSessionInstructions, buildRealtimeVoiceSpeakExactMessage, canonicalizeRealtimeVoiceProviderId, classifyRealtimeVoiceConsultToolCall, classifySkippableRealtimeVoiceConsultTranscript, controlRealtimeVoiceAgentRun, createRealtimeVoiceAgentTalkbackQueue, createRealtimeVoiceSessionHarness, createRealtimeVoiceTurnContextTracker, isRealtimeVoiceWakeNameRequired, matchRealtimeVoiceActivationName, matchRealtimeVoiceConsultQuestions, parseRealtimeVoiceAgentControlToolArgs, realtimeVoiceAudioDurationMs, resolveConfiguredRealtimeVoiceProvider, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceBargeIn, resolveRealtimeVoiceInterruptResponseOnInputAudio, resolveRealtimeVoiceMinBargeInAudioEndMs, resolveRealtimeVoiceSessionPolicy } from "openclaw/plugin-sdk/realtime-voice";
+import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AGENT_CONTROL_TOOL, REALTIME_VOICE_AGENT_CONTROL_TOOL_NAME, REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ, buildRealtimeVoiceAgentErrorProviderResult, buildRealtimeVoiceSessionInstructions, buildRealtimeVoiceSpeakExactMessage, canonicalizeRealtimeVoiceProviderId, classifyRealtimeVoiceConsultToolCall, classifySkippableRealtimeVoiceConsultTranscript, controlRealtimeVoiceAgentRun, createRealtimeVoiceAgentTalkbackQueue, createRealtimeVoiceOutputActivityTracker, createRealtimeVoiceSessionHarness, isRealtimeVoiceWakeNameRequired, matchRealtimeVoiceActivationName, matchRealtimeVoiceConsultQuestions, parseRealtimeVoiceAgentControlToolArgs, realtimeVoiceAudioDurationMs, resolveConfiguredRealtimeVoiceProvider, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceBargeIn, resolveRealtimeVoiceInterruptResponseOnInputAudio, resolveRealtimeVoiceMinBargeInAudioEndMs, resolveRealtimeVoiceSessionPolicy } from "openclaw/plugin-sdk/realtime-voice";
 import { PassThrough, pipeline } from "node:stream";
+//#region extensions/discord/src/voice/realtime-player.ts
+/** One physical player serves every speaker lane in the room. */
+var DiscordRealtimePlayer = class {
+	constructor(player) {
+		this.player = player;
+		this.queue = [];
+		this.lanes = /* @__PURE__ */ new Set();
+		this.changing = false;
+		this.closed = false;
+		this.onIdle = () => {
+			const request = this.current;
+			this.current = void 0;
+			if (request) this.transition(() => request.onIdle());
+		};
+		player.on(loadDiscordVoiceSdk().AudioPlayerStatus.Idle, this.onIdle);
+	}
+	registerLane(lane) {
+		this.lanes.add(lane);
+		return () => this.lanes.delete(lane);
+	}
+	enqueue(request) {
+		if (this.closed || this.current === request || this.queue.includes(request)) return;
+		this.queue.push(request);
+		this.drain();
+	}
+	cancel(request) {
+		this.queue = this.queue.filter((queued) => queued !== request);
+		if (this.current !== request) return;
+		this.current = void 0;
+		this.transition(() => this.player.stop(true));
+	}
+	handleBargeIn(reason = "barge-in") {
+		if (this.current) {
+			this.current.onBargeIn(reason);
+			return;
+		}
+		for (const lane of this.lanes) if (lane.hasOutput()) lane.onBargeIn(reason);
+	}
+	isActive() {
+		return this.current !== void 0 || Array.from(this.lanes).some((lane) => lane.hasOutput());
+	}
+	cancelForControl() {
+		this.transition(() => {
+			this.queue = [];
+			for (const lane of this.lanes) lane.cancelForControl();
+		});
+	}
+	close() {
+		this.closed = true;
+		this.queue = [];
+		this.lanes.clear();
+		this.current = void 0;
+		this.player.off(loadDiscordVoiceSdk().AudioPlayerStatus.Idle, this.onIdle);
+		this.player.stop(true);
+	}
+	transition(action) {
+		const wasChanging = this.changing;
+		this.changing = true;
+		try {
+			action();
+		} finally {
+			this.changing = wasChanging;
+			this.drain();
+		}
+	}
+	drain() {
+		if (this.closed || this.changing || this.current) return;
+		const next = this.queue.shift();
+		if (!next) return;
+		this.current = next;
+		this.transition(() => {
+			try {
+				this.player.play(next.createResource());
+				next.onStart();
+			} catch (error) {
+				this.current = void 0;
+				this.player.stop(true);
+				next.onError(error);
+			}
+		});
+	}
+};
+//#endregion
 //#region extensions/discord/src/voice/realtime-transcript.ts
+const PARTIAL_TRANSCRIPT_MAX_CHARS = 240;
 function mergeRealtimePartialTranscript(previous, next) {
 	const trimmed = next.trim();
 	if (!trimmed) return previous;
-	return sliceUtf16Safe(trimmed.startsWith(previous) ? trimmed : `${previous}${next}`, -240);
+	const merged = trimmed.startsWith(previous) ? trimmed : `${previous}${next}`;
+	return sliceUtf16Safe(merged, 0, PARTIAL_TRANSCRIPT_MAX_CHARS);
 }
 //#endregion
 //#region extensions/discord/src/voice/realtime-turns.ts
-const logger$3 = createSubsystemLogger("discord/voice");
-const DISCORD_REALTIME_PENDING_SPEAKER_CONTEXT_LIMIT = 32;
-const DISCORD_REALTIME_IGNORED_WAKE_NAME_CONTEXT_TTL_MS = 1e4;
+const logger$5 = createSubsystemLogger("discord/voice");
 const DISCORD_REALTIME_WAKE_NAME_FOLLOWUP_TTL_MS = 1e4;
 const REALTIME_PCM16_BYTES_PER_SAMPLE = 2;
 const DISCORD_REALTIME_TRAILING_SILENCE_MIN_MS = 700;
@@ -25,48 +109,59 @@ const DISCORD_REALTIME_TRAILING_SILENCE_MAX_MS = 3e3;
 var DiscordRealtimeTurns = class {
 	constructor(params) {
 		this.params = params;
-		this.speakerTurns = createRealtimeVoiceTurnContextTracker({
-			limit: DISCORD_REALTIME_PENDING_SPEAKER_CONTEXT_LIMIT,
-			ignoredContextTtlMs: DISCORD_REALTIME_IGNORED_WAKE_NAME_CONTEXT_TTL_MS,
-			deferUntilAudio: true
-		});
+		this.pendingAudio = false;
 		this.partialUserTranscript = "";
 		this.wakeNameAckedForTurn = false;
 	}
 	beginSpeakerTurn(context, userId) {
+		if (this.source && (this.source.userId !== userId || this.source.senderIsOwner !== context.senderIsOwner)) throw new Error("A Discord realtime connection cannot change speaker authority");
+		this.source ??= Object.freeze({
+			userId,
+			senderIsOwner: context.senderIsOwner
+		});
 		this.resetPartialWakeNameTracking();
-		const turn = this.speakerTurns.open({
-			...context,
-			userId
-		}, {
+		const turn = {
+			context: {
+				...context,
+				...this.source
+			},
+			startedAt: Date.now(),
+			hasAudio: false,
+			closed: false,
+			transcripts: this.params.entry.transcripts,
 			inputDiscordBytes: 0,
 			inputRealtimeBytes: 0,
 			inputChunks: 0,
 			interruptedPlayback: false
-		});
+		};
 		return {
 			sendInputAudio: (discordPcm48kStereo) => this.sendInputAudioForTurn(turn, discordPcm48kStereo),
 			close: () => {
 				this.sendRealtimeTrailingSilenceForTurn(turn);
 				this.logSpeakerTurnClosed(turn);
-				this.speakerTurns.close(turn);
+				turn.closed = true;
 			}
 		};
 	}
 	handlePartialUserTranscript(text) {
-		if (!this.isWakeNameRequired() || this.wakeNameAckedForTurn) return;
+		if (!this.lastSpeakerTurn || !this.isWakeNameRequired() || this.wakeNameAckedForTurn) return;
 		this.partialUserTranscript = mergeRealtimePartialTranscript(this.partialUserTranscript, text);
 		const wakeNameResult = matchRealtimeVoiceActivationName(this.partialUserTranscript, this.params.wakeNames());
-		if (!wakeNameResult || wakeNameResult.edge !== "leading") return;
+		if (wakeNameResult?.edge !== "leading" || wakeNameResult.match !== "exact") return;
 		this.wakeNameAckedForTurn = true;
 		this.params.playback.sendWakeNameAck(wakeNameResult);
 	}
 	async handleFinalUserTranscript(text) {
+		if (!this.lastSpeakerTurn || this.params.stopped()) return;
 		const providerEpoch = this.params.providerEpoch();
 		const trimmed = text.trim();
-		if (!trimmed) return;
+		if (!trimmed) {
+			this.pendingAudio = false;
+			this.resetPartialWakeNameTracking();
+			return;
+		}
 		this.partialUserTranscript = "";
-		const transcriptsTurn = this.peekPendingSpeakerTurn();
+		const transcriptsTurn = this.lastSpeakerTurn;
 		let transcriptAttribution = this.transcriptAttributionFromTurn(transcriptsTurn);
 		const humanParticipantCount = this.params.getHumanParticipantCount();
 		const requireWakeName = this.isWakeNameRequired(humanParticipantCount);
@@ -77,12 +172,12 @@ var DiscordRealtimeTurns = class {
 			transcriptAttribution ??= pendingWakeNameFollowup;
 			if (!pendingWakeNameFollowup) {
 				this.recordTranscriptUtterance(trimmed, transcriptAttribution, providerEpoch);
-				this.rememberIgnoredWakeNameSpeakerContext(this.consumePendingSpeakerContext());
-				logger$3.info(`discord voice: realtime wake-name gate ignored transcript chars=${trimmed.length} humanParticipants=${humanParticipantCount} voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId} wakeNames=${this.params.wakeNames().join(",") || "none"}`);
+				this.consumePendingSpeakerContext();
+				logger$5.info(`discord voice: realtime wake-name gate ignored transcript chars=${trimmed.length} humanParticipants=${humanParticipantCount} voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId} wakeNames=${this.params.wakeNames().join(",") || "none"}`);
 				return;
 			}
 			forcedSpeakerContext = pendingWakeNameFollowup.context;
-			logger$3.info(`discord voice: realtime wake-name follow-up accepted chars=${trimmed.length} speaker=${forcedSpeakerContext.speakerLabel} voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId}`);
+			logger$5.info(`discord voice: realtime wake-name follow-up accepted chars=${trimmed.length} speaker=${forcedSpeakerContext.speakerLabel} voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId}`);
 		}
 		this.recordTranscriptUtterance(trimmed, transcriptAttribution, providerEpoch);
 		const acceptedText = wakeNameResult.allowed ? wakeNameResult.text || trimmed : trimmed;
@@ -100,23 +195,24 @@ var DiscordRealtimeTurns = class {
 	resetProviderContinuity() {
 		this.partialUserTranscript = "";
 		this.pendingWakeNameFollowup = void 0;
+		this.pendingAudio = false;
+		this.lastSpeakerTurn = void 0;
 	}
 	clear() {
-		this.speakerTurns.clear();
+		this.pendingAudio = false;
+		this.lastSpeakerTurn = void 0;
 		this.resetPartialWakeNameTracking();
 		this.pendingWakeNameFollowup = void 0;
 	}
 	consumePendingSpeakerContext() {
-		return this.speakerTurns.consumeAudioContext();
-	}
-	consumeRecentIgnoredWakeNameSpeakerContext() {
-		return this.speakerTurns.consumeIgnoredContext();
+		this.pendingAudio = false;
+		return this.speakerContext();
 	}
-	peekPendingSpeakerTurn() {
-		return this.speakerTurns.peekAudioTurn();
+	speakerContext() {
+		return this.lastSpeakerTurn?.context;
 	}
 	hasPendingSpeakerAudioContext() {
-		return this.speakerTurns.hasAudioContext();
+		return this.pendingAudio;
 	}
 	sendInputAudioForTurn(turn, discordPcm48kStereo) {
 		const bridge = this.params.bridge();
@@ -127,27 +223,28 @@ var DiscordRealtimeTurns = class {
 			turn.inputDiscordBytes += discordPcm48kStereo.length;
 			turn.inputRealtimeBytes += realtimePcm.length;
 			turn.inputChunks += 1;
-			if (turn.inputChunks === 1) logger$3.info(`discord voice: realtime input audio started guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} user=${turn.context.userId} speaker=${turn.context.speakerLabel} discordBytes=${discordPcm48kStereo.length} realtimeBytes=${realtimePcm.length} outputAudioMs=${this.params.playback.outputAudioMs()} outputActive=${this.params.playback.isOutputAudioActive()}`);
-			const outputActive = this.params.playback.hasInterruptibleOutputAudio();
-			if (!turn.interruptedPlayback && this.params.playback.isBargeInEnabled() && outputActive) {
+			if (turn.inputChunks === 1) logger$5.info(`discord voice: realtime input audio started guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} user=${turn.context.userId} speaker=${turn.context.speakerLabel} discordBytes=${discordPcm48kStereo.length} realtimeBytes=${realtimePcm.length} outputAudioMs=${this.params.playback.outputAudioMs()} outputActive=${this.params.playback.isOutputAudioActive()}`);
+			if (!turn.interruptedPlayback && this.params.interruptRoomPlayback()) {
 				turn.interruptedPlayback = true;
 				logVoiceVerbose(`realtime barge-in from active speaker audio: guild ${this.params.entry.guildId} channel ${this.params.entry.channelId} user ${turn.context.userId}`);
-				logger$3.info(`discord voice: realtime barge-in detected source=active-speaker-audio guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} user=${turn.context.userId} speaker=${turn.context.speakerLabel} outputAudioMs=${this.params.playback.outputAudioMs()} outputActive=${this.params.playback.isOutputAudioActive()} discordBytes=${discordPcm48kStereo.length} realtimeBytes=${realtimePcm.length}`);
-				this.params.playback.handleBargeIn("active-speaker-audio");
+				logger$5.info(`discord voice: realtime barge-in detected source=active-speaker-audio guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} user=${turn.context.userId} speaker=${turn.context.speakerLabel} discordBytes=${discordPcm48kStereo.length} realtimeBytes=${realtimePcm.length}`);
 			}
 			if (this.params.recordInputAudio(realtimePcm)) bridge.sendAudio(realtimePcm);
 		}
 	}
 	registerSpeakerTurnAudioStarted(turn) {
+		this.pendingAudio = true;
+		this.lastSpeakerTurn = turn;
+		turn.lastAudioAt = Date.now();
 		if (turn.hasAudio) return;
-		this.speakerTurns.markAudio(turn);
-		logger$3.info(`discord voice: realtime speaker turn opened guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} user=${turn.context.userId} speaker=${turn.context.speakerLabel} owner=${turn.context.senderIsOwner} pendingTurns=${this.speakerTurns.size()}`);
+		turn.hasAudio = true;
+		logger$5.info(`discord voice: realtime speaker turn opened guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} user=${turn.context.userId} speaker=${turn.context.speakerLabel} owner=${turn.context.senderIsOwner}`);
 	}
 	logSpeakerTurnClosed(turn) {
 		if (turn.closed || !turn.hasAudio) return;
 		const elapsedMs = Date.now() - turn.startedAt;
 		const sinceLastAudioMs = turn.lastAudioAt ? Date.now() - turn.lastAudioAt : void 0;
-		logger$3.info(`discord voice: realtime speaker turn closed guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} user=${turn.context.userId} speaker=${turn.context.speakerLabel} owner=${turn.context.senderIsOwner} hasAudio=${turn.hasAudio} chunks=${turn.inputChunks} discordBytes=${turn.inputDiscordBytes} realtimeBytes=${turn.inputRealtimeBytes} elapsedMs=${elapsedMs}${sinceLastAudioMs === void 0 ? "" : ` sinceLastAudioMs=${sinceLastAudioMs}`} interruptedPlayback=${turn.interruptedPlayback}`);
+		logger$5.info(`discord voice: realtime speaker turn closed guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} user=${turn.context.userId} speaker=${turn.context.speakerLabel} owner=${turn.context.senderIsOwner} hasAudio=${turn.hasAudio} chunks=${turn.inputChunks} discordBytes=${turn.inputDiscordBytes} realtimeBytes=${turn.inputRealtimeBytes} elapsedMs=${elapsedMs}${sinceLastAudioMs === void 0 ? "" : ` sinceLastAudioMs=${sinceLastAudioMs}`} interruptedPlayback=${turn.interruptedPlayback}`);
 	}
 	sendRealtimeTrailingSilenceForTurn(turn) {
 		const bridge = this.params.bridge();
@@ -158,7 +255,7 @@ var DiscordRealtimeTurns = class {
 		const silenceBytes = Math.ceil(24e3 * silenceMs / 1e3) * REALTIME_PCM16_BYTES_PER_SAMPLE;
 		const silence = Buffer.alloc(silenceBytes);
 		bridge.sendAudio(silence);
-		logger$3.info(`discord voice: realtime trailing silence sent guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} user=${turn.context.userId} speaker=${turn.context.speakerLabel} silenceMs=${silenceMs} realtimeBytes=${silence.length}`);
+		logger$5.info(`discord voice: realtime trailing silence sent guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} user=${turn.context.userId} speaker=${turn.context.speakerLabel} silenceMs=${silenceMs} realtimeBytes=${silence.length}`);
 	}
 	resolveWakeNameTranscript(text, requireWakeName) {
 		if (!requireWakeName) return {
@@ -171,7 +268,7 @@ var DiscordRealtimeTurns = class {
 		};
 		const wakeNameResult = matchRealtimeVoiceActivationName(text, this.params.wakeNames());
 		if (wakeNameResult) {
-			logger$3.info(`discord voice: realtime wake-name gate matched canonical=${wakeNameResult.activationName} heard=${wakeNameResult.heardName} match=${wakeNameResult.match} voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId}`);
+			logger$5.info(`discord voice: realtime wake-name gate matched canonical=${wakeNameResult.activationName} heard=${wakeNameResult.heardName} match=${wakeNameResult.match} voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId}`);
 			return wakeNameResult;
 		}
 		return {
@@ -185,12 +282,13 @@ var DiscordRealtimeTurns = class {
 	transcriptAttributionFromTurn(turn) {
 		return turn ? {
 			context: turn.context,
-			startedAt: turn.startedAt
+			startedAt: turn.startedAt,
+			transcripts: turn.transcripts
 		} : void 0;
 	}
 	recordTranscriptUtterance(text, attribution, providerEpoch) {
-		const transcripts = this.params.entry.transcripts;
-		if (!transcripts || !attribution) return;
+		const transcripts = attribution?.transcripts;
+		if (!transcripts || !attribution || this.params.entry.transcripts !== transcripts) return;
 		const context = attribution.context;
 		const utterance = {
 			sessionId: transcripts.sessionId,
@@ -209,27 +307,28 @@ var DiscordRealtimeTurns = class {
 			}
 		};
 		Promise.resolve().then(() => {
-			if (providerEpoch !== this.params.providerEpoch()) return;
+			if (providerEpoch !== this.params.providerEpoch() || this.params.entry.transcripts !== transcripts) return;
 			return transcripts.onUtterance(utterance);
 		}).catch((error) => {
-			logger$3.warn(`discord voice: realtime transcripts utterance failed: ${formatErrorMessage(error)}`);
+			logger$5.warn(`discord voice: realtime transcripts utterance failed: ${formatErrorMessage(error)}`);
 		});
 	}
 	armWakeNameFollowup() {
-		const turn = this.peekPendingSpeakerTurn();
+		const turn = this.lastSpeakerTurn;
 		const context = this.consumePendingSpeakerContext();
 		if (!context) {
-			logger$3.warn(`discord voice: realtime wake-name follow-up has no speaker context voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId}`);
+			logger$5.warn(`discord voice: realtime wake-name follow-up has no speaker context voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId}`);
 			return;
 		}
 		const expiresAt = resolveExpiresAtMsFromDurationMs(DISCORD_REALTIME_WAKE_NAME_FOLLOWUP_TTL_MS);
 		if (expiresAt === void 0) return;
 		this.pendingWakeNameFollowup = {
 			context,
+			transcripts: turn?.transcripts,
 			startedAt: turn?.startedAt ?? Date.now(),
 			expiresAt
 		};
-		logger$3.info(`discord voice: realtime wake-name follow-up armed speaker=${context.speakerLabel} voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId}`);
+		logger$5.info(`discord voice: realtime wake-name follow-up armed speaker=${context.speakerLabel} voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId}`);
 	}
 	consumePendingWakeNameFollowup() {
 		const pending = this.pendingWakeNameFollowup;
@@ -237,37 +336,41 @@ var DiscordRealtimeTurns = class {
 		const now = asDateTimestampMs(Date.now());
 		const expiresAt = pending ? asDateTimestampMs(pending.expiresAt) : void 0;
 		if (!pending || now === void 0 || expiresAt === void 0 || now > expiresAt) return;
-		const currentTurn = this.peekPendingSpeakerTurn();
-		if (currentTurn && currentTurn.context.userId !== pending.context.userId) return;
-		if (currentTurn) this.consumePendingSpeakerContext();
+		this.consumePendingSpeakerContext();
 		return {
 			context: pending.context,
-			startedAt: pending.startedAt
+			startedAt: pending.startedAt,
+			transcripts: pending.transcripts
 		};
 	}
-	rememberIgnoredWakeNameSpeakerContext(context) {
-		this.speakerTurns.rememberIgnoredContext(context);
-	}
 };
 function isDiscordRealtimeSpeakerContext(value) {
 	return Boolean(value) && typeof value === "object" && typeof value.userId === "string" && typeof value.senderIsOwner === "boolean" && typeof value.speakerLabel === "string";
 }
 //#endregion
 //#region extensions/discord/src/voice/realtime-consults.ts
-const logger$2 = createSubsystemLogger("discord/voice");
+const logger$4 = createSubsystemLogger("discord/voice");
 const DISCORD_REALTIME_TALKBACK_DEBOUNCE_MS = 350;
 const DISCORD_REALTIME_FALLBACK_TEXT = "I hit an error while checking that. Please try again.";
 const DISCORD_REALTIME_FORCED_CONSULT_FALLBACK_DELAY_MS = 200;
 const DISCORD_REALTIME_FORCED_CONSULT_REASON = "provider_final_transcript_without_openclaw_agent_consult";
+const CANCELLED_CONSULT_RESULT = {
+	status: "cancelled",
+	message: "OpenClaw cancelled this consult before completion. Do not restart it."
+};
 var DiscordRealtimeConsults = class {
 	constructor(params) {
 		this.params = params;
+		this.providerDeliveries = /* @__PURE__ */ new Map();
 		this.talkback = this.createTalkbackQueue();
 	}
 	close() {
 		this.talkback.close();
 		this.clearProviderConsultState();
 	}
+	isIdle() {
+		return this.talkback.isIdle() && this.providerDeliveries.size === 0 && this.params.harness.forcedConsults.handles().every((handle) => handle.context?.result);
+	}
 	resetProviderContinuity() {
 		this.talkback.close();
 		this.talkback = this.createTalkbackQueue();
@@ -276,6 +379,10 @@ var DiscordRealtimeConsults = class {
 	async handleToolCall(event, session) {
 		const providerEpoch = this.params.providerEpoch();
 		const callId = event.callId || event.itemId || "unknown";
+		if (this.params.stopped() || !this.params.turns.speakerContext()) {
+			await session.submitToolResult(callId, { error: "No Discord speaker context available" });
+			return;
+		}
 		if (event.name === REALTIME_VOICE_AGENT_CONTROL_TOOL_NAME) {
 			await this.handleAgentControlToolCall(event, session, callId, providerEpoch);
 			return;
@@ -291,23 +398,19 @@ var DiscordRealtimeConsults = class {
 		const outcome = classifyRealtimeVoiceConsultToolCall(event.args, { retainedExactSpeechTexts: this.params.playback.retainedExactSpeechTexts() });
 		switch (outcome.kind) {
 			case "exact-speech-echo":
-				logger$2.info(`discord voice: realtime exact speech consult bypassed call=${callId || "unknown"} answerChars=${outcome.text.length}`);
+				logger$4.info(`discord voice: realtime exact speech consult bypassed call=${callId || "unknown"} answerChars=${outcome.text.length}`);
 				await session.submitToolResult(callId, { text: outcome.text });
 				return;
 			case "malformed":
-				logger$2.warn(`discord voice: realtime consult rejected malformed args call=${callId || "unknown"}: ${outcome.error}`);
+				logger$4.warn(`discord voice: realtime consult rejected malformed args call=${callId || "unknown"}: ${outcome.error}`);
 				await session.submitToolResult(callId, { error: outcome.error });
 				return;
-			case "consult": break;
 		}
 		const consultMessage = outcome.message;
-		logger$2.info(`discord voice: realtime consult requested call=${callId || "unknown"} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} question=${formatVoiceLogPreview(consultMessage)}`);
+		logger$4.info(`discord voice: realtime consult requested call=${callId || "unknown"} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} question=${formatVoiceLogPreview(consultMessage)}`);
 		const nativeConsult = this.params.harness.forcedConsults.recordNativeConsult(event.args, callId);
 		if (nativeConsult.kind === "already_delivered" && this.params.harness.forcedConsults.isCancelled(nativeConsult.handle)) {
-			await this.submitTerminalRealtimeToolResult(callId, session, {
-				status: "cancelled",
-				message: "OpenClaw cancelled this consult before completion. Do not restart it."
-			});
+			await this.submitTerminalRealtimeToolResult(callId, session, CANCELLED_CONSULT_RESULT);
 			return;
 		}
 		const pendingConsult = nativeConsult.kind === "pending" ? nativeConsult.handle : void 0;
@@ -319,7 +422,7 @@ var DiscordRealtimeConsults = class {
 			if (recentConsult) {
 				const recentSpeaker = recentConsult.context?.speaker;
 				if (this.params.turns.hasPendingSpeakerAudioContext()) {
-					logger$2.info(`discord voice: realtime consult matched recent agent result but newer speaker audio is pending call=${callId} speaker=${recentSpeaker?.speakerLabel ?? "unknown"} owner=${recentSpeaker?.senderIsOwner ?? false}`);
+					logger$4.info(`discord voice: realtime consult matched recent agent result but newer speaker audio is pending call=${callId} speaker=${recentSpeaker?.speakerLabel ?? "unknown"} owner=${recentSpeaker?.senderIsOwner ?? false}`);
 					await session.submitToolResult(callId, { error: "Discord speaker context changed before this realtime consult completed" });
 					return;
 				}
@@ -334,28 +437,18 @@ var DiscordRealtimeConsults = class {
 			});
 		}
 		if (!context) {
-			logger$2.warn(`discord voice: realtime consult has no speaker context call=${callId || "unknown"}`);
+			logger$4.warn(`discord voice: realtime consult has no speaker context call=${callId || "unknown"}`);
 			await session.submitToolResult(callId, { error: "No Discord speaker context available" });
 			return;
 		}
-		const promise = this.runAgentTurn({
+		const result = await this.trackAgentProxyConsult(recent, this.runAgentTurn({
 			context,
 			message: consultMessage
-		});
-		if (recent) this.setRecentAgentProxyConsultPromise(recent, promise);
-		let text;
-		try {
-			text = await promise;
-		} catch (error) {
-			if (providerEpoch !== this.params.providerEpoch()) return;
-			const message = formatErrorMessage(error);
-			logger$2.warn(`discord voice: realtime consult failed call=${callId || "unknown"}: ${message}`);
-			await session.submitToolResult(callId, { error: message });
-			return;
-		}
+		}));
 		if (providerEpoch !== this.params.providerEpoch()) return;
-		logger$2.info(`discord voice: realtime consult answer (${text.length} chars) voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} speaker=${context.speakerLabel} owner=${context.senderIsOwner}: ${formatVoiceLogPreview(text)}`);
-		await session.submitToolResult(callId, { text });
+		if ("text" in result) logger$4.info(`discord voice: realtime consult answer (${result.text.length} chars) voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} speaker=${context.speakerLabel} owner=${context.senderIsOwner}: ${formatVoiceLogPreview(result.text)}`);
+		else if ("error" in result) logger$4.warn(`discord voice: realtime consult failed call=${callId}: ${result.error}`);
+		await this.submitAgentProxyConsultResult(callId, session, result);
 	}
 	async handleAcceptedTranscript(acceptedText, forcedSpeakerContext, providerEpoch) {
 		const usesRealtimeAgentHandoff = this.params.usesRealtimeAgentHandoff();
@@ -369,7 +462,7 @@ var DiscordRealtimeConsults = class {
 			});
 		} catch (error) {
 			if (providerEpoch !== this.params.providerEpoch()) return;
-			logger$2.warn(`discord voice: realtime active-run control failed; falling back to normal transcript handling: ${formatErrorMessage(error)}`);
+			logger$4.warn(`discord voice: realtime active-run control failed; falling back to normal transcript handling: ${formatErrorMessage(error)}`);
 			control = void 0;
 		}
 		if (providerEpoch !== this.params.providerEpoch()) return;
@@ -391,7 +484,7 @@ var DiscordRealtimeConsults = class {
 		return createRealtimeVoiceAgentTalkbackQueue({
 			debounceMs: this.params.debounceMs() ?? DISCORD_REALTIME_TALKBACK_DEBOUNCE_MS,
 			isStopped: () => this.params.stopped() || providerEpoch !== this.params.providerEpoch(),
-			logger: logger$2,
+			logger: logger$4,
 			logPrefix: "[discord] realtime agent",
 			responseStyle: "Brief, natural spoken answer for a Discord voice channel.",
 			fallbackText: DISCORD_REALTIME_FALLBACK_TEXT,
@@ -434,7 +527,7 @@ var DiscordRealtimeConsults = class {
 		});
 	}
 	logAgentControlResult(result) {
-		logger$2.info(`discord voice: realtime active-run control handled mode=${result.mode} ok=${result.ok} active=${result.active} reason=${result.reason ?? "none"} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId}`);
+		logger$4.info(`discord voice: realtime active-run control handled mode=${result.mode} ok=${result.ok} active=${result.active} reason=${result.reason ?? "none"} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId}`);
 	}
 	prepareForcedAgentProxyConsult(transcript, speakerContext) {
 		if (this.params.consultPolicy() !== "always" && this.params.wakeNamePolicy() === "never") return;
@@ -443,18 +536,17 @@ var DiscordRealtimeConsults = class {
 		const skipReason = classifySkippableRealtimeVoiceConsultTranscript(question);
 		if (skipReason) {
 			const context = this.params.turns.consumePendingSpeakerContext();
-			logger$2.info(`discord voice: realtime forced agent consult skipped reason=${skipReason} chars=${question.length} speaker=${context?.speakerLabel ?? "unknown"} transcript=${formatVoiceLogPreview(question)}`);
+			logger$4.info(`discord voice: realtime forced agent consult skipped reason=${skipReason} chars=${question.length} speaker=${context?.speakerLabel ?? "unknown"} transcript=${formatVoiceLogPreview(question)}`);
 			return;
 		}
-		let context = speakerContext ?? this.params.turns.consumePendingSpeakerContext();
-		if (!context) context = this.params.turns.consumeRecentIgnoredWakeNameSpeakerContext();
+		const context = speakerContext ?? this.params.turns.consumePendingSpeakerContext();
 		if (!context) {
 			const recent = this.findRecentAgentProxyConsultContext(question);
 			if (recent) {
 				logVoiceVerbose(`realtime forced agent consult skipped (already delegated): guild ${this.params.entry.guildId} channel ${this.params.entry.channelId} speaker ${recent.context?.speaker.userId ?? "unknown"}`);
 				return;
 			}
-			logger$2.warn("discord voice: realtime forced agent consult has no speaker context");
+			logger$4.warn("discord voice: realtime forced agent consult has no speaker context");
 			return;
 		}
 		return this.params.harness.forcedConsults.prepare(question, { context: {
@@ -479,27 +571,21 @@ var DiscordRealtimeConsults = class {
 			return;
 		}
 		const startedAt = Date.now();
-		logger$2.info(`discord voice: realtime forced agent consult starting chars=${question.length} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} speaker=${context.speakerLabel} owner=${context.senderIsOwner}`);
-		logger$2.debug(`discord voice: realtime forced agent consult reason=${DISCORD_REALTIME_FORCED_CONSULT_REASON} consultPolicy=${this.params.consultPolicy()} wakeNamePolicy=${this.params.wakeNamePolicy()} requireWakeName=${this.params.isWakeNameRequired()} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} speaker=${context.speakerLabel}`);
-		if (this.params.playback.hasInterruptibleOutputAudio()) logger$2.info(`discord voice: realtime forced agent consult preserving active playback guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} outputAudioMs=${this.params.playback.outputAudioMs()} outputActive=${this.params.playback.isOutputAudioActive()} playbackChunks=${this.params.harness.outputActivity.snapshot().chunks}`);
+		logger$4.info(`discord voice: realtime forced agent consult starting chars=${question.length} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} speaker=${context.speakerLabel} owner=${context.senderIsOwner}`);
+		logger$4.debug(`discord voice: realtime forced agent consult reason=${DISCORD_REALTIME_FORCED_CONSULT_REASON} consultPolicy=${this.params.consultPolicy()} wakeNamePolicy=${this.params.wakeNamePolicy()} requireWakeName=${this.params.isWakeNameRequired()} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} speaker=${context.speakerLabel}`);
+		if (this.params.playback.hasInterruptibleOutputAudio()) logger$4.info(`discord voice: realtime forced agent consult preserving active playback guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} outputAudioMs=${this.params.playback.outputAudioMs()} outputActive=${this.params.playback.isOutputAudioActive()} playbackChunks=${this.params.harness.outputActivity.snapshot().chunks}`);
 		state.handledByForcedPlayback = true;
-		try {
-			const promise = this.runAgentTurn({
-				context,
-				message: question
-			});
-			this.setRecentAgentProxyConsultPromise(pending, promise);
-			const text = await promise;
-			await state.providerDelivery;
-			if (state.providerEpoch !== this.params.providerEpoch()) return;
-			logger$2.info(`discord voice: realtime forced agent consult answer (${text.length} chars) elapsedMs=${Date.now() - startedAt} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId}: ${formatVoiceLogPreview(text)}`);
-			if (text.trim() && state.handledByForcedPlayback) this.params.playback.enqueueExactSpeechMessage(text);
-		} catch (error) {
-			await state.providerDelivery;
-			if (state.providerEpoch !== this.params.providerEpoch()) return;
-			logger$2.warn(`discord voice: realtime forced agent consult failed elapsedMs=${Date.now() - startedAt}: ${formatErrorMessage(error)}`);
-			if (state.handledByForcedPlayback) this.params.playback.enqueueExactSpeechMessage(DISCORD_REALTIME_FALLBACK_TEXT);
-		}
+		const result = await this.trackAgentProxyConsult(pending, this.runAgentTurn({
+			context,
+			message: question
+		}));
+		const deliveries = this.providerDeliveries.get(state);
+		await Promise.all(Array.from(deliveries ?? [], (delivery) => delivery.promise));
+		if (state.providerEpoch !== this.params.providerEpoch() || "status" in result) return;
+		if ("text" in result) logger$4.info(`discord voice: realtime forced agent consult answer (${result.text.length} chars) elapsedMs=${Date.now() - startedAt} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId}: ${formatVoiceLogPreview(result.text)}`);
+		else logger$4.warn(`discord voice: realtime forced agent consult failed elapsedMs=${Date.now() - startedAt}: ${result.error}`);
+		const text = "text" in result ? result.text : DISCORD_REALTIME_FALLBACK_TEXT;
+		if (text.trim() && state.handledByForcedPlayback) this.params.playback.enqueueExactSpeechMessage(text);
 	}
 	rememberRecentAgentProxyConsultContext(question, context, options = {}) {
 		const handle = this.params.harness.forcedConsults.prepare(question, {
@@ -513,26 +599,19 @@ var DiscordRealtimeConsults = class {
 		if (options.started) this.params.harness.forcedConsults.markStarted(handle);
 		return handle;
 	}
-	setRecentAgentProxyConsultPromise(recent, promise) {
-		const state = recent.context;
-		if (!state) return;
-		this.params.harness.forcedConsults.markStarted(recent);
-		state.promise = promise;
-		promise.then((text) => {
-			if (state.providerEpoch !== this.params.providerEpoch()) return;
-			state.result = {
-				status: "fulfilled",
-				text
-			};
-			this.params.harness.forcedConsults.markDelivered(recent);
-		}).catch((error) => {
-			if (state.providerEpoch !== this.params.providerEpoch()) return;
-			state.result = {
-				status: "rejected",
-				error: formatErrorMessage(error)
-			};
-			this.params.harness.forcedConsults.markDelivered(recent);
+	trackAgentProxyConsult(recent, promise) {
+		const state = recent?.context;
+		if (recent) this.params.harness.forcedConsults.markStarted(recent);
+		const tracked = promise.then((text) => ({ text }), buildRealtimeVoiceAgentErrorProviderResult).then((result) => {
+			if (recent && state && state.providerEpoch === this.params.providerEpoch()) {
+				state.result = result;
+				if ("status" in result) this.params.harness.forcedConsults.markCancelled(recent);
+				else this.params.harness.forcedConsults.markDelivered(recent);
+			}
+			return result;
 		});
+		if (state) state.promise = tracked;
+		return tracked;
 	}
 	findRecentAgentProxyConsultContext(consultMessage) {
 		return this.params.harness.forcedConsults.findRecent(consultMessage);
@@ -548,139 +627,311 @@ var DiscordRealtimeConsults = class {
 		const state = recent.context;
 		if (!state) return false;
 		if (state.providerEpoch !== this.params.providerEpoch()) return true;
-		const providerOwnsDelivery = Boolean(state.handledByForcedPlayback && state.promise && !state.result && session.bridge.supportsToolResultSuppression === false);
-		let resolveProviderDelivery;
-		if (providerOwnsDelivery) state.providerDelivery = new Promise((resolve) => {
-			resolveProviderDelivery = resolve;
-			state.settleProviderDelivery = resolve;
+		const pendingResult = state.result ?? state.promise;
+		if (!pendingResult) return false;
+		const providerDelivery = state.handledByForcedPlayback && !state.result && session.bridge.supportsToolResultSuppression === false ? createDeferred() : void 0;
+		if (providerDelivery) {
+			const deliveries = this.providerDeliveries.get(state) ?? /* @__PURE__ */ new Set();
+			deliveries.add(providerDelivery);
+			this.providerDeliveries.set(state, deliveries);
+		}
+		logger$4.info(`discord voice: realtime consult ${state.result ? "reused recent" : "joined in-flight"} agent result call=${callId} speaker=${state.speaker.speakerLabel} owner=${state.speaker.senderIsOwner}`);
+		try {
+			const result = await pendingResult;
+			if (state.providerEpoch !== this.params.providerEpoch()) return true;
+			await this.submitAgentProxyConsultResult(callId, session, result, Boolean(state.handledByForcedPlayback && !providerDelivery));
+			if (providerDelivery && state.providerEpoch === this.params.providerEpoch()) state.handledByForcedPlayback = false;
+		} finally {
+			if (providerDelivery) {
+				providerDelivery.resolve();
+				const deliveries = this.providerDeliveries.get(state);
+				deliveries?.delete(providerDelivery);
+				if (deliveries?.size === 0) this.providerDeliveries.delete(state);
+			}
+		}
+		return true;
+	}
+	async submitAgentProxyConsultResult(callId, session, result, alreadyDelivered = false) {
+		if ("status" in result) await this.submitTerminalRealtimeToolResult(callId, session, CANCELLED_CONSULT_RESULT);
+		else if (alreadyDelivered) await this.submitTerminalRealtimeToolResult(callId, session, {
+			status: "already_delivered",
+			message: "OpenClaw already delivered this answer to Discord voice. Do not repeat it."
+		});
+		else await session.submitToolResult(callId, result);
+	}
+	clearProviderConsultState() {
+		for (const [state, deliveries] of this.providerDeliveries) {
+			state.handledByForcedPlayback = false;
+			for (const delivery of deliveries) delivery.resolve();
+		}
+		this.providerDeliveries.clear();
+		this.params.harness.forcedConsults.clear();
+	}
+};
+//#endregion
+//#region extensions/discord/src/voice/realtime-output.ts
+const logger$3 = createSubsystemLogger("discord/voice");
+const DISCORD_RAW_PCM_FRAME_BYTES = 3840;
+const DISCORD_RAW_PCM_BYTES_PER_MS = 192;
+const DISCORD_REALTIME_OUTPUT_PREROLL_FRAMES = 25;
+const DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS = 3e3;
+/** One output stream retains ownership through queued and audible playback. */
+var DiscordRealtimeOutput = class {
+	constructor(params) {
+		this.params = params;
+		this.activity = createRealtimeVoiceOutputActivityTracker();
+		this.stream = new PassThrough({ highWaterMark: DISCORD_RAW_PCM_FRAME_BYTES * 128 });
+		this.playbackMarks = [];
+		this.playedPcmBytes = 0;
+		this.reportedPlaybackMs = 0;
+		this.audioSpans = [];
+		this.buffers = [];
+		this.bufferedBytes = 0;
+		this.closed = false;
+		this.failed = false;
+		this.stream.once("close", () => {
+			if (!this.activity.snapshot().playbackStarted) this.close("stream-close");
+		});
+	}
+	pendingBytes() {
+		return this.closed ? 0 : this.bufferedBytes + this.stream.writableLength + this.stream.readableLength;
+	}
+	playbackItems() {
+		const playedMs = Math.min(this.playedPcmBytes / DISCORD_RAW_PCM_BYTES_PER_MS, this.activity.snapshot().audioMs);
+		for (const span of this.audioSpans) span.item.audioEndMs += Math.max(0, Math.min(playedMs, span.endMs) - Math.max(this.reportedPlaybackMs, span.startMs));
+		this.reportedPlaybackMs = playedMs;
+		return this.audioSpans.filter(({ endMs }) => endMs > playedMs).map(({ item }) => item);
+	}
+	markPlayback(acknowledge) {
+		if (!this.closed) this.playbackMarks.push({
+			endBytes: this.activity.snapshot().sinkAudioBytes,
+			acknowledge
 		});
-		const submitAlreadyDelivered = async () => {
-			if (state.providerEpoch !== this.params.providerEpoch()) return;
-			await this.submitTerminalRealtimeToolResult(callId, session, {
-				status: "already_delivered",
-				message: "OpenClaw already delivered this answer to Discord voice. Do not repeat it."
+	}
+	append(pcm, activity, item) {
+		if (this.closed) return;
+		const startMs = this.activity.snapshot().audioMs;
+		if (item) {
+			const previous = this.audioSpans.at(-1);
+			const endMs = startMs + activity.audioMs;
+			if (previous?.item === item && previous.endMs === startMs) previous.endMs = endMs;
+			else this.audioSpans.push({
+				item,
+				startMs,
+				endMs
 			});
-		};
-		const submitResult = async (result) => {
-			if (state.providerEpoch !== this.params.providerEpoch()) return;
-			if (state.handledByForcedPlayback && !providerOwnsDelivery) {
-				await submitAlreadyDelivered();
-				return;
-			}
-			if (result.status === "fulfilled") {
-				await session.submitToolResult(callId, { text: result.text });
-				return;
-			}
-			await session.submitToolResult(callId, { error: result.error });
-		};
-		if (state.result) {
-			logger$2.info(`discord voice: realtime consult reused recent agent result call=${callId || "unknown"} speaker=${state.speaker.speakerLabel} owner=${state.speaker.senderIsOwner}`);
-			await submitResult(state.result);
-			return true;
 		}
-		if (!state.promise) return false;
-		logger$2.info(`discord voice: realtime consult joined in-flight agent result call=${callId || "unknown"} speaker=${state.speaker.speakerLabel} owner=${state.speaker.senderIsOwner}`);
-		if (state.handledByForcedPlayback && !providerOwnsDelivery) {
-			await state.promise.catch(() => void 0);
-			if (state.providerEpoch !== this.params.providerEpoch()) return true;
-			await submitAlreadyDelivered();
-			return true;
+		this.activity.markAudio(activity);
+		if (this.activity.snapshot().playbackStarted && !this.drainHandler) {
+			if (!this.stream.write(pcm)) this.waitForDrain();
+			return;
+		}
+		this.buffers.push(pcm);
+		this.bufferedBytes += pcm.length;
+		if (!this.drainHandler && this.bufferedBytes >= DISCORD_RAW_PCM_FRAME_BYTES * DISCORD_REALTIME_OUTPUT_PREROLL_FRAMES) this.startPlayback();
+	}
+	finish(reason, playBuffered) {
+		if (this.closed) return;
+		this.activity.markStreamEnding();
+		const activity = this.activity.snapshot();
+		logger$3.info(`discord voice: realtime audio playback finishing reason=${reason} ${this.params.logContext} audioMs=${Math.floor(activity.audioMs)} chunks=${activity.chunks}`);
+		if (!playBuffered) {
+			this.close(reason);
+			return;
+		}
+		this.startPlayback();
+		if (this.activity.snapshot().playbackStarted) {
+			this.scheduleWatchdog(reason);
+			if (!this.drainHandler) this.stream.end();
+		}
+	}
+	close(reason) {
+		if (this.closed) return;
+		const playbackRetirement = reason === "player-idle" || reason === "output-pipeline-error" || reason === "playback-watchdog";
+		const heardMarks = playbackRetirement ? this.playbackMarks.filter((mark) => mark.endBytes <= this.playedPcmBytes) : [];
+		const lostPlaybackMarks = playbackRetirement && this.playbackMarks.some((mark) => mark.endBytes > this.playedPcmBytes);
+		this.closed = true;
+		this.playbackMarks = [];
+		this.playbackItems();
+		this.clearWatchdog();
+		const activity = this.activity.snapshot();
+		logger$3.info(`discord voice: realtime audio playback stopped reason=${reason} ${this.params.logContext} audioMs=${Math.floor(activity.audioMs)} elapsedMs=${this.activity.elapsedPlaybackMs()} chunks=${activity.chunks} discordBytes=${activity.sinkAudioBytes} realtimeBytes=${activity.sourceAudioBytes}`);
+		this.buffers = [];
+		this.bufferedBytes = 0;
+		if (this.drainHandler) {
+			this.stream.off("drain", this.drainHandler);
+			this.drainHandler = void 0;
+		}
+		this.stream.end();
+		this.stream.destroy();
+		if (lostPlaybackMarks) this.params.onError(/* @__PURE__ */ new Error(`Discord realtime audio stopped before playback completed: ${reason}`));
+		this.params.onClose(this, reason);
+		if (this.request) {
+			this.params.player.cancel(this.request);
+			this.request = void 0;
 		}
-		let result;
 		try {
-			result = {
-				status: "fulfilled",
-				text: await state.promise
-			};
+			for (const mark of heardMarks) mark.acknowledge();
 		} catch (error) {
-			result = {
-				status: "rejected",
-				error: formatErrorMessage(error)
-			};
+			this.params.onError(error);
 		}
-		if (state.providerEpoch !== this.params.providerEpoch()) return true;
+	}
+	startPlayback() {
+		if (this.closed || this.request) return;
+		this.request = {
+			createResource: () => this.createResource(),
+			onStart: () => {
+				this.activity.markPlaybackStarted();
+				this.params.onStart();
+				if (this.activity.snapshot().streamEnding) {
+					this.scheduleWatchdog("player-start");
+					if (!this.drainHandler) this.stream.end();
+				}
+			},
+			onIdle: () => this.close(this.failed ? "output-pipeline-error" : "player-idle"),
+			onBargeIn: this.params.onBargeIn,
+			onError: this.params.onError
+		};
+		this.params.player.enqueue(this.request);
+	}
+	createResource() {
+		const voiceSdk = loadDiscordVoiceSdk();
+		const opusStream = createDiscordOpusEncodeStream();
+		opusStream.once("error", () => {
+			this.failed = true;
+		});
+		pipeline(this.stream, opusStream, (error) => {
+			if (!error || this.closed) return;
+			logger$3.warn(`discord voice: realtime output pipeline failed ${this.params.logContext}: ${formatErrorMessage(error)}`);
+			this.close("output-pipeline-error");
+		});
+		const buffered = Buffer.concat(this.buffers, this.bufferedBytes);
+		this.buffers = [];
+		this.bufferedBytes = 0;
+		if (buffered.length > 0 && !this.stream.write(buffered)) this.waitForDrain();
+		const resource = voiceSdk.createAudioResource(opusStream, { inputType: voiceSdk.StreamType.Opus });
+		const read = resource.read.bind(resource);
+		resource.read = () => {
+			let packet;
+			try {
+				packet = read();
+				if (!packet && opusStream.flushPartialFrame()) packet = read();
+				if (packet) this.playedPcmBytes += opusStream.takePcmBytes(packet);
+			} catch (error) {
+				opusStream.destroy(error instanceof Error ? error : new Error(formatErrorMessage(error)));
+				return null;
+			}
+			if (this.playbackMarks.length > 0) queueMicrotask(() => this.acknowledgePlayedMarks());
+			return packet;
+		};
+		return resource;
+	}
+	acknowledgePlayedMarks() {
 		try {
-			await submitResult(result);
-			if (providerOwnsDelivery) {
-				state.handledByForcedPlayback = false;
-				state.settleProviderDelivery = void 0;
-				resolveProviderDelivery?.(true);
+			while (!this.closed) {
+				const mark = this.playbackMarks[0];
+				if (!mark || mark.endBytes > this.playedPcmBytes) return;
+				this.playbackMarks.shift();
+				mark.acknowledge();
 			}
 		} catch (error) {
-			state.settleProviderDelivery = void 0;
-			resolveProviderDelivery?.(false);
-			throw error;
+			this.params.onError(error);
 		}
-		return true;
 	}
-	clearProviderConsultState() {
-		for (const handle of this.params.harness.forcedConsults.handles()) {
-			const state = handle.context;
-			if (!state) continue;
-			state.handledByForcedPlayback = false;
-			state.settleProviderDelivery?.(false);
-			state.settleProviderDelivery = void 0;
-			state.providerDelivery = void 0;
-		}
-		this.params.harness.forcedConsults.clear();
+	waitForDrain() {
+		if (this.drainHandler || this.closed) return;
+		logger$3.info(`discord voice: realtime audio playback buffering ${this.params.logContext} bufferedBytes=${this.stream.writableLength + this.stream.readableLength}`);
+		this.drainHandler = () => {
+			this.drainHandler = void 0;
+			if (this.closed) return;
+			let refreshWatchdog = this.activity.snapshot().streamEnding;
+			while (this.buffers.length > 0) {
+				const buffered = this.buffers.shift();
+				if (!buffered) break;
+				this.bufferedBytes -= buffered.length;
+				const writable = this.stream.write(buffered);
+				if (refreshWatchdog) {
+					this.scheduleWatchdog("output-drain");
+					refreshWatchdog = false;
+				}
+				if (!writable) {
+					this.waitForDrain();
+					return;
+				}
+			}
+			if (this.activity.snapshot().streamEnding) this.stream.end();
+		};
+		this.stream.once("drain", this.drainHandler);
+	}
+	scheduleWatchdog(reason) {
+		this.clearWatchdog();
+		const timeoutMs = this.activity.playbackWatchdogDelayMs({
+			marginMs: DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS,
+			minMs: DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS
+		});
+		if (timeoutMs === void 0) return;
+		this.watchdog = setTimeout(() => {
+			this.watchdog = void 0;
+			logger$3.warn(`discord voice: realtime audio playback watchdog fired reason=${reason} ${this.params.logContext} audioMs=${Math.floor(this.activity.snapshot().audioMs)} elapsedMs=${this.activity.elapsedPlaybackMs()}`);
+			this.close("playback-watchdog");
+		}, timeoutMs);
+	}
+	clearWatchdog() {
+		clearTimeout(this.watchdog);
+		this.watchdog = void 0;
 	}
 };
 //#endregion
 //#region extensions/discord/src/voice/realtime-playback.ts
-const logger$1 = createSubsystemLogger("discord/voice");
+const logger$2 = createSubsystemLogger("discord/voice");
 const DISCORD_REALTIME_CONTROL_SPEECH_DEDUPE_MS = 5e3;
-const DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS = 3e3;
-const DISCORD_REALTIME_MAX_RETAINED_EXACT_SPEECH_MESSAGES = 32;
-const DISCORD_REALTIME_MAX_RETAINED_EXACT_SPEECH_BYTES = 32 * 1024;
+const DISCORD_REALTIME_MAX_RETAINED_RESPONSES = 32;
+const DISCORD_REALTIME_MAX_RETAINED_EXACT_SPEECH_BYTES = 32768;
 const DISCORD_REALTIME_WAKE_ACKS = [
 	"Yeah.",
 	"Mm-hmm.",
 	"Got it.",
 	"One sec."
 ];
-const DISCORD_RAW_PCM_FRAME_BYTES = 3840;
-const DISCORD_REALTIME_OUTPUT_PREROLL_FRAMES = 25;
-const DISCORD_REALTIME_MAX_PENDING_OUTPUT_BYTES = DISCORD_RAW_PCM_FRAME_BYTES * 6e3;
+const DISCORD_REALTIME_MAX_PENDING_OUTPUT_BYTES = 2304e4;
 function normalizeControlSpeechText(text) {
 	return text.toLowerCase().replace(/\s+/g, " ").trim();
 }
 var DiscordRealtimePlayback = class {
 	constructor(params) {
 		this.params = params;
-		this.outputStream = null;
-		this.outputPacedBuffers = [];
-		this.outputPacedBytes = 0;
+		this.outputs = /* @__PURE__ */ new Set();
+		this.generatingItems = /* @__PURE__ */ new Map();
+		this.responseAudio = "completed";
 		this.queuedExactSpeechMessages = [];
 		this.exactSpeechState = { status: "idle" };
 		this.wakeNameAckIndex = 0;
-		this.playerIdleHandler = () => {
-			const hadOutputAudio = this.isOutputAudioActive();
-			this.resetOutputStream("player-idle");
-			if (hadOutputAudio) this.completeExactSpeechResponse("player-idle");
-		};
-	}
-	attachPlayer() {
-		const voiceSdk = loadDiscordVoiceSdk();
-		this.params.entry.player.on(voiceSdk.AudioPlayerStatus.Idle, this.playerIdleHandler);
+		this.unregisterPlayerLane = this.params.player.registerLane({
+			hasOutput: () => this.isOutputAudioActive(),
+			onBargeIn: (reason) => this.handleBargeIn(reason),
+			cancelForControl: () => this.cancelForControl()
+		});
 	}
 	close() {
+		this.unregisterPlayerLane();
 		this.queuedExactSpeechMessages = [];
 		this.exactSpeechState = { status: "idle" };
 		this.clearOutputAudio("session-close");
-		const voiceSdk = loadDiscordVoiceSdk();
-		this.params.entry.player.off(voiceSdk.AudioPlayerStatus.Idle, this.playerIdleHandler);
 	}
 	handleBargeIn(reason = "barge-in") {
 		if (!this.isBargeInEnabled()) {
-			logger$1.info(`discord voice: realtime barge-in ignored reason=${reason} bargeIn=false guild=${this.params.entry.guildId} channel=${this.params.entry.channelId}`);
+			logger$2.info(`discord voice: realtime barge-in ignored reason=${reason} bargeIn=false guild=${this.params.entry.guildId} channel=${this.params.entry.channelId}`);
 			return;
 		}
 		if (!this.hasInterruptibleOutputAudio()) {
-			logger$1.info(`discord voice: realtime barge-in ignored reason=${reason} outputActive=false guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} playbackChunks=${this.params.harness.outputActivity.snapshot().chunks}`);
+			logger$2.info(`discord voice: realtime barge-in ignored reason=${reason} outputActive=false guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} playbackChunks=${this.params.harness.outputActivity.snapshot().chunks}`);
 			return;
 		}
-		logger$1.info(`discord voice: realtime barge-in requested reason=${reason} guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} outputAudioMs=${this.outputAudioMs()} outputActive=${this.isOutputAudioActive()} playbackChunks=${this.params.harness.outputActivity.snapshot().chunks}`);
-		this.params.harness.handleBargeIn({ audioPlaybackActive: true }, () => {});
+		logger$2.info(`discord voice: realtime barge-in requested reason=${reason} guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} outputAudioMs=${this.outputAudioMs()} outputActive=${this.isOutputAudioActive()} playbackChunks=${this.params.harness.outputActivity.snapshot().chunks}`);
+		const bridge = this.params.bridge();
+		this.params.harness.handleBargeIn({ audioPlaybackActive: true }, () => {
+			if (!bridge?.bridge.handleBargeIn) this.clearOutputAudio(reason);
+		});
 	}
 	isBargeInEnabled() {
 		if (this.params.wakeNameRequired()) return false;
@@ -693,67 +944,89 @@ var DiscordRealtimePlayback = class {
 	}
 	hasInterruptibleOutputAudio() {
 		this.params.bridge()?.setMediaTimestamp(this.outputAudioMs());
-		const streamActive = Boolean(this.outputStream && !this.outputStream.destroyed);
-		return this.params.harness.outputActivity.isInterruptible(streamActive);
+		return this.isOutputAudioActive();
+	}
+	getPlaybackState() {
+		const items = /* @__PURE__ */ new Set();
+		for (const output of this.outputs) {
+			const outputItems = output.playbackItems();
+			if (outputItems.some((item) => this.generatingItems.get(item.itemId) === item)) for (const item of this.generatingItems.values()) items.add(item);
+			for (const item of outputItems) items.add(item);
+		}
+		for (const item of this.generatingItems.values()) items.add(item);
+		return Array.from(items, (item) => ({
+			...item,
+			audioEndMs: Math.floor(item.audioEndMs)
+		}));
+	}
+	beginResponse() {
+		if (this.responseAudio === "completed") this.responseAudio = "accepting";
+	}
+	sendOutputMark(acknowledge) {
+		if (!this.params.stopped() && this.responseAudio === "accepting") this.generatingOutput?.markPlayback(acknowledge);
 	}
-	sendOutputAudio(realtimePcm24kMono) {
+	sendOutputAudio(realtimePcm24kMono, metadata) {
 		this.params.markProviderGenerationObserved();
-		if (this.params.stopped()) return;
+		if (this.params.stopped() || this.responseAudio === "discarding") return;
 		const discordPcm = convertRealtimePcm24kMonoToDiscordPcm48kStereo(realtimePcm24kMono);
 		if (discordPcm.length === 0) return;
 		this.params.bridge()?.setMediaTimestamp(this.outputAudioMs());
-		if (this.params.harness.outputActivity.snapshot().streamEnding) {
-			logVoiceVerbose(`realtime output audio ignored after stream ending: guild ${this.params.entry.guildId} channel ${this.params.entry.channelId}`);
+		const pendingBytes = Array.from(this.outputs).reduce((total, output) => total + output.pendingBytes(), 0);
+		if (discordPcm.length > DISCORD_REALTIME_MAX_PENDING_OUTPUT_BYTES - pendingBytes || !this.generatingOutput && this.outputs.size >= DISCORD_REALTIME_MAX_RETAINED_RESPONSES) {
+			this.stopAfterPlaybackFailure("output-audio-overflow", /* @__PURE__ */ new Error(`Discord realtime audio playback overflow: responses=${this.outputs.size} pendingBytes=${pendingBytes} incomingBytes=${discordPcm.length}`));
 			return;
 		}
-		const stream = this.ensureOutputStream();
-		if (this.exactSpeechState.status === "active") this.exactSpeechState = {
-			...this.exactSpeechState,
-			audioStarted: true
-		};
-		this.params.harness.recordOutputAudio(realtimePcm24kMono, {
+		this.beginResponse();
+		const output = this.generatingOutput ?? this.createOutput();
+		const activity = {
 			audioMs: realtimeVoiceAudioDurationMs(REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ, realtimePcm24kMono.byteLength),
 			sourceAudioBytes: realtimePcm24kMono.length,
 			sinkAudioBytes: discordPcm.length
-		});
-		this.queueOutputAudio(stream, discordPcm);
+		};
+		let item;
+		if (metadata) {
+			item = this.generatingItems.get(metadata.itemId);
+			if (!item) {
+				item = {
+					itemId: metadata.itemId,
+					audioEndMs: 0
+				};
+				this.generatingItems.set(metadata.itemId, item);
+			}
+		}
+		this.params.harness.recordOutputAudio(realtimePcm24kMono, activity);
+		output.append(discordPcm, activity, item);
 	}
 	clearOutputAudio(reason = "clear") {
-		this.resetOutputStream(reason);
-		this.params.entry.player.stop(true);
-	}
-	finishOutputAudioStream(reason, { playBuffered = true } = {}) {
-		const stream = this.outputStream;
-		if (!stream || stream.destroyed || this.params.harness.outputActivity.snapshot().streamEnding) return;
-		this.params.harness.outputActivity.markStreamEnding();
-		logger$1.info(`discord voice: realtime audio playback finishing reason=${reason} guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} audioMs=${this.outputAudioMs()} chunks=${this.params.harness.outputActivity.snapshot().chunks}`);
-		if (playBuffered) {
-			this.startOutputPlayback(stream);
-			this.scheduleOutputPlaybackWatchdog(reason, stream);
-		} else {
-			this.resetOutputStream(reason);
-			this.params.entry.player.stop(true);
-			this.completeExactSpeechResponse(reason);
-			return;
-		}
-		if (!this.outputDrainHandler) stream.end();
+		if (this.responseAudio === "accepting") this.responseAudio = "discarding";
+		this.generatingOutput = void 0;
+		this.generatingItems.clear();
+		const outputs = Array.from(this.outputs);
+		this.outputs.clear();
+		for (const output of outputs.toReversed()) output.close(reason);
+		this.params.harness.outputActivity.reset();
+		this.completeExactSpeechResponse(reason);
 	}
 	handleResponseDone(outcome) {
-		if (this.exactSpeechState.status === "active" && !this.exactSpeechState.audioStarted) this.completeExactSpeechResponse(outcome.status);
-		this.finishOutputAudioStream(outcome.status, { playBuffered: outcome.status === "completed" });
+		const output = this.generatingOutput;
+		this.generatingOutput = void 0;
+		this.generatingItems.clear();
+		this.responseAudio = "completed";
+		output?.finish(outcome.status, outcome.status === "completed");
+		this.completeExactSpeechResponse(outcome.status);
 	}
 	enqueueExactSpeechMessage(text) {
 		if (this.params.stopped() || !text.trim()) return;
 		const retainedMessages = this.queuedExactSpeechMessages.length + (this.exactSpeechState.status === "active" ? 1 : 0);
 		const retainedBytes = this.queuedExactSpeechMessages.reduce((total, message) => total + Buffer.byteLength(message, "utf8"), 0) + Buffer.byteLength(this.exactSpeechState.status === "active" ? this.exactSpeechState.message : "", "utf8");
 		const incomingBytes = Buffer.byteLength(text, "utf8");
-		if (retainedMessages >= DISCORD_REALTIME_MAX_RETAINED_EXACT_SPEECH_MESSAGES || retainedBytes + incomingBytes > DISCORD_REALTIME_MAX_RETAINED_EXACT_SPEECH_BYTES) {
-			this.stopAfterOverflow("exact-speech-overflow", /* @__PURE__ */ new Error(`Discord realtime exact speech overflow: retained=${retainedMessages} retainedBytes=${retainedBytes} incomingBytes=${incomingBytes}`));
+		if (retainedMessages >= DISCORD_REALTIME_MAX_RETAINED_RESPONSES || retainedBytes + incomingBytes > DISCORD_REALTIME_MAX_RETAINED_EXACT_SPEECH_BYTES) {
+			this.stopAfterPlaybackFailure("exact-speech-overflow", /* @__PURE__ */ new Error(`Discord realtime exact speech overflow: retained=${retainedMessages} retainedBytes=${retainedBytes} incomingBytes=${incomingBytes}`));
 			return;
 		}
-		if (!this.params.bridgeReady() || this.exactSpeechState.status === "active" || this.hasInterruptibleOutputAudio()) {
+		if (!this.params.bridgeReady() || this.responseAudio !== "completed" || this.exactSpeechState.status === "active" || this.hasInterruptibleOutputAudio()) {
 			this.queuedExactSpeechMessages.push(text);
-			logger$1.info(`discord voice: realtime exact speech queued guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} queued=${this.queuedExactSpeechMessages.length} outputAudioMs=${this.outputAudioMs()} outputActive=${this.isOutputAudioActive()}`);
+			logger$2.info(`discord voice: realtime exact speech queued guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} queued=${this.queuedExactSpeechMessages.length} outputAudioMs=${this.outputAudioMs()} outputActive=${this.isOutputAudioActive()}`);
 			return;
 		}
 		this.sendExactSpeechMessage(text);
@@ -762,32 +1035,27 @@ var DiscordRealtimePlayback = class {
 		return [...this.exactSpeechState.status === "active" ? [this.exactSpeechState.message] : [], ...this.queuedExactSpeechMessages];
 	}
 	drainQueuedExactSpeechMessages(reason) {
-		if (this.params.stopped() || !this.params.bridgeReady() || this.exactSpeechState.status === "active" || this.queuedExactSpeechMessages.length === 0 || this.hasInterruptibleOutputAudio()) return;
+		if (this.params.stopped() || !this.params.bridgeReady() || this.responseAudio !== "completed" || this.exactSpeechState.status === "active" || this.queuedExactSpeechMessages.length === 0 || this.hasInterruptibleOutputAudio()) return;
 		const next = this.queuedExactSpeechMessages.shift();
 		if (!next) return;
-		logger$1.info(`discord voice: realtime exact speech dequeued reason=${reason} guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} queued=${this.queuedExactSpeechMessages.length}`);
+		logger$2.info(`discord voice: realtime exact speech dequeued reason=${reason} guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} queued=${this.queuedExactSpeechMessages.length}`);
 		this.sendExactSpeechMessage(next);
 	}
 	sendWakeNameAck(result) {
 		if (!result.allowed || this.params.stopped() || this.exactSpeechState.status === "active") return;
-		if (this.hasInterruptibleOutputAudio()) {
-			logger$1.info(`discord voice: realtime wake-name ack skipped outputActive=true voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId}`);
+		if (this.params.player.isActive() || this.hasInterruptibleOutputAudio()) {
+			logger$2.info(`discord voice: realtime wake-name ack skipped outputActive=true voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId}`);
 			return;
 		}
 		const ack = DISCORD_REALTIME_WAKE_ACKS[this.wakeNameAckIndex % DISCORD_REALTIME_WAKE_ACKS.length];
 		this.wakeNameAckIndex += 1;
-		logger$1.info(`discord voice: realtime wake-name ack canonical=${result.activationName} heard=${result.heardName} match=${result.match} voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId}`);
+		logger$2.info(`discord voice: realtime wake-name ack canonical=${result.activationName} heard=${result.heardName} match=${result.match} voiceSession=${this.params.entry.voiceSessionKey} agent=${this.params.entry.route.agentId}`);
 		this.enqueueExactSpeechMessage(ack ?? "Yeah.");
 	}
 	speakControlResult(text) {
 		const trimmed = text.trim();
 		if (this.params.stopped() || !trimmed) return;
-		this.queuedExactSpeechMessages = [];
-		this.completeExactSpeechResponse("active-run-control", { drain: false });
-		this.params.harness.handleBargeIn({
-			audioPlaybackActive: true,
-			force: true
-		}, () => this.clearOutputAudio("active-run-control"));
+		this.params.player.cancelForControl();
 		this.lastControlSpeech = {
 			normalizedText: normalizeControlSpeechText(trimmed),
 			sentAt: Date.now(),
@@ -795,6 +1063,15 @@ var DiscordRealtimePlayback = class {
 		};
 		this.enqueueExactSpeechMessage(trimmed);
 	}
+	cancelForControl() {
+		this.queuedExactSpeechMessages = [];
+		this.exactSpeechState = { status: "idle" };
+		if (this.responseAudio === "completed" && this.outputs.size === 0) return;
+		this.params.harness.handleBargeIn({
+			audioPlaybackActive: true,
+			force: true
+		}, () => this.clearOutputAudio("active-run-control"));
+	}
 	suppressDuplicateControlSpeech(text) {
 		const recent = this.lastControlSpeech;
 		if (!recent) return;
@@ -805,7 +1082,7 @@ var DiscordRealtimePlayback = class {
 		if (normalizeControlSpeechText(text) !== recent.normalizedText) return;
 		recent.assistantTranscriptCount += 1;
 		if (recent.assistantTranscriptCount <= 1) return;
-		logger$1.info(`discord voice: realtime duplicate active-run control speech suppressed guild=${this.params.entry.guildId} channel=${this.params.entry.channelId}`);
+		logger$2.info(`discord voice: realtime duplicate active-run control speech suppressed guild=${this.params.entry.guildId} channel=${this.params.entry.channelId}`);
 		this.params.harness.handleBargeIn({
 			audioPlaybackActive: true,
 			force: true
@@ -813,168 +1090,73 @@ var DiscordRealtimePlayback = class {
 	}
 	resetProviderContinuity(reason) {
 		this.lastControlSpeech = void 0;
-		const replayExactSpeech = this.exactSpeechState.status === "active" && !this.params.harness.outputActivity.snapshot().playbackStarted ? this.exactSpeechState.message : void 0;
+		const replayExactSpeech = this.exactSpeechState.status === "active" && !this.exactSpeechState.output?.activity.snapshot().playbackStarted ? this.exactSpeechState.message : void 0;
 		this.exactSpeechState = { status: "idle" };
 		if (replayExactSpeech) this.queuedExactSpeechMessages.unshift(replayExactSpeech);
+		this.responseAudio = "discarding";
 		this.params.harness.flushOutput(() => this.clearOutputAudio(reason));
+		this.responseAudio = "completed";
 		this.params.harness.finishOutputAudio(reason);
 	}
 	outputAudioMs() {
 		return Math.floor(this.params.harness.outputActivity.snapshot().audioMs);
 	}
 	isOutputAudioActive() {
-		return this.params.harness.outputActivity.isActive(Boolean(this.outputStream && !this.outputStream.destroyed));
+		return this.outputs.size > 0 || this.generatingItems.size > 0;
 	}
-	currentOutputStream() {
-		return this.outputStream;
-	}
-	stopAfterOverflow(reason, error) {
-		this.params.stopTerminally(reason);
+	stopAfterPlaybackFailure(reason, error) {
+		this.params.stopTerminally();
 		this.queuedExactSpeechMessages = [];
 		this.exactSpeechState = { status: "idle" };
 		this.clearOutputAudio(reason);
 		this.params.onTerminalError(error);
 	}
-	ensureOutputStream() {
-		if (this.outputStream && !this.outputStream.destroyed && !this.outputStream.writableEnded) return this.outputStream;
-		const stream = new PassThrough({ highWaterMark: DISCORD_RAW_PCM_FRAME_BYTES * 128 });
-		this.outputStream = stream;
-		this.outputPacedBuffers = [];
-		this.outputPacedBytes = 0;
-		this.params.harness.outputActivity.markStreamOpened();
-		stream.once("close", () => {
-			if (this.outputStream !== stream || this.params.harness.outputActivity.snapshot().playbackStarted) return;
-			this.resetOutputStream("stream-close");
-			this.completeExactSpeechResponse("stream-close");
-		});
-		return stream;
-	}
-	queueOutputAudio(stream, discordPcm) {
-		const pendingBytes = this.outputPacedBytes + stream.writableLength + stream.readableLength;
-		if (discordPcm.length > DISCORD_REALTIME_MAX_PENDING_OUTPUT_BYTES - pendingBytes) {
-			this.stopAfterOverflow("output-audio-overflow", /* @__PURE__ */ new Error(`Discord realtime audio playback overflow: pendingBytes=${pendingBytes} incomingBytes=${discordPcm.length}`));
-			return;
-		}
-		if (this.params.harness.outputActivity.snapshot().playbackStarted && !this.outputDrainHandler) {
-			if (!stream.write(discordPcm)) this.waitForOutputDrain(stream);
-			return;
-		}
-		this.outputPacedBuffers.push(discordPcm);
-		this.outputPacedBytes += discordPcm.length;
-		if (!this.outputDrainHandler && this.outputPacedBytes >= DISCORD_RAW_PCM_FRAME_BYTES * DISCORD_REALTIME_OUTPUT_PREROLL_FRAMES) this.startOutputPlayback(stream);
-	}
-	waitForOutputDrain(stream) {
-		if (this.outputDrainHandler || this.outputStream !== stream) return;
-		logger$1.info(`discord voice: realtime audio playback buffering guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} bufferedBytes=${stream.writableLength + stream.readableLength}`);
-		this.outputDrainHandler = () => {
-			if (this.params.stopped() || this.outputStream !== stream || stream.destroyed) return;
-			this.outputDrainHandler = void 0;
-			let refreshWatchdog = this.params.harness.outputActivity.snapshot().streamEnding;
-			while (this.outputPacedBuffers.length > 0) {
-				const buffered = this.outputPacedBuffers.shift();
-				if (!buffered) break;
-				this.outputPacedBytes -= buffered.length;
-				const writable = stream.write(buffered);
-				if (refreshWatchdog) {
-					this.scheduleOutputPlaybackWatchdog("output-drain", stream);
-					refreshWatchdog = false;
-				}
-				if (!writable) {
-					this.waitForOutputDrain(stream);
-					return;
+	createOutput() {
+		const logContext = `guild=${this.params.entry.guildId} channel=${this.params.entry.channelId}`;
+		const output = new DiscordRealtimeOutput({
+			player: this.params.player,
+			logContext,
+			onStart: () => {
+				this.params.harness.outputActivity.markPlaybackStarted();
+				const config = this.params.realtimeConfig();
+				logger$2.info(`discord voice: realtime audio playback started ${logContext} mode=${this.params.mode} model=${config?.model ?? "provider-default"} voice=${config?.speakerVoice ?? config?.speakerVoiceId ?? "provider-default"}`);
+			},
+			onClose: (closed, reason) => {
+				if (!this.outputs.delete(closed)) return;
+				if (this.generatingOutput === closed) {
+					this.generatingOutput = void 0;
+					if (reason !== "player-idle") this.responseAudio = "discarding";
 				}
-			}
-			if (this.params.harness.outputActivity.snapshot().streamEnding) stream.end();
-		};
-		stream.once("drain", this.outputDrainHandler);
-	}
-	startOutputPlayback(stream) {
-		if (this.params.harness.outputActivity.snapshot().playbackStarted || stream.destroyed) return;
-		const voiceSdk = loadDiscordVoiceSdk();
-		const opusStream = createDiscordOpusEncodeStream();
-		pipeline(stream, opusStream, (err) => {
-			if (!err || this.outputStream !== stream) return;
-			logger$1.warn(`discord voice: realtime output pipeline failed guild=${this.params.entry.guildId} channel=${this.params.entry.channelId}: ${formatErrorMessage(err)}`);
-			this.clearOutputAudio("output-pipeline-error");
-			this.completeExactSpeechResponse("output-pipeline-error");
-		});
-		const buffered = Buffer.concat(this.outputPacedBuffers, this.outputPacedBytes);
-		this.outputPacedBuffers = [];
-		this.outputPacedBytes = 0;
-		if (buffered.length > 0 && !stream.write(buffered)) this.waitForOutputDrain(stream);
-		const resource = voiceSdk.createAudioResource(opusStream, { inputType: voiceSdk.StreamType.Opus });
-		this.params.entry.player.play(resource);
-		this.params.harness.outputActivity.markPlaybackStarted();
-		const realtimeConfig = this.params.realtimeConfig();
-		logger$1.info(`discord voice: realtime audio playback started guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} mode=${this.params.mode} model=${realtimeConfig?.model ?? "provider-default"} voice=${realtimeConfig?.speakerVoice ?? realtimeConfig?.speakerVoiceId ?? "provider-default"}`);
-	}
-	resetOutputStream(reason = "reset") {
-		const stream = this.outputStream;
-		this.clearOutputPlaybackWatchdog();
-		this.logOutputAudioStopped(reason);
-		this.outputStream = null;
-		this.outputPacedBuffers = [];
-		this.outputPacedBytes = 0;
-		if (this.outputDrainHandler) {
-			stream?.off("drain", this.outputDrainHandler);
-			this.outputDrainHandler = void 0;
-		}
-		this.params.harness.outputActivity.reset();
-		stream?.end();
-		stream?.destroy();
-	}
-	scheduleOutputPlaybackWatchdog(reason, stream) {
-		this.clearOutputPlaybackWatchdog();
-		const timeoutMs = this.params.harness.outputActivity.playbackWatchdogDelayMs({
-			marginMs: DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS,
-			minMs: DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS
+				if (this.outputs.size === 0) this.params.harness.outputActivity.reset();
+				this.completeExactSpeechResponse(reason);
+			},
+			onBargeIn: (reason) => this.handleBargeIn(reason),
+			onError: (error) => this.stopAfterPlaybackFailure("output-playback-error", error instanceof Error ? error : new Error(formatErrorMessage(error)))
 		});
-		if (timeoutMs === void 0) return;
-		this.outputPlaybackWatchdog = setTimeout(() => {
-			this.outputPlaybackWatchdog = void 0;
-			if (this.outputStream && this.outputStream !== stream) return;
-			if (!this.outputStream && !this.isOutputAudioActive()) {
-				this.completeExactSpeechResponse("playback-watchdog");
-				return;
-			}
-			logger$1.warn(`discord voice: realtime audio playback watchdog fired reason=${reason} guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} audioMs=${this.outputAudioMs()} elapsedMs=${this.params.harness.outputActivity.elapsedPlaybackMs()}`);
-			this.clearOutputAudio("playback-watchdog");
-			this.completeExactSpeechResponse("playback-watchdog");
-		}, timeoutMs);
-	}
-	clearOutputPlaybackWatchdog() {
-		if (!this.outputPlaybackWatchdog) return;
-		clearTimeout(this.outputPlaybackWatchdog);
-		this.outputPlaybackWatchdog = void 0;
+		if (this.outputs.size === 0) this.params.harness.outputActivity.markStreamOpened();
+		this.outputs.add(output);
+		this.generatingOutput = output;
+		if (this.exactSpeechState.status === "active") this.exactSpeechState.output ??= output;
+		return output;
 	}
 	sendExactSpeechMessage(text) {
 		if (this.params.stopped() || !text.trim()) return;
 		this.exactSpeechState = {
 			status: "active",
-			message: text,
-			audioStarted: false
+			message: text
 		};
+		this.beginResponse();
 		this.params.bridge()?.sendUserMessage(this.params.buildSpeakExactMessage(text));
 	}
-	completeExactSpeechResponse(reason, options) {
-		if (this.exactSpeechState.status === "idle" && this.queuedExactSpeechMessages.length === 0) return;
+	completeExactSpeechResponse(reason) {
+		if (this.responseAudio !== "completed" || this.outputs.size > 0) return;
 		this.exactSpeechState = { status: "idle" };
-		if (options?.drain === false) return;
 		this.drainQueuedExactSpeechMessages(reason);
 	}
-	logOutputAudioStopped(reason) {
-		const activity = this.params.harness.outputActivity.snapshot();
-		const audioMs = Math.floor(activity.audioMs);
-		const chunks = activity.chunks;
-		const discordBytes = activity.sinkAudioBytes;
-		const realtimeBytes = activity.sourceAudioBytes;
-		const elapsedMs = this.params.harness.outputActivity.elapsedPlaybackMs();
-		if (this.outputStream || chunks > 0 || audioMs > 0) logger$1.info(`discord voice: realtime audio playback stopped reason=${reason} guild=${this.params.entry.guildId} channel=${this.params.entry.channelId} audioMs=${audioMs} elapsedMs=${elapsedMs} chunks=${chunks} discordBytes=${discordBytes} realtimeBytes=${realtimeBytes}`);
-	}
 };
 //#endregion
-//#region extensions/discord/src/voice/realtime-session.runtime.ts
-const logger = createSubsystemLogger("discord/voice");
+//#region extensions/discord/src/voice/realtime-speaker-session.ts
+const logger$1 = createSubsystemLogger("discord/voice");
 const DISCORD_REALTIME_DUPLICATE_ERROR_SUPPRESS_MS = 6e4;
 const discordRealtimeTalkPayload = () => ({});
 const DISCORD_REALTIME_VERBOSE_OMITTED_EVENTS = /* @__PURE__ */ new Set([
@@ -1010,7 +1192,7 @@ function readProviderConfigString(config, key) {
 function isDiscordAgentProxyVoiceMode(mode) {
 	return mode === "agent-proxy";
 }
-var DiscordRealtimeVoiceSession = class {
+var DiscordRealtimeSpeakerSession = class {
 	constructor(params) {
 		this.params = params;
 		this.bridge = null;
@@ -1018,16 +1200,19 @@ var DiscordRealtimeVoiceSession = class {
 			status: "inactive",
 			generation: 0
 		};
-		this.nextLifecycleGeneration = 0;
 		this.consultToolPolicy = "safe-read-only";
 		this.consultPolicy = "auto";
 		this.wakeNamePolicy = "never";
 		this.wakeNames = [];
 		this.providerGenerationObserved = false;
 		this.providerContinuityEpoch = 0;
+		this.captures = /* @__PURE__ */ new Set();
+		this.inputOpen = true;
+		this.activeOperations = 0;
+		this.lastActivityAt = Date.now();
 		this.harness = createRealtimeVoiceSessionHarness({
 			talk: {
-				sessionId: `discord:${this.params.entry.voiceSessionKey}:realtime`,
+				sessionId: this.params.sessionId,
 				mode: "realtime",
 				transport: "gateway-relay",
 				brain: "agent-consult"
@@ -1054,14 +1239,15 @@ var DiscordRealtimeVoiceSession = class {
 				surfaceLabel: "the Discord voice channel"
 			}),
 			entry: this.params.entry,
+			player: this.params.player,
 			harness: this.harness,
 			markProviderGenerationObserved: () => this.markProviderGenerationObserved(),
 			mode: this.params.mode,
 			onTerminalError: this.params.onTerminalError,
 			providerId: () => this.realtimeProviderId,
 			realtimeConfig: () => this.realtimeConfig,
-			stopTerminally: (reason) => {
-				this.stopLifecycle(reason);
+			stopTerminally: () => {
+				this.lifecycle.status = "stopped";
 				this.consults.close();
 			},
 			stopped: () => this.isStopped(),
@@ -1071,6 +1257,11 @@ var DiscordRealtimeVoiceSession = class {
 			bridge: () => this.bridge,
 			entry: this.params.entry,
 			getHumanParticipantCount: () => this.humanParticipantCount(),
+			interruptRoomPlayback: () => {
+				if (!this.playback.isBargeInEnabled() || !this.params.player.isActive()) return false;
+				this.params.player.handleBargeIn("active-speaker-audio");
+				return true;
+			},
 			onAcceptedTranscript: (text, context, providerEpoch) => this.consults.handleAcceptedTranscript(text, context, providerEpoch),
 			playback: this.playback,
 			providerEpoch: () => this.providerContinuityEpoch,
@@ -1092,7 +1283,7 @@ var DiscordRealtimeVoiceSession = class {
 			isWakeNameRequired: () => this.isWakeNameRequired(),
 			playback: this.playback,
 			providerEpoch: () => this.providerContinuityEpoch,
-			runAgentTurn: this.params.runAgentTurn,
+			runAgentTurn: (turn) => this.trackOperation(() => this.params.runAgentTurn(turn)),
 			stopped: () => this.isStopped(),
 			turns: this.turns,
 			usesRealtimeAgentHandoff: () => this.params.mode === "bidi" || this.consultToolPolicy !== "none",
@@ -1100,11 +1291,10 @@ var DiscordRealtimeVoiceSession = class {
 		});
 	}
 	async connect() {
-		const lifecycleGeneration = ++this.nextLifecycleGeneration;
+		const lifecycleGeneration = this.lifecycle.generation + 1;
 		this.lifecycle = {
 			status: "starting",
-			generation: lifecycleGeneration,
-			instance: this
+			generation: lifecycleGeneration
 		};
 		const configuredProviderId = this.realtimeConfig?.provider?.trim();
 		if (configuredProviderId) {
@@ -1157,6 +1347,10 @@ var DiscordRealtimeVoiceSession = class {
 			toolPolicy,
 			consultPolicy
 		});
+		const onReady = () => {
+			this.markProviderGenerationObserved();
+			if (this.markLifecycleReady(lifecycleGeneration)) this.playback.drainQueuedExactSpeechMessages("provider-ready");
+		};
 		this.bridge = this.harness.createBridge({
 			provider: resolved.provider,
 			cfg: this.params.cfg,
@@ -1166,53 +1360,67 @@ var DiscordRealtimeVoiceSession = class {
 			instructions,
 			autoRespondToAudio,
 			interruptResponseOnInputAudio,
-			markStrategy: "ack-immediately",
+			markStrategy: "transport",
 			tools: usesRealtimeAgentHandoff ? resolveRealtimeVoiceAgentConsultTools(toolPolicy, toolPolicy !== "none" ? [REALTIME_VOICE_AGENT_CONTROL_TOOL] : []) : [],
 			audioSink: {
 				isOpen: () => !this.isStopped(),
-				sendAudio: (audio) => this.playback.sendOutputAudio(audio),
+				sendAudio: (audio, metadata) => this.playback.sendOutputAudio(audio, metadata),
+				sendMark: (markName, acknowledge) => {
+					if (acknowledge) this.playback.sendOutputMark(acknowledge);
+					else this.bridge?.acknowledgeMark(markName);
+				},
+				getPlaybackState: () => this.playback.getPlaybackState(),
 				clearAudio: () => {
 					this.markProviderGenerationObserved();
 					this.harness.flushOutput(() => this.playback.clearOutputAudio("provider-clear-audio"));
 				}
 			},
 			onTranscript: (role, text, isFinal) => {
+				if (this.isStopped()) return;
 				this.markProviderGenerationObserved();
-				if (isFinal && text.trim()) logger.info(`discord voice: realtime ${role} transcript (${text.length} chars): ${formatVoiceLogPreview(text)}`);
+				if (isFinal && text.trim()) logger$1.info(`discord voice: realtime ${role} transcript (${text.length} chars): ${formatVoiceLogPreview(text)}`);
 				if (isFinal && role === "assistant") this.playback.suppressDuplicateControlSpeech(text);
 				if (role !== "user") return;
 				if (!isFinal) {
 					this.turns.handlePartialUserTranscript(text);
 					return;
 				}
-				this.turns.handleFinalUserTranscript(text);
+				this.trackOperation(() => this.turns.handleFinalUserTranscript(text)).catch((error) => this.logRealtimeError(formatErrorMessage(error)));
 			},
 			onToolCall: (event, session) => {
+				if (this.isStopped()) return;
 				this.markProviderGenerationObserved();
-				return this.consults.handleToolCall(event, session);
+				return this.trackOperation(() => this.consults.handleToolCall(event, session));
 			},
-			onReady: () => {
-				this.markProviderGenerationObserved();
-				if (this.markLifecycleReady(lifecycleGeneration)) this.playback.drainQueuedExactSpeechMessages("provider-ready");
+			onReady,
+			onEvent: (event) => {
+				if (this.isStopped()) return;
+				this.handleBridgeEvent(event);
+				if (event.direction === "client" && event.type === "session.reconnect.ready") onReady();
 			},
-			onEvent: (event) => this.handleBridgeEvent(event),
 			onResponseDone: (outcome) => {
+				if (this.isStopped()) return;
 				this.markProviderGenerationObserved();
 				this.playback.handleResponseDone(outcome);
-				if (outcome.status === "cancelled") logger.info(`discord voice: realtime model interrupt confirmed server:response.done status=cancelled${outcome.reason ? ` reason=${outcome.reason}` : ""}`);
+				if (outcome.status === "cancelled") logger$1.info(`discord voice: realtime model interrupt confirmed server:response.done status=cancelled${outcome.reason ? ` reason=${outcome.reason}` : ""}`);
 				else if (outcome.status === "failed" || outcome.status === "incomplete") this.logRealtimeError(outcome.message);
 			},
 			onError: (error) => this.logRealtimeError(formatErrorMessage(error)),
 			onClose: (reason) => {
-				this.flushSuppressedRealtimeErrors();
-				logVoiceVerbose(`realtime closed: ${reason}`);
+				if (!this.isStopped()) {
+					this.lifecycle.status = "stopped";
+					this.params.onTerminalError(/* @__PURE__ */ new Error(`Realtime provider closed unexpectedly: ${reason}`));
+				}
 			}
 		});
+		if (this.isStopped()) {
+			this.close();
+			return;
+		}
 		const resolvedModel = readProviderConfigString(resolved.providerConfig, "model") ?? resolved.provider.defaultModel;
 		const resolvedVoice = readProviderConfigString(resolved.providerConfig, "voice");
 		const humanParticipantCount = this.humanParticipantCount();
-		logger.info(`discord voice: realtime bridge starting mode=${this.params.mode} provider=${resolved.provider.id} model=${resolvedModel ?? "default"} voice=${resolvedVoice ?? "default"} consultPolicy=${consultPolicy} toolPolicy=${toolPolicy} autoRespond=${autoRespondToAudio} wakeNamePolicy=${this.wakeNamePolicy} requireWakeName=${this.isWakeNameRequired(humanParticipantCount)} humanParticipants=${humanParticipantCount} wakeNames=${this.wakeNames.join(",") || "none"} interruptResponse=${interruptResponseOnInputAudio} bargeIn=${bargeIn} minBargeInAudioEndMs=${minBargeInAudioEndMs}`);
-		this.playback.attachPlayer();
+		logger$1.info(`discord voice: realtime bridge starting mode=${this.params.mode} provider=${resolved.provider.id} model=${resolvedModel ?? "default"} voice=${resolvedVoice ?? "default"} consultPolicy=${consultPolicy} toolPolicy=${toolPolicy} autoRespond=${autoRespondToAudio} wakeNamePolicy=${this.wakeNamePolicy} requireWakeName=${this.isWakeNameRequired(humanParticipantCount)} humanParticipants=${humanParticipantCount} wakeNames=${this.wakeNames.join(",") || "none"} interruptResponse=${interruptResponseOnInputAudio} bargeIn=${bargeIn} minBargeInAudioEndMs=${minBargeInAudioEndMs}`);
 		await this.bridge.connect();
 		if (!this.markLifecycleReady(lifecycleGeneration)) {
 			this.bridge?.close();
@@ -1220,10 +1428,11 @@ var DiscordRealtimeVoiceSession = class {
 		}
 		this.markProviderGenerationObserved();
 		this.playback.drainQueuedExactSpeechMessages("provider-connected");
-		logger.info(`discord voice: realtime bridge ready mode=${this.params.mode} provider=${resolved.provider.id} model=${resolvedModel ?? "default"} voice=${resolvedVoice ?? "default"}`);
+		logger$1.info(`discord voice: realtime bridge ready mode=${this.params.mode} provider=${resolved.provider.id} model=${resolvedModel ?? "default"} voice=${resolvedVoice ?? "default"}`);
 	}
 	close() {
-		this.stopLifecycle("session close");
+		this.lifecycle.status = "stopped";
+		this.drain();
 		this.providerContinuityEpoch += 1;
 		this.flushSuppressedRealtimeErrors();
 		this.consults.close();
@@ -1235,7 +1444,46 @@ var DiscordRealtimeVoiceSession = class {
 		this.realtimeProviderId = void 0;
 	}
 	beginSpeakerTurn(context, userId) {
-		return this.turns.beginSpeakerTurn(context, userId);
+		if (!this.inputOpen || this.isStopped()) throw new Error("Discord realtime speaker input is closed");
+		const turn = this.turns.beginSpeakerTurn(context, userId);
+		let closed = false;
+		const capture = {
+			sendInputAudio: (audio) => {
+				if (!closed) {
+					this.lastActivityAt = Date.now();
+					turn.sendInputAudio(audio);
+				}
+			},
+			close: () => {
+				if (closed) return;
+				closed = true;
+				this.captures.delete(capture);
+				this.lastActivityAt = Date.now();
+				turn.close();
+			}
+		};
+		this.captures.add(capture);
+		return capture;
+	}
+	drain() {
+		this.inputOpen = false;
+		for (const capture of this.captures) capture.close();
+	}
+	releaseReasonBefore(cutoff) {
+		if (!(this.lastActivityAt < cutoff && this.captures.size === 0 && this.activeOperations === 0 && this.consults.isIdle() && !this.playback.isOutputAudioActive() && this.playback.retainedExactSpeechTexts().length === 0)) return;
+		return this.turns.hasPendingSpeakerAudioContext() ? "input-timeout" : "idle";
+	}
+	notify(text) {
+		this.playback.enqueueExactSpeechMessage(text);
+	}
+	async trackOperation(operation) {
+		this.activeOperations += 1;
+		try {
+			return await operation();
+		} finally {
+			this.activeOperations -= 1;
+			this.lastActivityAt = Date.now();
+		}
 	}
 	handleBargeIn(reason = "barge-in") {
 		this.playback.handleBargeIn(reason);
@@ -1255,21 +1503,9 @@ var DiscordRealtimeVoiceSession = class {
 	}
 	markLifecycleReady(generation) {
 		if (this.lifecycle.status !== "starting" && this.lifecycle.status !== "active" || this.lifecycle.generation !== generation) return false;
-		this.lifecycle = {
-			status: "active",
-			generation,
-			instance: this
-		};
+		this.lifecycle.status = "active";
 		return true;
 	}
-	stopLifecycle(reason) {
-		const generation = this.lifecycle.generation;
-		this.lifecycle = {
-			status: "stopped",
-			generation,
-			reason
-		};
-	}
 	humanParticipantCount() {
 		return this.params.getHumanParticipantCount?.() ?? 0;
 	}
@@ -1280,24 +1516,22 @@ var DiscordRealtimeVoiceSession = class {
 		if (!(event.direction === "client" && event.type === "session.continuity.reset")) this.markProviderGenerationObserved();
 		const detail = event.detail ? ` ${event.detail}` : "";
 		if (event.direction === "client" && event.type === "session.continuity.reset") this.resetProviderContinuity(event.type);
+		if (event.direction === "server" && event.type === "response.created") this.playback.beginResponse();
 		if (event.direction === "server" && event.type === "input_audio_buffer.speech_started") this.turns.resetPartialWakeNameTracking();
 		if (shouldLogRealtimeVerboseEvent(event)) logVoiceVerbose(`realtime ${event.direction}:${event.type}${detail}`);
 		const interruptionLog = formatRealtimeInterruptionLog(event);
-		if (interruptionLog) logger.info(interruptionLog);
+		if (interruptionLog) logger$1.info(interruptionLog);
 		const lifecycleLog = formatRealtimeLifecycleLog(event);
-		if (lifecycleLog) logger.info(lifecycleLog);
+		if (lifecycleLog) logger$1.info(lifecycleLog);
 	}
 	markProviderGenerationObserved() {
+		this.lastActivityAt = Date.now();
 		this.providerGenerationObserved = true;
 	}
 	resetProviderContinuity(reason) {
 		if (!this.providerGenerationObserved) return;
 		this.providerGenerationObserved = false;
-		if (this.lifecycle.status === "active") this.lifecycle = {
-			status: "starting",
-			generation: this.lifecycle.generation,
-			instance: this
-		};
+		if (this.lifecycle.status === "active") this.lifecycle.status = "starting";
 		this.providerContinuityEpoch += 1;
 		this.consults.resetProviderContinuity();
 		this.turns.resetProviderContinuity();
@@ -1315,11 +1549,11 @@ var DiscordRealtimeVoiceSession = class {
 			suppressed: 0,
 			lastLoggedAt: now
 		};
-		logger.warn(`discord voice: realtime error: ${message}`);
+		logger$1.warn(`discord voice: realtime error: ${message}`);
 	}
 	flushSuppressedRealtimeErrors() {
 		if (!this.lastRealtimeError || this.lastRealtimeError.suppressed === 0) return;
-		logger.warn(`discord voice: suppressed ${this.lastRealtimeError.suppressed} duplicate realtime errors: ${this.lastRealtimeError.message}`);
+		logger$1.warn(`discord voice: suppressed ${this.lastRealtimeError.suppressed} duplicate realtime errors: ${this.lastRealtimeError.message}`);
 		this.lastRealtimeError.suppressed = 0;
 	}
 };
@@ -1336,4 +1570,120 @@ function buildProviderConfigOverrides(realtimeConfig) {
 	return Object.keys(overrides).length > 0 ? overrides : void 0;
 }
 //#endregion
+//#region extensions/discord/src/voice/realtime-session.runtime.ts
+const logger = createSubsystemLogger("discord/voice");
+const MAX_REALTIME_SPEAKERS = 8;
+const REALTIME_SPEAKER_IDLE_MS = 6e4;
+/** The room shares its agent and player; each provider connection has one immutable speaker. */
+var DiscordRealtimeVoiceSession = class {
+	constructor(params) {
+		this.params = params;
+		this.speakers = /* @__PURE__ */ new Map();
+		this.sessions = /* @__PURE__ */ new Set();
+		this.nextSessionId = 0;
+		this.closed = false;
+		this.player = new DiscordRealtimePlayer(params.entry.player);
+	}
+	async connect() {
+		if (this.closed) throw new Error("Discord realtime voice session is closed");
+		const session = this.createSession();
+		this.warmSession = session;
+		await session.connect();
+		if (this.closed) {
+			session.close();
+			return;
+		}
+		this.idleTimer = setInterval(() => this.releaseIdleSpeakers(), REALTIME_SPEAKER_IDLE_MS);
+		this.idleTimer.unref?.();
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		clearInterval(this.idleTimer);
+		this.idleTimer = void 0;
+		this.player.close();
+		this.warmSession?.close();
+		this.warmSession = void 0;
+		for (const { session } of this.sessions) session.close();
+		this.speakers.clear();
+		this.sessions.clear();
+	}
+	beginSpeakerTurn(context, userId) {
+		if (this.closed) throw new Error("Discord realtime voice session is closed");
+		for (const previous of this.sessions) if (previous.userId === userId && previous.senderIsOwner !== context.senderIsOwner) this.retireSpeaker(previous, "admission-changed");
+		let speaker = this.speakers.get(userId);
+		if (speaker && speaker.transcripts !== this.params.entry.transcripts) {
+			this.speakers.delete(userId);
+			speaker.session.drain();
+			speaker = void 0;
+		}
+		if (!speaker) {
+			this.releaseIdleSpeakers();
+			if (this.sessions.size >= MAX_REALTIME_SPEAKERS) {
+				const message = "Voice is busy with other speakers. Please try again after their replies.";
+				this.notify(message);
+				throw new Error(message);
+			}
+			const warm = this.warmSession;
+			this.warmSession = void 0;
+			const session = warm ?? this.createSession();
+			speaker = {
+				userId,
+				senderIsOwner: context.senderIsOwner,
+				transcripts: this.params.entry.transcripts,
+				session
+			};
+			this.speakers.set(userId, speaker);
+			this.sessions.add(speaker);
+			if (!warm) session.connect().catch((error) => this.handleSpeakerFailure(session, error));
+		}
+		return speaker.session.beginSpeakerTurn(context, userId);
+	}
+	handleBargeIn(reason = "barge-in") {
+		this.player.handleBargeIn(reason);
+	}
+	isBargeInEnabled() {
+		return (this.warmSession ?? this.sessions.values().next().value?.session)?.isBargeInEnabled() ?? false;
+	}
+	createSession() {
+		const session = new DiscordRealtimeSpeakerSession({
+			...this.params,
+			player: this.player,
+			sessionId: `discord:${this.params.entry.voiceSessionKey}:realtime:${++this.nextSessionId}`,
+			onTerminalError: (error) => this.handleSpeakerFailure(session, error)
+		});
+		return session;
+	}
+	handleSpeakerFailure(session, error) {
+		if (this.closed) return;
+		if (this.warmSession === session) {
+			this.params.onTerminalError(error instanceof Error ? error : new Error(String(error)));
+			return;
+		}
+		for (const speaker of this.sessions) {
+			if (speaker.session !== session) continue;
+			logger.warn(`discord voice: realtime speaker failed user=${speaker.userId}: ${formatErrorMessage(error)}`);
+			this.retireSpeaker(speaker, "provider-failed");
+			this.notify("I lost a speaker's voice connection. Please try speaking again.");
+			return;
+		}
+	}
+	notify(text) {
+		(this.warmSession ?? this.sessions.values().next().value?.session)?.notify(text);
+	}
+	releaseIdleSpeakers() {
+		const cutoff = Date.now() - REALTIME_SPEAKER_IDLE_MS;
+		for (const speaker of this.sessions) {
+			const reason = speaker.session.releaseReasonBefore(cutoff);
+			if (reason) this.retireSpeaker(speaker, reason);
+		}
+	}
+	retireSpeaker(speaker, reason) {
+		if (this.speakers.get(speaker.userId) === speaker) this.speakers.delete(speaker.userId);
+		this.sessions.delete(speaker);
+		speaker.session.close();
+		logger.info(`discord voice: realtime speaker retired user=${speaker.userId} reason=${reason}${reason === "input-timeout" ? "; idle speaker input expired; speak again to reconnect" : ""}`);
+	}
+};
+//#endregion
 export { DiscordRealtimeVoiceSession };