@getpaseo/server 0.1.26 → 0.1.28

package/dist/server/server/session.js

@@ -13,6 +13,7 @@ import { STTManager } from './agent/stt-manager.js';
 import { maybePersistTtsDebugAudio } from './agent/tts-debug.js';
 import { isPaseoDictationDebugEnabled } from './agent/recordings-debug.js';
 import { DictationStreamManager, } from './dictation/dictation-stream-manager.js';
+import { createVoiceTurnController, } from './voice/voice-turn-controller.js';
 import { buildConfigOverrides, buildSessionConfig, extractTimestamps } from './persistence-hooks.js';
 import { experimental_createMCPClient } from 'ai';
 import { buildProviderRegistry } from './agent/provider-registry.js';
@@ -35,6 +36,7 @@ import { getProjectIcon } from '../utils/project-icon.js';
 import { expandTilde } from '../utils/path.js';
 import { searchHomeDirectories, searchWorkspaceEntries } from '../utils/directory-suggestions.js';
 import { ensureLocalSpeechModels, getLocalSpeechModelDir, listLocalSpeechModels, } from './speech/providers/local/models.js';
+import { toResolver } from './speech/provider-resolver.js';
 import { resolveClientMessageId } from './client-message-id.js';
 const execAsync = promisify(exec);
 const MAX_INITIAL_AGENT_TITLE_CHARS = Math.min(60, MAX_EXPLICIT_AGENT_TITLE_CHARS);
@@ -88,11 +90,10 @@ const PCM_BITS_PER_SAMPLE = 16;
 const PCM_BYTES_PER_MS = (PCM_SAMPLE_RATE * PCM_CHANNELS * (PCM_BITS_PER_SAMPLE / 8)) / 1000;
 const MIN_STREAMING_SEGMENT_DURATION_MS = 1000;
 const MIN_STREAMING_SEGMENT_BYTES = Math.round(PCM_BYTES_PER_MS * MIN_STREAMING_SEGMENT_DURATION_MS);
-const VOICE_MODE_INACTIVITY_FLUSH_MS = 4500;
-const VOICE_INTERNAL_DICTATION_ID_PREFIX = '__voice_turn__:';
 const SAFE_GIT_REF_PATTERN = /^[A-Za-z0-9._\/-]+$/;
 const AgentIdSchema = z.string().uuid();
 const VOICE_MCP_SERVER_NAME = 'paseo_voice';
+const VOICE_INTERRUPT_CONFIRMATION_MS = 500;
 class VoiceFeatureUnavailableError extends Error {
     constructor(context) {
         super(context.message);
@@ -161,19 +162,16 @@ export class Session {
         // Voice mode state
         this.isVoiceMode = false;
         this.speechInProgress = false;
+        this.pendingVoiceSpeechStartAt = null;
+        this.pendingVoiceSpeechTimer = null;
+        this.voiceTurnController = null;
+        this.voiceInputChunkCount = 0;
+        this.voiceInputBytes = 0;
+        this.voiceInputWindowStartedAt = Date.now();
         // Audio buffering for interruption handling
         this.pendingAudioSegments = [];
         this.bufferTimeout = null;
-        this.voiceModeInactivityTimeout = null;
         this.audioBuffer = null;
-        this.activeVoiceDictationId = null;
-        this.activeVoiceDictationFormat = null;
-        this.activeVoiceDictationNextSeq = 0;
-        this.activeVoiceDictationStartPromise = null;
-        this.activeVoiceDictationFinalizePromise = null;
-        this.activeVoiceDictationResultPromise = null;
-        this.activeVoiceDictationResolve = null;
-        this.activeVoiceDictationReject = null;
         // Optional TTS debug capture (persisted per utterance)
         this.ttsDebugStreams = new Map();
         // Per-session MCP client and tools
@@ -221,6 +219,7 @@ export class Session {
             this.unsubscribeTerminalsChanged = this.terminalManager.subscribeTerminalsChanged((event) => this.handleTerminalsChanged(event));
         }
         this.voiceAgentMcpStdio = voice?.voiceAgentMcpStdio ?? null;
+        this.resolveVoiceTurnDetection = toResolver(voice?.turnDetection ?? null);
         const configuredModelsDir = dictation?.localModels?.modelsDir?.trim();
         this.localSpeechModelsDir =
             configuredModelsDir && configuredModelsDir.length > 0
@@ -257,13 +256,6 @@ export class Session {
             stt: dictation?.stt ?? null,
             finalTimeoutMs: dictation?.finalTimeoutMs,
         });
-        this.voiceStreamManager = new DictationStreamManager({
-            logger: this.sessionLogger.child({ stream: 'voice-internal' }),
-            sessionId: this.sessionId,
-            emit: (msg) => this.handleDictationManagerMessage(msg),
-            stt: stt,
-            finalTimeoutMs: dictation?.finalTimeoutMs,
-        });
         // Initialize agent MCP client asynchronously
         void this.initializeAgentMcp();
         this.subscribeToAgentEvents();
@@ -699,6 +691,100 @@ export class Session {
             paseoHome: this.paseoHome,
         });
     }
+    buildPersistedProjectRecord(input) {
+        return createPersistedProjectRecord({
+            projectId: input.placement.projectKey,
+            rootPath: deriveProjectRootPath({
+                cwd: input.workspaceId,
+                checkout: input.placement.checkout,
+            }),
+            kind: deriveProjectKind(input.placement.checkout),
+            displayName: input.placement.projectName,
+            createdAt: input.createdAt,
+            updatedAt: input.updatedAt,
+            archivedAt: null,
+        });
+    }
+    buildPersistedWorkspaceRecord(input) {
+        return createPersistedWorkspaceRecord({
+            workspaceId: input.workspaceId,
+            projectId: input.placement.projectKey,
+            cwd: input.workspaceId,
+            kind: deriveWorkspaceKind(input.placement.checkout),
+            displayName: deriveWorkspaceDisplayName({
+                cwd: input.workspaceId,
+                checkout: input.placement.checkout,
+            }),
+            createdAt: input.createdAt,
+            updatedAt: input.updatedAt,
+            archivedAt: null,
+        });
+    }
+    async archiveProjectRecordIfEmpty(projectId, archivedAt) {
+        const siblingWorkspaces = (await this.workspaceRegistry.list()).filter((workspace) => workspace.projectId === projectId && !workspace.archivedAt);
+        if (siblingWorkspaces.length === 0) {
+            await this.projectRegistry.archive(projectId, archivedAt);
+        }
+    }
+    async reconcileWorkspaceRecord(workspaceId) {
+        const normalizedWorkspaceId = normalizePersistedWorkspaceId(workspaceId);
+        const existing = await this.workspaceRegistry.get(normalizedWorkspaceId);
+        const placement = await this.buildProjectPlacement(normalizedWorkspaceId);
+        const now = new Date().toISOString();
+        const nextProjectCreatedAt = existing?.createdAt ?? now;
+        const nextWorkspaceCreatedAt = existing?.createdAt ?? now;
+        const currentProjectRecord = await this.projectRegistry.get(placement.projectKey);
+        const nextProjectRecord = this.buildPersistedProjectRecord({
+            workspaceId: normalizedWorkspaceId,
+            placement,
+            createdAt: currentProjectRecord?.createdAt ?? nextProjectCreatedAt,
+            updatedAt: now,
+        });
+        const nextWorkspaceRecord = this.buildPersistedWorkspaceRecord({
+            workspaceId: normalizedWorkspaceId,
+            placement,
+            createdAt: nextWorkspaceCreatedAt,
+            updatedAt: now,
+        });
+        const needsWorkspaceUpdate = !existing ||
+            existing.archivedAt ||
+            existing.projectId !== nextWorkspaceRecord.projectId ||
+            existing.kind !== nextWorkspaceRecord.kind ||
+            existing.displayName !== nextWorkspaceRecord.displayName;
+        const needsProjectUpdate = !currentProjectRecord ||
+            currentProjectRecord.archivedAt ||
+            currentProjectRecord.rootPath !== nextProjectRecord.rootPath ||
+            currentProjectRecord.kind !== nextProjectRecord.kind ||
+            currentProjectRecord.displayName !== nextProjectRecord.displayName;
+        if (!needsWorkspaceUpdate && !needsProjectUpdate) {
+            return {
+                workspace: existing,
+                changed: false,
+            };
+        }
+        await this.projectRegistry.upsert(nextProjectRecord);
+        await this.workspaceRegistry.upsert(nextWorkspaceRecord);
+        if (existing &&
+            !existing.archivedAt &&
+            existing.projectId !== nextWorkspaceRecord.projectId) {
+            await this.archiveProjectRecordIfEmpty(existing.projectId, now);
+        }
+        return {
+            workspace: nextWorkspaceRecord,
+            changed: true,
+        };
+    }
+    async reconcileActiveWorkspaceRecords() {
+        const changedWorkspaceIds = new Set();
+        const activeWorkspaces = (await this.workspaceRegistry.list()).filter((workspace) => !workspace.archivedAt);
+        for (const workspace of activeWorkspaces) {
+            const result = await this.reconcileWorkspaceRecord(workspace.workspaceId);
+            if (result.changed) {
+                changedWorkspaceIds.add(result.workspace.workspaceId);
+            }
+        }
+        return changedWorkspaceIds;
+    }
     async forwardAgentUpdate(agent) {
         try {
             await this.ensureWorkspaceRegistered(agent.cwd);
@@ -1315,7 +1401,9 @@ export class Session {
      * Handle voice mode toggle
      */
     async handleSetVoiceMode(enabled, agentId, requestId) {
+        const startedAt = Date.now();
         try {
+            this.sessionLogger.info({ enabled, requestedAgentId: agentId ?? null, requestId: requestId ?? null }, 'set_voice_mode started');
             if (enabled) {
                 const unavailable = this.resolveVoiceFeatureUnavailableContext('voice_mode');
                 if (unavailable) {
@@ -1325,15 +1413,26 @@ export class Session {
                 if (this.isVoiceMode &&
                     this.voiceModeAgentId &&
                     this.voiceModeAgentId !== normalizedAgentId) {
+                    this.sessionLogger.info({
+                        previousAgentId: this.voiceModeAgentId,
+                        nextAgentId: normalizedAgentId,
+                        elapsedMs: Date.now() - startedAt,
+                    }, 'set_voice_mode disabling previous active voice agent');
                     await this.disableVoiceModeForActiveAgent(true);
                 }
                 if (!this.isVoiceMode || this.voiceModeAgentId !== normalizedAgentId) {
+                    this.sessionLogger.info({ agentId: normalizedAgentId, elapsedMs: Date.now() - startedAt }, 'set_voice_mode enabling voice for agent');
                     const refreshedAgentId = await this.enableVoiceModeForAgent(normalizedAgentId);
                     this.voiceModeAgentId = refreshedAgentId;
+                    this.sessionLogger.info({ agentId: refreshedAgentId, elapsedMs: Date.now() - startedAt }, 'set_voice_mode agent enable complete');
                 }
+                this.sessionLogger.info({ agentId: this.voiceModeAgentId, elapsedMs: Date.now() - startedAt }, 'set_voice_mode starting voice turn controller');
+                await this.startVoiceTurnController();
+                this.sessionLogger.info({ agentId: this.voiceModeAgentId, elapsedMs: Date.now() - startedAt }, 'set_voice_mode voice turn controller started');
                 this.isVoiceMode = true;
                 this.sessionLogger.info({
                     agentId: this.voiceModeAgentId,
+                    elapsedMs: Date.now() - startedAt,
                 }, 'Voice mode enabled for existing agent');
                 if (requestId) {
                     this.emit({
@@ -1349,9 +1448,10 @@ export class Session {
                 }
                 return;
             }
+            this.sessionLogger.info({ agentId: this.voiceModeAgentId, elapsedMs: Date.now() - startedAt }, 'set_voice_mode disabling active voice mode');
             await this.disableVoiceModeForActiveAgent(true);
             this.isVoiceMode = false;
-            this.sessionLogger.info('Voice mode disabled');
+            this.sessionLogger.info({ elapsedMs: Date.now() - startedAt }, 'Voice mode disabled');
             if (requestId) {
                 this.emit({
                     type: 'set_voice_mode_response',
@@ -1372,6 +1472,7 @@ export class Session {
                 err: error,
                 enabled,
                 requestedAgentId: agentId ?? null,
+                elapsedMs: Date.now() - startedAt,
             }, 'set_voice_mode failed');
             if (requestId) {
                 this.emit({
@@ -1419,12 +1520,17 @@ export class Session {
         };
     }
     async enableVoiceModeForAgent(agentId) {
+        const startedAt = Date.now();
         const ensureVoiceSocket = this.ensureVoiceMcpSocketForAgent;
         if (!ensureVoiceSocket) {
             throw new Error('Voice MCP socket bridge is not configured');
         }
+        this.sessionLogger.info({ agentId }, 'enableVoiceModeForAgent.ensureAgentLoaded.start');
         const existing = await this.ensureAgentLoaded(agentId);
+        this.sessionLogger.info({ agentId, elapsedMs: Date.now() - startedAt }, 'enableVoiceModeForAgent.ensureAgentLoaded.done');
+        this.sessionLogger.info({ agentId }, 'enableVoiceModeForAgent.ensureVoiceSocket.start');
         const socketPath = await ensureVoiceSocket(agentId);
+        this.sessionLogger.info({ agentId, socketPath, elapsedMs: Date.now() - startedAt }, 'enableVoiceModeForAgent.ensureVoiceSocket.done');
         this.registerVoiceBridgeForAgent(agentId);
         const baseConfig = {
             systemPrompt: stripVoiceModeSystemPrompt(existing.config.systemPrompt),
@@ -1436,7 +1542,9 @@ export class Session {
             mcpServers: this.buildVoiceModeMcpServers(baseConfig.mcpServers, socketPath),
         };
         try {
+            this.sessionLogger.info({ agentId, elapsedMs: Date.now() - startedAt }, 'enableVoiceModeForAgent.reloadAgentSession.start');
             const refreshed = await this.agentManager.reloadAgentSession(agentId, refreshOverrides);
+            this.sessionLogger.info({ agentId, refreshedAgentId: refreshed.id, elapsedMs: Date.now() - startedAt }, 'enableVoiceModeForAgent.reloadAgentSession.done');
             return refreshed.id;
         }
         catch (error) {
@@ -1448,8 +1556,7 @@ export class Session {
         }
     }
     async disableVoiceModeForActiveAgent(restoreAgentConfig) {
-        this.clearVoiceModeInactivityTimeout();
-        this.cancelActiveVoiceDictationStream('voice mode disabled');
+        await this.stopVoiceTurnController();
         const agentId = this.voiceModeAgentId;
         if (!agentId) {
             this.voiceModeBaseConfig = null;
@@ -1475,197 +1582,107 @@ export class Session {
         this.voiceModeBaseConfig = null;
         this.voiceModeAgentId = null;
     }
-    isInternalVoiceDictationId(dictationId) {
-        return dictationId.startsWith(VOICE_INTERNAL_DICTATION_ID_PREFIX);
-    }
     handleDictationManagerMessage(msg) {
-        if (msg.type === 'activity_log') {
-            const metadata = msg.payload.metadata;
-            const dictationId = metadata && typeof metadata.dictationId === 'string' ? metadata.dictationId : null;
-            if (dictationId && this.isInternalVoiceDictationId(dictationId)) {
-                return;
-            }
-            this.emit(msg);
-            return;
-        }
-        const payloadWithDictationId = msg.payload;
-        const dictationId = payloadWithDictationId && typeof payloadWithDictationId.dictationId === 'string'
-            ? payloadWithDictationId.dictationId
-            : null;
-        if (!dictationId || !this.isInternalVoiceDictationId(dictationId)) {
-            this.emit(msg);
-            return;
-        }
-        if (msg.type === 'dictation_stream_final') {
-            if (dictationId !== this.activeVoiceDictationId || !this.activeVoiceDictationResolve) {
-                return;
-            }
-            this.activeVoiceDictationResolve({
-                text: msg.payload.text,
-                ...(msg.payload.debugRecordingPath
-                    ? { debugRecordingPath: msg.payload.debugRecordingPath }
-                    : {}),
-            });
-            return;
-        }
-        if (msg.type === 'dictation_stream_error') {
-            if (dictationId !== this.activeVoiceDictationId || !this.activeVoiceDictationReject) {
-                return;
-            }
-            this.activeVoiceDictationReject(new Error(msg.payload.error));
-            return;
-        }
-        // Ack/partial messages for internal voice dictation are consumed server-side.
-    }
-    resetActiveVoiceDictationState() {
-        this.activeVoiceDictationId = null;
-        this.activeVoiceDictationFormat = null;
-        this.activeVoiceDictationNextSeq = 0;
-        this.activeVoiceDictationStartPromise = null;
-        this.activeVoiceDictationFinalizePromise = null;
-        this.activeVoiceDictationResultPromise = null;
-        this.activeVoiceDictationResolve = null;
-        this.activeVoiceDictationReject = null;
-    }
-    cancelActiveVoiceDictationStream(reason) {
-        const dictationId = this.activeVoiceDictationId;
-        if (!dictationId) {
-            return;
-        }
-        this.sessionLogger.debug({ dictationId, reason }, 'Cancelling active internal voice dictation stream');
-        if (this.activeVoiceDictationReject) {
-            this.activeVoiceDictationReject(new Error(`Voice dictation cancelled: ${reason}`));
-        }
-        this.voiceStreamManager.handleCancel(dictationId);
-        this.resetActiveVoiceDictationState();
+        this.emit(msg);
     }
-    async ensureActiveVoiceDictationStream(format) {
-        if (this.activeVoiceDictationId && this.activeVoiceDictationFormat === format) {
-            if (this.activeVoiceDictationStartPromise) {
-                await this.activeVoiceDictationStartPromise;
-            }
+    async startVoiceTurnController() {
+        if (this.voiceTurnController) {
+            this.sessionLogger.info('startVoiceTurnController skipped: already running');
             return;
         }
-        if (this.activeVoiceDictationId) {
-            await this.finalizeActiveVoiceDictationStream('voice format changed');
-        }
-        const dictationId = `${VOICE_INTERNAL_DICTATION_ID_PREFIX}${uuidv4()}`;
-        let resolve = null;
-        let reject = null;
-        const resultPromise = new Promise((resolveFn, rejectFn) => {
-            resolve = resolveFn;
-            reject = rejectFn;
-        });
-        // Prevent process-level unhandled rejection warnings when cancellation races are resolved later.
-        void resultPromise.catch(() => undefined);
-        this.activeVoiceDictationId = dictationId;
-        this.activeVoiceDictationFormat = format;
-        this.activeVoiceDictationNextSeq = 0;
-        this.activeVoiceDictationFinalizePromise = null;
-        this.activeVoiceDictationResultPromise = resultPromise;
-        this.activeVoiceDictationResolve = resolve;
-        this.activeVoiceDictationReject = reject;
-        this.setPhase('transcribing');
-        this.emit({
-            type: 'activity_log',
-            payload: {
-                id: uuidv4(),
-                timestamp: new Date(),
-                type: 'system',
-                content: 'Transcribing audio...',
+        const turnDetection = this.resolveVoiceTurnDetection();
+        if (!turnDetection) {
+            throw new Error('Voice turn detection is not configured');
+        }
+        this.sessionLogger.info({ providerId: turnDetection.id }, 'startVoiceTurnController creating controller');
+        const controller = createVoiceTurnController({
+            logger: this.sessionLogger.child({ component: 'voice-turn-controller' }),
+            turnDetection,
+            utteranceSink: {
+                submitUtterance: async ({ pcm16, format, sampleRate, startedAt, endedAt }) => {
+                    this.sessionLogger.debug({
+                        audioBytes: pcm16.length,
+                        sampleRate,
+                        startedAt,
+                        endedAt,
+                        durationMs: Math.max(0, endedAt - startedAt),
+                    }, 'Submitting detected voice utterance');
+                    await this.processCompletedAudio(pcm16, format);
+                },
+            },
+            callbacks: {
+                onSpeechStarted: async () => {
+                    this.handleProvisionalVoiceSpeechStarted();
+                },
+                onSpeechStopped: async () => {
+                    this.handleVoiceSpeechStopped();
+                },
+                onError: (error) => {
+                    this.sessionLogger.error({ err: error }, 'Voice turn controller failed');
+                },
             },
         });
-        const startPromise = this.voiceStreamManager.handleStart(dictationId, format);
-        this.activeVoiceDictationStartPromise = startPromise;
-        try {
-            await startPromise;
-        }
-        catch (error) {
-            this.resetActiveVoiceDictationState();
-            throw error;
-        }
-        finally {
-            if (this.activeVoiceDictationId === dictationId) {
-                this.activeVoiceDictationStartPromise = null;
-            }
-        }
-    }
-    async appendToActiveVoiceDictationStream(audioBase64, format) {
-        if (this.activeVoiceDictationFinalizePromise) {
-            await this.activeVoiceDictationFinalizePromise.catch(() => undefined);
-        }
-        await this.ensureActiveVoiceDictationStream(format);
-        const dictationId = this.activeVoiceDictationId;
-        if (!dictationId) {
-            throw new Error('Voice dictation stream did not initialize');
-        }
-        const seq = this.activeVoiceDictationNextSeq;
-        this.activeVoiceDictationNextSeq += 1;
-        await this.voiceStreamManager.handleChunk({
-            dictationId,
-            seq,
-            audioBase64,
-            format,
-        });
+        this.sessionLogger.info('startVoiceTurnController connecting controller');
+        await controller.start();
+        this.voiceTurnController = controller;
+        this.sessionLogger.info('startVoiceTurnController connected');
     }
-    async finalizeActiveVoiceDictationStream(reason) {
-        const dictationId = this.activeVoiceDictationId;
-        if (!dictationId) {
+    async stopVoiceTurnController() {
+        if (!this.voiceTurnController) {
             return;
         }
-        this.clearVoiceModeInactivityTimeout();
-        if (this.activeVoiceDictationStartPromise) {
-            await this.activeVoiceDictationStartPromise;
+        this.clearPendingVoiceSpeechStart('turn-controller-stop');
+        const controller = this.voiceTurnController;
+        this.voiceTurnController = null;
+        await controller.stop();
+    }
+    clearPendingVoiceSpeechStart(reason) {
+        if (this.pendingVoiceSpeechTimer) {
+            clearTimeout(this.pendingVoiceSpeechTimer);
+            this.pendingVoiceSpeechTimer = null;
         }
-        if (this.activeVoiceDictationFinalizePromise) {
-            await this.activeVoiceDictationFinalizePromise;
-            return;
+        if (this.pendingVoiceSpeechStartAt !== null) {
+            this.sessionLogger.debug({ reason }, 'Clearing provisional voice speech start');
+            this.pendingVoiceSpeechStartAt = null;
         }
-        const finalSeq = this.activeVoiceDictationNextSeq - 1;
-        const resultPromise = this.activeVoiceDictationResultPromise;
-        if (!resultPromise) {
-            this.resetActiveVoiceDictationState();
+    }
+    handleProvisionalVoiceSpeechStarted() {
+        if (this.speechInProgress || this.pendingVoiceSpeechTimer) {
             return;
         }
-        this.activeVoiceDictationFinalizePromise = (async () => {
-            this.sessionLogger.debug({ dictationId, finalSeq, reason }, 'Finalizing internal voice dictation stream');
-            await this.voiceStreamManager.handleFinish(dictationId, finalSeq);
-            const result = await resultPromise;
-            this.resetActiveVoiceDictationState();
-            const requestId = uuidv4();
-            const transcriptText = result.text.trim();
-            this.sessionLogger.info({
-                requestId,
-                isVoiceMode: this.isVoiceMode,
-                transcriptLength: transcriptText.length,
-                transcript: transcriptText,
-            }, 'Transcription result');
-            await this.handleTranscriptionResultPayload({
-                text: result.text,
-                requestId,
-                ...(result.debugRecordingPath
-                    ? { debugRecordingPath: result.debugRecordingPath, format: 'audio/wav' }
-                    : {}),
-            });
-        })();
-        try {
-            await this.activeVoiceDictationFinalizePromise;
-        }
-        catch (error) {
-            this.resetActiveVoiceDictationState();
-            this.setPhase('idle');
-            this.clearSpeechInProgress('transcription error');
+        const startedAt = Date.now();
+        this.pendingVoiceSpeechStartAt = startedAt;
+        this.sessionLogger.info({ confirmationMs: VOICE_INTERRUPT_CONFIRMATION_MS }, 'Silero VAD provisional speech_started');
+        this.pendingVoiceSpeechTimer = setTimeout(() => {
+            this.pendingVoiceSpeechTimer = null;
+            if (this.pendingVoiceSpeechStartAt !== startedAt || this.speechInProgress) {
+                return;
+            }
+            this.pendingVoiceSpeechStartAt = null;
+            this.sessionLogger.info('voice_input_state emitting isSpeaking=true');
             this.emit({
-                type: 'activity_log',
+                type: 'voice_input_state',
                 payload: {
-                    id: uuidv4(),
-                    timestamp: new Date(),
-                    type: 'error',
-                    content: `Transcription error: ${error instanceof Error ? error.message : String(error)}`,
+                    isSpeaking: true,
                 },
             });
-            throw error;
+            void this.handleVoiceSpeechStart();
+        }, VOICE_INTERRUPT_CONFIRMATION_MS);
+    }
+    handleVoiceSpeechStopped() {
+        if (this.pendingVoiceSpeechStartAt !== null) {
+            const durationMs = Date.now() - this.pendingVoiceSpeechStartAt;
+            this.clearPendingVoiceSpeechStart('speech-stopped-before-confirmation');
+            this.sessionLogger.info({ durationMs, confirmationMs: VOICE_INTERRUPT_CONFIRMATION_MS }, 'Ignoring provisional voice speech start that ended before confirmation');
+            return;
         }
+        this.sessionLogger.info('voice_input_state emitting isSpeaking=false');
+        this.emit({
+            type: 'voice_input_state',
+            payload: {
+                isSpeaking: false,
+            },
+        });
     }
     /**
      * Handle text message to agent (with optional image attachments)
@@ -4027,7 +4044,7 @@ export class Session {
             diffStat,
         };
     }
-    async listWorkspaceDescriptors() {
+    async listWorkspaceDescriptorsSnapshot() {
         const [agents, persistedWorkspaces, persistedProjects] = await Promise.all([
             this.listAgentPayloads(),
             this.workspaceRegistry.list(),
@@ -4058,6 +4075,10 @@ export class Session {
         }
         return Array.from(descriptorsByWorkspaceId.values());
     }
+    async listWorkspaceDescriptors() {
+        await this.reconcileActiveWorkspaceRecords();
+        return this.listWorkspaceDescriptorsSnapshot();
+    }
     normalizeFetchWorkspacesSort(sort) {
         const fallback = [{ key: 'activity_at', direction: 'desc' }];
         if (!sort || sort.length === 0) {
@@ -4257,41 +4278,7 @@ export class Session {
     }
     async ensureWorkspaceRegistered(cwd) {
         const workspaceId = normalizePersistedWorkspaceId(cwd);
-        const existing = await this.workspaceRegistry.get(workspaceId);
-        if (existing && !existing.archivedAt) {
-            return existing;
-        }
-        const placement = await this.buildProjectPlacement(workspaceId);
-        const now = new Date().toISOString();
-        const projectExisting = await this.projectRegistry.get(placement.projectKey);
-        const projectRecord = createPersistedProjectRecord({
-            projectId: placement.projectKey,
-            rootPath: deriveProjectRootPath({
-                cwd: workspaceId,
-                checkout: placement.checkout,
-            }),
-            kind: deriveProjectKind(placement.checkout),
-            displayName: placement.projectName,
-            createdAt: projectExisting?.createdAt ?? now,
-            updatedAt: now,
-            archivedAt: null,
-        });
-        await this.projectRegistry.upsert(projectRecord);
-        const workspaceRecord = createPersistedWorkspaceRecord({
-            workspaceId,
-            projectId: placement.projectKey,
-            cwd: workspaceId,
-            kind: deriveWorkspaceKind(placement.checkout),
-            displayName: deriveWorkspaceDisplayName({
-                cwd: workspaceId,
-                checkout: placement.checkout,
-            }),
-            createdAt: existing?.createdAt ?? now,
-            updatedAt: now,
-            archivedAt: null,
-        });
-        await this.workspaceRegistry.upsert(workspaceRecord);
-        return workspaceRecord;
+        return (await this.reconcileWorkspaceRecord(workspaceId)).workspace;
     }
     async archiveWorkspaceRecord(workspaceId, archivedAt) {
         const existing = await this.workspaceRegistry.get(workspaceId);
@@ -4311,32 +4298,31 @@ export class Session {
             return;
         }
         const workspaceId = normalizePersistedWorkspaceId(cwd);
-        const all = await this.listWorkspaceDescriptors();
-        const workspace = all.find((entry) => entry.id === workspaceId);
-        if (!workspace) {
-            this.bufferOrEmitWorkspaceUpdate(subscription, {
-                kind: 'remove',
-                id: workspaceId,
-            });
-            return;
-        }
-        if (!this.matchesWorkspaceFilter({ workspace, filter: subscription.filter })) {
+        const changedWorkspaceIds = await this.reconcileActiveWorkspaceRecords();
+        const all = await this.listWorkspaceDescriptorsSnapshot();
+        const descriptorsByWorkspaceId = new Map(all.map((entry) => [entry.id, entry]));
+        const workspaceIdsToEmit = new Set([workspaceId, ...changedWorkspaceIds]);
+        for (const nextWorkspaceId of workspaceIdsToEmit) {
+            const workspace = descriptorsByWorkspaceId.get(nextWorkspaceId);
+            if (!workspace || !this.matchesWorkspaceFilter({ workspace, filter: subscription.filter })) {
+                this.bufferOrEmitWorkspaceUpdate(subscription, {
+                    kind: 'remove',
+                    id: nextWorkspaceId,
+                });
+                continue;
+            }
             this.bufferOrEmitWorkspaceUpdate(subscription, {
-                kind: 'remove',
-                id: workspaceId,
+                kind: 'upsert',
+                workspace,
             });
-            return;
         }
-        this.bufferOrEmitWorkspaceUpdate(subscription, {
-            kind: 'upsert',
-            workspace,
-        });
     }
     async emitWorkspaceUpdatesForCwds(cwds) {
         if (!this.workspaceUpdatesSubscription) {
             return;
         }
-        const uniqueWorkspaceCwds = new Set();
+        const changedWorkspaceIds = await this.reconcileActiveWorkspaceRecords();
+        const uniqueWorkspaceCwds = new Set(changedWorkspaceIds);
         for (const cwd of cwds) {
             const normalized = normalizePersistedWorkspaceId(cwd);
             if (!normalized) {
@@ -4344,8 +4330,22 @@ export class Session {
             }
             uniqueWorkspaceCwds.add(normalized);
         }
-        for (const workspaceCwd of uniqueWorkspaceCwds) {
-            await this.emitWorkspaceUpdateForCwd(workspaceCwd);
+        const subscription = this.workspaceUpdatesSubscription;
+        const all = await this.listWorkspaceDescriptorsSnapshot();
+        const descriptorsByWorkspaceId = new Map(all.map((entry) => [entry.id, entry]));
+        for (const workspaceId of uniqueWorkspaceCwds) {
+            const workspace = descriptorsByWorkspaceId.get(workspaceId);
+            if (!workspace || !this.matchesWorkspaceFilter({ workspace, filter: subscription.filter })) {
+                this.bufferOrEmitWorkspaceUpdate(subscription, {
+                    kind: 'remove',
+                    id: workspaceId,
+                });
+                continue;
+            }
+            this.bufferOrEmitWorkspaceUpdate(subscription, {
+                kind: 'upsert',
+                workspace,
+            });
         }
     }
     async handleFetchAgents(request) {
@@ -4882,18 +4882,37 @@ export class Session {
         if (!this.isVoiceMode) {
             this.sessionLogger.warn('Received voice_audio_chunk while voice mode is disabled; transcript will be emitted but voice assistant turn is skipped');
         }
-        await this.handleVoiceSpeechStart();
         const chunkFormat = msg.format || 'audio/wav';
         if (this.isVoiceMode) {
-            await this.appendToActiveVoiceDictationStream(msg.audio, chunkFormat);
-            if (!msg.isLast) {
-                this.setVoiceModeInactivityTimeout();
-                this.sessionLogger.debug('Voice mode: streaming chunk, waiting for speech end');
-                return;
+            if (!this.voiceTurnController) {
+                throw new Error('Voice mode is enabled but the voice turn controller is not running');
+            }
+            const chunkBytes = Buffer.byteLength(msg.audio, 'base64');
+            this.voiceInputChunkCount += 1;
+            this.voiceInputBytes += chunkBytes;
+            if (this.voiceInputChunkCount === 1) {
+                this.sessionLogger.info({
+                    format: chunkFormat,
+                    audioBytes: chunkBytes,
+                }, 'Received first voice_audio_chunk for active voice mode');
             }
-            this.clearVoiceModeInactivityTimeout();
-            this.sessionLogger.debug('Voice mode: speech ended, finalizing streaming transcription');
-            await this.finalizeActiveVoiceDictationStream('speech ended');
+            const now = Date.now();
+            if (this.voiceInputChunkCount % 50 === 0 ||
+                now - this.voiceInputWindowStartedAt >= 1000) {
+                this.sessionLogger.info({
+                    chunkCount: this.voiceInputChunkCount,
+                    audioBytes: this.voiceInputBytes,
+                    windowMs: now - this.voiceInputWindowStartedAt,
+                    format: chunkFormat,
+                }, 'Voice input chunk summary');
+                this.voiceInputWindowStartedAt = now;
+                this.voiceInputChunkCount = 0;
+                this.voiceInputBytes = 0;
+            }
+            await this.voiceTurnController.appendClientChunk({
+                audioBase64: msg.audio,
+                format: chunkFormat,
+            });
             return;
         }
         const chunkBuffer = Buffer.from(msg.audio, 'base64');
@@ -4974,9 +4993,8 @@ export class Session {
         };
     }
     async processCompletedAudio(audio, format) {
-        const shouldBuffer = this.processingPhase === 'transcribing' && this.pendingAudioSegments.length === 0;
-        if (shouldBuffer) {
-            this.sessionLogger.debug({ phase: this.processingPhase }, `Buffering audio segment (phase: ${this.processingPhase})`);
+        if (this.processingPhase === 'transcribing') {
+            this.sessionLogger.debug({ phase: this.processingPhase, segmentCount: this.pendingAudioSegments.length + 1 }, `Buffering audio segment (phase: ${this.processingPhase})`);
             this.pendingAudioSegments.push({
                 audio,
                 format,
@@ -5000,6 +5018,18 @@ export class Session {
         }
         await this.processAudio(audio, format);
     }
+    async flushPendingAudioSegments(reason) {
+        if (this.processingPhase === 'transcribing' || this.pendingAudioSegments.length === 0) {
+            return;
+        }
+        const pendingSegments = [...this.pendingAudioSegments];
+        this.pendingAudioSegments = [];
+        this.clearBufferTimeout();
+        this.sessionLogger.debug({ reason, segmentCount: pendingSegments.length }, `Flushing ${pendingSegments.length} buffered audio segment(s)`);
+        const combinedAudio = Buffer.concat(pendingSegments.map((segment) => segment.audio));
+        const combinedFormat = pendingSegments[pendingSegments.length - 1].format;
+        await this.processAudio(combinedAudio, combinedFormat);
+    }
     /**
      * Process audio through STT and then LLM
      */
@@ -5042,6 +5072,7 @@ export class Session {
         catch (error) {
             this.setPhase('idle');
             this.clearSpeechInProgress('transcription error');
+            await this.flushPendingAudioSegments('transcription error');
             this.emit({
                 type: 'activity_log',
                 payload: {
@@ -5076,6 +5107,7 @@ export class Session {
             this.sessionLogger.debug('Empty transcription (false positive), not aborting');
             this.setPhase('idle');
             this.clearSpeechInProgress('empty transcription');
+            await this.flushPendingAudioSegments('empty transcription');
             return;
         }
         // Has content - abort any in-progress stream now
@@ -5113,16 +5145,19 @@ export class Session {
         this.setPhase('idle');
         if (!this.isVoiceMode) {
             this.sessionLogger.debug({ requestId: result.requestId }, 'Skipping voice agent processing because voice mode is disabled');
+            await this.flushPendingAudioSegments('voice mode disabled');
             return;
         }
         const agentId = this.voiceModeAgentId;
         if (!agentId) {
             this.sessionLogger.warn({ requestId: result.requestId }, 'Skipping voice agent processing because no agent is currently voice-enabled');
+            await this.flushPendingAudioSegments('no active voice agent');
             return;
         }
         // Route voice utterances through the same send path as regular text input:
         // interrupt-if-running, record message, then start a new stream.
         await this.handleSendAgentMessage(agentId, result.text);
+        await this.flushPendingAudioSegments('transcription complete');
     }
     registerVoiceBridgeForAgent(agentId) {
         this.registerVoiceSpeakHandler?.(agentId, async ({ text, signal }) => {
@@ -5203,8 +5238,6 @@ export class Session {
             this.sessionLogger.debug({ chunks: this.audioBuffer.chunks.length, pcmBytes: this.audioBuffer.totalPCMBytes }, `Clearing partial audio buffer (${this.audioBuffer.chunks.length} chunk(s)${this.audioBuffer.isPCM ? `, ${this.audioBuffer.totalPCMBytes} PCM bytes` : ''})`);
             this.audioBuffer = null;
         }
-        this.cancelActiveVoiceDictationStream('new speech turn started');
-        this.clearVoiceModeInactivityTimeout();
         this.clearBufferTimeout();
         this.abortController.abort();
         await this.handleAbort();
@@ -5215,6 +5248,7 @@ export class Session {
      * Clear speech-in-progress flag once the user turn has completed
      */
     clearSpeechInProgress(reason) {
+        this.clearPendingVoiceSpeechStart(`clear-speech-in-progress:${reason}`);
         if (!this.speechInProgress) {
             return;
         }
@@ -5244,6 +5278,11 @@ export class Session {
         this.clearBufferTimeout();
         this.bufferTimeout = setTimeout(async () => {
             this.sessionLogger.debug('Buffer timeout reached, processing pending segments');
+            if (this.processingPhase === 'transcribing') {
+                this.sessionLogger.debug({ segmentCount: this.pendingAudioSegments.length }, 'Buffer timeout deferred because transcription is still in progress');
+                this.setBufferTimeout();
+                return;
+            }
             if (this.pendingAudioSegments.length > 0) {
                 const segments = [...this.pendingAudioSegments];
                 this.pendingAudioSegments = [];
@@ -5253,32 +5292,6 @@ export class Session {
             }
         }, 10000); // 10 second timeout
     }
-    setVoiceModeInactivityTimeout() {
-        if (!this.isVoiceMode) {
-            return;
-        }
-        this.clearVoiceModeInactivityTimeout();
-        this.voiceModeInactivityTimeout = setTimeout(() => {
-            this.voiceModeInactivityTimeout = null;
-            if (!this.isVoiceMode || !this.activeVoiceDictationId) {
-                return;
-            }
-            this.sessionLogger.warn({
-                timeoutMs: VOICE_MODE_INACTIVITY_FLUSH_MS,
-                dictationId: this.activeVoiceDictationId,
-                nextSeq: this.activeVoiceDictationNextSeq,
-            }, 'Voice mode inactivity timeout reached without isLast; finalizing active voice dictation stream');
-            void this.finalizeActiveVoiceDictationStream('inactivity timeout').catch((error) => {
-                this.sessionLogger.error({ err: error }, 'Failed to finalize voice dictation stream after inactivity timeout');
-            });
-        }, VOICE_MODE_INACTIVITY_FLUSH_MS);
-    }
-    clearVoiceModeInactivityTimeout() {
-        if (this.voiceModeInactivityTimeout) {
-            clearTimeout(this.voiceModeInactivityTimeout);
-            this.voiceModeInactivityTimeout = null;
-        }
-    }
     /**
      * Clear buffer timeout
      */
@@ -5354,16 +5367,14 @@ export class Session {
         // Abort any ongoing operations
         this.abortController.abort();
         // Clear timeouts
-        this.clearVoiceModeInactivityTimeout();
         this.clearBufferTimeout();
         // Clear buffers
-        this.cancelActiveVoiceDictationStream('session cleanup');
         this.pendingAudioSegments = [];
         this.audioBuffer = null;
+        await this.stopVoiceTurnController();
         // Cleanup managers
         this.ttsManager.cleanup();
         this.sttManager.cleanup();
-        this.voiceStreamManager.cleanupAll();
         this.dictationStreamManager.cleanupAll();
         // Close MCP clients
         if (this.agentMcpClient) {
@@ -5749,7 +5760,7 @@ export class Session {
         const streamId = this.allocateTerminalStreamId();
         const requestedResumeOffset = typeof msg.resumeOffset === 'number'
             ? msg.resumeOffset
-            : session.getOutputOffset();
+            : 0;
         const initialOffset = Math.max(0, Math.floor(requestedResumeOffset));
         const binding = {
             terminalId: msg.terminalId,