@openclaw/discord 2026.9.5 → 2026.9.7

package/dist/.setup/{realtime-session.runtime-DTccTgTM.mjs → realtime-session.runtime-oUd9DOcz.mjs}

@@ -1,16 +1,83 @@
-import { a as buildProviderConfigs, i as buildProviderConfigOverrides } from "./transcripts-source-CuWYgayu.mjs";
-import { n as discordRealtimeVoiceSecretOwnerId } from "./secret-config-contract-DFu9hfU8.mjs";
-import { _ as loadDiscordVoiceSdk, a as createDiscordPcmToRealtimeConverter, c as handleDiscordVoiceAgentControlToolCall, d as formatRealtimeInterruptionLog, f as formatRealtimeLifecycleLog, g as DiscordRealtimePlayer, h as DISCORD_REALTIME_PLAYBACK_IDLE_MS, i as createDiscordOpusEncodeStream, l as logDiscordVoiceAgentControlResult, m as shouldLogRealtimeVerboseEvent, n as DiscordRealtimeRecording, o as createRealtimePcmToDiscordConverter, p as formatVoiceLogPreview, r as logVoiceVerbose, s as formatVoiceIngressPrompt, u as maybeControlDiscordVoiceAgentRun } from "./voice-runtime-DHVQ2mFz.mjs";
+import { _ as releaseDiscordAudioInput, g as getDiscordAudioOutputStatus, h as admitDiscordAudioInput, m as DiscordAudioOutputStatus, u as createDiscordPcmToRealtimeConverter, v as restoreDiscordAudioError, x as setDiscordAudioOutputStatus } from "./receive-recovery-CHPOsnLc.mjs";
+import { n as discordRealtimeVoiceSecretOwnerId } from "./secret-config-contract-uOE2J7yM.mjs";
+import { g as logVoiceVerbose } from "./provider-B_G5hASF.mjs";
+import { a as logDiscordVoiceAgentControlResult, c as formatRealtimeLifecycleLog, i as handleDiscordVoiceAgentControlToolCall, l as formatVoiceLogPreview, n as DiscordRealtimeRecording, o as maybeControlDiscordVoiceAgentRun, r as formatVoiceIngressPrompt, s as formatRealtimeInterruptionLog, u as shouldLogRealtimeVerboseEvent } from "./voice-runtime-B46rcwrG.mjs";
 import { randomUUID } from "node:crypto";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/ssrf-runtime";
 import { formatErrorMessage as formatErrorMessage$1, readErrorName, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
 import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { MessageChannel } from "node:worker_threads";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 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, createRealtimeVoiceAgentTalkbackQueue, createRealtimeVoiceOutputActivityTracker, createRealtimeVoiceSessionHarness, isRealtimeVoiceAudioAudible, isRealtimeVoiceWakeNameRequired, matchRealtimeVoiceActivationName, matchRealtimeVoiceConsultQuestions, projectInternalRealtimeVoicePublicConfig, realtimeVoiceAudioDurationMs, registerRealtimeVoiceSelection, resolveConfiguredRealtimeVoiceProvider, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceBargeIn, resolveRealtimeVoiceInterruptResponseOnInputAudio, resolveRealtimeVoiceMinBargeInAudioEndMs, resolveRealtimeVoiceSessionPolicy } from "openclaw/plugin-sdk/realtime-voice";
-import { PassThrough, pipeline } from "node:stream";
 import { assertSecretOwnerAvailable, isSecretOwnerAvailable } from "openclaw/plugin-sdk/channel-secret-owner-runtime";
+//#region extensions/discord/src/voice/realtime-player.ts
+/** Room-level policy stays on main; the worker owns the physical player and FIFO. */
+var DiscordRealtimePlayer = class {
+	constructor(audio) {
+		this.audio = audio;
+		this.lanes = /* @__PURE__ */ new Set();
+		this.outputs = /* @__PURE__ */ new Map();
+		this.closed = false;
+		this.onEvent = (event) => {
+			if (event.type === "output-start" || event.type === "continuous-start") this.current = event.id;
+			if ((event.type === "output-close" || event.type === "continuous-idle") && this.current === event.id) this.current = void 0;
+		};
+		audio.on("event", this.onEvent);
+	}
+	registerLane(lane) {
+		this.lanes.add(lane);
+		return () => this.lanes.delete(lane);
+	}
+	registerOutput(id, onBargeIn) {
+		this.outputs.set(id, onBargeIn);
+		return () => {
+			this.outputs.delete(id);
+			if (this.current === id) this.current = void 0;
+		};
+	}
+	handleBargeIn(reason = "barge-in") {
+		const current = this.current === void 0 ? void 0 : this.outputs.get(this.current);
+		if (current) return current(reason);
+		let interrupted = false;
+		for (const lane of [...this.lanes].filter((candidate) => candidate.hasOutput())) interrupted = lane.onBargeIn(reason) || interrupted;
+		return interrupted;
+	}
+	isActive() {
+		return this.current !== void 0 || [...this.lanes].some((lane) => lane.hasOutput());
+	}
+	cancelForControl() {
+		this.transition(() => {
+			for (const lane of this.lanes) lane.cancelForControl();
+		});
+	}
+	transition(action) {
+		this.audio.send({
+			type: "output-hold",
+			hold: true
+		});
+		try {
+			action();
+		} finally {
+			this.audio.send({
+				type: "output-hold",
+				hold: false
+			});
+		}
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.lanes.clear();
+		this.outputs.clear();
+		this.current = void 0;
+		this.audio.off("event", this.onEvent);
+		this.audio.send({ type: "output-shutdown" });
+	}
+};
+//#endregion
 //#region extensions/discord/src/voice/realtime-transcript.ts
 const PARTIAL_TRANSCRIPT_MAX_CHARS = 240;
 function mergeRealtimePartialTranscript(previous, next) {
@@ -21,7 +88,7 @@ function mergeRealtimePartialTranscript(previous, next) {
 }
 //#endregion
 //#region extensions/discord/src/voice/realtime-turns.ts
-const logger$5 = createSubsystemLogger("discord/voice");
+const logger$4 = 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;
@@ -100,11 +167,11 @@ var DiscordRealtimeTurns = class {
 			const pendingWakeNameFollowup = this.consumePendingWakeNameFollowup();
 			if (!pendingWakeNameFollowup) {
 				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"}`);
+				logger$4.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;
-			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}`);
+			logger$4.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}`);
 		}
 		const acceptedText = wakeNameResult.allowed ? wakeNameResult.text || trimmed : trimmed;
 		if (wakeNameResult.allowed && !wakeNameResult.text.trim()) {
@@ -157,11 +224,11 @@ var DiscordRealtimeTurns = class {
 			this.registerSpeakerTurnAudioStarted(turn);
 			turn.inputRealtimeBytes += realtimePcm.length;
 			turn.inputChunks += 1;
-			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.inputChunks === 1) logger$4.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 && isRealtimeVoiceAudioAudible(discordPcm48kStereo, REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ) && isRealtimeVoiceAudioAudible(realtimePcm, REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ) && 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$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}`);
+				logger$4.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) && this.isTurnProviderCurrent(turn)) bridge.sendAudio(realtimePcm);
 		}
@@ -175,13 +242,13 @@ var DiscordRealtimeTurns = class {
 		turn.lastAudioAt = Date.now();
 		if (turn.hasAudio) return;
 		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}`);
+		logger$4.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$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}`);
+		logger$4.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 = turn.bridge;
@@ -192,7 +259,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$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}`);
+		logger$4.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 {
@@ -205,7 +272,7 @@ var DiscordRealtimeTurns = class {
 		};
 		const wakeNameResult = matchRealtimeVoiceActivationName(text, this.params.wakeNames());
 		if (wakeNameResult) {
-			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}`);
+			logger$4.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 {
@@ -219,7 +286,7 @@ var DiscordRealtimeTurns = class {
 	armWakeNameFollowup() {
 		const context = this.consumePendingSpeakerContext();
 		if (!context) {
-			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}`);
+			logger$4.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);
@@ -228,7 +295,7 @@ var DiscordRealtimeTurns = class {
 			context,
 			expiresAt
 		};
-		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}`);
+		logger$4.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;
@@ -245,7 +312,7 @@ function isDiscordRealtimeSpeakerContext(value) {
 }
 //#endregion
 //#region extensions/discord/src/voice/realtime-consults.ts
-const logger$4 = createSubsystemLogger("discord/voice");
+const logger$3 = 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;
@@ -318,16 +385,16 @@ var DiscordRealtimeConsults = class {
 		const outcome = classifyRealtimeVoiceConsultToolCall(event.args, { retainedExactSpeechTexts: this.params.playback.retainedExactSpeechTexts() });
 		switch (outcome.kind) {
 			case "exact-speech-echo":
-				logger$4.info(`discord voice: realtime exact speech consult bypassed call=${callId || "unknown"} answerChars=${outcome.text.length}`);
+				logger$3.info(`discord voice: realtime exact speech consult bypassed call=${callId} answerChars=${outcome.text.length}`);
 				await session.submitToolResult(callId, { text: outcome.text });
 				return;
 			case "malformed":
-				logger$4.warn(`discord voice: realtime consult rejected malformed args call=${callId || "unknown"}: ${outcome.error}`);
+				logger$3.warn(`discord voice: realtime consult rejected malformed args call=${callId}: ${outcome.error}`);
 				await session.submitToolResult(callId, { error: outcome.error });
 				return;
 		}
 		const consultMessage = outcome.message;
-		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)}`);
+		logger$3.info(`discord voice: realtime consult requested call=${callId} 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, CANCELLED_CONSULT_RESULT);
@@ -342,7 +409,7 @@ var DiscordRealtimeConsults = class {
 			if (recentConsult) {
 				const recentSpeaker = recentConsult.context?.speaker;
 				if (this.params.turns.hasPendingSpeakerAudioContext()) {
-					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}`);
+					logger$3.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;
 				}
@@ -351,14 +418,22 @@ var DiscordRealtimeConsults = class {
 		}
 		if (!context) {
 			context = this.params.turns.consumePendingSpeakerContext();
-			if (context) recent = this.rememberRecentAgentProxyConsultContext(consultMessage, context, {
-				...callId === "unknown" ? {} : { id: `native-consult:${callId}` },
-				started: true
-			});
+			if (context) {
+				recent = this.params.harness.forcedConsults.prepare(consultMessage, {
+					context: {
+						speaker: context,
+						providerEpoch: this.params.providerEpoch(),
+						delivery: "provider"
+					},
+					...callId === "unknown" ? {} : { id: `native-consult:${callId}` }
+				});
+				if (!recent) throw new Error("Discord realtime consult context requires a non-empty question");
+				this.params.harness.forcedConsults.markStarted(recent);
+			}
 		}
 		const state = recent?.context;
 		if (!context || !state) {
-			logger$4.warn(`discord voice: realtime consult has no speaker context call=${callId || "unknown"}`);
+			logger$3.warn(`discord voice: realtime consult has no speaker context call=${callId}`);
 			await session.submitToolResult(callId, { error: "No Discord speaker context available" });
 			return;
 		}
@@ -371,8 +446,8 @@ var DiscordRealtimeConsults = class {
 				deliveryOwner: "consult"
 			}));
 			if (this.params.stopped() || providerEpoch !== this.params.providerEpoch()) return;
-			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}`);
+			if ("text" in result) logger$3.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$3.warn(`discord voice: realtime consult failed call=${callId}: ${result.error}`);
 			delivery.submissionStarted = true;
 			await this.submitAgentProxyConsultResult(callId, session, result);
 			if (state.delivery === "provider-pending") state.delivery = "provider";
@@ -394,10 +469,10 @@ var DiscordRealtimeConsults = class {
 			if (this.params.stopped() || providerEpoch !== this.params.providerEpoch()) return;
 			if (readErrorName(error) === "AbortError") {
 				if (pendingForcedConsult) this.params.harness.forcedConsults.remove(pendingForcedConsult);
-				logger$4.warn(`discord voice: realtime transcript cancelled: ${formatErrorMessage$1(error)}`);
+				logger$3.warn(`discord voice: realtime transcript cancelled: ${formatErrorMessage$1(error)}`);
 				return;
 			}
-			logger$4.warn(`discord voice: realtime active-run control failed; falling back to normal transcript handling: ${formatErrorMessage$1(error)}`);
+			logger$3.warn(`discord voice: realtime active-run control failed; falling back to normal transcript handling: ${formatErrorMessage$1(error)}`);
 			control = void 0;
 		}
 		if (this.params.stopped() || providerEpoch !== this.params.providerEpoch()) return;
@@ -409,7 +484,7 @@ var DiscordRealtimeConsults = class {
 		}
 		if (!this.params.isAgentProxy()) return;
 		if (usesRealtimeAgentHandoff) {
-			if (pendingForcedConsult) this.schedulePreparedForcedAgentProxyConsult(pendingForcedConsult);
+			if (pendingForcedConsult) this.params.harness.forcedConsults.schedule(pendingForcedConsult, DISCORD_REALTIME_FORCED_CONSULT_FALLBACK_DELAY_MS, (handle) => void this.runForcedAgentProxyConsult(handle));
 			return;
 		}
 		this.talkback.enqueue(acceptedText, fallbackSpeakerContext);
@@ -419,7 +494,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$4,
+			logger: logger$3,
 			logPrefix: "[discord] realtime agent",
 			responseStyle: "Brief, natural spoken answer for a Discord voice channel.",
 			fallbackText: DISCORD_REALTIME_FALLBACK_TEXT,
@@ -468,7 +543,7 @@ var DiscordRealtimeConsults = class {
 		const skipReason = classifySkippableRealtimeVoiceConsultTranscript(question);
 		if (skipReason) {
 			const context = this.params.turns.consumePendingSpeakerContext();
-			logger$4.info(`discord voice: realtime forced agent consult skipped reason=${skipReason} chars=${question.length} speaker=${context?.speakerLabel ?? "unknown"} transcript=${formatVoiceLogPreview(question)}`);
+			logger$3.info(`discord voice: realtime forced agent consult skipped reason=${skipReason} chars=${question.length} speaker=${context?.speakerLabel ?? "unknown"} transcript=${formatVoiceLogPreview(question)}`);
 			return;
 		}
 		const context = speakerContext ?? this.params.turns.consumePendingSpeakerContext();
@@ -478,7 +553,7 @@ var DiscordRealtimeConsults = class {
 				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$4.warn("discord voice: realtime forced agent consult has no speaker context");
+			logger$3.warn("discord voice: realtime forced agent consult has no speaker context");
 			return;
 		}
 		return this.params.harness.forcedConsults.prepare(question, { context: {
@@ -487,9 +562,6 @@ var DiscordRealtimeConsults = class {
 			delivery: "provider"
 		} });
 	}
-	schedulePreparedForcedAgentProxyConsult(pending) {
-		this.params.harness.forcedConsults.schedule(pending, DISCORD_REALTIME_FORCED_CONSULT_FALLBACK_DELAY_MS, (handle) => void this.runForcedAgentProxyConsult(handle));
-	}
 	async runForcedAgentProxyConsult(pending) {
 		this.params.harness.forcedConsults.markStarted(pending);
 		const state = pending.context;
@@ -504,9 +576,9 @@ var DiscordRealtimeConsults = class {
 			return;
 		}
 		const startedAt = Date.now();
-		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}`);
+		logger$3.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$3.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$3.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.delivery = "forced-pending";
 		const result = await this.trackAgentProxyConsult(pending, this.runAgentTurn({
 			context,
@@ -516,27 +588,14 @@ var DiscordRealtimeConsults = class {
 		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}`);
+		if ("text" in result) logger$3.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$3.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.delivery === "forced-pending") {
 			state.delivery = "playback";
 			this.params.playback.enqueueExactSpeechMessage(text);
 		}
 	}
-	rememberRecentAgentProxyConsultContext(question, context, options = {}) {
-		const handle = this.params.harness.forcedConsults.prepare(question, {
-			context: {
-				speaker: context,
-				providerEpoch: this.params.providerEpoch(),
-				delivery: "provider"
-			},
-			...options.id ? { id: options.id } : {}
-		});
-		if (!handle) throw new Error("Discord realtime consult context requires a non-empty question");
-		if (options.started) this.params.harness.forcedConsults.markStarted(handle);
-		return handle;
-	}
 	trackAgentProxyConsult(recent, promise) {
 		const state = recent?.context;
 		if (recent) this.params.harness.forcedConsults.markStarted(recent);
@@ -569,7 +628,7 @@ var DiscordRealtimeConsults = class {
 		const pendingResult = state.result ?? state.promise;
 		if (!pendingResult) return false;
 		const providerDelivery = state.delivery === "provider-pending" || state.delivery === "forced-pending" && !state.result && session.bridge.supportsToolResultSuppression === false ? this.beginProviderDelivery(state) : void 0;
-		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}`);
+		logger$3.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 (this.params.stopped() || state.providerEpoch !== this.params.providerEpoch() || state.delivery === "detached" || state.delivery === "retired") return true;
@@ -629,286 +688,156 @@ var DiscordRealtimeConsults = class {
 };
 //#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_CONTINUOUS_PREROLL_FRAMES = 6;
-const DISCORD_CONTINUOUS_START_DEADLINE_MS = 120;
-const DISCORD_REALTIME_OUTPUT_PLAYBACK_WATCHDOG_MARGIN_MS = 3e3;
-/** One output stream retains ownership through queued and audible playback. */
+/** Main retains provider item identity; physical output state belongs to the worker. */
 var DiscordRealtimeOutput = class {
+	get activity() {
+		if (Atomics.load(this.clock, 2) !== 0n && !this.activityTracker.snapshot().playbackStarted) this.activityTracker.markPlaybackStarted();
+		return this.activityTracker;
+	}
 	constructor(params) {
 		this.params = params;
-		this.activity = createRealtimeVoiceOutputActivityTracker();
-		this.converter = createRealtimePcmToDiscordConverter();
-		this.stream = new PassThrough({ highWaterMark: DISCORD_RAW_PCM_FRAME_BYTES * 128 });
-		this.ready = false;
-		this.playbackMarks = [];
-		this.playedPcmBytes = 0;
-		this.lastAudiblePcmEndBytes = 0;
-		this.reportedPlaybackMs = 0;
-		this.audioSpans = [];
-		this.buffers = [];
-		this.bufferedBytes = 0;
+		this.activityTracker = createRealtimeVoiceOutputActivityTracker();
+		this.clock = new BigInt64Array(new SharedArrayBuffer(24));
+		this.marks = /* @__PURE__ */ new Map();
+		this.nextMark = 0;
 		this.closed = false;
-		this.failed = false;
-		this.stream.once("close", () => {
-			if (!this.activity.snapshot().playbackStarted) this.close("stream-close");
+		this.reportedPlaybackMs = 0;
+		this.spans = [];
+		this.onEvent = (event) => {
+			if (!("id" in event) || event.id !== this.id || this.closed) return;
+			switch (event.type) {
+				case "output-start":
+					this.activity.markPlaybackStarted();
+					this.params.onStart();
+					break;
+				case "output-close":
+					this.retire(event.reason);
+					break;
+				case "output-error":
+					this.params.onError(restoreDiscordAudioError(event.error));
+					break;
+				case "output-mark": {
+					const acknowledge = this.marks.get(event.markId);
+					this.marks.delete(event.markId);
+					try {
+						acknowledge?.();
+					} catch (error) {
+						this.params.onError(error);
+					}
+					break;
+				}
+			}
+		};
+		this.onStopped = () => {
+			if (!this.closed) {
+				this.params.onError(/* @__PURE__ */ new Error("Discord audio worker stopped during playback."));
+				this.retire("worker-stopped");
+			}
+		};
+		this.id = params.player.audio.allocateId();
+		this.unregister = params.player.registerOutput(this.id, params.onBargeIn);
+		params.player.audio.on("event", this.onEvent);
+		params.player.audio.on("stopped", this.onStopped);
+		params.player.audio.send({
+			type: "output-create",
+			id: this.id,
+			continuous: params.continuous,
+			clock: this.clock.buffer
 		});
 	}
+	playedBytes() {
+		return Number(Atomics.load(this.clock, 0));
+	}
 	pendingBytes() {
-		return this.closed ? 0 : Math.max(0, this.activity.snapshot().sourceAudioBytes * 4 - this.playedPcmBytes);
+		return this.closed ? 0 : Math.max(0, this.activity.snapshot().sourceAudioBytes * 4 - this.playedBytes());
 	}
 	isAcceptingAudio() {
-		return !this.closed && !this.activity.snapshot().streamEnding && (!this.request || !this.params.player.isRetiring(this.request));
-	}
-	hasUnplayedAudibleAudio() {
-		return !this.closed && this.playedPcmBytes < this.lastAudiblePcmEndBytes;
+		return !this.closed && !this.activity.snapshot().streamEnding && getDiscordAudioOutputStatus(this.clock) < DiscordAudioOutputStatus.Retiring;
 	}
 	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));
+		const playedMs = Math.min(this.playedBytes() / 192, this.activity.snapshot().audioMs);
+		for (const span of this.spans) 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);
+		return this.spans.filter(({ endMs }) => endMs > playedMs).map(({ item }) => item);
 	}
 	markPlayback(acknowledge) {
-		if (!this.closed) this.playbackMarks.push({
-			endBytes: this.activity.snapshot().sinkAudioBytes,
-			acknowledge
+		if (this.closed) return;
+		const markId = ++this.nextMark;
+		this.marks.set(markId, acknowledge);
+		this.params.player.audio.send({
+			type: "output-mark",
+			id: this.id,
+			markId
 		});
 	}
-	append(sourcePcm, audible, item) {
-		if (this.closed) return;
+	append(audio, audible, item, onAccepted) {
+		if (this.closed || this.activity.snapshot().streamEnding || !admitDiscordAudioInput(this.clock)) return false;
+		try {
+			onAccepted();
+		} catch (error) {
+			releaseDiscordAudioInput(this.clock);
+			throw error;
+		}
+		if (this.closed) {
+			releaseDiscordAudioInput(this.clock);
+			return true;
+		}
 		const previous = this.activity.snapshot();
-		const sinkBytes = Math.floor((previous.sourceAudioBytes + sourcePcm.length) / 2) * 8;
-		const audioMs = (sinkBytes - previous.sinkAudioBytes) / DISCORD_RAW_PCM_BYTES_PER_MS;
-		const startMs = previous.audioMs;
+		const sinkBytes = Math.floor((previous.sourceAudioBytes + audio.length) / 2) * 8;
+		const audioMs = (sinkBytes - previous.sinkAudioBytes) / 192;
 		if (item) {
-			const previousSpan = this.audioSpans.at(-1);
-			const endMs = startMs + audioMs;
-			if (previousSpan?.item === item && previousSpan.endMs === startMs) previousSpan.endMs = endMs;
-			else this.audioSpans.push({
+			const last = this.spans.at(-1);
+			if (last?.item === item && last.endMs === previous.audioMs) last.endMs += audioMs;
+			else this.spans.push({
 				item,
-				startMs,
-				endMs
+				startMs: previous.audioMs,
+				endMs: previous.audioMs + audioMs
 			});
 		}
 		this.activity.markAudio({
 			audioMs,
-			sourceAudioBytes: sourcePcm.length,
+			sourceAudioBytes: audio.length,
 			sinkAudioBytes: sinkBytes - previous.sinkAudioBytes
 		});
-		if (audible) {
-			this.clearSilenceTimer();
-			this.silentSince = void 0;
-			this.lastAudiblePcmEndBytes = this.activity.snapshot().sinkAudioBytes;
-		}
-		this.writeConverted(this.converter.process(sourcePcm));
-		this.scheduleSilenceRetirement();
-		if (this.params.continuous) this.enqueuePlayback();
-		const prerollFrames = this.params.continuous ? DISCORD_CONTINUOUS_PREROLL_FRAMES : DISCORD_REALTIME_OUTPUT_PREROLL_FRAMES;
-		if (this.activity.snapshot().sinkAudioBytes >= DISCORD_RAW_PCM_FRAME_BYTES * prerollFrames) this.startPlayback();
-		else if (this.params.continuous && !this.ready && !this.startupTimer) {
-			this.startupTimer = setTimeout(() => {
-				this.startupTimer = void 0;
-				this.startPlayback();
-			}, DISCORD_CONTINUOUS_START_DEADLINE_MS);
-			this.startupTimer.unref?.();
-		}
-	}
-	writeConverted(pcm) {
-		if (pcm.length === 0 || this.closed) return;
-		if (this.activity.snapshot().playbackStarted && !this.drainHandler) {
-			if (!this.stream.write(pcm)) this.waitForDrain();
-			return;
-		}
-		this.buffers.push(pcm);
-		this.bufferedBytes += pcm.length;
+		this.params.player.audio.send({
+			type: "output-audio",
+			id: this.id,
+			audio,
+			audible
+		});
+		return true;
 	}
 	finish(reason, playBuffered) {
 		if (this.closed) return;
-		this.clearSilenceTimer();
-		if (playBuffered) this.writeConverted(this.converter.flush());
 		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();
-		}
+		if (!playBuffered) setDiscordAudioOutputStatus(this.clock, DiscordAudioOutputStatus.Closed);
+		this.params.player.audio.send({
+			type: "output-finish",
+			id: this.id,
+			reason,
+			playBuffered
+		});
+		if (!playBuffered) this.retire(reason);
 	}
 	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.clearSilenceTimer();
-		clearTimeout(this.startupTimer);
-		this.startupTimer = void 0;
-		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;
-		}
-		try {
-			for (const mark of heardMarks) mark.acknowledge();
-		} catch (error) {
-			this.params.onError(error);
-		}
-	}
-	startPlayback() {
-		if (this.closed || this.ready) return;
-		clearTimeout(this.startupTimer);
-		this.startupTimer = void 0;
-		if (this.bufferedBytes < DISCORD_RAW_PCM_FRAME_BYTES) this.writeConverted(this.converter.drain());
-		this.ready = true;
-		this.enqueuePlayback();
-	}
-	enqueuePlayback() {
-		this.request ??= {
-			isReady: () => this.ready,
-			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;
+		setDiscordAudioOutputStatus(this.clock, DiscordAudioOutputStatus.Closed);
+		this.params.player.audio.send({
+			type: "output-close",
+			id: this.id,
+			reason
 		});
-		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();
-		if (this.params.continuous && buffered.length > 0 && buffered.length < DISCORD_RAW_PCM_FRAME_BYTES) opusStream.flushPartialFrameWhenReady();
-		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);
-					const remaining = this.activity.snapshot().sinkAudioBytes - this.playedPcmBytes;
-					if (remaining > 0 && remaining <= DISCORD_RAW_PCM_FRAME_BYTES) this.writeConverted(this.converter.drain());
-					this.scheduleSilenceRetirement();
-				}
-			} 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;
+		this.retire(reason);
 	}
-	acknowledgePlayedMarks() {
-		try {
-			while (!this.closed) {
-				const mark = this.playbackMarks[0];
-				if (!mark || mark.endBytes > this.playedPcmBytes) return;
-				this.playbackMarks.shift();
-				mark.acknowledge();
-			}
-		} catch (error) {
-			this.params.onError(error);
-		}
-	}
-	scheduleSilenceRetirement() {
-		const activity = this.activity.snapshot();
-		if (!this.params.continuous || this.closed || activity.streamEnding || !activity.playbackStarted || this.hasUnplayedAudibleAudio()) return;
-		this.silentSince ??= performance.now();
-		if (activity.sinkAudioBytes <= this.lastAudiblePcmEndBytes || this.silenceTimer) return;
-		this.silenceTimer = setTimeout(() => {
-			this.silenceTimer = void 0;
-			if (!this.closed && !this.activity.snapshot().streamEnding && !this.hasUnplayedAudibleAudio()) this.finish("continuous-idle", true);
-		}, Math.max(0, DISCORD_REALTIME_PLAYBACK_IDLE_MS - (performance.now() - this.silentSince)));
-		this.silenceTimer.unref?.();
-	}
-	clearSilenceTimer() {
-		clearTimeout(this.silenceTimer);
-		this.silenceTimer = void 0;
-	}
-	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;
+	retire(reason) {
+		if (this.closed) return;
+		this.playbackItems();
+		this.closed = true;
+		this.marks.clear();
+		this.params.player.audio.off("event", this.onEvent);
+		this.params.player.audio.off("stopped", this.onStopped);
+		this.unregister();
+		this.params.onClose(this, reason);
 	}
 };
 //#endregion
@@ -930,12 +859,14 @@ function normalizeControlSpeechText(text) {
 var DiscordRealtimePlayback = class {
 	constructor(params) {
 		this.params = params;
+		this.outputClearGeneration = 0;
 		this.outputs = /* @__PURE__ */ new Set();
 		this.generatingItems = /* @__PURE__ */ new Map();
 		this.responseAudio = "completed";
 		this.queuedExactSpeechMessages = [];
 		this.retainedSpeechClosed = false;
 		this.exactSpeechState = { status: "idle" };
+		this.nextExactSpeechEpoch = 0n;
 		this.wakeNameAckIndex = 0;
 		this.unregisterPlayerLane = this.params.player.registerLane({
 			hasOutput: () => this.isOutputAudioActive(),
@@ -943,16 +874,77 @@ var DiscordRealtimePlayback = class {
 			cancelForControl: () => this.cancelForControl()
 		});
 	}
+	/** Only continuous provider media uses this generation-scoped, PCM24k mono port. */
+	createOutputAudioPort(enabled = true) {
+		this.directOutput?.close();
+		const { port1, port2 } = new MessageChannel();
+		const id = this.params.entry.audio.allocateId();
+		const state = new Int32Array(new SharedArrayBuffer(4));
+		const clock = new BigInt64Array(new SharedArrayBuffer(24));
+		const unregister = this.params.player.registerOutput(id, (reason) => this.handleBargeIn(reason));
+		const onEvent = (event) => {
+			if (!("id" in event) || event.id !== id || this.directOutput?.id !== id) return;
+			if ((event.type === "continuous-start" || event.type === "continuous-idle") && this.exactSpeechState.status === "active" && this.exactSpeechState.direct && event.speechEpoch !== this.exactSpeechState.direct.epoch) return;
+			if (event.type === "continuous-error") this.stopAfterPlaybackFailure("direct-output-error", restoreDiscordAudioError(event.error));
+			if (event.type === "continuous-start") this.params.harness.outputActivity.markPlaybackStarted();
+			if (event.type === "continuous-flushed" && event.marker === this.pendingDirectCompletion) {
+				this.pendingDirectCompletion = void 0;
+				this.responseAudio = "completed";
+				this.completeExactSpeechResponse("provider-completed");
+			}
+			if (event.type === "continuous-idle") {
+				this.responseAudio = "completed";
+				this.params.harness.finishOutputAudio("player-idle");
+				this.params.harness.outputActivity.reset();
+				this.completeExactSpeechResponse("player-idle");
+			}
+		};
+		const close = () => {
+			Atomics.store(state, 0, 1);
+			this.params.entry.audio.off("event", onEvent);
+			unregister();
+			this.params.entry.audio.send({
+				type: "continuous-close",
+				id
+			});
+			if (this.directOutput?.id === id) this.directOutput = void 0;
+		};
+		this.directOutput = {
+			id,
+			clock,
+			close
+		};
+		this.params.entry.audio.on("event", onEvent);
+		this.params.entry.audio.send({
+			type: "continuous-port",
+			id,
+			enabled,
+			port: port1,
+			state: state.buffer,
+			clock: clock.buffer
+		}, [port1]);
+		return {
+			port: port2,
+			state: state.buffer
+		};
+	}
+	activateOutputAudioPort() {
+		if (this.directOutput) this.params.entry.audio.send({
+			type: "continuous-activate",
+			id: this.directOutput.id
+		});
+	}
 	close(preserveUnplayedSpeech = false) {
 		this.unregisterPlayerLane();
-		if (preserveUnplayedSpeech) this.requeueUnplayedExactSpeech();
+		if (preserveUnplayedSpeech) this.retireExactSpeech(true);
 		else {
 			this.retainedSpeechClosed = true;
 			this.speechSuccessor = void 0;
 			this.queuedExactSpeechMessages = [];
-			this.exactSpeechState = { status: "idle" };
+			this.retireExactSpeech();
 		}
 		this.clearOutputAudio("session-close");
+		this.directOutput?.close();
 	}
 	transferPendingSpeechTo(target) {
 		this.speechSuccessor = target;
@@ -970,13 +962,14 @@ var DiscordRealtimePlayback = class {
 			return false;
 		}
 		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 clearGeneration = this.outputClearGeneration;
 		const bridge = this.params.bridge();
 		const outputs = Array.from(this.outputs);
 		const items = Array.from(this.generatingItems.values());
 		this.params.harness.handleBargeIn({ audioPlaybackActive: true }, () => {
 			if (!bridge?.bridge.handleBargeIn) this.clearOutputAudio(reason);
 		});
-		return outputs.some((output) => !this.outputs.has(output)) || items.some((item) => this.generatingItems.get(item.itemId) !== item);
+		return clearGeneration !== this.outputClearGeneration || outputs.some((output) => !this.outputs.has(output)) || items.some((item) => this.generatingItems.get(item.itemId) !== item);
 	}
 	isBargeInEnabled() {
 		if (this.params.wakeNameRequired()) return false;
@@ -1043,10 +1036,15 @@ var DiscordRealtimePlayback = class {
 				this.generatingItems.set(metadata.itemId, item);
 			}
 		}
-		this.params.harness.recordOutputAudio(realtimePcm24kMono, activity);
-		output.append(realtimePcm24kMono, audible, item);
+		const onAccepted = () => this.params.harness.recordOutputAudio(realtimePcm24kMono, activity);
+		if (!output.append(realtimePcm24kMono, audible, item, onAccepted)) {
+			this.generatingOutput = void 0;
+			this.sendOutputAudio(realtimePcm24kMono, metadata);
+		}
 	}
 	clearOutputAudio(reason = "clear") {
+		this.outputClearGeneration += 1;
+		this.retireExactSpeech();
 		if (this.isContinuousOutput()) this.responseAudio = "completed";
 		else if (this.responseAudio === "accepting") this.responseAudio = "discarding";
 		this.generatingOutput = void 0;
@@ -1055,9 +1053,26 @@ var DiscordRealtimePlayback = class {
 		this.outputs.clear();
 		for (const output of outputs.toReversed()) output.close(reason);
 		this.params.harness.outputActivity.reset();
+		if (this.directOutput) {
+			if (reason === "session-close" || this.params.stopped()) this.directOutput.close();
+			else this.params.entry.audio.send({
+				type: "continuous-clear",
+				id: this.directOutput.id
+			});
+		}
 		this.completeExactSpeechResponse(reason);
 	}
 	handleResponseDone(outcome) {
+		if (this.directOutput && outcome.status === "completed") {
+			const marker = this.params.entry.audio.allocateId();
+			this.pendingDirectCompletion = marker;
+			this.params.entry.audio.send({
+				type: "continuous-flush",
+				id: this.directOutput.id,
+				marker
+			});
+			return;
+		}
 		const output = this.generatingOutput;
 		this.generatingOutput = void 0;
 		this.generatingItems.clear();
@@ -1077,8 +1092,9 @@ var DiscordRealtimePlayback = class {
 	/** Accept completed consult ownership without starting provider work during transport cleanup. */
 	retainExactSpeechMessage(text) {
 		if (!text.trim()) return false;
-		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 retained = this.retainedExactSpeechTexts();
+		const retainedMessages = retained.length;
+		const retainedBytes = retained.reduce((total, message) => total + Buffer.byteLength(message, "utf8"), 0);
 		const incomingBytes = Buffer.byteLength(text, "utf8");
 		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}`));
@@ -1122,8 +1138,12 @@ var DiscordRealtimePlayback = class {
 	}
 	cancelForControl() {
 		this.queuedExactSpeechMessages = [];
-		this.exactSpeechState = { status: "idle" };
-		if (this.responseAudio === "completed" && this.outputs.size === 0) return;
+		this.retireExactSpeech();
+		if (this.responseAudio === "completed" && !this.isOutputAudioActive()) return;
+		if (this.isContinuousOutput()) {
+			this.params.harness.flushOutput(() => this.clearOutputAudio("active-run-control"));
+			return;
+		}
 		this.params.harness.handleBargeIn({
 			audioPlaybackActive: true,
 			force: true
@@ -1147,22 +1167,25 @@ var DiscordRealtimePlayback = class {
 	}
 	resetProviderContinuity(reason) {
 		this.lastControlSpeech = void 0;
-		this.requeueUnplayedExactSpeech();
+		this.retireExactSpeech(true);
 		this.responseAudio = "discarding";
 		this.params.harness.flushOutput(() => this.clearOutputAudio(reason));
 		this.responseAudio = "completed";
 		this.params.harness.finishOutputAudio(reason);
 	}
-	requeueUnplayedExactSpeech() {
-		const replayExactSpeech = this.exactSpeechState.status === "active" && !this.exactSpeechState.output?.activity.snapshot().playbackStarted ? this.exactSpeechState.message : void 0;
+	retireExactSpeech(preserveUnplayed = false) {
+		this.pendingDirectCompletion = void 0;
+		const speech = this.exactSpeechState;
 		this.exactSpeechState = { status: "idle" };
-		if (replayExactSpeech) this.queuedExactSpeechMessages.unshift(replayExactSpeech);
+		if (speech.status !== "active") return;
+		const directStarted = speech.direct && Atomics.exchange(speech.direct.clock, 2, 0n) === -speech.direct.epoch;
+		if (preserveUnplayed && !directStarted && !speech.output?.activity.snapshot().playbackStarted) this.queuedExactSpeechMessages.unshift(speech.message);
 	}
 	outputAudioMs() {
-		return Math.floor(this.params.harness.outputActivity.snapshot().audioMs);
+		return this.directOutput ? Math.floor(Number(Atomics.load(this.directOutput.clock, 1)) / 48) : Math.floor(this.params.harness.outputActivity.snapshot().audioMs);
 	}
 	isOutputAudioActive() {
-		return this.outputs.size > 0 || this.generatingItems.size > 0;
+		return this.outputs.size > 0 || this.generatingItems.size > 0 || this.directOutput !== void 0 && Atomics.load(this.directOutput.clock, 0) > 0n;
 	}
 	isContinuousOutput() {
 		return this.params.bridge()?.bridge.outputAudioMode === "continuous";
@@ -1172,7 +1195,7 @@ var DiscordRealtimePlayback = class {
 		this.speechSuccessor = void 0;
 		this.params.stopTerminally();
 		this.queuedExactSpeechMessages = [];
-		this.exactSpeechState = { status: "idle" };
+		this.retireExactSpeech();
 		this.clearOutputAudio(reason);
 		this.params.onTerminalError(error);
 	}
@@ -1180,7 +1203,6 @@ var DiscordRealtimePlayback = class {
 		const logContext = `guild=${this.params.entry.guildId} channel=${this.params.entry.channelId}`;
 		const output = new DiscordRealtimeOutput({
 			player: this.params.player,
-			logContext,
 			continuous: this.isContinuousOutput(),
 			onStart: () => {
 				this.params.harness.outputActivity.markPlaybackStarted();
@@ -1214,25 +1236,27 @@ var DiscordRealtimePlayback = class {
 	}
 	sendExactSpeechMessage(text) {
 		if (this.params.stopped() || !text.trim()) return;
+		const direct = this.directOutput ? {
+			clock: this.directOutput.clock,
+			epoch: ++this.nextExactSpeechEpoch
+		} : void 0;
 		this.exactSpeechState = {
 			status: "active",
-			message: text
+			message: text,
+			direct
 		};
+		if (direct) Atomics.store(direct.clock, 2, direct.epoch);
 		this.beginResponse();
 		this.params.bridge()?.sendUserMessage(this.params.buildSpeakExactMessage(text));
 	}
 	completeExactSpeechResponse(reason) {
-		if (this.responseAudio !== "completed" || this.outputs.size > 0) return;
-		this.exactSpeechState = { status: "idle" };
+		if (this.pendingDirectCompletion !== void 0 || this.responseAudio !== "completed" || this.isOutputAudioActive()) return;
+		this.retireExactSpeech();
 		this.drainQueuedExactSpeechMessages(reason);
 	}
 };
 //#endregion
 //#region extensions/discord/src/voice/realtime-speaker-config.ts
-function readProviderConfigString(config, key) {
-	const value = config[key];
-	return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
 /** Resolve the same provider, voice catalog, and policies for initial and replacement connections. */
 function resolveDiscordRealtimeSpeakerConfig(params) {
 	const { realtimeConfig, isAgentProxy } = params;
@@ -1243,11 +1267,14 @@ function resolveDiscordRealtimeSpeakerConfig(params) {
 		if (canonicalProviderId) ownerProviderIds.add(canonicalProviderId);
 		for (const providerId of ownerProviderIds) assertSecretOwnerAvailable("capability", discordRealtimeVoiceSecretOwnerId(params.accountId, providerId));
 	}
+	const configuredVoice = realtimeConfig?.speakerVoice || realtimeConfig?.speakerVoiceId;
 	const resolved = resolveConfiguredRealtimeVoiceProvider({
 		configuredProviderId: realtimeConfig?.provider,
-		providerConfigs: buildProviderConfigs(realtimeConfig),
+		providerConfigs: { ...realtimeConfig?.providers },
 		providerConfigOverrides: {
-			...buildProviderConfigOverrides(realtimeConfig),
+			...realtimeConfig?.model ? { model: realtimeConfig.model } : {},
+			...configuredVoice ? { voice: configuredVoice } : {},
+			...typeof realtimeConfig?.minBargeInAudioEndMs === "number" ? { minBargeInAudioEndMs: realtimeConfig.minBargeInAudioEndMs } : {},
 			...params.voiceOverride ? {
 				voice: params.voiceOverride,
 				speakerVoice: params.voiceOverride
@@ -1265,14 +1292,14 @@ function resolveDiscordRealtimeSpeakerConfig(params) {
 	});
 	assertSecretOwnerAvailable("capability", discordRealtimeVoiceSecretOwnerId(params.accountId, resolved.provider.id));
 	const capabilities = resolved.capabilities;
-	const model = readProviderConfigString(resolved.providerConfig, "model") ?? resolved.provider.defaultModel;
+	const model = normalizeOptionalString(resolved.providerConfig.model) ?? resolved.provider.defaultModel;
 	const voices = [...capabilities?.voices ?? (model ? capabilities?.voicesByModel?.[model] : void 0) ?? resolved.provider.voices ?? []];
 	const publicConfig = projectInternalRealtimeVoicePublicConfig({
 		provider: resolved.provider,
 		providerConfig: resolved.providerConfig,
 		config: {
 			model,
-			voice: readProviderConfigString(resolved.providerConfig, "speakerVoice") ?? readProviderConfigString(resolved.providerConfig, "voice")
+			voice: normalizeOptionalString(resolved.providerConfig.speakerVoice) ?? normalizeOptionalString(resolved.providerConfig.voice)
 		}
 	});
 	const selection = {
@@ -1323,7 +1350,7 @@ function resolveDiscordRealtimeSpeakerConfig(params) {
 		bargeIn,
 		minBargeInAudioEndMs,
 		resolvedModel: model,
-		resolvedVoice: readProviderConfigString(resolved.providerConfig, "voice")
+		resolvedVoice: normalizeOptionalString(resolved.providerConfig.voice)
 	};
 }
 //#endregion
@@ -1331,9 +1358,6 @@ function resolveDiscordRealtimeSpeakerConfig(params) {
 const logger$1 = createSubsystemLogger("discord/voice");
 const DISCORD_REALTIME_DUPLICATE_ERROR_SUPPRESS_MS = 6e4;
 const discordRealtimeTalkPayload = () => ({});
-function isDiscordAgentProxyVoiceMode(mode) {
-	return mode === "agent-proxy";
-}
 var DiscordRealtimeSpeakerSession = class {
 	constructor(params) {
 		this.params = params;
@@ -1356,7 +1380,12 @@ var DiscordRealtimeSpeakerSession = class {
 		this.inputIdleListeners = /* @__PURE__ */ new Set();
 		this.lastActivityAt = Date.now();
 		this.outputEnabled = !params.standby;
-		this.recording = this.createRecording();
+		const recordingEpoch = this.providerContinuityEpoch;
+		this.recording = new DiscordRealtimeRecording({
+			entry: this.params.entry,
+			isCurrent: () => this.lifecycle.status !== "stopped" && this.providerContinuityEpoch === recordingEpoch,
+			warn: (message) => logger$1.warn(message)
+		});
 		this.harness = createRealtimeVoiceSessionHarness({
 			talk: {
 				sessionId: this.params.sessionId,
@@ -1427,7 +1456,7 @@ var DiscordRealtimeSpeakerSession = class {
 			debounceMs: () => this.realtimeConfig?.debounceMs,
 			entry: this.params.entry,
 			harness: this.harness,
-			isAgentProxy: () => isDiscordAgentProxyVoiceMode(this.params.mode) && !this.handlesAgentConsult,
+			isAgentProxy: () => this.params.mode === "agent-proxy" && !this.handlesAgentConsult,
 			isWakeNameRequired: () => this.isWakeNameRequired(),
 			playback: this.playback,
 			providerEpoch: () => this.providerContinuityEpoch,
@@ -1450,7 +1479,7 @@ var DiscordRealtimeSpeakerSession = class {
 			agentId: this.params.entry.route.agentId,
 			cfg: this.params.cfg,
 			realtimeConfig: this.realtimeConfig,
-			isAgentProxy: isDiscordAgentProxyVoiceMode(this.params.mode),
+			isAgentProxy: this.params.mode === "agent-proxy",
 			bootstrapContextInstructions: this.params.bootstrapContextInstructions,
 			voiceOverride: this.params.voiceOverride,
 			conversationHistory: this.params.conversationHistory
@@ -1548,6 +1577,7 @@ var DiscordRealtimeSpeakerSession = class {
 		}
 		const humanParticipantCount = this.humanParticipantCount();
 		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}`);
+		this.attachOutputAudioPort();
 		await this.bridge.connect();
 		if (!this.markLifecycleReady(lifecycleGeneration)) {
 			await this.close();
@@ -1671,6 +1701,11 @@ var DiscordRealtimeSpeakerSession = class {
 	activateOutput() {
 		this.readVoiceSelection();
 		this.outputEnabled = true;
+		this.playback.activateOutputAudioPort();
+	}
+	attachOutputAudioPort() {
+		const provider = this.bridge?.bridge;
+		if (this.wakeNamePolicy === "never" && provider?.outputAudioMode === "continuous" && provider.setAudioOutputPort) provider.setAudioOutputPort(this.playback.createOutputAudioPort(this.outputEnabled));
 	}
 	hasActiveInput() {
 		return this.captures.size > 0;
@@ -1750,14 +1785,6 @@ var DiscordRealtimeSpeakerSession = class {
 		this.turns.resetProviderContinuity();
 		this.playback.resetProviderContinuity(reason);
 	}
-	createRecording() {
-		const epoch = this.providerContinuityEpoch;
-		return new DiscordRealtimeRecording({
-			entry: this.params.entry,
-			isCurrent: () => this.lifecycle.status !== "stopped" && this.providerContinuityEpoch === epoch,
-			warn: (message) => logger$1.warn(message)
-		});
-	}
 	logRealtimeError(message) {
 		const now = Date.now();
 		if (this.lastRealtimeError?.message === message && now - this.lastRealtimeError.lastLoggedAt < DISCORD_REALTIME_DUPLICATE_ERROR_SUPPRESS_MS) {
@@ -1795,7 +1822,7 @@ var DiscordRealtimeVoiceSession = class {
 		this.changingVoice = false;
 		this.callAbort = new AbortController();
 		this.candidates = /* @__PURE__ */ new Set();
-		this.player = new DiscordRealtimePlayer(params.entry.player);
+		this.player = new DiscordRealtimePlayer(params.entry.audio);
 	}
 	async connect() {
 		if (this.closed) throw new Error("Discord realtime voice session is closed");