@codingame/monaco-vscode-chat-service-override 34.1.3 → 35.0.0

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

@@ -0,0 +1,2117 @@
+
+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 };