@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/voiceClient/voiceSessionController.js

@@ -1,2117 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Disposable, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { disposableWindowInterval } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
-import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
-import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
-import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
-import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
-import { IVoiceTranscriptStore } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/agentsVoice/common/voiceTranscriptStore.service';
-import { IVoiceClientService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/voiceClient/voiceClientService.service';
-import { IMicCaptureService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/micCaptureService.service';
-import { ITtsPlaybackService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/ttsPlaybackService.service';
-import { VoiceToolDispatchService } from './voiceToolDispatchService.js';
-import { IVoiceToolDispatchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceToolDispatchService.service';
-import { IVoicePlaybackService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/voicePlaybackService.service';
-import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
-import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
-import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
-import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
-import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
-import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { AccessibilitySignal } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
-import { IAccessibilitySignalService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service';
-import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
-import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
-import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
-import { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
-import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
-
-var VoiceSessionController_1;
-let VoiceSessionController = class VoiceSessionController extends Disposable {
-    static {
-        VoiceSessionController_1 = this;
-    }
-    static {
-        this._MAX_TURNS = 2;
-    }
-    static {
-        this._PTT_MAX_DURATION_MS = 5 * 60 * 1000;
-    }
-    static {
-        this._PTT_TOGGLE_THRESHOLD_MS = 300;
-    }
-    static {
-        this._AUTO_LISTEN_QUIET_MS = 1200;
-    }
-    static {
-        this._USER_CANCEL_SUPPRESS_MS = 10_000;
-    }
-    static {
-        this._CONFIRMATION_FLUSH_DELAY_MS = 1500;
-    }
-    static {
-        this.PRIOR_TIMELINE_ENTRY_LIMIT = 30;
-    }
-    static {
-        this.CODING_AGENT_REPLY_SENTENCE_LIMIT = 2;
-    }
-    constructor(
-        voiceClientService,
-        micCaptureService,
-        ttsPlaybackService,
-        voiceToolDispatchService,
-        voicePlaybackService,
-        agentSessionsService,
-        chatService,
-        commandService,
-        authenticationService,
-        voiceTranscriptStore,
-        logService,
-        environmentService,
-        telemetryService,
-        configurationService,
-        accessibilitySignalService,
-        accessibilityService
-    ) {
-        super();
-        this.voiceClientService = voiceClientService;
-        this.micCaptureService = micCaptureService;
-        this.ttsPlaybackService = ttsPlaybackService;
-        this.voiceToolDispatchService = voiceToolDispatchService;
-        this.voicePlaybackService = voicePlaybackService;
-        this.agentSessionsService = agentSessionsService;
-        this.chatService = chatService;
-        this.commandService = commandService;
-        this.authenticationService = authenticationService;
-        this.voiceTranscriptStore = voiceTranscriptStore;
-        this.logService = logService;
-        this.environmentService = environmentService;
-        this.telemetryService = telemetryService;
-        this.configurationService = configurationService;
-        this.accessibilitySignalService = accessibilitySignalService;
-        this.accessibilityService = accessibilityService;
-        this._voiceState = observableValue(this, "idle");
-        this.voiceState = this._voiceState;
-        this._statusText = observableValue(this, "Tap to start");
-        this.statusText = this._statusText;
-        this._transcriptTurns = observableValue(this, []);
-        this.transcriptTurns = this._transcriptTurns;
-        this._isConnected = observableValue(this, false);
-        this.isConnected = this._isConnected;
-        this._isConnecting = observableValue(this, false);
-        this.isConnecting = this._isConnecting;
-        this._isReconnecting = observableValue(this, false);
-        this.isReconnecting = this._isReconnecting;
-        this._pendingToolConfirmations = observableValue(this, []);
-        this.pendingToolConfirmations = this._pendingToolConfirmations;
-        this._targetSession = observableValue(this, undefined);
-        this.targetSession = this._targetSession;
-        this._pttHeld = false;
-        this._pttToggleMode = false;
-        this._pttCurrentTurnId = "";
-        this._voiceEventDisposables = this._register(( new DisposableStore()));
-        this._voiceAutorunDisposable = this._register(( new MutableDisposable()));
-        this._autoApprovedSessions = ( new Set());
-        this._pttWaitingForPlayback = false;
-        this._replyPlayedSinceSend = false;
-        this._awaitingReplyAudio = false;
-        this._autoListenAfterGreeting = false;
-        this._hasPlayedInitialListenCue = false;
-        this._audioQueue = [];
-        this._currentPlaybackSessionId = null;
-        this._isProcessingQueue = false;
-        this._suppressIncomingAudio = false;
-        this._sessionAudioCache = ( new Map());
-        this._prevSessionStates = ( new Map());
-        this._userCancelledSessions = ( new Map());
-        this._confirmationFlushWatchdogs = ( new Map());
-        this._eagerModelRefs = ( new Map());
-        this._eagerModelLoading = ( new Set());
-        this._pendingIdleNarration = ( new Set());
-        this._telemetrySessionIndex = 0;
-        this._telemetryTurnCount = 0;
-        this._telemetryReconnectCount = 0;
-        this._telemetryFirstConnect = true;
-        this._telemetryTtsInterrupted = false;
-        this._pendingPriorTimeline = [];
-        this.voiceToolDispatchService.setDelegate({
-            acceptInput: text => {
-                this.commandService.executeCommand("_chat.voice.acceptInput", text).catch(err => {
-                    this.logService.warn("[voice] acceptInput delegate failed:", err);
-                });
-                return true;
-            },
-            getCurrentSessionResource: async () => {
-                const resourceStr = await this.commandService.executeCommand("_chat.voice.getCurrentSession").catch(() => undefined);
-                return resourceStr ? ( URI.parse(resourceStr)) : undefined;
-            },
-            switchToSession: resource => {
-                this.commandService.executeCommand("_chat.voice.switchToSession", ( resource.toString()));
-            },
-            getAutoApprovedSessions: () => {
-                return this._autoApprovedSessions;
-            },
-            addAllAutoApprovedSessions: () => {
-                const sessions = this.agentSessionsService.model.sessions.filter(s => !s.isArchived());
-                for (const s of sessions) {
-                    this._autoApprovedSessions.add(( s.resource.toString()));
-                    const model = this.chatService.getSession(s.resource);
-                    if (model) {
-                        for (const req of model.getRequests()) {
-                            const pending = req.response?.isPendingConfirmation.get();
-                            if (pending && req.response) {
-                                for (const part of req.response.response.value) {
-                                    if (part.kind === "toolInvocation") {
-                                        IChatToolInvocation.confirmWith(part, {
-                                            type: ToolConfirmKind.UserAction
-                                        });
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            },
-            removeAutoApprovedSession: resource => {
-                this._autoApprovedSessions.delete(resource);
-            },
-            triggerAutoApproveCheck: () => {
-                this._autoApproveCheck();
-            }
-        });
-        this._register(autorun(reader => {
-            const agentSessions = this.agentSessionsService.model.sessions.filter(s => !s.isArchived());
-            const toolConfirmations = [];
-            const processedResources = ( new Set());
-            const modelsToCheck = [];
-            for (const s of agentSessions) {
-                processedResources.add(( s.resource.toString()));
-                const model = this.chatService.getSession(s.resource);
-                if (model) {
-                    modelsToCheck.push({
-                        model,
-                        resource: s.resource,
-                        label: s.label || "Untitled session"
-                    });
-                }
-            }
-            for (const chatModel of this.chatService.chatModels.read(reader)) {
-                const key = ( chatModel.sessionResource.toString());
-                if (( processedResources.has(key))) {
-                    continue;
-                }
-                if (chatModel.getRequests().length === 0) {
-                    continue;
-                }
-                processedResources.add(key);
-                modelsToCheck.push({
-                    model: chatModel,
-                    resource: chatModel.sessionResource,
-                    label: chatModel.title || "Chat"
-                });
-            }
-            for (const {
-                model,
-                resource,
-                label
-            } of modelsToCheck) {
-                const lastReq = model.lastRequestObs.read(reader);
-                if (lastReq?.response) {
-                    const pending = lastReq.response.isPendingConfirmation.read(reader);
-                    if (pending && !( this._autoApprovedSessions.has(( resource.toString())))) {
-                        const confirmType = this._classifyPendingType(lastReq.response);
-                        const desc = this._getConfirmationDescription(lastReq.response);
-                        toolConfirmations.push({
-                            type: confirmType,
-                            sessionLabel: label,
-                            sessionResource: resource,
-                            description: desc || pending.detail || (confirmType === "input" ? "Needs your input" : "Needs approval"),
-                            approve: () => {
-                                if (lastReq.response) {
-                                    for (const part of lastReq.response.response.value) {
-                                        if (part.kind === "toolInvocation") {
-                                            IChatToolInvocation.confirmWith(part, {
-                                                type: ToolConfirmKind.UserAction
-                                            });
-                                        }
-                                    }
-                                }
-                            },
-                            deny: () => {
-                                if (lastReq.response) {
-                                    for (const part of lastReq.response.response.value) {
-                                        if (part.kind === "toolInvocation") {
-                                            IChatToolInvocation.confirmWith(part, {
-                                                type: ToolConfirmKind.Denied
-                                            });
-                                        }
-                                    }
-                                }
-                            }
-                        });
-                    }
-                    if (!pending && !( this._autoApprovedSessions.has(( resource.toString())))) {
-                        for (const part of lastReq.response.response.value) {
-                            if (part.kind === "toolInvocation") {
-                                const toolState = part.state.read(reader);
-                                if (toolState.type === IChatToolInvocation.StateKind.WaitingForConfirmation) {
-                                    const params = toolState.parameters;
-                                    const questions = params?.["questions"];
-                                    let desc = "";
-                                    if (Array.isArray(questions) && questions.length > 0) {
-                                        desc = ( questions.map(q => {
-                                            const title = q["header"] || q["question"];
-                                            if (!title) {
-                                                return "";
-                                            }
-                                            const options = q["options"];
-                                            if (Array.isArray(options) && options.length > 0) {
-                                                const labels = ( options.map(o => o["label"])).filter(Boolean);
-                                                if (labels.length > 0) {
-                                                    return `${title}: ${labels.join(", ")}`;
-                                                }
-                                            }
-                                            return title;
-                                        })).filter(Boolean).join("; ");
-                                    }
-                                    toolConfirmations.push({
-                                        type: "input",
-                                        sessionLabel: label,
-                                        sessionResource: resource,
-                                        description: desc || "Needs your input",
-                                        approve: () => {
-                                            IChatToolInvocation.confirmWith(part, {
-                                                type: ToolConfirmKind.UserAction
-                                            });
-                                        },
-                                        deny: () => {
-                                            IChatToolInvocation.confirmWith(part, {
-                                                type: ToolConfirmKind.Denied
-                                            });
-                                        }
-                                    });
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            this._pendingToolConfirmations.set(toolConfirmations, undefined);
-        }));
-        this._register(
-            CommandsRegistry.registerCommand("_chat.voicePlayback.replay", (_accessor, payload) => {
-                const sessionId = payload?.sessionId;
-                if (!sessionId) {
-                    return;
-                }
-                this._replaySessionAudio(sessionId);
-            })
-        );
-        this._register(
-            CommandsRegistry.registerCommand("_chat.voicePlayback.stop", (_accessor, payload) => {
-                this._stopReplay();
-                if (payload?.sessionId) {
-                    this.voicePlaybackService.notifyPlaybackEnd(( URI.parse(payload.sessionId)));
-                }
-            })
-        );
-        this._register({
-            dispose: () => this.disconnect()
-        });
-    }
-    async connect(window) {
-        if (this._isConnecting.get() || this._isConnected.get()) {
-            return;
-        }
-        this._window = window;
-        this._isConnecting.set(true, undefined);
-        this._statusText.set("Connecting...", undefined);
-        this._voiceState.set("idle", undefined);
-        this._telemetryConnectStartMs = Date.now();
-        let authToken;
-        try {
-            const sessions = await this.authenticationService.getSessions("github");
-            this._userLogin = sessions[0]?.account.label;
-            authToken = sessions[0]?.accessToken;
-            if (!this._userLogin) {
-                this.logService.warn("[voice] no GitHub session found; transcripts will not be persisted");
-            } else {
-                const lastTurn = (await this.voiceTranscriptStore.loadTurns(this._userLogin, {
-                    limit: 1
-                }))[0];
-                this._lastPersistedTurnId = lastTurn?.turnId;
-                try {
-                    const recent = await this.voiceTranscriptStore.loadTurns(this._userLogin, {
-                        limit: VoiceSessionController_1.PRIOR_TIMELINE_ENTRY_LIMIT
-                    });
-                    this._pendingPriorTimeline = this._buildPriorTimeline(recent);
-                } catch (err) {
-                    this.logService.warn("[voice] failed to load prior timeline entries for context", err);
-                    this._pendingPriorTimeline = [];
-                }
-            }
-        } catch (err) {
-            this.logService.warn("[voice] failed to resolve GitHub session", err);
-        }
-        this._voiceEventDisposables.clear();
-        this._voiceEventDisposables.add(this.micCaptureService.onPttStart(() => {
-            this.voiceClientService.sendPttStart(this._pttCurrentTurnId);
-        }));
-        this._voiceEventDisposables.add(this.micCaptureService.onPttAudioChunk(b64 => {
-            this.voiceClientService.sendPttAudioChunk(b64);
-        }));
-        this._voiceEventDisposables.add(this.micCaptureService.onPttEnd(() => {
-            this.voiceClientService.sendPttEnd();
-        }));
-        this._voiceEventDisposables.add(this.micCaptureService.onPttDiagnostic(diag => {
-            this.logService.info(
-                `[voice] ptt.diagnostic turn_id=${diag.turnId} ` + `msHeld=${diag.msHeld} chunksSent=${diag.chunksSent} samplesSent=${diag.samplesSent} ` + `drainFired=${diag.drainFired} drainChunks=${diag.drainChunks} drainSamples=${diag.drainSamples} drainWindowMs=${diag.drainWindowMs} ` + `drainSkippedByMute=${diag.drainSkippedByMute} drainSkippedBySuppression=${diag.drainSkippedBySuppression} ` + `postReleaseCallbacks=${diag.postReleaseCallbacks} postReleaseSamples=${diag.postReleaseSamples} ` + `postReleaseSkippedByMute=${diag.postReleaseSkippedByMute} postReleaseSkippedBySuppression=${diag.postReleaseSkippedBySuppression} ` + `postReleaseWindowMs=${diag.postReleaseWindowMs} ` + `releasedDuringAcquire=${diag.releasedDuringAcquire} pttUpWithoutCapture=${diag.pttUpWithoutCapture}`
-            );
-            this.voiceClientService.sendPttDiagnostic(diag.turnId, {
-                ms_held: diag.msHeld,
-                chunks_sent: diag.chunksSent,
-                samples_sent: diag.samplesSent,
-                drain_fired: diag.drainFired,
-                drain_chunks: diag.drainChunks,
-                drain_samples: diag.drainSamples,
-                drain_window_ms: diag.drainWindowMs,
-                drain_skipped_by_mute: diag.drainSkippedByMute,
-                drain_skipped_by_suppression: diag.drainSkippedBySuppression,
-                post_release_callbacks: diag.postReleaseCallbacks,
-                post_release_samples: diag.postReleaseSamples,
-                post_release_skipped_by_mute: diag.postReleaseSkippedByMute,
-                post_release_skipped_by_suppression: diag.postReleaseSkippedBySuppression,
-                post_release_window_ms: diag.postReleaseWindowMs,
-                released_during_acquire: diag.releasedDuringAcquire,
-                ptt_up_without_capture: diag.pttUpWithoutCapture
-            });
-        }));
-        this._voiceEventDisposables.add(this.ttsPlaybackService.onPlaybackStopped(() => {
-            const listenedToEnd = !this._telemetryTtsInterrupted;
-            this.telemetryService.publicLog2("voiceTtsListenThrough", {
-                listenedToEnd,
-                listenedPct: listenedToEnd ? 100 : 50
-            });
-            this._telemetryTtsInterrupted = false;
-            const finishedSessionId = this._currentPlaybackSessionId;
-            const samples = this.ttsPlaybackService.getLastPlayedSamples();
-            if (samples && finishedSessionId !== null) {
-                const cacheKey = finishedSessionId ?? "__generic__";
-                this._sessionAudioCache.set(cacheKey, samples);
-            }
-            this.voicePlaybackService.notifyPlaybackEnd(undefined);
-            this._currentPlaybackSessionId = null;
-            if (this._audioQueue.length > 0) {
-                setTimeout(() => this._processQueue(), 500);
-            } else {
-                if (this._pttHeld) {
-                    this._voiceState.set("listening", undefined);
-                    this._statusText.set("Listening...", undefined);
-                } else {
-                    this._voiceState.set("idle", undefined);
-                    this._statusText.set("Hold to speak...", undefined);
-                    if (this._pttWaitingForPlayback) {
-                        this._scheduleDelayedMicStop();
-                    }
-                    if (this._isAutoSendEnabled() && !this._awaitingReplyAudio) {
-                        if (this._autoListenAfterGreeting) {
-                            this._autoListenAfterGreeting = false;
-                            this._enterAutoListen();
-                        } else if (this._replyPlayedSinceSend) {
-                            this._scheduleAutoListen();
-                        }
-                    }
-                }
-            }
-        }));
-        this._voiceEventDisposables.add(this.voiceClientService.onDidChangeConnectionState(async connected => {
-            if (connected) {
-                const pbCtx = this.ttsPlaybackService.ensureContext(window);
-                pbCtx.resume();
-                const isResuming = this.voiceClientService.isResuming;
-                const now = Date.now();
-                const connectMs = this._telemetryConnectStartMs ? now - this._telemetryConnectStartMs : 0;
-                if (this._telemetryFirstConnect) {
-                    this._telemetryFirstConnect = false;
-                    this.telemetryService.publicLog2("voiceFirstConnect", {
-                        timeToConnectMs: connectMs
-                    });
-                }
-                if (isResuming) {
-                    this._telemetryReconnectCount++;
-                    const secSinceLast = this._telemetryLastConnectMs ? Math.round((now - this._telemetryLastConnectMs) / 1000) : 0;
-                    this.telemetryService.publicLog2("voiceReconnect", {
-                        timeSinceLastConnectSec: secSinceLast
-                    });
-                } else {
-                    this._telemetrySessionIndex++;
-                    this._telemetrySessionStart = now;
-                    this._telemetryTurnCount = 0;
-                    this._telemetryReconnectCount = 0;
-                    this.telemetryService.publicLog2("voiceSessionStarted", {
-                        sessionIndex: this._telemetrySessionIndex
-                    });
-                }
-                this._telemetryLastConnectMs = now;
-                if (isResuming) {
-                    this.voiceClientService.sendResumeSession(this._buildSessionContext(), this._getMachineId());
-                } else {
-                    const priorTimeline = this._pendingPriorTimeline;
-                    this._pendingPriorTimeline = [];
-                    this.voiceClientService.sendStartSession(this._buildSessionContext(), this._getMachineId(), priorTimeline);
-                }
-                if (isResuming) {
-                    this.micCaptureService.stopCapture();
-                }
-                this.micCaptureService.prepare(window);
-                transaction(tx => {
-                    this._isConnecting.set(false, tx);
-                    this._isReconnecting.set(false, tx);
-                    this._isConnected.set(true, tx);
-                });
-                const seededResources = ( new Set());
-                for (const s of this.agentSessionsService.model.sessions.filter(ss => !ss.isArchived())) {
-                    seededResources.add(( s.resource.toString()));
-                    const model = this.chatService.getSession(s.resource);
-                    const info = model ? this._getAgentStateInfo(model) : undefined;
-                    const currentState = info?.state ?? (s.status === ChatSessionStatus.InProgress ? "thinking" : s.status === ChatSessionStatus.NeedsInput ? "waiting_for_confirmation" : s.status === ChatSessionStatus.Completed ? "idle" : "unknown");
-                    if (currentState !== "unknown") {
-                        this._prevSessionStates.set(( s.resource.toString()), {
-                            state: currentState,
-                            detail: info?.detail ?? ""
-                        });
-                    }
-                }
-                for (const chatModel of this.chatService.chatModels.get()) {
-                    const key = ( chatModel.sessionResource.toString());
-                    if (( seededResources.has(key))) {
-                        continue;
-                    }
-                    if (chatModel.getRequests().length === 0) {
-                        continue;
-                    }
-                    const info = this._getAgentStateInfo(chatModel);
-                    if (info.state !== "unknown") {
-                        this._prevSessionStates.set(key, {
-                            state: info.state,
-                            detail: info.detail ?? ""
-                        });
-                    }
-                }
-                const sessionChangeListener = this.agentSessionsService.model.onDidChangeSessions(() => {
-                    this._checkSessionStateChanges();
-                    this._sendContext();
-                });
-                const autorunDisposable = autorun(reader => {
-                    const agentSessions = this.agentSessionsService.model.sessions.filter(s => !s.isArchived());
-                    let needsRecheck = false;
-                    const stateChanges = [];
-                    const waitingForConfirmationSessions = [];
-                    const processedResources = ( new Set());
-                    const processModel = (model, resource, label) => {
-                        const sessionId = ( resource.toString());
-                        this._pendingIdleNarration.delete(sessionId);
-                        const lastReq = model.lastRequestObs.read(reader);
-                        if (lastReq?.response) {
-                            lastReq.response.isIncomplete.read(reader);
-                            const pending = lastReq.response.isPendingConfirmation.read(reader);
-                            if (pending && ( this._autoApprovedSessions.has(sessionId))) {
-                                for (const part of lastReq.response.response.value) {
-                                    if (part.kind === "toolInvocation") {
-                                        if (IChatToolInvocation.confirmWith(part, {
-                                            type: ToolConfirmKind.UserAction
-                                        })) {
-                                            needsRecheck = true;
-                                        }
-                                    }
-                                }
-                            }
-                            const responseSignal = observableSignalFromEvent(lastReq.response, lastReq.response.onDidChange);
-                            responseSignal.read(reader);
-                        }
-                        const info = this._getAgentStateInfo(model);
-                        const currentState = info.state;
-                        const detail = info.detail;
-                        const lastResponseSummary = info.last_response_summary;
-                        const prev = this._prevSessionStates.get(sessionId);
-                        const isStateTransition = prev !== undefined && prev.state !== currentState && currentState !== "unknown";
-                        const isDetailTransition = !isStateTransition && prev !== undefined && currentState === "waiting_for_confirmation" && (detail ?? "") !== prev.detail;
-                        const isTransition = isStateTransition || isDetailTransition;
-                        if (isTransition) {
-                            this.logService.info(
-                                `[voice] autorun transition id=${sessionId.slice(-32)} ${prev?.state}→${currentState} detailChanged=${isDetailTransition} hasDetail=${!!detail}`
-                            );
-                            const cancelExpiry = this._userCancelledSessions.get(sessionId);
-                            if (cancelExpiry) {
-                                this.logService.info(
-                                    `[voice] autorun swallowing transition (user-cancelled) id=${sessionId.slice(-32)}`
-                                );
-                                clearTimeout(cancelExpiry);
-                                this._userCancelledSessions.delete(sessionId);
-                            } else {
-                                stateChanges.push({
-                                    sessionId,
-                                    currentState,
-                                    label,
-                                    detail,
-                                    lastResponseSummary,
-                                    detailOnly: isDetailTransition
-                                });
-                            }
-                        }
-                        if (currentState !== "unknown") {
-                            this._prevSessionStates.set(sessionId, {
-                                state: currentState,
-                                detail: detail ?? ""
-                            });
-                        }
-                        if (currentState === "waiting_for_confirmation") {
-                            waitingForConfirmationSessions.push({
-                                sessionId,
-                                label,
-                                detail,
-                                transition: isTransition
-                            });
-                        }
-                    };
-                    for (const s of agentSessions) {
-                        processedResources.add(( s.resource.toString()));
-                        const model = this.chatService.getSession(s.resource);
-                        if (model) {
-                            processModel(model, s.resource, s.label || "Untitled session");
-                        } else {
-                            const sessionId = ( s.resource.toString());
-                            const currentState = s.status === ChatSessionStatus.InProgress ? "thinking" : s.status === ChatSessionStatus.NeedsInput ? "waiting_for_confirmation" : s.status === ChatSessionStatus.Completed ? "idle" : "unknown";
-                            if (s.status === ChatSessionStatus.NeedsInput) {
-                                this._ensureModelLoaded(s.resource);
-                            }
-                            const prev = this._prevSessionStates.get(sessionId);
-                            const isStateTransition = prev !== undefined && prev.state !== currentState && currentState !== "unknown";
-                            if (isStateTransition && currentState === "idle") {
-                                this._deferIdleNarrationUntilModelLoaded(s.resource);
-                                continue;
-                            }
-                            if (isStateTransition) {
-                                const cancelExpiry = this._userCancelledSessions.get(sessionId);
-                                if (cancelExpiry) {
-                                    clearTimeout(cancelExpiry);
-                                    this._userCancelledSessions.delete(sessionId);
-                                } else {
-                                    stateChanges.push({
-                                        sessionId,
-                                        currentState,
-                                        label: s.label || "Untitled session"
-                                    });
-                                }
-                            }
-                            if (currentState !== "unknown") {
-                                this._prevSessionStates.set(sessionId, {
-                                    state: currentState,
-                                    detail: ""
-                                });
-                            }
-                            if (currentState === "waiting_for_confirmation") {
-                                waitingForConfirmationSessions.push({
-                                    sessionId,
-                                    label: s.label || "Untitled session",
-                                    detail: undefined,
-                                    transition: isStateTransition
-                                });
-                            }
-                        }
-                    }
-                    for (const chatModel of this.chatService.chatModels.read(reader)) {
-                        const key = ( chatModel.sessionResource.toString());
-                        if (( processedResources.has(key))) {
-                            continue;
-                        }
-                        if (chatModel.getRequests().length === 0) {
-                            continue;
-                        }
-                        processedResources.add(key);
-                        processModel(chatModel, chatModel.sessionResource, chatModel.title || "Chat");
-                    }
-                    if (needsRecheck) {
-                        setTimeout(() => this._autoApproveCheck(), 500);
-                    }
-                    this._sendContext();
-                    if (stateChanges.length > 0) {
-                        for (const change of stateChanges) {
-                            if (change.detailOnly) {
-                                this.voiceClientService.invalidateSessionCache(change.sessionId);
-                            }
-                        }
-                        if (( stateChanges.some(c => c.detailOnly))) {
-                            this._sendContext();
-                        }
-                        this.logService.info(
-                            `[voice] autorun stateChanges=${stateChanges.length} flushing immediately: ${( stateChanges.map(c => `${c.label}:${c.currentState}${c.detailOnly ? " (detail-only)" : ""}`)).join(", ")}`
-                        );
-                        this.voiceClientService.flushSessionContext();
-                    }
-                    for (const change of stateChanges) {
-                        this._persistEntry("coding_event", `session "${change.label}" → ${change.currentState}`, {
-                            codingSessionId: change.sessionId,
-                            codingStatus: change.currentState,
-                            codingSessionLabel: change.label
-                        });
-                    }
-                    for (const w of waitingForConfirmationSessions) {
-                        this._armConfirmationFlushWatchdog(w.sessionId, w.label, w.transition);
-                    }
-                    const stillWaiting = ( new Set(( waitingForConfirmationSessions.map(w => w.sessionId))));
-                    for (const id of [...( this._confirmationFlushWatchdogs.keys())]) {
-                        if (!( stillWaiting.has(id))) {
-                            const t = this._confirmationFlushWatchdogs.get(id);
-                            if (t) {
-                                clearTimeout(t);
-                            }
-                            this._confirmationFlushWatchdogs.delete(id);
-                        }
-                    }
-                    for (const id of [...( this._eagerModelRefs.keys())]) {
-                        if (!( stillWaiting.has(id))) {
-                            this._eagerModelRefs.get(id).dispose();
-                            this._eagerModelRefs.delete(id);
-                        }
-                    }
-                });
-                const connectionDisposables = ( new DisposableStore());
-                connectionDisposables.add(sessionChangeListener);
-                connectionDisposables.add(autorunDisposable);
-                connectionDisposables.add(
-                    disposableWindowInterval(this._window, () => this._checkSessionStateChanges(), 5000)
-                );
-                this._voiceAutorunDisposable.value = connectionDisposables;
-                this.micCaptureService.isMuted = false;
-                this._statusText.set("Hold to speak...", undefined);
-                this._voiceState.set("idle", undefined);
-                if (!isResuming && this._isAutoSendEnabled()) {
-                    this._autoListenAfterGreeting = true;
-                }
-            } else if (this._isConnected.get()) {
-                this._onConnectionLost();
-            } else if (this._isReconnecting.get()) {
-                this._isReconnecting.set(false, undefined);
-                this._voiceState.set("idle", undefined);
-                this._statusText.set("Tap to start", undefined);
-            } else if (this._isConnecting.get()) {
-                this._isConnecting.set(false, undefined);
-                this._voiceState.set("idle", undefined);
-                this._statusText.set("Tap to start", undefined);
-            } else {
-                this._voiceState.set("idle", undefined);
-            }
-        }));
-        this._voiceEventDisposables.add(this.voiceClientService.onSpeechStarted(() => {
-            this._clearAutoSendSilenceTimer();
-            this._clearAutoListenTimer();
-            this.ttsPlaybackService.stopPlayback();
-            this._audioQueue.length = 0;
-            this._currentPlaybackSessionId = null;
-            this._isProcessingQueue = false;
-            this._suppressIncomingAudio = true;
-            this._startUserTurn();
-        }));
-        this._voiceEventDisposables.add(this.voiceClientService.onTranscription(e => {
-            if (!this._telemetryFirstTranscriptionMs && this._telemetryPttDownMs) {
-                this._telemetryFirstTranscriptionMs = Date.now();
-            }
-            let text = e.text;
-            if (this._pttToggleMode && this._pttHeld) {
-                const strippedText = this._checkSendKeyword(text);
-                if (strippedText !== undefined) {
-                    text = strippedText;
-                    this._updateUserTurn(text, e.committed ?? "", false);
-                    this._persistTurn("user", text);
-                    this._pttToggleMode = false;
-                    this._finishPtt();
-                    return;
-                }
-            }
-            this._updateUserTurn(text, e.committed ?? "", e.status === "partial");
-            if (e.status !== "partial") {
-                if (!this._pttHeld) {
-                    this._voiceState.set("processing", undefined);
-                    this._statusText.set("Processing...", undefined);
-                }
-                this._persistTurn("user", text);
-            }
-            if (this._pttToggleMode && this._pttHeld) {
-                this._scheduleAutoSendOnSilence();
-            }
-        }));
-        this._voiceEventDisposables.add(this.voiceClientService.onAudioResponse(e => {
-            if (e.isFirstChunk && this._telemetryPttUpMs) {
-                const ttft = this._telemetryFirstTranscriptionMs && this._telemetryPttDownMs ? this._telemetryFirstTranscriptionMs - this._telemetryPttDownMs : 0;
-                const e2e = Date.now() - this._telemetryPttUpMs;
-                this.telemetryService.publicLog2("voiceLatency", {
-                    timeToFirstTranscriptionMs: ttft,
-                    endToEndTurnMs: e2e
-                });
-                this._telemetryPttUpMs = undefined;
-            }
-            this._enqueueAudio(e.codingSessionId, e.audio, e.isFirstChunk, e.isFinal, e.transcript);
-            if (e.isFinal && e.transcript) {
-                this._persistTurn("assistant", e.transcript);
-            }
-        }));
-        this._voiceEventDisposables.add(this.voiceClientService.onToolCall(e => {
-            const allowedTools = [
-                "send_to_chat",
-                "get_session_info",
-                "get_session_changes",
-                "get_session_thread",
-                "approve_confirmation",
-                "reject_confirmation",
-                "auto_approve_session",
-                "revoke_auto_approve",
-                "focus_session"
-            ];
-            if (e.name === "send_to_chat") {
-                let text = typeof e.args?.["text"] === "string" ? e.args["text"] : "";
-                const stripped = this._checkSendKeyword(text);
-                if (stripped !== undefined) {
-                    text = stripped;
-                }
-                this._statusText.set(VoiceToolDispatchService.getActionLabel(e.name), undefined);
-                this._persistEntry("agent_tool_call", this._renderToolCallSummary(e.name, e.args), {
-                    toolName: e.name,
-                    toolArgs: e.args
-                });
-                this._setAwaitingReply();
-                const sendPromise = text.trim() ? this._sendTranscriptionToChat(text) : Promise.resolve();
-                sendPromise.finally(() => {
-                    this.voiceClientService.sendToolResult(e.callId, "ok");
-                    this._voiceState.set("idle", undefined);
-                    this._statusText.set("Hold to speak...", undefined);
-                    this._sendContext();
-                });
-                return;
-            }
-            if (allowedTools.includes(e.name)) {
-                this._statusText.set(VoiceToolDispatchService.getActionLabel(e.name), undefined);
-                this._persistEntry("agent_tool_call", this._renderToolCallSummary(e.name, e.args), {
-                    toolName: e.name,
-                    toolArgs: e.args
-                });
-                if (e.name === "approve_confirmation" || e.name === "reject_confirmation") {
-                    this.telemetryService.publicLog2("voiceToolApproval", {
-                        toolName: e.name,
-                        approved: e.name === "approve_confirmation"
-                    });
-                }
-                if (this._pttHeld) {
-                    this._finishPtt();
-                }
-                this._suppressIncomingAudio = false;
-                this._setAwaitingReply();
-                this.voiceToolDispatchService.dispatchToolCall(e).then(result => {
-                    this.voiceClientService.sendToolResult(e.callId, result);
-                    this._voiceState.set("idle", undefined);
-                    this._statusText.set("Hold to speak...", undefined);
-                    this._sendContext();
-                });
-            } else {
-                this.voiceClientService.sendToolResult(e.callId, "ok");
-            }
-        }));
-        this._voiceEventDisposables.add(this.voiceClientService.onError(detail => {
-            if (!this._isConnecting.get()) {
-                this._voiceState.set("error", undefined);
-                this._statusText.set(`Error: ${detail}`, undefined);
-            }
-        }));
-        await this.voiceClientService.connect(window, authToken);
-        const connectTimeout = setTimeout(() => {
-            if (this._isConnecting.get() && !this._isConnected.get()) {
-                this.disconnect();
-            }
-        }, 10000);
-        this._voiceEventDisposables.add({
-            dispose: () => clearTimeout(connectTimeout)
-        });
-    }
-    disconnect() {
-        if (this._telemetrySessionStart) {
-            const durationSec = Math.round((Date.now() - this._telemetrySessionStart) / 1000);
-            this.telemetryService.publicLog2("voiceSessionEnded", {
-                turnCount: this._telemetryTurnCount,
-                durationSec,
-                reconnectCount: this._telemetryReconnectCount
-            });
-            this._telemetrySessionStart = undefined;
-        }
-        this._isConnecting.set(false, undefined);
-        this._isReconnecting.set(false, undefined);
-        this._voiceAutorunDisposable.clear();
-        this._voiceEventDisposables.clear();
-        this.ttsPlaybackService.closeContext();
-        this.micCaptureService.stopCapture();
-        this.voiceClientService.disconnect();
-        this._pttHeld = false;
-        this._pttToggleMode = false;
-        this._isConnected.set(false, undefined);
-        this._voiceState.set("idle", undefined);
-        this._statusText.set("Tap to start", undefined);
-        this._transcriptTurns.set([], undefined);
-        this._clearAutoSendSilenceTimer();
-        this._clearAutoListenTimer();
-        this._clearAwaitingReply();
-        this._autoListenAfterGreeting = false;
-        this._hasPlayedInitialListenCue = false;
-        this._replyPlayedSinceSend = false;
-        this._audioQueue.length = 0;
-        this._currentPlaybackSessionId = null;
-        this._isProcessingQueue = false;
-        this._suppressIncomingAudio = false;
-        this._prevSessionStates.clear();
-        for (const t of ( this._userCancelledSessions.values())) {
-            clearTimeout(t);
-        }
-        this._userCancelledSessions.clear();
-        for (const t of ( this._confirmationFlushWatchdogs.values())) {
-            clearTimeout(t);
-        }
-        this._confirmationFlushWatchdogs.clear();
-        for (const ref of ( this._eagerModelRefs.values())) {
-            ref.dispose();
-        }
-        this._eagerModelRefs.clear();
-        this._eagerModelLoading.clear();
-        this._pendingIdleNarration.clear();
-        this._userLogin = undefined;
-        this._lastPersistedTurnId = undefined;
-        this._pendingPriorTimeline = [];
-        this._stopReplay();
-        this._sessionAudioCache.clear();
-    }
-    simulateConnection() {
-        this._isConnected.set(true, undefined);
-        this._isConnecting.set(false, undefined);
-        this._voiceState.set("idle", undefined);
-        this._statusText.set("Hold to speak...", undefined);
-        this._voiceEventDisposables.add(disposableTimeout(() => {
-            if (!this._isConnected.get()) {
-                return;
-            }
-            this._voiceState.set("listening", undefined);
-            this._transcriptTurns.set([{
-                speaker: "user",
-                text: "Create a",
-                committed: "",
-                isPartial: true
-            }], undefined);
-        }, 1000));
-        this._voiceEventDisposables.add(disposableTimeout(() => {
-            if (!this._isConnected.get()) {
-                return;
-            }
-            this._transcriptTurns.set([{
-                speaker: "user",
-                text: "Create a new React component",
-                committed: "Create a ",
-                isPartial: true
-            }], undefined);
-        }, 2000));
-        this._voiceEventDisposables.add(disposableTimeout(() => {
-            if (!this._isConnected.get()) {
-                return;
-            }
-            this._transcriptTurns.set([{
-                speaker: "user",
-                text: "Create a new React component for the dashboard",
-                committed: "Create a new React component for the dashboard",
-                isPartial: false
-            }], undefined);
-            this._voiceState.set("idle", undefined);
-        }, 3000));
-        this._voiceEventDisposables.add(disposableTimeout(() => {
-            if (!this._isConnected.get()) {
-                return;
-            }
-            this._transcriptTurns.set([{
-                speaker: "user",
-                text: "Create a new React component for the dashboard",
-                committed: "Create a new React component for the dashboard",
-                isPartial: false
-            }, {
-                speaker: "assistant",
-                text: "I'll create a Dashboard component with some widgets...",
-                committed: "",
-                isPartial: false
-            }], undefined);
-        }, 4500));
-    }
-    _onConnectionLost() {
-        this.logService.warn("[voice] connection lost, preserving state for reconnect");
-        this.ttsPlaybackService.closeContext();
-        this._pttHeld = false;
-        this._pttToggleMode = false;
-        this._isConnected.set(false, undefined);
-        this._isReconnecting.set(true, undefined);
-        this._voiceState.set("idle", undefined);
-        this._statusText.set("Reconnecting...", undefined);
-    }
-    pttDown() {
-        if (!this._isConnected.get()) {
-            return;
-        }
-        this._clearAutoSendSilenceTimer();
-        if (this._pttToggleMode) {
-            this._pttToggleMode = false;
-            this._finishPtt();
-            return;
-        }
-        if (this._pttHeld) {
-            return;
-        }
-        this._pttHeld = true;
-        this._autoListenAfterGreeting = false;
-        this._clearAutoListenTimer();
-        this._pttCurrentTurnId = generateUuid();
-        this._pttWaitingForPlayback = false;
-        this._telemetryPttDownMs = Date.now();
-        this._telemetryFirstTranscriptionMs = undefined;
-        this._telemetryTurnCount++;
-        this._telemetryTtsInterrupted = this.ttsPlaybackService.isPlaying;
-        if (this._delayedMicStopTimer) {
-            clearTimeout(this._delayedMicStopTimer);
-            this._delayedMicStopTimer = undefined;
-        }
-        this._cancelTranscriptFade();
-        this._startUserTurn();
-        this._audioQueue.length = 0;
-        this._currentPlaybackSessionId = null;
-        this._isProcessingQueue = false;
-        this._suppressIncomingAudio = true;
-        this.micCaptureService.isMuted = false;
-        this.micCaptureService.pttDown(this._pttCurrentTurnId).catch(() => {
-            this._pttHeld = false;
-            this._statusText.set("Microphone denied", undefined);
-            this._voiceState.set("error", undefined);
-            if (this._pttMaxDurationTimer) {
-                clearTimeout(this._pttMaxDurationTimer);
-                this._pttMaxDurationTimer = undefined;
-            }
-            this.disconnect();
-        });
-        this.ttsPlaybackService.stopPlayback();
-        this._voiceState.set("listening", undefined);
-        this._statusText.set("Listening...", undefined);
-        if (this._isAutoSendEnabled()) {
-            if (!this._hasPlayedInitialListenCue) {
-                this._hasPlayedInitialListenCue = true;
-                this.accessibilitySignalService.playSignal(AccessibilitySignal.voiceRecordingStarted);
-            } else if (this.accessibilityService.isScreenReaderOptimized()) {
-                this.accessibilitySignalService.playSignal(AccessibilitySignal.voiceRecordingStarted);
-            }
-        }
-        this._pttMaxDurationTimer = setTimeout(() => {
-            if (this._pttHeld) {
-                this._statusText.set("Max duration reached", undefined);
-                this.pttUp();
-            }
-        }, VoiceSessionController_1._PTT_MAX_DURATION_MS);
-    }
-    pttUp() {
-        if (!this._pttHeld) {
-            return;
-        }
-        const holdMs = this._telemetryPttDownMs ? Date.now() - this._telemetryPttDownMs : Infinity;
-        if (holdMs < VoiceSessionController_1._PTT_TOGGLE_THRESHOLD_MS) {
-            this._pttToggleMode = true;
-            return;
-        }
-        this._finishPtt();
-    }
-    _finishPtt() {
-        if (!this._pttHeld) {
-            return;
-        }
-        this._clearAutoSendSilenceTimer();
-        this._clearAutoListenTimer();
-        this._pttHeld = false;
-        this._telemetryPttUpMs = Date.now();
-        const holdMs = this._telemetryPttDownMs ? Date.now() - this._telemetryPttDownMs : 0;
-        this.telemetryService.publicLog2("voicePtt", {
-            holdDurationMs: holdMs
-        });
-        if (this._pttMaxDurationTimer) {
-            clearTimeout(this._pttMaxDurationTimer);
-            this._pttMaxDurationTimer = undefined;
-        }
-        this._voiceState.set("processing", undefined);
-        this._statusText.set("Processing...", undefined);
-        this._replyPlayedSinceSend = false;
-        this._clearAwaitingReply();
-        this._suppressIncomingAudio = false;
-        this.micCaptureService.pttUp();
-        if (this.accessibilityService.isScreenReaderOptimized()) {
-            this.accessibilitySignalService.playSignal(AccessibilitySignal.voiceRecordingStopped);
-        }
-    }
-    markUserCancelled(sessionId) {
-        const existing = this._userCancelledSessions.get(sessionId);
-        if (existing) {
-            clearTimeout(existing);
-        }
-        const expiry = setTimeout(() => {
-            this._userCancelledSessions.delete(sessionId);
-        }, VoiceSessionController_1._USER_CANCEL_SUPPRESS_MS);
-        this._userCancelledSessions.set(sessionId, expiry);
-    }
-    setTargetSession(resource) {
-        this._targetSession.set(resource, undefined);
-    }
-    newSessionAsTarget() {
-        const ref = this.chatService.startNewLocalSession(ChatAgentLocation.Chat);
-        const resource = ref.object.sessionResource;
-        ref.dispose();
-        this._targetSession.set(resource, undefined);
-        this.commandService.executeCommand("_chat.voice.switchToSession", ( resource.toString())).catch(() => {});
-    }
-    _scheduleDelayedMicStop() {
-        if (this._delayedMicStopTimer) {
-            clearTimeout(this._delayedMicStopTimer);
-        }
-        this._delayedMicStopTimer = setTimeout(() => {
-            this._delayedMicStopTimer = undefined;
-            this._pttWaitingForPlayback = false;
-        }, 1000);
-    }
-    _isAutoSendEnabled() {
-        const delayMs = this.configurationService.getValue("agents.voice.autoSendDelay");
-        return typeof delayMs === "number" && delayMs >= 0;
-    }
-    _checkSendKeyword(text) {
-        const keyword = this.configurationService.getValue("agents.voice.sendKeyword")?.trim();
-        if (!keyword) {
-            return undefined;
-        }
-        const trimmed = text.trimEnd().replace(/[.,!?;:]+$/, "").trimEnd();
-        const keywordLower = keyword.toLowerCase();
-        if (trimmed.toLowerCase().endsWith(keywordLower)) {
-            const stripped = trimmed.slice(0, trimmed.length - keyword.length).trimEnd();
-            return stripped || undefined;
-        }
-        return undefined;
-    }
-    _enterAutoListen() {
-        this._clearAutoListenTimer();
-        if (!this._isConnected.get() || this._pttHeld) {
-            return;
-        }
-        if (this.ttsPlaybackService.isPlaying || this._audioQueue.length > 0 || this._currentPlaybackSessionId !== null) {
-            return;
-        }
-        this.pttDown();
-        this.pttUp();
-    }
-    _scheduleAutoListen() {
-        this._clearAutoListenTimer();
-        this._autoListenTimer = setTimeout(() => {
-            this._autoListenTimer = undefined;
-            if (this._awaitingReplyAudio) {
-                return;
-            }
-            this._enterAutoListen();
-        }, VoiceSessionController_1._AUTO_LISTEN_QUIET_MS);
-    }
-    _clearAutoListenTimer() {
-        if (this._autoListenTimer) {
-            clearTimeout(this._autoListenTimer);
-            this._autoListenTimer = undefined;
-        }
-    }
-    _scheduleAutoSendOnSilence() {
-        this._clearAutoSendSilenceTimer();
-        const delayMs = this.configurationService.getValue("agents.voice.autoSendDelay");
-        if (typeof delayMs !== "number" || delayMs < 0) {
-            return;
-        }
-        this._autoSendSilenceTimer = setTimeout(() => {
-            this._autoSendSilenceTimer = undefined;
-            if (this._pttToggleMode && this._pttHeld) {
-                this._pttToggleMode = false;
-                this._finishPtt();
-            }
-        }, delayMs);
-    }
-    _clearAutoSendSilenceTimer() {
-        if (this._autoSendSilenceTimer) {
-            clearTimeout(this._autoSendSilenceTimer);
-            this._autoSendSilenceTimer = undefined;
-        }
-    }
-    _setAwaitingReply() {
-        this._awaitingReplyAudio = true;
-        this._clearAutoListenTimer();
-        if (this._awaitingReplyWatchdog) {
-            clearTimeout(this._awaitingReplyWatchdog);
-        }
-        this._awaitingReplyWatchdog = setTimeout(() => {
-            this._awaitingReplyWatchdog = undefined;
-            this._awaitingReplyAudio = false;
-            if (this._isAutoSendEnabled() && !this._pttHeld) {
-                this._enterAutoListen();
-            }
-        }, 30_000);
-    }
-    _clearAwaitingReply() {
-        this._awaitingReplyAudio = false;
-        if (this._awaitingReplyWatchdog) {
-            clearTimeout(this._awaitingReplyWatchdog);
-            this._awaitingReplyWatchdog = undefined;
-        }
-    }
-    async _sendTranscriptionToChat(text) {
-        const target = this._targetSession.get();
-        if (target) {
-            const currentSession = await this.commandService.executeCommand("_chat.voice.getCurrentSession").catch(() => undefined);
-            const isTargetVisible = currentSession === ( target.toString());
-            if (isTargetVisible) {
-                await this.commandService.executeCommand("_chat.voice.acceptInput", text).catch(err => {
-                    this.logService.warn("[voice] acceptInput failed for visible target:", err);
-                });
-            } else {
-                const cts = ( new CancellationTokenSource());
-                const ref = await this.chatService.acquireOrLoadSession(target, ChatAgentLocation.Chat, cts.token, "voice-send").catch(err => {
-                    this.logService.warn("[voice] Failed to load target session:", err);
-                    return undefined;
-                });
-                cts.dispose();
-                if (!ref) {
-                    this.logService.warn("[voice] Could not load target session, falling back to switch");
-                    const switched = await this.commandService.executeCommand("_chat.voice.switchToSession", ( target.toString())).catch(() => false);
-                    if (switched) {
-                        await ( new Promise(resolve => setTimeout(resolve, 200)));
-                        await this.commandService.executeCommand("_chat.voice.acceptInput", text).catch(() => {});
-                    }
-                    return;
-                }
-                const result = await this.chatService.sendRequest(target, text).catch(err => {
-                    this.logService.warn("[voice] Error sending transcription to target session:", err);
-                    return undefined;
-                });
-                if (result && result.kind !== "rejected") {
-                    this._watchResponseForFloatingWindow(target);
-                    this.commandService.executeCommand("_agentsVoice.openWindow").catch(() => {});
-                    const model = this.chatService.getSession(target);
-                    if (model) {
-                        const lastReq = model.getRequests().at(-1);
-                        if (lastReq?.response && !lastReq.response.isComplete && !lastReq.response.isCanceled) {
-                            const responseDisposable = lastReq.response.onDidChange(() => {
-                                if (lastReq.response.isComplete || lastReq.response.isCanceled) {
-                                    responseDisposable.dispose();
-                                    ref.dispose();
-                                }
-                            });
-                        } else {
-                            ref.dispose();
-                        }
-                    } else {
-                        ref.dispose();
-                    }
-                } else {
-                    ref.dispose();
-                }
-            }
-        } else {
-            const currentSession = await this.commandService.executeCommand("_chat.voice.getCurrentSession").catch(() => undefined);
-            if (currentSession) {
-                this.commandService.executeCommand("_chat.voice.acceptInput", text).catch(err => {
-                    this.logService.warn("[voice] acceptInput failed for current session:", err);
-                });
-            } else {
-                const models = [...this.chatService.chatModels.get()];
-                const existingSession = models.length > 0 ? models[models.length - 1] : undefined;
-                const sessionResource = existingSession?.sessionResource;
-                if (sessionResource) {
-                    const switched = await this.commandService.executeCommand("_chat.voice.switchToSession", ( sessionResource.toString())).catch(() => false);
-                    if (switched) {
-                        await ( new Promise(resolve => setTimeout(resolve, 200)));
-                        await this.commandService.executeCommand("_chat.voice.acceptInput", text).catch(err => {
-                            this.logService.warn("[voice] acceptInput failed after switch to existing:", err);
-                        });
-                    } else {
-                        this.chatService.sendRequest(sessionResource, text).catch(err => {
-                            this.logService.warn("[voice] Error sending transcription to existing session:", err);
-                        });
-                    }
-                } else {
-                    const ref = this.chatService.startNewLocalSession(ChatAgentLocation.Chat);
-                    const resource = ref.object.sessionResource;
-                    ref.dispose();
-                    this.commandService.executeCommand("_chat.voice.switchToSession", ( resource.toString())).catch(() => {});
-                    this.chatService.sendRequest(resource, text).catch(err => {
-                        this.logService.warn("[voice] Error sending transcription to new session:", err);
-                    });
-                }
-            }
-            this.commandService.executeCommand("workbench.panel.chat.view.copilot.focus").catch(() => {});
-        }
-    }
-    _watchResponseForFloatingWindow(sessionResource) {
-        const model = this.chatService.getSession(sessionResource);
-        if (!model) {
-            return;
-        }
-        this._prevSessionStates.set(( sessionResource.toString()), {
-            state: "thinking",
-            detail: ""
-        });
-        this._sendContext();
-        const disposables = ( new DisposableStore());
-        let lastText = "";
-        const updateFromResponse = () => {
-            const lastReq = model.lastRequest;
-            const response = lastReq?.response;
-            if (!response) {
-                return;
-            }
-            const markdown = response.response.getMarkdown();
-            const previewText = markdown.length > 200 ? markdown.slice(0, 200) + "…" : markdown;
-            if (previewText && previewText !== lastText) {
-                const isFirst = lastText === "";
-                lastText = previewText;
-                this._setAssistantTurn(previewText, {
-                    startNewTurn: isFirst
-                });
-            }
-            if (response.isComplete || response.isCanceled) {
-                this._prevSessionStates.set(( sessionResource.toString()), {
-                    state: "idle",
-                    detail: ""
-                });
-                this._sendContext();
-                this.voiceClientService.flushSessionContext();
-                disposables.dispose();
-            }
-        };
-        const checkResponse = () => {
-            const lastReq = model.lastRequest;
-            if (lastReq?.response) {
-                disposables.add(lastReq.response.onDidChange(() => updateFromResponse()));
-                updateFromResponse();
-            }
-        };
-        disposables.add(model.onDidChange(e => {
-            if (e.kind === "addResponse") {
-                checkResponse();
-            }
-        }));
-        checkResponse();
-        const timeout = setTimeout(() => disposables.dispose(), 5 * 60 * 1000);
-        disposables.add({
-            dispose: () => clearTimeout(timeout)
-        });
-    }
-    _pushTurn(turn) {
-        const cur = this._transcriptTurns.get();
-        const next = [...cur, turn].slice(-VoiceSessionController_1._MAX_TURNS);
-        this._transcriptTurns.set(next, undefined);
-    }
-    _startUserTurn() {
-        const cur = this._transcriptTurns.get();
-        const last = cur[cur.length - 1];
-        if (last && last.speaker === "user" && !last.text) {
-            return;
-        }
-        this._pushTurn({
-            speaker: "user",
-            text: "",
-            committed: "",
-            isPartial: true
-        });
-    }
-    _updateUserTurn(text, committed, isPartial) {
-        const cur = this._transcriptTurns.get();
-        const last = cur[cur.length - 1];
-        if (!last || last.speaker !== "user") {
-            this._pushTurn({
-                speaker: "user",
-                text,
-                committed,
-                isPartial
-            });
-            return;
-        }
-        const updated = {
-            speaker: "user",
-            text,
-            committed,
-            isPartial
-        };
-        this._transcriptTurns.set([...cur.slice(0, -1), updated], undefined);
-    }
-    _setAssistantTurn(
-        text,
-        opts = {
-            startNewTurn: true
-        }
-    ) {
-        const cur = this._transcriptTurns.get();
-        const last = cur[cur.length - 1];
-        if (!opts.startNewTurn && last && last.speaker === "assistant") {
-            const updated = {
-                speaker: "assistant",
-                text,
-                committed: "",
-                isPartial: false
-            };
-            this._transcriptTurns.set([...cur.slice(0, -1), updated], undefined);
-            return;
-        }
-        this._pushTurn({
-            speaker: "assistant",
-            text,
-            committed: "",
-            isPartial: false
-        });
-    }
-    _cancelTranscriptFade() {
-        if (this._transcriptFadeTimer) {
-            clearTimeout(this._transcriptFadeTimer);
-            this._transcriptFadeTimer = undefined;
-        }
-    }
-    _persistEntry(kind, text, metadata) {
-        const userId = this._userLogin;
-        if (!userId || !text) {
-            return;
-        }
-        const entry = {
-            turnId: generateUuid(),
-            ancestorIds: this._lastPersistedTurnId ? [this._lastPersistedTurnId] : [],
-            kind,
-            role: kind === "user_voice" ? "user" : "assistant",
-            text,
-            timestamp: ( new Date()).toISOString(),
-            ...(metadata ? {
-                metadata
-            } : {})
-        };
-        this._lastPersistedTurnId = entry.turnId;
-        this.voiceTranscriptStore.appendTurn(userId, entry).catch(err => {
-            this.logService.warn("[voice] failed to persist transcript entry", err);
-        });
-    }
-    _persistTurn(role, text) {
-        this._persistEntry(role === "user" ? "user_voice" : "agent_voice", text);
-    }
-    _renderToolCallSummary(name, args) {
-        if (!args || ( Object.keys(args)).length === 0) {
-            return `${name}()`;
-        }
-        const pairs = [];
-        for (const [k, v] of Object.entries(args)) {
-            let rendered;
-            if (typeof v === "string") {
-                rendered = v.length > 200 ? `${v.slice(0, 197)}...` : v;
-                rendered = JSON.stringify(rendered);
-            } else {
-                try {
-                    const json = JSON.stringify(v);
-                    rendered = json.length > 200 ? `${json.slice(0, 197)}...` : json;
-                } catch {
-                    rendered = String(v);
-                }
-            }
-            pairs.push(`${k}=${rendered}`);
-        }
-        return `${name}(${pairs.join(", ")})`;
-    }
-    _buildPriorTimeline(turns) {
-        const out = [];
-        for (const t of turns) {
-            const kind = t.kind;
-            if (!kind) {
-                continue;
-            }
-            const entry = {
-                kind,
-                text: t.text,
-                timestamp: ( new Date(t.timestamp)).toISOString(),
-                ...(t.metadata?.toolName ? {
-                    toolName: t.metadata.toolName
-                } : {}),
-                ...(t.metadata?.codingSessionId ? {
-                    codingSessionId: t.metadata.codingSessionId
-                } : {}),
-                ...(t.metadata?.codingStatus ? {
-                    codingStatus: t.metadata.codingStatus
-                } : {})
-            };
-            out.push(entry);
-        }
-        try {
-            const sessions = this.agentSessionsService.model.sessions.filter(s => !s.isArchived());
-            for (const session of sessions) {
-                const model = this.chatService.getSession(session.resource);
-                const lastReq = model?.getRequests().at(-1);
-                const value = lastReq?.response?.response.value;
-                if (!value) {
-                    continue;
-                }
-                const full = ( value.filter(p => p.kind === "markdownContent").map(p => p.content.value)).join(" ").trim();
-                if (!full) {
-                    continue;
-                }
-                const summary = this._firstSentences(full, VoiceSessionController_1.CODING_AGENT_REPLY_SENTENCE_LIMIT);
-                if (!summary) {
-                    continue;
-                }
-                out.push({
-                    kind: "coding_agent_reply",
-                    text: summary,
-                    timestamp: ( new Date()).toISOString(),
-                    codingSessionId: ( session.resource.toString())
-                });
-            }
-        } catch (err) {
-            this.logService.warn("[voice] failed to synthesize coding_agent_reply timeline entries", err);
-        }
-        return out;
-    }
-    _firstSentences(text, n) {
-        const collapsed = text.replace(/\s+/g, " ").trim();
-        if (!collapsed) {
-            return "";
-        }
-        const sentences = [];
-        const re = /[^.!?]+[.!?]+(\s|$)/g;
-        let m;
-        while ((m = re.exec(collapsed)) !== null && sentences.length < n) {
-            sentences.push(m[0].trim());
-        }
-        if (sentences.length === 0) {
-            return collapsed.length > 600 ? `${collapsed.slice(0, 597)}...` : collapsed;
-        }
-        return sentences.join(" ");
-    }
-    _enqueueAudio(sessionId, audio, isFirstChunk, isFinal, transcript) {
-        if (this._suppressIncomingAudio) {
-            if (isFirstChunk) {
-                this._suppressIncomingAudio = false;
-            } else {
-                return;
-            }
-        }
-        if (isFirstChunk) {
-            this._clearAwaitingReply();
-        }
-        const nothingPlaying = this._currentPlaybackSessionId === null;
-        const sameSession = !nothingPlaying && this._currentPlaybackSessionId === sessionId;
-        if ((nothingPlaying && this._audioQueue.length === 0) || sameSession) {
-            this._playChunk(sessionId, audio, isFirstChunk, isFinal, transcript);
-            return;
-        }
-        let entry = this._audioQueue.find(
-            e => e.sessionId === sessionId || (e.sessionId === undefined && sessionId === undefined)
-        );
-        if (!entry) {
-            entry = {
-                sessionId,
-                chunks: []
-            };
-            this._audioQueue.push(entry);
-        }
-        entry.chunks.push({
-            audio,
-            isFirstChunk,
-            isFinal,
-            transcript
-        });
-        if (this._currentPlaybackSessionId === null && !this._isProcessingQueue) {
-            this._processQueue();
-        }
-    }
-    _playChunk(sessionId, audio, isFirstChunk, isFinal, transcript) {
-        this._currentPlaybackSessionId = sessionId;
-        if (transcript) {
-            this._setAssistantTurn(transcript, {
-                startNewTurn: isFirstChunk
-            });
-        }
-        const sessionResource = sessionId ? ( URI.parse(sessionId)) : undefined;
-        if (sessionResource) {
-            this.voicePlaybackService.notifyPlaybackStart(sessionResource, transcript);
-        }
-        const ttsEnabled = this.configurationService.getValue("agents.voice.textToSpeech") !== false;
-        if (ttsEnabled && audio) {
-            this._clearAutoListenTimer();
-            this._replyPlayedSinceSend = true;
-            this.micCaptureService.suppressUntil(Date.now() + 800);
-            this._voiceState.set("speaking", undefined);
-            this._statusText.set("Speaking...", undefined);
-            this.ttsPlaybackService.playAudioChunk(audio, isFinal, this._window);
-        } else if (!ttsEnabled) {
-            this._replyPlayedSinceSend = true;
-            if (isFinal) {
-                this._currentPlaybackSessionId = null;
-                this._processQueue();
-                if (this._isAutoSendEnabled()) {
-                    this._scheduleAutoListen();
-                }
-            }
-        } else {
-            this.ttsPlaybackService.playAudioChunk(audio, isFinal, this._window);
-        }
-    }
-    _processQueue() {
-        if (this._audioQueue.length === 0 || this._currentPlaybackSessionId !== null) {
-            this._isProcessingQueue = false;
-            return;
-        }
-        this._isProcessingQueue = true;
-        const next = this._audioQueue.shift();
-        for (const chunk of next.chunks) {
-            this._playChunk(
-                next.sessionId,
-                chunk.audio,
-                chunk.isFirstChunk,
-                chunk.isFinal,
-                chunk.transcript
-            );
-        }
-        this._isProcessingQueue = false;
-    }
-    _replaySessionAudio(sessionId) {
-        this._stopReplay();
-        const samples = this._sessionAudioCache.get(sessionId);
-        if (!samples || !this._window) {
-            return;
-        }
-        const ctx = this.ttsPlaybackService.ensureContext(this._window);
-        const buffer = ctx.createBuffer(1, samples.length, 24000);
-        buffer.getChannelData(0).set(samples);
-        const source = ctx.createBufferSource();
-        source.buffer = buffer;
-        source.connect(ctx.destination);
-        this._replaySourceNode = source;
-        const sessionResource = ( URI.parse(sessionId));
-        this.voicePlaybackService.notifyPlaybackStart(sessionResource, undefined);
-        this._voiceState.set("speaking", undefined);
-        this._statusText.set("Replaying...", undefined);
-        source.onended = () => {
-            if (this._replaySourceNode === source) {
-                this._replaySourceNode = undefined;
-                this.voicePlaybackService.notifyPlaybackEnd(sessionResource);
-                this._voiceState.set("idle", undefined);
-                this._statusText.set("Hold to speak...", undefined);
-            }
-        };
-        source.start(0);
-    }
-    _stopReplay() {
-        if (this._replaySourceNode) {
-            try {
-                this._replaySourceNode.stop();
-            } catch {}
-            this._replaySourceNode = undefined;
-        }
-    }
-    _sendContext() {
-        this.voiceClientService.sendSessionContext(this._buildSessionContext());
-    }
-    _armConfirmationFlushWatchdog(sessionId, label, isTransition) {
-        if (( this._confirmationFlushWatchdogs.has(sessionId))) {
-            return;
-        }
-        if (isTransition) {
-            this.logService.info(
-                `[voice] arming confirmation flush watchdog id=${sessionId.slice(-32)} label="${label}"`
-            );
-        }
-        const timer = setTimeout(() => {
-            this._confirmationFlushWatchdogs.delete(sessionId);
-            this.logService.info(
-                `[voice] confirmation flush watchdog firing id=${sessionId.slice(-32)} label="${label}"`
-            );
-            this._sendContext();
-            this.voiceClientService.flushSessionContext();
-        }, VoiceSessionController_1._CONFIRMATION_FLUSH_DELAY_MS);
-        this._confirmationFlushWatchdogs.set(sessionId, timer);
-    }
-    _checkSessionStateChanges() {
-        const sessions = this.agentSessionsService.model.sessions.filter(s => !s.isArchived());
-        const stateChanges = [];
-        const processedResources = ( new Set());
-        for (const s of sessions) {
-            processedResources.add(( s.resource.toString()));
-            const sessionId = ( s.resource.toString());
-            const model = this.chatService.getSession(s.resource);
-            let currentState;
-            let detail;
-            let lastResponseSummary;
-            if (model) {
-                const info = this._getAgentStateInfo(model);
-                currentState = info.state;
-                detail = info.detail;
-                lastResponseSummary = info.last_response_summary;
-                this._pendingIdleNarration.delete(sessionId);
-            } else {
-                currentState = s.status === ChatSessionStatus.InProgress ? "thinking" : s.status === ChatSessionStatus.NeedsInput ? "waiting_for_confirmation" : s.status === ChatSessionStatus.Completed ? "idle" : "unknown";
-                if (s.status === ChatSessionStatus.NeedsInput) {
-                    this._ensureModelLoaded(s.resource);
-                }
-            }
-            const prev = this._prevSessionStates.get(sessionId);
-            const isStateChange = prev !== undefined && prev.state !== currentState && currentState !== "unknown";
-            const isDetailChange = !isStateChange && prev !== undefined && currentState === "waiting_for_confirmation" && (detail ?? "") !== prev.detail;
-            if (!model && currentState === "idle" && isStateChange) {
-                this._deferIdleNarrationUntilModelLoaded(s.resource);
-                continue;
-            }
-            if (isStateChange || isDetailChange) {
-                const cancelExpiry = this._userCancelledSessions.get(sessionId);
-                if (cancelExpiry) {
-                    clearTimeout(cancelExpiry);
-                    this._userCancelledSessions.delete(sessionId);
-                } else {
-                    if (isDetailChange) {
-                        this.voiceClientService.invalidateSessionCache(sessionId);
-                    }
-                    stateChanges.push({
-                        sessionId,
-                        currentState,
-                        label: s.label || "Untitled session",
-                        detail,
-                        lastResponseSummary
-                    });
-                }
-            }
-            if (currentState !== "unknown") {
-                this._prevSessionStates.set(sessionId, {
-                    state: currentState,
-                    detail: detail ?? ""
-                });
-            }
-        }
-        for (const chatModel of this.chatService.chatModels.get()) {
-            const key = ( chatModel.sessionResource.toString());
-            if (( processedResources.has(key))) {
-                continue;
-            }
-            if (chatModel.getRequests().length === 0) {
-                continue;
-            }
-            const info = this._getAgentStateInfo(chatModel);
-            const currentState = info.state;
-            const detail = info.detail;
-            const lastResponseSummary = info.last_response_summary;
-            const prev = this._prevSessionStates.get(key);
-            const isStateChange = prev !== undefined && prev.state !== currentState && currentState !== "unknown";
-            const isDetailChange = !isStateChange && prev !== undefined && currentState === "waiting_for_confirmation" && (detail ?? "") !== prev.detail;
-            if (isStateChange || isDetailChange) {
-                if (isDetailChange) {
-                    this.voiceClientService.invalidateSessionCache(key);
-                }
-                stateChanges.push({
-                    sessionId: key,
-                    currentState,
-                    label: chatModel.title || "Chat",
-                    detail,
-                    lastResponseSummary
-                });
-            }
-            if (currentState !== "unknown") {
-                this._prevSessionStates.set(key, {
-                    state: currentState,
-                    detail: detail ?? ""
-                });
-            }
-        }
-        if (stateChanges.length > 0) {
-            this.logService.info(
-                `[voice] onDidChangeSessions detected ${stateChanges.length} state change(s): ${( stateChanges.map(c => `${c.label}: ${c.currentState}`)).join(", ")}`
-            );
-            this._sendContext();
-            this.voiceClientService.flushSessionContext();
-            for (const change of stateChanges) {
-                this._persistEntry("coding_event", `session "${change.label}" → ${change.currentState}`, {
-                    codingSessionId: change.sessionId,
-                    codingStatus: change.currentState,
-                    codingSessionLabel: change.label
-                });
-            }
-        }
-    }
-    _buildSessionContext() {
-        const oneHourAgo = Date.now() - 60 * 60 * 1000;
-        const sessions = this.agentSessionsService.model.sessions.filter(s => {
-            if (s.isArchived()) {
-                return false;
-            }
-            if (s.status === ChatSessionStatus.InProgress || s.status === ChatSessionStatus.NeedsInput) {
-                return true;
-            }
-            if (s.status === ChatSessionStatus.Completed) {
-                const endedAt = s.timing.lastRequestEnded ?? s.timing.created;
-                return endedAt !== undefined && endedAt > oneHourAgo;
-            }
-            return false;
-        });
-        const targetSessionId = this._targetSession.get()?.toString();
-        const sessionList = ( sessions.map(s => {
-            const model = this.chatService.getSession(s.resource);
-            const isActive = ( s.resource.toString()) === targetSessionId;
-            if (!model) {
-                const sessionIdStr = ( s.resource.toString());
-                let fallbackState = s.status === ChatSessionStatus.InProgress ? "thinking" : s.status === ChatSessionStatus.NeedsInput ? "waiting_for_confirmation" : s.status === ChatSessionStatus.Completed ? "idle" : "unknown";
-                if (fallbackState === "idle" && ( this._pendingIdleNarration.has(sessionIdStr))) {
-                    const prev = this._prevSessionStates.get(sessionIdStr);
-                    if (prev?.state) {
-                        fallbackState = prev.state;
-                    }
-                }
-                return {
-                    id: sessionIdStr,
-                    is_active: isActive,
-                    agent_state: fallbackState
-                };
-            }
-            const stateInfo = this._getAgentStateInfo(model);
-            return {
-                id: ( s.resource.toString()),
-                is_active: isActive,
-                agent_state: stateInfo.state,
-                ...(stateInfo.detail ? {
-                    agent_state_detail: stateInfo.detail
-                } : {}),
-                ...(stateInfo.last_response_summary ? {
-                    last_response_summary: stateInfo.last_response_summary
-                } : {})
-            };
-        }));
-        const agentResources = ( new Set(( this.agentSessionsService.model.sessions.map(s => ( s.resource.toString())))));
-        for (const chatModel of this.chatService.chatModels.get()) {
-            const key = ( chatModel.sessionResource.toString());
-            if (( agentResources.has(key))) {
-                continue;
-            }
-            if (chatModel.getRequests().length === 0) {
-                continue;
-            }
-            const stateInfo = this._getAgentStateInfo(chatModel);
-            if (stateInfo.state === "idle") {
-                const lastActive = chatModel.lastMessageDate;
-                if (lastActive < oneHourAgo) {
-                    continue;
-                }
-            }
-            sessionList.push({
-                id: key,
-                is_active: key === targetSessionId,
-                agent_state: stateInfo.state,
-                ...(stateInfo.detail ? {
-                    agent_state_detail: stateInfo.detail
-                } : {}),
-                ...(stateInfo.last_response_summary ? {
-                    last_response_summary: stateInfo.last_response_summary
-                } : {})
-            });
-        }
-        const context = {
-            sessions: sessionList,
-            display_locale: this._window?.navigator.language
-        };
-        return context;
-    }
-    _ensureModelLoaded(resource) {
-        const key = ( resource.toString());
-        if (( this._eagerModelRefs.has(key)) || ( this._eagerModelLoading.has(key)) || this.chatService.getSession(resource)) {
-            return;
-        }
-        this.logService.info(`[voice] eagerly loading model for session ${key.slice(-32)}`);
-        this._eagerModelLoading.add(key);
-        const cts = ( new CancellationTokenSource());
-        this.chatService.acquireOrLoadSession(
-            resource,
-            ChatAgentLocation.Chat,
-            cts.token,
-            "VoiceSessionController#eagerLoad"
-        ).then(ref => {
-            this._eagerModelLoading.delete(key);
-            if (ref) {
-                const existing = this._eagerModelRefs.get(key);
-                if (!this._isConnected.get() || existing) {
-                    ref.dispose();
-                    if (!this._isConnected.get()) {
-                        this._pendingIdleNarration.delete(key);
-                    }
-                } else {
-                    this._eagerModelRefs.set(key, ref);
-                }
-            } else {
-                this._pendingIdleNarration.delete(key);
-            }
-            cts.dispose();
-        }, () => {
-            this._eagerModelLoading.delete(key);
-            this._pendingIdleNarration.delete(key);
-            cts.dispose();
-        });
-    }
-    _deferIdleNarrationUntilModelLoaded(resource) {
-        this._pendingIdleNarration.add(( resource.toString()));
-        this._ensureModelLoaded(resource);
-    }
-    _getAgentStateInfo(model) {
-        if (!model) {
-            return {
-                state: "unknown"
-            };
-        }
-        const lastRequest = model.getRequests().at(-1);
-        const pendingConfirmation = lastRequest?.response?.isPendingConfirmation.get();
-        if (pendingConfirmation) {
-            let confirmDetail = "";
-            for (const part of lastRequest?.response?.response.value ?? []) {
-                if (part.kind === "questionCarousel" && !part.isUsed) {
-                    const carousel = part;
-                    const titles = ( (carousel.questions ?? []).map(q => q.title)).filter(Boolean);
-                    if (titles.length > 0) {
-                        confirmDetail = `questions: ${titles.join(", ")}`;
-                    } else {
-                        const msg = carousel.message;
-                        confirmDetail = msg ? (typeof msg === "string" ? msg : msg.value) : "asking clarifying questions";
-                    }
-                } else if (part.kind === "planReview" && !part.isUsed) {
-                    confirmDetail = "review the plan to continue";
-                } else if (part.kind === "elicitation2") {
-                    const elicitation = part;
-                    if (elicitation.state.get() === "pending") {
-                        const title = elicitation.title;
-                        confirmDetail = title ? (typeof title === "string" ? title : title.value) : "needs input";
-                    }
-                } else if (part.kind === "confirmation" && !part.isUsed) {
-                    const conf = part;
-                    confirmDetail = conf.title ?? "needs approval";
-                } else if (part.kind === "toolInvocation") {
-                    const state = part.state.get();
-                    if (state.type === IChatToolInvocation.StateKind.WaitingForConfirmation) {
-                        const params = state.parameters;
-                        const command = params?.["command"] ?? params?.["input"];
-                        const explanation = params?.["explanation"] ?? params?.["goal"];
-                        if (typeof command === "string" && command) {
-                            confirmDetail = `command: ${command}`;
-                            if (typeof explanation === "string" && explanation) {
-                                confirmDetail += `\nreason: ${explanation}`;
-                            }
-                        } else {
-                            confirmDetail = pendingConfirmation.detail ?? "";
-                        }
-                    }
-                }
-            }
-            return {
-                state: "waiting_for_confirmation",
-                detail: confirmDetail || pendingConfirmation.detail || ""
-            };
-        }
-        if (lastRequest?.response) {
-            let fallbackDetail;
-            for (const part of lastRequest.response.response.value) {
-                if (part.kind === "toolInvocation") {
-                    const state = part.state.get();
-                    if (state.type === IChatToolInvocation.StateKind.WaitingForConfirmation) {
-                        const params = state.parameters;
-                        const questions = params?.["questions"];
-                        let detail = "";
-                        if (Array.isArray(questions) && questions.length > 0) {
-                            const headers = ( questions.map(q => q["header"] || q["question"])).filter(Boolean).join(", ");
-                            detail = headers ? `questions: ${headers}` : "asking clarifying questions";
-                        }
-                        if (!detail) {
-                            const invMsg = part.invocationMessage;
-                            detail = invMsg ? (typeof invMsg === "string" ? invMsg : invMsg.value) : "needs input";
-                        }
-                        fallbackDetail = detail;
-                    }
-                }
-            }
-            if (fallbackDetail !== undefined) {
-                return {
-                    state: "waiting_for_confirmation",
-                    detail: fallbackDetail
-                };
-            }
-        }
-        const incomplete = lastRequest?.response?.isIncomplete.get() ?? false;
-        if (incomplete) {
-            return {
-                state: "thinking"
-            };
-        }
-        const responseText = lastRequest?.response?.response.getMarkdown().trim() ?? "";
-        return {
-            state: "idle",
-            ...(responseText ? {
-                last_response_summary: responseText
-            } : {})
-        };
-    }
-    _classifyPendingType(response) {
-        let result = "input";
-        for (const part of response.response.value) {
-            if (part.kind === "toolInvocation") {
-                const invocation = part;
-                const state = invocation.state.get();
-                if (state.type === IChatToolInvocation.StateKind.WaitingForConfirmation || state.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
-                    result = "approval";
-                }
-            }
-            if (part.kind === "confirmation" && !part.isUsed) {
-                result = "approval";
-            }
-            if (part.kind === "questionCarousel" && !part.isUsed) {
-                result = "input";
-            }
-            if (part.kind === "planReview" && !part.isUsed) {
-                result = "input";
-            }
-            if (part.kind === "elicitation2") {
-                result = "input";
-            }
-        }
-        return result;
-    }
-    _getConfirmationDescription(response) {
-        let desc = "";
-        for (const part of response.response.value) {
-            if (part.kind === "toolInvocation") {
-                const invocation = part;
-                const state = invocation.state.get();
-                if (state.type === IChatToolInvocation.StateKind.WaitingForConfirmation) {
-                    const params = state.parameters;
-                    const command = params?.["command"] ?? params?.["input"];
-                    const explanation = params?.["explanation"] ?? params?.["goal"];
-                    if (typeof command === "string" && command) {
-                        desc = typeof explanation === "string" ? `${command} — ${explanation}` : command;
-                    }
-                }
-            } else if (part.kind === "questionCarousel" && !part.isUsed) {
-                const carousel = part;
-                const titles = ( (carousel.questions ?? []).map(q => q.title)).filter(Boolean);
-                if (titles.length > 0) {
-                    desc = titles.join(", ");
-                } else {
-                    const msg = carousel.message;
-                    desc = msg ? (typeof msg === "string" ? msg : msg.value) : "asking clarifying questions";
-                }
-            } else if (part.kind === "elicitation2") {
-                const elicitation = part;
-                if (elicitation.state.get() === "pending") {
-                    const title = elicitation.title;
-                    desc = title ? (typeof title === "string" ? title : title.value) : "needs input";
-                }
-            } else if (part.kind === "planReview" && !part.isUsed) {
-                desc = "review the plan to continue";
-            } else if (part.kind === "confirmation" && !part.isUsed) {
-                desc = part.title ?? "needs approval";
-            }
-        }
-        return desc;
-    }
-    _autoApproveCheck() {
-        if (this._autoApprovedSessions.size === 0) {
-            return;
-        }
-        const sessions = this.agentSessionsService.model.sessions.filter(s => !s.isArchived());
-        for (const s of sessions) {
-            if (!( this._autoApprovedSessions.has(( s.resource.toString())))) {
-                continue;
-            }
-            const model = this.chatService.getSession(s.resource);
-            if (!model) {
-                continue;
-            }
-            for (const req of model.getRequests()) {
-                const pending = req.response?.isPendingConfirmation.get();
-                if (pending && req.response) {
-                    for (const part of req.response.response.value) {
-                        if (part.kind === "toolInvocation") {
-                            IChatToolInvocation.confirmWith(part, {
-                                type: ToolConfirmKind.UserAction
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-    _getMachineId() {
-        return this.environmentService.machineId ?? "unknown";
-    }
-    async submitFeedback(feedbackText) {
-        let userId = this._userLogin;
-        if (!userId) {
-            try {
-                const sessions = await this.authenticationService.getSessions("github");
-                userId = sessions[0]?.account.label ?? "unknown";
-            } catch {
-                userId = "unknown";
-            }
-        }
-        let transcriptHistory = [];
-        try {
-            const turns = await this.voiceTranscriptStore.loadTurns(userId);
-            transcriptHistory = ( turns.map(t => ({
-                role: t.role,
-                text: t.text,
-                timestamp: t.timestamp
-            })));
-        } catch (err) {
-            this.logService.warn("[voice] failed to load transcript history for feedback", err);
-        }
-        const sessions = this.agentSessionsService.model.sessions.filter(s => !s.isArchived());
-        const clientSessionState = {
-            voiceState: this._voiceState.get(),
-            isConnected: this._isConnected.get(),
-            isConnecting: this._isConnecting.get(),
-            isReconnecting: this._isReconnecting.get(),
-            pendingToolConfirmations: ( this._pendingToolConfirmations.get().map(tc => ({
-                type: tc.type,
-                sessionLabel: tc.sessionLabel,
-                description: tc.description
-            }))),
-            activeSessions: ( sessions.map(s => ({
-                id: ( s.resource.toString()),
-                label: s.label,
-                status: s.status
-            })))
-        };
-        const clientEnvironment = {
-            machineId: this._getMachineId()
-        };
-        const payload = {
-            feedbackText,
-            machineId: this._getMachineId(),
-            userId,
-            sessionId: this.voiceClientService.currentSessionId ?? "",
-            submissionId: generateUuid(),
-            transcriptHistory,
-            clientSessionState,
-            clientEnvironment,
-            timestamp: ( new Date()).toISOString()
-        };
-        return this.voiceClientService.submitFeedback(payload);
-    }
-};
-VoiceSessionController = VoiceSessionController_1 = ( __decorate([( __param(0, IVoiceClientService)), ( __param(1, IMicCaptureService)), ( __param(2, ITtsPlaybackService)), ( __param(3, IVoiceToolDispatchService)), ( __param(4, IVoicePlaybackService)), ( __param(5, IAgentSessionsService)), ( __param(6, IChatService)), ( __param(7, ICommandService)), ( __param(8, IAuthenticationService)), ( __param(9, IVoiceTranscriptStore)), ( __param(10, ILogService)), ( __param(11, IWorkbenchEnvironmentService)), ( __param(12, ITelemetryService)), ( __param(13, IConfigurationService)), ( __param(14, IAccessibilitySignalService)), ( __param(15, IAccessibilityService))], VoiceSessionController));
-
-export { VoiceSessionController };