osborn 0.9.251 → 0.9.252-swap.0

package/dist/index.js

@@ -2016,6 +2016,12 @@ async function main() {
     let participantConnectedHandler = null;
     let currentAgent = null; // For updateChatCtx() context injection
     let currentLLM = null;
+    // Voice bus for instance-swap handoff (assigned in createDirectSession). Declared
+    // here so the swap_foreground handler (different scope) can re-pipe the voice to a
+    // promoted background slot. See the "Voice bus" block in createDirectSession.
+    let voiceBus = null;
+    let unpipeVoice = null;
+    let pipeVoiceFrom = null;
     const slots = new Map();
     let focusedSlotId = null; // reserved for future focused-slot wiring; not used yet
     // P1 host-agent anchor: the dashboard-started session that owns the room's env + keeps it alive.
@@ -2212,6 +2218,44 @@ async function main() {
     // Output events are forwarded to the frontend data channel only,
     // tagged with the slot id so the frontend can distinguish them.
     // ============================================================
+    // Attach a background slot's UI forwarders to the emitter its consumer emits on, and
+    // return a disposer. Forwards turn events to the frontend tagged with slotId but
+    // DELIBERATELY never forwards tts_say — a background slot must stay silent. Shared by
+    // spawnBackgroundSession (fresh slot) and the swap demote path (adopted old foreground)
+    // so both slot kinds behave identically, and so promotion can cleanly stop background
+    // forwarding (call the disposer) before re-piping that same emitter to the voice bus.
+    function attachBackgroundForwarders(emitter, slotId) {
+        const handlers = [];
+        const on = (ev, fn) => { emitter.on(ev, fn); handlers.push([ev, fn]); };
+        on('assistant_text', ({ text }) => { sendToFrontend({ type: 'claude_output', slotId, text }).catch(() => { }); });
+        on('tool_use', ({ name, input, agentRole, agentId }) => { sendToFrontend({ type: 'tool_use', slotId, name, input, agentRole, agentId }).catch(() => { }); });
+        on('tool_result', ({ name, response, agentRole, agentId }) => { sendToFrontend({ type: 'tool_result', slotId, name, response, agentRole, agentId }).catch(() => { }); });
+        on('tool_blocked', ({ name, reason }) => { sendToFrontend({ type: 'tool_blocked', slotId, name, reason }).catch(() => { }); });
+        on('session_id', ({ sessionId: sid }) => { sendToFrontend({ type: 'background_session_ready', slotId, sessionId: sid }).catch(() => { }); });
+        on('session_resume_failed', ({ requestedSessionId, actualSessionId }) => {
+            console.error(`❌ Background slot ${slotId.substring(0, 8)}: resume failed — requested ${requestedSessionId?.substring(0, 8)} got ${actualSessionId?.substring(0, 8)}`);
+            sendToFrontend({ type: 'background_session_error', slotId, error: 'Session resume failed' }).catch(() => { });
+        });
+        on('consumer_error', ({ message }) => {
+            console.error(`❌ Background slot ${slotId.substring(0, 8)}: consumer error — ${message}`);
+            sendToFrontend({ type: 'background_session_error', slotId, error: String(message || 'Background session failed to start') }).catch(() => { });
+        });
+        on('assistant_result', ({ text }) => {
+            const slot = slots.get(slotId);
+            if (!slot)
+                return;
+            if (!slot.kickoffDone) {
+                slot.kickoffDone = true;
+                return;
+            }
+            if (!slot.dispatchInFlight)
+                return;
+            slot.dispatchInFlight = false;
+            sendToFrontend({ type: 'background_update', sessionId: slotId, stage: 'done', summary: (text || '').trim().slice(0, 500) }).catch(() => { });
+        });
+        return () => { for (const [ev, fn] of handlers)
+            emitter.off(ev, fn); };
+    }
     async function spawnBackgroundSession(sessionId, bgWorkingDir) {
         // Hard cap: focused session + background slots must not exceed 3 total.
         // slots Map holds ONLY background slots; focused session is separate.
@@ -2224,73 +2268,30 @@ async function main() {
         const slotWorkingDir = bgWorkingDir || workingDir;
         const slotId = sessionId; // use sessionId as the slot id for traceability
         console.log(`🔲 Spawning background slot: sessionId=${slotId.substring(0, 8)} cwd=${slotWorkingDir}`);
-        // Create a headless LLM instance — reuse the same factory, no voice options.
+        // Create the headless LLM in the SAME SHAPE as the foreground inner so it can be
+        // promoted to the voice session with a simple re-pipe (no reconfiguration):
+        //   skipTTSQueue: true → its consumer emits `tts_say` (speech), exactly like the
+        //   foreground, instead of queue.put. All events land on the instance's own
+        //   `.events` emitter (the unified bus), so promote = pipe the voice bus from
+        //   slot.llm.events; background = forward those same events to the UI minus tts_say.
         // permissionMode bypassPermissions: no dialogs (headless — nobody to click Allow).
-        // No AgentSession, no room involvement.
         const bgLLM = createClaudeLLM({
             workingDirectory: slotWorkingDir,
             sessionBaseDir: slotWorkingDir,
             resumeSessionId: sessionId,
             voiceMode: 'direct', // picks up the research system prompt
-            skipTTSQueue: false, // not going through TTS at all
+            skipTTSQueue: true, // emit tts_say like the foreground (promotable)
             permissionMode: 'bypassPermissions',
         });
         // Register slot BEFORE cold-starting so list_slots is accurate from the
         // first moment even if the subprocess takes a few seconds to init.
         const slot = { id: slotId, llm: bgLLM, isFocused: false, workingDir: slotWorkingDir };
         slots.set(slotId, slot);
-        // Dedicated EventEmitter for this background slot's SDK events.
-        // Forwards every event to the frontend data channel tagged with slotId.
-        // NEVER touches session.say() / TTS / voice.
-        const { EventEmitter: SlotEventEmitter } = await import('node:events');
-        const bgEmitter = new SlotEventEmitter();
-        bgEmitter.on('assistant_text', ({ text }) => {
-            sendToFrontend({ type: 'claude_output', slotId, text }).catch(() => { });
-        });
-        bgEmitter.on('tool_use', ({ name, input, agentRole }) => {
-            sendToFrontend({ type: 'tool_use', slotId, name, input, agentRole }).catch(() => { });
-        });
-        bgEmitter.on('tool_result', ({ name, response, agentRole }) => {
-            sendToFrontend({ type: 'tool_result', slotId, name, response, agentRole }).catch(() => { });
-        });
-        bgEmitter.on('tool_blocked', ({ name, reason }) => {
-            sendToFrontend({ type: 'tool_blocked', slotId, name, reason }).catch(() => { });
-        });
-        bgEmitter.on('session_id', ({ sessionId: sid }) => {
-            sendToFrontend({ type: 'background_session_ready', slotId, sessionId: sid }).catch(() => { });
-        });
-        bgEmitter.on('session_resume_failed', ({ requestedSessionId, actualSessionId }) => {
-            console.error(`❌ Background slot ${slotId.substring(0, 8)}: resume failed — requested ${requestedSessionId?.substring(0, 8)} got ${actualSessionId?.substring(0, 8)}`);
-            sendToFrontend({ type: 'background_session_error', slotId, error: 'Session resume failed' }).catch(() => { });
-        });
-        // Cold-start crash in the background consumer (claude-llm #startBackgroundConsumer
-        // catch): surface it so the frontend's "Spawning…" clears instead of hanging forever.
-        bgEmitter.on('consumer_error', ({ message }) => {
-            console.error(`❌ Background slot ${slotId.substring(0, 8)}: consumer error — ${message}`);
-            sendToFrontend({ type: 'background_session_error', slotId, error: String(message || 'Background session failed to start') }).catch(() => { });
-        });
-        // P1: a real dispatch finished — notify the frontend. The [BACKGROUND_INIT]
-        // ack also fires assistant_result, so gate on dispatchInFlight to skip it.
-        bgEmitter.on('assistant_result', ({ text }) => {
-            const slot = slots.get(slotId);
-            if (!slot)
-                return;
-            // The [BACKGROUND_INIT] kickoff also fires assistant_result and, on the cold-spawn
-            // dispatch path, can arrive AFTER dispatchInFlight was set. Consume that first result
-            // as the kickoff ack so it's never mis-reported as (and never clobbers) the dispatch's
-            // real answer.
-            if (!slot.kickoffDone) {
-                slot.kickoffDone = true;
-                return;
-            }
-            if (!slot.dispatchInFlight)
-                return; // only notify for a real dispatched instruction
-            slot.dispatchInFlight = false;
-            sendToFrontend({ type: 'background_update', sessionId: slotId, stage: 'done', summary: (text || '').trim().slice(0, 500) }).catch(() => { });
-        });
-        // Wire up the LLM's internal EventEmitter so hook-emitted events also flow.
-        bgLLM.events.on('session_id', (data) => bgEmitter.emit('session_id', data));
-        bgLLM.events.on('tool_blocked', (data) => bgEmitter.emit('tool_blocked', data));
+        // Background UI forwarders on the instance's own emitter (the unified bus). Silent
+        // (no tts_say). Disposer stored so promotion can stop background forwarding before
+        // the same emitter is piped to the voice bus.
+        const unforward = attachBackgroundForwarders(bgLLM.events, slotId);
+        slot.unforward = unforward;
         // Build minimal sdkOptions for the headless cold start.
         // resume: sessionId brings up real prior context from JSONL.
         // env: CLAUDE_CODE_DISABLE_AUTO_MEMORY prevents concurrent subprocesses
@@ -2320,11 +2321,11 @@ async function main() {
             settingSources: ['project', 'user'],
             env: bgEnv,
         };
-        // P1: persist the cold-start emitter + sdkOptions on the slot so a later
-        // dispatch_background can reuse them. CRITICAL: pushMessage's fast path
-        // ignores the callbacks/emitter arg once the subprocess exists, so a
-        // dispatch MUST reuse THIS emitter — otherwise its output goes nowhere.
-        slot.emitter = bgEmitter;
+        // Persist the cold-start emitter + sdkOptions on the slot so a later
+        // dispatch_background can reuse them. The slot's output emitter IS its own
+        // bgLLM.events (unified bus) — pushMessage's fast path ignores the callbacks/emitter
+        // arg once the subprocess exists, so the consumer stays bound to bgLLM.events.
+        slot.emitter = bgLLM.events;
         slot.sdkOptions = bgSdkOptions;
         // Cold-start: deliver an init message so the subprocess actually spawns
         // and begins consuming the session JSONL.
@@ -2332,10 +2333,10 @@ async function main() {
         bgLLM.pushMessage(KICKOFF_TEXT, bgSdkOptions, {
             onSessionId: (sid) => {
                 console.log(`✅ Background slot ${slotId.substring(0, 8)}: session confirmed ${sid.substring(0, 8)}`);
-                bgEmitter.emit('session_id', { sessionId: sid });
+                bgLLM.events.emit('session_id', { sessionId: sid });
             },
             onCheckpoint: (_ckpt) => { },
-            eventEmitter: bgEmitter,
+            eventEmitter: bgLLM.events,
         });
         console.log(`✅ Background slot registered: id=${slotId.substring(0, 8)} workingDir=${slotWorkingDir}`);
         await sendToFrontend({ type: 'background_session_spawned', slotId, workingDir: slotWorkingDir });
@@ -3352,6 +3353,31 @@ async function main() {
         // PipelineDirectLLM (llmOverride path) wraps its own ClaudeLLM and may not expose setTurbo.
         directLLM?.setTurbo?.(turboMode);
         currentLLM = directLLM;
+        // ── Voice bus (instance-swap handoff) ───────────────────────────────────────
+        // The heavy LLM-event handlers below attach ONCE to this stable bus. A thin
+        // pipe forwards events from whichever inner ClaudeLLM is currently foreground.
+        // To hand the voice to a different, already-running subprocess (a background
+        // slot) we just re-pipe the bus (swap_foreground) — the handlers never move,
+        // and neither subprocess is killed. Handlers that need the live foreground LLM
+        // (respondToPermission / suppressMeetingTTS) read `currentLLM`, which the swap
+        // keeps pointed at the voice-owning wrapper.
+        const { EventEmitter: VoiceBusEmitter } = await import('node:events');
+        const vbus = new VoiceBusEmitter();
+        vbus.setMaxListeners(50);
+        voiceBus = vbus;
+        const VOICE_EVENTS = ['mcp_servers_changed', 'tool_use', 'tool_result', 'assistant_text', 'assistant_result', 'tts_chunks', 'permission_request', 'tts_say', 'session_resume_failed', 'checkpoint_captured', 'dispatch_rejected', 'task_completed', 'agent_started'];
+        pipeVoiceFrom = (emitter) => {
+            const forwarders = [];
+            for (const ev of VOICE_EVENTS) {
+                const fn = (...args) => { vbus.emit(ev, ...args); };
+                emitter.on(ev, fn);
+                forwarders.push([ev, fn]);
+            }
+            return () => { for (const [ev, fn] of forwarders)
+                emitter.off(ev, fn); };
+        };
+        // Pipe the initial foreground inner. Reassigned by swap_foreground.
+        unpipeVoice = pipeVoiceFrom(directLLM.events);
         // P1 host-agent anchor: this dashboard-started session owns the room's env
         // and keeps it alive (agentsActive → true) so background dispatches survive.
         // Keep-alive keys off the hostActive boolean, NOT a session_id event;
@@ -3383,7 +3409,7 @@ async function main() {
             prewarmBM25Index(resumeSessionId, workingDir).catch(() => { });
         }
         // Wire up MCP server changes to frontend
-        directLLM.events.on('mcp_servers_changed', (data) => {
+        vbus.on('mcp_servers_changed', (data) => {
             console.log(`🔌 MCP servers changed: ${data.enabledKeys.join(', ') || 'none'}`);
             sendToFrontend({
                 type: 'mcp_servers_changed',
@@ -3392,11 +3418,11 @@ async function main() {
             });
         });
         // Wire up events from the Claude SDK wrapper to frontend
-        directLLM.events.on('tool_use', (data) => {
+        vbus.on('tool_use', (data) => {
             console.log(`🔧 Claude: ${data.name}`);
             sendToFrontend(buildToolLogEvent(data.name, data.input, 'running', data.agentRole || 'main', data.agentId));
         });
-        directLLM.events.on('tool_result', (data) => {
+        vbus.on('tool_result', (data) => {
             console.log(`✅ Done: ${data.name}`);
             sendToFrontend(buildToolLogEvent(data.name, data.input, 'completed', data.agentRole || 'main', data.agentId));
             // Detect research artifact writes (session workspace or legacy research dir)
@@ -3412,7 +3438,7 @@ async function main() {
             }
         });
         // Wire up Claude text output - RAW text goes to frontend for chat bubbles
-        directLLM.events.on('assistant_text', (data) => {
+        vbus.on('assistant_text', (data) => {
             console.log(`💬 Claude text (${data.text?.length || 0} chars): ${data.text || ''}`);
             sendToFrontend({
                 type: 'claude_output',
@@ -3424,7 +3450,7 @@ async function main() {
             });
         });
         // Wire up Claude final result - RAW result goes to frontend
-        directLLM.events.on('assistant_result', (data) => {
+        vbus.on('assistant_result', (data) => {
             console.log(`📋 Claude result (${data.text?.length || 0} chars): ${data.text || ''}`);
             sendToFrontend({
                 type: 'claude_output',
@@ -3436,7 +3462,7 @@ async function main() {
             });
         });
         // Wire up ordered TTS chunk list — emitted once per turn for read-along
-        directLLM.events.on('tts_chunks', (data) => {
+        vbus.on('tts_chunks', (data) => {
             sendToFrontend({
                 type: 'tts_chunks',
                 messageId: data.messageId,
@@ -3444,7 +3470,7 @@ async function main() {
             });
         });
         // Wire up permission requests - sends to frontend for user approval
-        directLLM.events.on('permission_request', (data) => {
+        vbus.on('permission_request', (data) => {
             console.log(`⚠️ Permission needed: ${data.toolName}`);
             const toolName = data.toolName;
             const input = data.input || {};
@@ -3453,7 +3479,7 @@ async function main() {
                 const filePath = String(input?.file_path || '');
                 if (filePath && sessionAlwaysAllowPaths.has(filePath)) {
                     console.log(`✅ Session always-allow: ${filePath}`);
-                    directLLM.respondToPermission(true);
+                    currentLLM?.respondToPermission(true);
                     return;
                 }
             }
@@ -3549,7 +3575,7 @@ async function main() {
         });
         // Wire up TTS say — bypass LiveKit's BufferedTokenStream, speak directly via session.say()
         // Each text block from Claude gets spoken immediately as it arrives, no internal buffering
-        directLLM.events.on('tts_say', (data) => {
+        vbus.on('tts_say', (data) => {
             if (!data.text?.trim()) {
                 console.log(`🔇 tts_say fired but text is empty — skipping`);
                 return;
@@ -3563,7 +3589,7 @@ async function main() {
             // nulled currentSession and EVERY meeting reply was "text dropped" — the
             // deaf-bot bug proven live 2026-08-01 via synthetic transcript inject.
             // Set by PipelineDirectLLM.chat() when the turn is a [MEETING —] chunk.
-            if (directLLM.suppressMeetingTTS) {
+            if (currentLLM.suppressMeetingTTS) {
                 // Parity relay (behind OSBORN_MEETING_AUDIO=parity) speaks via
                 // session.say, so it still needs a live session — it falls through to
                 // the normal browser-TTS path below only when currentSession exists.
@@ -3718,7 +3744,7 @@ async function main() {
             }
         });
         // Wire up session resume failure - notify frontend when SDK creates new session instead
-        directLLM.events.on('session_resume_failed', (data) => {
+        vbus.on('session_resume_failed', (data) => {
             console.error(`❌ Session resume failed: ${data.requestedSessionId} → ${data.actualSessionId}`);
             sendToFrontend({
                 type: 'session_resume_failed',
@@ -3727,7 +3753,7 @@ async function main() {
             });
         });
         // Wire up file checkpoint capture - track restore points for file rewind
-        directLLM.events.on('checkpoint_captured', (data) => {
+        vbus.on('checkpoint_captured', (data) => {
             console.log(`📍 Checkpoint: ${data.checkpointId.substring(0, 8)}...`);
             sendToFrontend({
                 type: 'checkpoint_captured',
@@ -3735,7 +3761,7 @@ async function main() {
             });
         });
         // Dispatcher v1 — writer reviewer rejected verdict → frontend
-        directLLM.events.on('dispatch_rejected', (data) => {
+        vbus.on('dispatch_rejected', (data) => {
             console.log(`[DISPATCH] dispatch_rejected tuid=${(data.tuid ?? '').slice(0, 8)} sending to frontend`);
             sendToFrontend({
                 type: 'task_review',
@@ -3745,14 +3771,14 @@ async function main() {
             });
         });
         // Dispatcher v1 — sub-agent completed → frontend (Feature A)
-        directLLM.events.on('task_completed', (d) => sendToFrontend({
+        vbus.on('task_completed', (d) => sendToFrontend({
             type: 'task_completed',
             agent_type: d.agent_type,
             agent_id: d.agent_id,
             last_assistant_message: d.last_assistant_message,
         }));
         // Dispatcher v1 — sub-agent started → frontend stop-key signal (Feature A2)
-        directLLM.events.on('agent_started', (d) => sendToFrontend({
+        vbus.on('agent_started', (d) => sendToFrontend({
             type: 'agent_started',
             agent_type: d.agent_type,
             agent_id: d.agent_id,
@@ -5937,6 +5963,10 @@ async function main() {
                 }
                 else {
                     const slot = slots.get(key);
+                    try {
+                        slot.unforward?.();
+                    }
+                    catch { } // remove its UI forwarders (no leak on repeat)
                     try {
                         slot.llm.abortQuery?.();
                         slot.llm.abortAgent?.();
@@ -5954,6 +5984,96 @@ async function main() {
                     armAloneTimer();
                 }
             }
+            else if (data.type === 'swap_foreground') {
+                // Promote a background slot to the live voice session, and DEMOTE the current
+                // foreground to a background slot — KEEPING BOTH SUBPROCESSES ALIVE (so the old
+                // primary's in-flight sub-agents keep running). Mechanics:
+                //   1. detach the voice bus from the old inner, 2. swapInner → the slot's ClaudeLLM,
+                //   3. re-pipe the bus from the promoted inner's events, 4. adopt the old inner as a
+                //   background slot with its own UI-forwarding, 5. drop the promoted slot from the map.
+                // The voice AgentSession is untouched (it holds the wrapper); no reconnect.
+                const sid = data.sessionId;
+                let key;
+                if (sid) {
+                    if (slots.has(sid))
+                        key = sid;
+                    else
+                        key = [...slots.keys()].find(k => k === sid || k.startsWith(sid) || sid.startsWith(k));
+                }
+                const wrapper = currentLLM;
+                if (!currentLLM || !voiceBus || !pipeVoiceFrom || typeof wrapper?.swapInner !== 'function') {
+                    await sendToFrontend({ type: 'background_session_error', slotId: sid ?? null, error: 'Swap unavailable (no live voice session or unsupported mode)' });
+                }
+                else if (!key) {
+                    await sendToFrontend({ type: 'background_session_error', slotId: sid ?? null, error: 'No matching background instance to promote' });
+                }
+                else {
+                    const slot = slots.get(key);
+                    const oldInner = wrapper.inner;
+                    // Require a CONFIRMED session id for the session being demoted — never fall back
+                    // to currentResumeSessionId, which can be stale from a prior swap and would tag the
+                    // demoted row (and its stop/re-promote key) with the wrong id. If the foreground
+                    // hasn't established its session yet (cold replay), refuse rather than mis-adopt.
+                    const oldId = oldInner?.sessionId || null;
+                    const oldWorkingDir = workingDir;
+                    if (!oldId || !oldInner) {
+                        await sendToFrontend({ type: 'background_session_error', slotId: sid ?? null, error: 'Foreground session not ready to demote yet — try again in a moment' });
+                    }
+                    else {
+                        console.log(`🔀 Swap foreground: promote ${key.substring(0, 8)} ⇄ demote ${oldId.substring(0, 8)}`);
+                        // PROMOTE — the slot was spawned in foreground shape (skipTTSQueue:true, events on
+                        // slot.llm.events). Stop forwarding it as a (silent) background row, then pipe the
+                        // voice bus from that SAME emitter so its tts_say/text/tools now drive the voice.
+                        try {
+                            slot.unforward?.();
+                        }
+                        catch { }
+                        try {
+                            unpipeVoice?.();
+                        }
+                        catch { }
+                        wrapper.swapInner(slot.llm); // also aborts old inner's in-flight fast-brain turn
+                        wrapper.setWorkingContext?.(slot.workingDir);
+                        unpipeVoice = pipeVoiceFrom(slot.llm.events);
+                        currentResumeSessionId = key;
+                        if (hostSessionId)
+                            hostSessionId = key;
+                        // DEMOTE — adopt the old foreground as a LIVE, full background slot (not killed).
+                        // Its consumer emits on oldInner.events, so attach the shared background forwarders
+                        // there (silent — no tts_say). Give it sdkOptions so dispatch_background accepts it,
+                        // and kickoffDone=true (it's already live; no [BACKGROUND_INIT] to consume).
+                        const demoteUnforward = attachBackgroundForwarders(oldInner.events, oldId);
+                        const demotedEnv = {};
+                        for (const [k, v] of Object.entries(process.env)) {
+                            if (v !== undefined)
+                                demotedEnv[k] = v;
+                        }
+                        demotedEnv['CLAUDE_CODE_DISABLE_AUTO_MEMORY'] = '1';
+                        demotedEnv['IS_SANDBOX'] = '1';
+                        const demoted = {
+                            id: oldId, llm: oldInner, isFocused: false, workingDir: oldWorkingDir,
+                            emitter: oldInner.events, unforward: demoteUnforward, kickoffDone: true,
+                            sdkOptions: { cwd: oldWorkingDir, resume: oldId, permissionMode: 'bypassPermissions', enableFileCheckpointing: false, settingSources: ['project', 'user'], env: demotedEnv },
+                        };
+                        slots.set(oldId, demoted);
+                        // The promoted session is now foreground — remove it from the slot registry.
+                        slots.delete(key);
+                        // Tell the frontend: reload the promoted session's context + refresh the panel.
+                        const summary = await getSessionSummary(key, workingDir).catch(() => null);
+                        const conversationHistory = await getConversationHistory(key, workingDir, 30).catch(() => []);
+                        await sendToFrontend({ type: 'session_switched', sessionId: key, success: true, summary, conversationHistory });
+                        const fId = key;
+                        const fEntry = [{ id: fId, isFocused: true, workingDir, hasSession: currentLLM.hasSession?.() ?? false }];
+                        const bEntries = [...slots.values()].map(s => ({ id: s.id, isFocused: s.isFocused, workingDir: s.workingDir, hasSession: s.llm.hasSession?.() ?? false }));
+                        await sendToFrontend({ type: 'slots_list', slots: [...fEntry, ...bEntries] });
+                        try {
+                            if (currentSession)
+                                await currentSession.say('Switched. This instance is live now — the previous one keeps running in the background.');
+                        }
+                        catch { }
+                    }
+                }
+            }
             else if (data.type === 'list_slots') {
                 // Return all live slots: the focused session + every background slot.
                 const focusedId = currentLLM?.sessionId || currentResumeSessionId || null;

package/dist/pipeline-direct-llm.d.ts

@@ -9,7 +9,7 @@
  * Phase 2 (future): Gemini speaks first, Claude suppressed when Gemini has HIGH confidence
  */
 import { llm, type APIConnectOptions } from '@livekit/agents';
-import { type ClaudeLLMOptions } from './claude-llm.js';
+import { ClaudeLLM, type ClaudeLLMOptions } from './claude-llm.js';
 import { EventEmitter } from 'events';
 export interface InterruptionContext {
     spokenText: string;
@@ -51,6 +51,9 @@ export declare class PipelineDirectLLM extends llm.LLM {
     get model(): string;
     get isResumingSession(): boolean;
     label(): string;
+    get inner(): ClaudeLLM;
+    swapInner(next: ClaudeLLM): ClaudeLLM;
+    setWorkingContext(workingDirectory: string, sessionBaseDir?: string): void;
     setResumeSessionId(id: string | null): void;
     setContinueSession(e: boolean): void;
     resetForSessionSwitch(): void;

package/dist/pipeline-direct-llm.js

@@ -94,6 +94,36 @@ export class PipelineDirectLLM extends llm.LLM {
     get model() { return this.#claudeLLM.model; }
     get isResumingSession() { return this.#claudeLLM.isResumingSession; }
     label() { return 'pipeline-direct'; }
+    // ── Instance swap (foreground ⇄ background handoff) ──────────────────────────
+    // The voice AgentSession binds THIS wrapper for the whole session; chat() routes
+    // to #claudeLLM. To move the voice to a different, already-running Claude
+    // subprocess (a background slot) WITHOUT tearing down the AgentSession or killing
+    // either subprocess, we hot-swap the inner ClaudeLLM. The caller is responsible
+    // for moving the voice event listeners from the old inner's emitter to the new
+    // one (wireVoice/unwireVoice in index.ts) — `.events` changes target after swap,
+    // but already-attached listeners stay on the old emitter until re-wired.
+    get inner() { return this.#claudeLLM; }
+    swapInner(next) {
+        const prev = this.#claudeLLM;
+        // Cancel any in-flight fast-brain turn bound to the OLD inner so its agentControl
+        // closures (which capture `this`) can't fire interrupt/sendPrompt into the newly
+        // promoted session. Clear per-turn flags so the new inner starts clean.
+        try {
+            this.#turnAbort?.abort();
+        }
+        catch { }
+        this.#turnAbort = null;
+        this.#postCompactionTailPending = false;
+        this.#claudeLLM = next;
+        console.log('🔁 [pipeline] swapped inner ClaudeLLM (voice handoff)');
+        return prev;
+    }
+    // After a swap, point the dir-derived work (fast brain, session-tail) at the promoted
+    // session's working dir. Without this, #opts stays bound to the pre-swap session and a
+    // slot spawned with a different cwd would search the wrong store.
+    setWorkingContext(workingDirectory, sessionBaseDir) {
+        this.#opts = { ...this.#opts, workingDirectory, sessionBaseDir: sessionBaseDir ?? workingDirectory };
+    }
     // Proxy all methods
     setResumeSessionId(id) { this.#claudeLLM.setResumeSessionId(id); }
     setContinueSession(e) { this.#claudeLLM.setContinueSession(e); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osborn",
-  "version": "0.9.251",
+  "version": "0.9.252-swap.0",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {

package/dist/bridge-llm.d.ts

@@ -1,22 +0,0 @@
-/**
- * Bridge LLM Module - Creates LLM instances for pipelined voice sessions
- *
- * In pipelined mode, we use a separate LLM (Gemini or GPT-4o) as the
- * "conversation manager" that handles voice I/O and routes to Claude Code.
- */
-import * as google from '@livekit/agents-plugin-google';
-import * as openai from '@livekit/agents-plugin-openai';
-export interface BridgeLLMConfig {
-    provider: 'gemini-pro' | 'gemini-flash' | 'gpt-4o' | 'gpt-4o-mini';
-    model?: string;
-}
-/**
- * Create Bridge LLM instance for pipelined voice sessions
- *
- * Options:
- * - gemini-pro: Gemini 2.5 Pro (smart, good reasoning)
- * - gemini-flash: Gemini 2.0 Flash (faster, cheaper)
- * - gpt-4o: GPT-4o (alternative if OpenAI preferred)
- * - gpt-4o-mini: GPT-4o Mini (faster, cheaper)
- */
-export declare function createBridgeLLM(config: BridgeLLMConfig): google.LLM | openai.LLM;

package/dist/bridge-llm.js

@@ -1,39 +0,0 @@
-/**
- * Bridge LLM Module - Creates LLM instances for pipelined voice sessions
- *
- * In pipelined mode, we use a separate LLM (Gemini or GPT-4o) as the
- * "conversation manager" that handles voice I/O and routes to Claude Code.
- */
-import * as google from '@livekit/agents-plugin-google';
-import * as openai from '@livekit/agents-plugin-openai';
-/**
- * Create Bridge LLM instance for pipelined voice sessions
- *
- * Options:
- * - gemini-pro: Gemini 2.5 Pro (smart, good reasoning)
- * - gemini-flash: Gemini 2.0 Flash (faster, cheaper)
- * - gpt-4o: GPT-4o (alternative if OpenAI preferred)
- * - gpt-4o-mini: GPT-4o Mini (faster, cheaper)
- */
-export function createBridgeLLM(config) {
-    switch (config.provider) {
-        case 'gemini-pro':
-            return new google.LLM({
-                model: config.model || 'gemini-2.5-pro',
-            });
-        case 'gemini-flash':
-            return new google.LLM({
-                model: config.model || 'gemini-2.0-flash',
-            });
-        case 'gpt-4o':
-            return new openai.LLM({
-                model: config.model || 'gpt-4o',
-            });
-        case 'gpt-4o-mini':
-            return new openai.LLM({
-                model: config.model || 'gpt-4o-mini',
-            });
-        default:
-            throw new Error(`Unknown Bridge LLM provider: ${config.provider}`);
-    }
-}

package/dist/codex-handler.d.ts

@@ -1,38 +0,0 @@
-import { EventEmitter } from 'events';
-type SandboxMode = 'workspace-write' | 'danger-full-access';
-type ApprovalPolicy = 'on-failure' | 'on-request' | 'never';
-interface CodexHandlerOptions {
-    workingDirectory?: string;
-    skipGitRepoCheck?: boolean;
-    sandboxMode?: SandboxMode;
-    approvalPolicy?: ApprovalPolicy;
-}
-/**
- * Codex Handler using the official OpenAI Codex SDK
- *
- * Features:
- * - Thread persistence (reuses same thread for context)
- * - Built-in coding tools (file operations, terminal commands)
- * - Hooks for observability
- *
- * Requirements:
- * - Codex CLI must be installed (npm install -g @openai/codex or use npx)
- * - Must be authenticated via: codex login (ChatGPT) or OPENAI_API_KEY env var
- *
- * Sandbox/Approval modes are configured via:
- * - ~/.codex/config.yaml for global settings
- * - CLI flags: --sandbox, --approval-policy
- *
- * Note: The SDK spawns the CLI binary, so authentication must be done beforehand.
- */
-export declare class CodexHandler extends EventEmitter {
-    private codex;
-    private thread;
-    private options;
-    constructor(options?: CodexHandlerOptions);
-    run(prompt: string): Promise<string>;
-    getThreadId(): string | null;
-    clearThread(): void;
-}
-export declare function askCodex(prompt: string, cwd?: string): Promise<string>;
-export {};