osborn 0.5.3 → 0.8.0

package/dist/index.js

@@ -5,14 +5,24 @@ import { Room, RoomEvent } from '@livekit/rtc-node';
 import { AccessToken } from 'livekit-server-sdk';
 // Initialize logger before anything else
 initializeLogger({ pretty: true, level: 'info' });
+// Prevent MaxListenersExceededWarning on AbortSignal from Claude SDK query() calls
+// Each resumed query() adds listeners to the shared signal; default limit is 10
+import { setMaxListeners } from 'node:events';
+setMaxListeners(50);
 import { createServer } from 'http';
-import { loadConfig, getMcpServers, getEnabledMcpServerNames, getVoiceMode, getRealtimeConfig, getDirectConfig, listSessions, getMostRecentSessionId, sessionExists, cleanupOrphanedMetadata, getSessionSummary, getConversationHistory, ensureSessionWorkspace, getMcpServerStatusList, buildMcpServersForKeys, listWorkspaceArtifacts, readSessionSpec, listLibraryFiles } from './config.js';
-import { createSTT, createTTS, createVAD, createRealtimeModelFromConfig } from './voice-io.js';
+import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createPatch } from 'diff';
+import { loadConfig, getMcpServers, getEnabledMcpServerNames, getVoiceMode, getRealtimeConfig, getDirectConfig, listSessions, getMostRecentSessionId, sessionExists, cleanupOrphanedMetadata, getSessionSummary, getConversationHistory, ensureSessionWorkspace, getMcpServerStatusList, buildMcpServersForKeys, listWorkspaceArtifacts } from './config.js';
+import { createSTT, createTTS, createRealtimeModelFromConfig, DIRECT_MODE_STT, DIRECT_MODE_TTS } from './voice-io.js';
 import { createClaudeLLM } from './claude-llm.js';
+import { clearPipelineFastBrainSession, prewarmBM25Index } from './pipeline-fastbrain.js';
+import { ensureClaudeAuth } from './claude-auth.js';
 import { createSmitheryProxy, destroySmitheryProxy, parseSmitheryUrl, isSmitheryUrl, SmitheryAuthorizationError } from './smithery-proxy.js';
-import { askHaiku, updateSpecFromJSONL, augmentResearchResult, writeQuestionToSpec, checkOutputAgainstQuestions, contextualizeResearchUpdate, generateProactivePrompt, generateVisualDocument, clearFastBrainHistory } from './fast-brain.js';
-import { DIRECT_MODE_PROMPT, getRealtimeInstructions, getResearchCompleteInjection, getResearchUpdateInjection, getNotificationInjection } from './prompts.js';
+import { askHaiku, askFastBrain, updateSpecFromJSONL, processResearchCompletion, handleResearchBatch, prepareBriefingScript, prepareRecoveryScript, writeQuestionToSpec, checkOutputAgainstQuestions, generateProactivePrompt, clearFastBrainSession } from './fast-brain.js';
+import { DIRECT_MODE_PROMPT, getRealtimeInstructions, getScriptInjection, getProactiveInjection, getNotificationInjection } from './prompts.js';
 import { MCP_CATALOG } from './config.js';
+import { getRecallClient } from './recall-client.js';
 import { llm } from '@livekit/agents';
 import { z } from 'zod';
 // ============================================================
@@ -28,6 +38,32 @@ import { z } from 'zod';
 //   - Voice LLM with tool calling (ask_agent, respond_permission)
 //   - Routes tasks to Claude agents for execution
 // ============================================================
+// Load skills list with name + description for frontend display
+function loadSkillsList(agentDir) {
+    const skillsDir = join(agentDir, '.claude', 'skills');
+    if (!existsSync(skillsDir))
+        return [];
+    const skills = [];
+    try {
+        for (const skillName of readdirSync(skillsDir)) {
+            const skillFile = join(skillsDir, skillName, 'SKILL.md');
+            if (existsSync(skillFile)) {
+                const content = readFileSync(skillFile, 'utf-8');
+                // Extract title from first # heading, or use folder name
+                const titleMatch = content.match(/^#\s+(?:Skill:\s*)?(.+)/m);
+                const name = titleMatch ? titleMatch[1].trim() : skillName;
+                // Extract description from first paragraph after heading
+                const descMatch = content.match(/^#[^\n]+\n+([^\n#]+)/m);
+                const description = descMatch ? descMatch[1].trim() : '';
+                skills.push({ name, description });
+            }
+        }
+    }
+    catch (err) {
+        console.warn('⚠️ Failed to load skills list:', err);
+    }
+    return skills;
+}
 // Generate a short, user-friendly room code
 function generateRoomCode() {
     const chars = 'abcdefghjkmnpqrstuvwxyz23456789';
@@ -75,9 +111,15 @@ process.on('unhandledRejection', (reason) => {
         console.log('⚠️ Post-disconnect cleanup error (harmless)');
         return;
     }
-    // generateReply timeout — usually from racing concurrent injections
-    if (msg.includes('generateReply timed out') || msg.includes('generation_created')) {
-        console.log('⚠️ generateReply timed out (concurrent injection race)');
+    // generateReply timeout — realtime LLM called a tool instead of speaking (toolChoice:'none' ignored)
+    // or Superseded — new generateReply cancelled a pending one
+    if (msg.includes('generateReply timed out') || msg.includes('generation_created') || msg.includes('Superseded')) {
+        console.log('⚠️ generateReply failed:', msg.substring(0, 80));
+        return;
+    }
+    // AdaptiveInterruptionDetector crash — LiveKit Cloud returns string instead of JSON.
+    // SDK handles this internally (retries → VAD fallback). Suppress residual noise.
+    if (msg.includes('interruption prediction') || msg.includes('AdaptiveInterruptionDetector')) {
         return;
     }
     console.error('❌ Unhandled Rejection:', msg);
@@ -92,11 +134,13 @@ process.on('uncaughtException', (error) => {
 // ============================================================
 // HTTP API SERVER - Exposes session data to cloud-deployed frontend
 // ============================================================
+// Module-level room code so the HTTP server can expose it via GET /room-code
+let currentRoomCode = null;
 function startApiServer(workingDir, port) {
     const server = createServer(async (req, res) => {
         // CORS headers for cloud frontend
         res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
         res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
         if (req.method === 'OPTIONS') {
             res.writeHead(204);
@@ -132,12 +176,52 @@ function startApiServer(workingDir, port) {
             res.end(JSON.stringify({ status: 'ok', workingDir }));
             return;
         }
+        // POST /webhook/recall — Recall.ai real-time transcript webhooks
+        if (req.method === 'POST' && url.pathname === '/webhook/recall') {
+            // Respond 200 immediately — never block or Node delays next webhooks
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end('{"ok":true}');
+            let body = '';
+            req.on('data', (chunk) => { body += chunk.toString(); });
+            req.on('end', () => {
+                try {
+                    const payload = JSON.parse(body);
+                    const recall = getRecallClient();
+                    if (recall)
+                        recall.handleWebhook(payload);
+                }
+                catch (e) {
+                    console.error('Recall webhook parse error:', e);
+                }
+            });
+            return;
+        }
+        // GET /meeting-output — Output Media webpage for Recall.ai bot audio
+        if (req.method === 'GET' && url.pathname === '/meeting-output') {
+            const htmlPath = join(process.cwd(), 'src', 'meeting-output.html');
+            try {
+                const html = readFileSync(htmlPath, 'utf-8');
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(html);
+            }
+            catch {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('meeting-output.html not found');
+            }
+            return;
+        }
+        if (req.method === 'GET' && url.pathname === '/room-code') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ roomCode: currentRoomCode }));
+            return;
+        }
         res.writeHead(404, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Not found' }));
     });
-    server.listen(port, () => {
-        console.log(`🌐 API server listening on http://localhost:${port}`);
-        console.log(`   Sessions: http://localhost:${port}/sessions`);
+    const host = process.env.HOST || '0.0.0.0';
+    server.listen(port, host, () => {
+        console.log(`🌐 API server listening on http://${host}:${port}`);
+        console.log(`   Sessions: http://${host}:${port}/sessions`);
     });
     server.on('error', (err) => {
         if (err.code === 'EADDRINUSE') {
@@ -158,48 +242,6 @@ function startApiServer(workingDir, port) {
  * Gemini has smaller context limits — cap at 10 exchanges with 500 char content.
  * OpenAI handles full history (30 exchanges, 2000 char content).
  */
-function buildContextBriefing(summary, history, provider) {
-    const isGemini = provider === 'gemini';
-    // Gemini: last 10 exchanges capped at 500 chars. OpenAI: full history.
-    const maxExchanges = isGemini ? 10 : history.length;
-    const maxContentLen = isGemini ? 500 : 2000;
-    const trimmedHistory = history.slice(-maxExchanges);
-    const lines = [
-        `Session ID: ${summary.sessionId.substring(0, 8)}`,
-        `Total messages: ${summary.messageCount}`,
-        '',
-        '=== SESSION CONVERSATION HISTORY ==='
-    ];
-    for (const exchange of trimmedHistory) {
-        const content = exchange.content.length > maxContentLen
-            ? exchange.content.substring(0, maxContentLen) + '...'
-            : exchange.content;
-        lines.push(`${exchange.role === 'user' ? 'User' : 'Assistant'}: ${content}`);
-        lines.push('');
-    }
-    return lines.join('\n');
-}
-/**
- * Read spec.md and format it for the realtime voice model.
- * Truncates to avoid bloating the context window.
- * Returns null if spec doesn't exist or session ID isn't available.
- */
-function getSpecForVoiceModel(workingDir, sessionId) {
-    if (!sessionId)
-        return null;
-    const specContent = readSessionSpec(workingDir, sessionId);
-    if (!specContent)
-        return null;
-    const MAX = 3000;
-    if (specContent.length <= MAX)
-        return specContent;
-    const truncated = specContent.substring(0, MAX);
-    const lastHeading = truncated.lastIndexOf('\n## ');
-    if (lastHeading > MAX * 0.5) {
-        return truncated.substring(0, lastHeading) + '\n\n[... truncated — call read_spec for full content]';
-    }
-    return truncated + '\n\n[... truncated]';
-}
 /**
  * Load full session conversation history into the realtime model's ChatContext.
  * This gives the model persistent memory of what was discussed/researched,
@@ -261,8 +303,20 @@ async function main() {
     if (enabledMcpNames.length > 0) {
         console.log(`🔌 Enabled MCP servers: ${enabledMcpNames.join(', ')}`);
     }
-    const workingDir = config.workingDirectory || process.cwd();
-    console.log(`📂 Working directory: ${workingDir}`);
+    // Two directory concepts:
+    // 1. workingDir (cwd) — where Claude Code operates. Configurable per-session.
+    //    Priority: OSBORN_CWD env > config.workingDirectory > process.cwd()
+    // 2. sessionBaseDir — where session artifacts live (spec.md, library/).
+    //    Always the Osborn agent install directory (where this process started).
+    //    This ensures .osborn/sessions/ doesn't scatter across random directories.
+    const sessionBaseDir = process.cwd(); // Always the Osborn install dir
+    const defaultWorkingDir = process.env.OSBORN_CWD || config.workingDirectory || process.cwd();
+    let workingDir = defaultWorkingDir;
+    console.log(`📂 Working directory (cwd): ${workingDir}`);
+    console.log(`📂 Session base directory: ${sessionBaseDir}`);
+    if (process.env.OSBORN_CWD) {
+        console.log(`   (cwd from OSBORN_CWD env var)`);
+    }
     console.log(`🔬 Mode: RESEARCH`);
     // Determine voice mode
     const voiceMode = getVoiceMode(config);
@@ -278,6 +332,7 @@ async function main() {
     }
     // Determine room code
     const roomCode = cliArgs.roomCode || generateRoomCode();
+    currentRoomCode = roomCode;
     const roomName = `osborn-${roomCode}`;
     if (cliArgs.roomCode) {
         console.log(`🔗 Joining room: ${roomCode}`);
@@ -315,14 +370,22 @@ async function main() {
     const room = new Room();
     room.setMaxListeners(50); // Prevent MaxListenersExceeded warnings on reconnect
     // Track state
+    let pendingSessionClose = null; // Tracks async session close for reconnect safety
     let currentSession = null;
     let currentAgent = null; // For updateChatCtx() context injection
     let currentLLM = null;
     let localParticipant = null;
     let agentState = 'initializing';
+    // Session-level always-allow list: paths the user has approved for this session without prompting
+    let sessionAlwaysAllowPaths = new Set();
     let userState = 'listening'; // Track user speech state for queue safety
     let currentVoiceMode = voiceMode; // Track active voice mode for data handlers
     let currentProvider = realtimeConfig.provider; // Track active realtime provider
+    // Track the active resume session ID across scopes (ParticipantConnected + DataReceived)
+    // Updated by resume_session, session_selected, continue_session, switch_session handlers
+    let currentResumeSessionId;
+    // Claude auth code submission handler (set during OAuth flow, cleared after)
+    let pendingAuthSubmitCode = null;
     // Task deduplication guard - prevents Gemini re-execution loops
     let lastTaskRequest = '';
     let lastTaskTime = 0;
@@ -330,8 +393,103 @@ async function main() {
     let haikuInFlight = null;
     // Background research state - tracks async ask_agent execution
     let activeResearch = null;
+    // Persist last completed research context so follow-up questions can reference it
+    // (activeResearch is set to null on completion — this preserves the context)
+    let lastCompletedResearch = null;
     // No manual queuing — the Claude SDK handles sequential queries internally
     // ============================================================
+    // Recall.ai — Meeting Transcript Routing
+    // ============================================================
+    const recall = getRecallClient();
+    if (recall) {
+        console.log('🎥 Recall.ai client initialized (RECALL_API_KEY present)');
+        recall.on('transcript', ({ botId, speaker, text }) => {
+            console.log(`📝 Meeting transcript [${speaker}]: ${text}`);
+            // Route meeting transcripts to Claude as user text with speaker attribution
+            if (currentLLM && currentSession) {
+                const meetingText = `[Meeting — ${speaker}]: ${text}`;
+                // Use the same pipeline as user_text data channel messages
+                try {
+                    if (currentVoiceMode === 'pipeline' || currentVoiceMode === 'direct') {
+                        const chatCtx = new llm.ChatContext();
+                        chatCtx.addMessage({ role: 'user', content: meetingText });
+                        currentLLM.chat({ chatCtx });
+                    }
+                }
+                catch (err) {
+                    console.error('❌ Failed to route meeting transcript:', err);
+                }
+            }
+        });
+    }
+    // ============================================================
+    // Interruption Tracking (Content Ledger)
+    // ============================================================
+    // When user interrupts TTS, LiveKit truncates chatCtx to what was spoken.
+    // We capture the spoken text (synchronizedTranscript) and on the next user
+    // message, read Claude's full output from JSONL + inject context so Claude
+    // knows what was heard vs lost. Claude decides: side question → answer +
+    // continue, or redirect → follow new direction.
+    // Current SpeechHandle from session.say() — only the latest one matters
+    let currentSpeechHandle = null;
+    // Last interruption context — gathered at interrupt time, consumed when user's message arrives
+    let lastInterruption = null;
+    /**
+     * Called when a SpeechHandle finishes (interrupted or not).
+     * If interrupted: gather spoken text + JSONL context. Does NOT send to Claude yet —
+     * that happens when the user's transcribed message arrives via chat().
+     */
+    async function handleSpeechDone(handle, fullText) {
+        if (!handle.interrupted) {
+            lastInterruption = null;
+            return;
+        }
+        // fullText is what was being spoken when interrupted (passed from tts_say handler).
+        // No word-level cutoff for say() — only generateReply pipeline has that — but Claude
+        // knows its own output from JSONL, so the full block is enough context.
+        console.log(`🔇 Speech interrupted. Was speaking: "${fullText.substring(0, 80)}..."`);
+        // Read last 10 assistant messages from JSONL (Claude's full untruncated output).
+        // SessionMessage.text is pre-joined from all text content blocks.
+        let recentMessages = '';
+        const sessionId = currentLLM?.sessionId;
+        if (sessionId) {
+            try {
+                const { readSessionHistory } = await import('./session-access.js');
+                const history = readSessionHistory(sessionId, workingDir, {
+                    lastN: 10,
+                    types: ['assistant'],
+                });
+                recentMessages = history
+                    .filter((m) => m.text)
+                    .map((m) => m.text)
+                    .join('\n---\n');
+            }
+            catch (err) {
+                console.warn('⚠️ Failed to read JSONL for interruption context:', err);
+            }
+        }
+        // Store — consumed when user's next message arrives via chat()
+        lastInterruption = { spokenText: fullText, recentMessages, timestamp: Date.now() };
+        console.log(`📋 Interruption context stored (text: ${fullText.length} chars, JSONL: ${recentMessages.length} chars)`);
+    }
+    /**
+     * Callback for PipelineDirectLLM — returns pending interruption context and clears it.
+     * Called in chat() when user's transcribed message arrives.
+     * PipelineDirectLLM enriches the user message with this context before sending to Claude.
+     */
+    function getAndConsumeInterruptionContext() {
+        if (!lastInterruption)
+            return null;
+        // Expire after 60s — user may have waited too long
+        if (Date.now() - lastInterruption.timestamp > 60_000) {
+            lastInterruption = null;
+            return null;
+        }
+        const ctx = { spokenText: lastInterruption.spokenText, recentMessages: lastInterruption.recentMessages };
+        lastInterruption = null;
+        return ctx;
+    }
+    // ============================================================
     // Unified Voice Injection Queue
     // ============================================================
     // ALL system injections (research updates, completions, notifications, errors)
@@ -364,43 +522,62 @@ async function main() {
             console.log(`⏸️ Voice queue: ${voiceQueue.length} items waiting (user speaking)`);
             return;
         }
+        // Don't inject while fast brain tool call is in flight — the tool response will
+        // race with our generateReply, causing Gemini to drop our content and only speak
+        // the tool response. Wait for the tool call to complete first.
+        if (haikuInFlight) {
+            console.log(`⏸️ Voice queue: ${voiceQueue.length} items waiting (fast brain in flight: "${haikuInFlight.question.substring(0, 40)}...")`);
+            return; // Will be retried when haikuInFlight clears (see tool execute handler)
+        }
         isProcessingQueue = true;
-        // Safety timeout: if agent_state_changed never fires (e.g. Gemini state machine hang),
-        // clear the guard after 30s so the queue isn't permanently stuck
+        // Batch ALL queued items into one generateReply call
+        const items = voiceQueue.splice(0);
+        const batchedInstruction = items.length === 1
+            ? items[0]
+            : items.join('\n\n---\n\n');
+        console.log(`📡 Voice queue: processing ${items.length} batched items (${batchedInstruction.length} chars)`);
+        // Safety timeout: if agent_state_changed never fires (edge case — e.g. Gemini
+        // WebSocket drops, or state machine hangs). 15s gives the model time to process.
         setTimeout(() => {
             if (isProcessingQueue) {
-                console.log('⚠️ Voice queue: isProcessingQueue stuck for 30s, clearing');
+                console.log('⚠️ Voice queue: safety timeout — clearing guard');
                 isProcessingQueue = false;
                 if (voiceQueue.length > 0 && agentState === 'listening') {
                     processVoiceQueue();
                 }
             }
-        }, 30000);
-        // Batch ALL queued items into one generateReply call
-        const items = voiceQueue.splice(0);
-        const batchedInstruction = items.length === 1
-            ? items[0]
-            : items.join('\n\n---\n\n');
-        console.log(`📡 Voice queue: processing ${items.length} batched items (${batchedInstruction.length} chars)`);
+        }, 15000);
         try {
             // Skip interrupt for Gemini — disrupts Gemini's state machine, causing it to
             // never transition back to 'listening' (hangs in speaking state indefinitely)
             if (currentProvider !== 'gemini') {
                 currentSession.interrupt();
             }
-            currentSession.generateReply({
-                instructions: batchedInstruction,
-                toolChoice: 'none',
-            });
+            if (currentProvider === 'gemini') {
+                // LiveKit SDK v1.0.51: generateReply({ instructions }) sends a system turn +
+                // synthetic "." user turn. After Gemini processes a tool call in this flow,
+                // autoToolReplyGeneration does NOT trigger continuation (system-only limitation).
+                // Using userInput instead makes it a "user-initiated" request where auto-continuation
+                // works. The ask_fast_brain injection bypass handles [SCRIPT]/[PROACTIVE]/[NOTIFICATION]
+                // prefixes and returns the content directly as a tool response.
+                currentSession.generateReply({
+                    userInput: batchedInstruction,
+                });
+            }
+            else {
+                // OpenAI respects toolChoice:'none' — speaks instructions directly
+                currentSession.generateReply({
+                    instructions: batchedInstruction,
+                    toolChoice: 'none',
+                });
+            }
             // Model transitions to thinking/speaking after this call.
             // When it returns to 'listening', agent_state_changed triggers processVoiceQueue() again.
             // Also inject into chatCtx as persistent context so the model remembers across turns
             injectIntoChatCtx(batchedInstruction);
         }
         catch (err) {
-            console.log('⚠️ Voice queue generateReply failed, dropping items:', err);
-            // Do NOT re-queue — re-queuing causes infinite retry cascades
-            // The frontend still has the updates via claude_output events
+            console.log('⚠️ Voice queue generateReply failed:', err);
             isProcessingQueue = false;
         }
         // isProcessingQueue is cleared when agent_state_changed fires
@@ -473,17 +650,16 @@ async function main() {
                 isStreaming: true,
                 agentRole: 'research-progress',
             });
-            // COMMENTED OUT — voice narration disabled, research progress goes to  -frontend logs only 
-            // // queueVoiceInjection(getResearchUpdateInjection(batchText))  
-            // Route through fast brain for contextual voice updates (capped at 3 per task)
-            if (activeResearch.voiceUpdateCount < 3) {
+            // Route through fast brain — it decides whether to speak (usually silent)
+            if (activeResearch.voiceUpdateCount < 2) {
                 const voiceSid = currentLLM?.sessionId;
                 if (voiceSid) {
-                    contextualizeResearchUpdate(workingDir, voiceSid, lastTaskRequest || '', updates, activeResearch.researchLog)
-                        .then(update => {
-                        if (update && update !== 'NOTHING' && activeResearch) {
+                    const chatHistory = getChatHistory(10);
+                    handleResearchBatch(workingDir, voiceSid, lastTaskRequest || '', updates, activeResearch.researchLog, chatHistory, sessionBaseDir)
+                        .then(script => {
+                        if (script && activeResearch) {
                             activeResearch.voiceUpdateCount++;
-                            queueVoiceInjection(getResearchUpdateInjection(update));
+                            queueVoiceInjection(getScriptInjection(script));
                         }
                     })
                         .catch(() => { }); // Silent fail — updates are optional
@@ -495,7 +671,7 @@ async function main() {
     let proactiveTimer = null;
     let proactivePromptHistory = [];
     const PROACTIVE_INTERVAL = 15000; // 15 seconds (offset from 8s batch timer)
-    const MAX_PROACTIVE_PROMPTS = 4; // Cap per research task
+    const MAX_PROACTIVE_PROMPTS = 2; // Cap per research task (reduced from 4 to minimize realtime LLM tokens)
     function startProactiveLoop(task, sessionId) {
         stopProactiveLoop();
         proactivePromptHistory = [];
@@ -514,11 +690,11 @@ async function main() {
             if (isProcessingQueue)
                 return; // Don't collide with voice queue
             try {
-                const prompt = await generateProactivePrompt(workingDir, sessionId, task, activeResearch.researchLog, proactivePromptHistory);
+                const prompt = await generateProactivePrompt(workingDir, sessionId, task, activeResearch.researchLog, proactivePromptHistory, sessionBaseDir);
                 if (prompt && prompt !== 'NOTHING') {
                     proactivePromptHistory.push(prompt);
                     proactiveCount++;
-                    queueVoiceInjection(`[PROACTIVE CONTEXT] ${prompt}. Say this naturally to the user. Do NOT call any tools.`);
+                    queueVoiceInjection(getProactiveInjection(prompt));
                 }
             }
             catch { } // Silent fail — proactive prompts are optional
@@ -580,28 +756,42 @@ async function main() {
         }
     }
     // Create DIRECT session (STT + Claude Agent SDK + TTS)
-    async function createDirectSession(resumeSessionId) {
+    async function createDirectSession(resumeSessionId, llmOverride) {
         console.log('🎯 Creating direct session...');
-        const stt = createSTT({ provider: 'deepgram' });
-        const tts = createTTS({ provider: 'deepgram', voice: 'aura-asteria-en' });
-        const vad = await createVAD();
-        // Create Claude LLM wrapper in research mode
-        const directLLM = createClaudeLLM({
+        const stt = createSTT(DIRECT_MODE_STT);
+        const tts = createTTS(DIRECT_MODE_TTS);
+        // Create Claude LLM wrapper — direct mode uses speech-optimized system prompt
+        // skipTTSQueue: bypass LiveKit's BufferedTokenStream, use session.say() instead
+        // llmOverride: pipeline mode passes PipelineDirectLLM which wraps its own ClaudeLLM
+        const directLLM = llmOverride || createClaudeLLM({
             workingDirectory: workingDir,
+            sessionBaseDir,
             mcpServers,
             resumeSessionId,
+            voiceMode: 'direct',
+            skipTTSQueue: true,
         });
         currentLLM = directLLM;
+        // Reset the session always-allow list for each new direct session
+        sessionAlwaysAllowPaths = new Set();
         // For resumed sessions, eagerly create workspace (we know the real ID)
         if (resumeSessionId) {
-            const workspace = ensureSessionWorkspace(workingDir, resumeSessionId);
+            const workspace = ensureSessionWorkspace(sessionBaseDir, resumeSessionId);
             console.log(`📁 Session workspace (resumed): ${workspace}`);
         }
         // For new sessions, create workspace when SDK assigns real session ID
         directLLM.events.once('session_id', ({ sessionId }) => {
-            const workspace = ensureSessionWorkspace(workingDir, sessionId);
+            const workspace = ensureSessionWorkspace(sessionBaseDir, sessionId);
             console.log(`📁 Session workspace created: ${workspace}`);
+            // Pipeline mode: pre-warm BM25 index so first fast brain query is fast
+            if (currentVoiceMode === 'pipeline') {
+                prewarmBM25Index(sessionId, workingDir).catch(() => { });
+            }
         });
+        // Also pre-warm for resumed sessions (sessionId already known)
+        if (resumeSessionId && currentVoiceMode === 'pipeline') {
+            prewarmBM25Index(resumeSessionId, workingDir).catch(() => { });
+        }
         // Wire up MCP server changes to frontend
         directLLM.events.on('mcp_servers_changed', (data) => {
             console.log(`🔌 MCP servers changed: ${data.enabledKeys.join(', ') || 'none'}`);
@@ -657,6 +847,15 @@ async function main() {
             console.log(`⚠️ Permission needed: ${data.toolName}`);
             const toolName = data.toolName;
             const input = data.input || {};
+            // Check session always-allow list before showing dialog
+            if (toolName === 'Write' || toolName === 'Edit' || toolName === 'MultiEdit') {
+                const filePath = String(input?.file_path || '');
+                if (filePath && sessionAlwaysAllowPaths.has(filePath)) {
+                    console.log(`✅ Session always-allow: ${filePath}`);
+                    directLLM.respondToPermission(true);
+                    return;
+                }
+            }
             // Build descriptive message based on tool type
             let description = `I need permission to use ${toolName}.`;
             if (toolName === 'Bash' && input.command) {
@@ -672,17 +871,120 @@ async function main() {
             else if (toolName === 'WebFetch' && input.url) {
                 description = `I want to fetch content from: ${input.url}`;
             }
+            // Generate diff for Write/Edit/MultiEdit tools
+            let diffString;
+            if (toolName === 'Write' || toolName === 'Edit' || toolName === 'MultiEdit') {
+                const diffStart = performance.now();
+                try {
+                    const filePath = String(input?.file_path || '');
+                    let beforeContent = '';
+                    const readStart = performance.now();
+                    try {
+                        beforeContent = readFileSync(filePath, 'utf-8');
+                    }
+                    catch {
+                        beforeContent = ''; // new file
+                    }
+                    const readMs = (performance.now() - readStart).toFixed(2);
+                    console.log(`⏱️ diff read: ${readMs}ms (${beforeContent.length} chars, ${filePath.split('/').pop()})`);
+                    let afterContent = beforeContent;
+                    if (toolName === 'Write') {
+                        afterContent = String(input?.content || '');
+                    }
+                    else if (toolName === 'Edit') {
+                        const oldStr = String(input?.old_string || '');
+                        const newStr = String(input?.new_string || '');
+                        const replaceAll = Boolean(input?.replace_all);
+                        if (replaceAll) {
+                            afterContent = beforeContent.split(oldStr).join(newStr);
+                        }
+                        else {
+                            afterContent = beforeContent.replace(oldStr, newStr);
+                        }
+                    }
+                    else if (toolName === 'MultiEdit') {
+                        afterContent = beforeContent;
+                        const edits = Array.isArray(input?.edits) ? input.edits : [];
+                        for (const edit of edits) {
+                            if (edit.replace_all) {
+                                afterContent = afterContent.split(edit.old_string).join(edit.new_string);
+                            }
+                            else {
+                                afterContent = afterContent.replace(edit.old_string, edit.new_string);
+                            }
+                        }
+                    }
+                    const patchStart = performance.now();
+                    const fileName = filePath.split('/').pop() || filePath;
+                    diffString = createPatch(fileName, beforeContent, afterContent, '', '', { context: 4 });
+                    const patchMs = (performance.now() - patchStart).toFixed(2);
+                    const totalMs = (performance.now() - diffStart).toFixed(2);
+                    console.log(`⏱️ diff patch: ${patchMs}ms | total: ${totalMs}ms (before: ${beforeContent.length} chars, after: ${afterContent.length} chars, diff: ${diffString.length} chars)`);
+                }
+                catch (e) {
+                    const totalMs = (performance.now() - diffStart).toFixed(2);
+                    console.log(`⏱️ diff failed after ${totalMs}ms:`, e);
+                    // diff generation failed — proceed without diff
+                    diffString = undefined;
+                }
+            }
+            console.log(`🔍 perm payload: diff=${diffString ? `✅ ${diffString.length} chars` : '❌ NONE'} toolName=${toolName}`);
             sendToFrontend({
                 type: 'permission_request',
                 toolName: data.toolName,
                 input: data.input,
                 description,
                 agentRole: 'direct',
+                diff: diffString,
             });
             // Speak the descriptive request so user knows to respond
             if (currentSession) {
                 const ttsMessage = `${description} Say yes, no, or always.`;
-                currentSession.say?.(ttsMessage).catch(() => { });
+                currentSession.say?.(ttsMessage);
+            }
+        });
+        // 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) => {
+            // Guard: session must be alive — TTS errors can kill the session while background query runs
+            if (!currentSession) {
+                console.warn(`⚠️ tts_say fired but currentSession is null — text dropped: "${data.text?.substring(0, 60)}"`);
+                return;
+            }
+            if (!data.text?.trim()) {
+                console.log(`🔇 tts_say fired but text is empty — skipping`);
+                return;
+            }
+            const sayId = Date.now(); // simple ID to correlate start/end logs
+            console.log(`🗣️ [${sayId}] session.say START (${data.text.length} chars): "${data.text.substring(0, 60)}..."`);
+            try {
+                const handle = currentSession.say(data.text);
+                if (handle && typeof handle.addDoneCallback === 'function') {
+                    // SpeechHandle — track it and register interruption callback
+                    currentSpeechHandle = handle;
+                    handle.addDoneCallback((sh) => {
+                        if (sh.interrupted) {
+                            console.log(`🔇 [${sayId}] session.say INTERRUPTED`);
+                            handleSpeechDone(sh, data.text);
+                        }
+                        else {
+                            console.log(`✅ [${sayId}] session.say DONE`);
+                            if (currentSpeechHandle === sh)
+                                lastInterruption = null;
+                        }
+                    });
+                    console.log(`🗣️ [${sayId}] session.say queued (SpeechHandle tracked)`);
+                }
+                else if (handle && typeof handle.then === 'function') {
+                    // Promise-based fallback (older SDK path)
+                    handle
+                        .then(() => console.log(`✅ [${sayId}] session.say DONE`))
+                        .catch((err) => console.error(`❌ [${sayId}] session.say FAILED:`, err?.message || err));
+                }
+            }
+            catch (err) {
+                // Catch synchronous "AgentSession is not running" errors
+                console.warn(`⚠️ [${sayId}] session.say threw — session likely dead: ${err?.message}`);
             }
         });
         // Wire up session resume failure - notify frontend when SDK creates new session instead
@@ -703,17 +1005,25 @@ async function main() {
             });
         });
         // Create the Agent with instructions, STT, LLM, TTS
+        // VAD (Silero ONNX) removed — caused 2-5s inference lag on CPU, making interruption detection worse
+        // Turn detection is server-side (Deepgram endpointing), interruptions handled by STT
         const agent = new voice.Agent({
             instructions: DIRECT_MODE_PROMPT,
             stt,
             llm: directLLM,
             tts,
-            vad,
-            turnDetection: 'vad',
+            turnDetection: 'stt',
         });
-        // Create the session (no longer passes STT/LLM/TTS here)
         const session = new voice.AgentSession({
-            turnDetection: 'vad',
+            turnDetection: 'stt',
+            preemptiveGeneration: false, // Only fire LLM on final committed transcript, not partial preemptives
+            turnHandling: {
+                endpointing: {
+                    mode: 'fixed',
+                    minDelay: 500, // Wait 500ms after STT commits before generating reply
+                    maxDelay: 2000, // Force end-of-turn after 2s to prevent hangs
+                },
+            },
         });
         return { session, agent };
     }
@@ -729,18 +1039,19 @@ async function main() {
         // Create Claude LLM for tool execution (research tasks)
         realtimeClaudeHandler = createClaudeLLM({
             workingDirectory: workingDir,
+            sessionBaseDir,
             mcpServers,
             resumeSessionId,
         });
         currentLLM = realtimeClaudeHandler;
         // For resumed sessions, eagerly create workspace (we know the real ID)
         if (resumeSessionId) {
-            const workspace = ensureSessionWorkspace(workingDir, resumeSessionId);
+            const workspace = ensureSessionWorkspace(sessionBaseDir, resumeSessionId);
             console.log(`📁 Session workspace (resumed): ${workspace}`);
         }
         // For new sessions, create workspace when SDK assigns real session ID
         realtimeClaudeHandler.events.once('session_id', ({ sessionId }) => {
-            const workspace = ensureSessionWorkspace(workingDir, sessionId);
+            const workspace = ensureSessionWorkspace(sessionBaseDir, sessionId);
             console.log(`📁 Session workspace created: ${workspace}`);
         });
         // Wire up MCP server changes to frontend
@@ -840,76 +1151,24 @@ async function main() {
                 checkpointId: data.checkpointId,
             });
         });
-        // Extract priority content from research results — preserves URLs, code blocks, and key details
-        function extractPriorityContent(result, maxChars = 4000) {
-            if (result.length <= maxChars)
-                return result;
-            // Extract URLs (preserve for voice relay)
-            const urlRegex = /https?:\/\/[^\s\)\"\'>\]]+/g;
-            const urls = [...new Set(result.match(urlRegex) || [])];
-            // Extract code blocks (first 2, up to 400 chars each)
-            const codeBlockRegex = /```[\s\S]*?```/g;
-            const codeBlocks = [];
-            let match;
-            while ((match = codeBlockRegex.exec(result)) !== null && codeBlocks.length < 2) {
-                const block = match[0].length > 400 ? match[0].substring(0, 397) + '```' : match[0];
-                codeBlocks.push(block);
-            }
-            // Build sections
-            const sections = [];
-            // Take the first ~2500 chars of narrative (intro + main findings)
-            const narrativeEnd = Math.min(result.length, 2500);
-            const narrativeTruncated = result.substring(0, narrativeEnd);
-            const lastPeriod = narrativeTruncated.lastIndexOf('.');
-            const narrative = lastPeriod > narrativeEnd * 0.6
-                ? narrativeTruncated.substring(0, lastPeriod + 1)
-                : narrativeTruncated;
-            sections.push(narrative);
-            // Append conclusion (last ~500 chars) if result is long enough
-            if (result.length > 3000) {
-                const tail = result.substring(result.length - 500);
-                const firstPeriod = tail.indexOf('.');
-                const conclusion = firstPeriod > 0 ? tail.substring(firstPeriod + 1).trim() : tail.trim();
-                if (conclusion.length > 50) {
-                    sections.push(`\n\n[CONCLUSION]\n${conclusion}`);
-                }
-            }
-            // Append code blocks if not already in the narrative
-            if (codeBlocks.length > 0) {
-                const codeSection = codeBlocks.filter(cb => !narrative.includes(cb));
-                if (codeSection.length > 0) {
-                    sections.push(`\n\n[CODE EXAMPLES]\n${codeSection.join('\n\n')}`);
-                }
-            }
-            // Append URLs if not already in the narrative
-            const newUrls = urls.filter(u => !narrative.includes(u));
-            if (newUrls.length > 0) {
-                sections.push(`\n\n[LINKS]\n${newUrls.slice(0, 5).join('\n')}`);
-            }
-            let assembled = sections.join('');
-            // Final safety truncation if assembled exceeds maxChars
-            if (assembled.length > maxChars) {
-                const truncated = assembled.substring(0, maxChars);
-                const lp = truncated.lastIndexOf('.');
-                assembled = lp > maxChars * 0.7 ? truncated.substring(0, lp + 1) : truncated + '...';
-            }
-            return assembled;
-        }
         // Extracted research execution — called by ask_agent, SDK handles queuing internally
         function executeResearch(task) {
             sendToFrontend({ type: 'system', text: `Executing: ${task}` });
             // Fire-and-forget: write user question to spec.md BEFORE agent starts
             const questionSid = currentLLM?.sessionId || resumeSessionId;
             if (questionSid) {
-                writeQuestionToSpec(workingDir, questionSid, task).catch(err => console.error('❌ writeQuestionToSpec failed:', err));
+                writeQuestionToSpec(sessionBaseDir, questionSid, task).catch(err => console.error('❌ writeQuestionToSpec failed:', err));
             }
-            // Clean up previous research listeners to avoid duplicate event handlers
+            // Clean up previous research UI tracking — but let the SDK query complete in background.
+            // The SDK has an internal queue: new query() calls enqueue behind running ones.
+            // Old research results land in JSONL and fast brain can access them later.
             if (activeResearch) {
-                activeResearch.cleanup();
+                activeResearch.cleanup(); // Remove event listeners so UI tracks new task
                 if (researchBatchTimer) {
                     clearTimeout(researchBatchTimer);
                     researchBatchTimer = null;
                 }
+                // NOTE: NOT aborting — old SDK process continues writing to JSONL
             }
             // Set up research log batching — events push to queue for state-driven injection
             const researchLog = [];
@@ -970,7 +1229,7 @@ async function main() {
                 if (resultText.length > ANSWER_CHECK_THRESHOLD) {
                     const sid = currentLLM?.sessionId || resumeSessionId;
                     if (sid)
-                        checkOutputAgainstQuestions(workingDir, sid, resultText, 'tool_result').catch(() => { });
+                        checkOutputAgainstQuestions(sessionBaseDir, sid, resultText, 'tool_result').catch(() => { });
                 }
                 // When AskUserQuestion completes, the user's answer is a decision — track it in spec
                 if (data.name === 'AskUserQuestion' && data.response) {
@@ -979,7 +1238,7 @@ async function main() {
                         const questionText = JSON.stringify(data.input?.questions || data.input || {});
                         const answerText = typeof data.response === 'string' ? data.response : JSON.stringify(data.response);
                         const specUpdate = `User answered a clarifying question during research.\nQuestion: ${questionText}\nAnswer: ${answerText}\nRecord this as a user decision in spec.md.`;
-                        askHaiku(workingDir, sid, specUpdate).catch(err => console.error('❌ Failed to record AskUserQuestion answer in spec:', err));
+                        askHaiku(workingDir, sid, specUpdate, undefined, undefined, undefined, sessionBaseDir).catch(err => console.error('❌ Failed to record AskUserQuestion answer in spec:', err));
                         console.log(`📝 AskUserQuestion answer forwarded to fast brain for spec tracking`);
                     }
                 }
@@ -996,36 +1255,53 @@ async function main() {
                     if (text.length > ANSWER_CHECK_THRESHOLD) {
                         const sid = currentLLM?.sessionId || resumeSessionId;
                         if (sid)
-                            checkOutputAgainstQuestions(workingDir, sid, text, 'assistant_text').catch(() => { });
+                            checkOutputAgainstQuestions(sessionBaseDir, sid, text, 'assistant_text').catch(() => { });
                     }
                 }
             };
+            // Capture the SDK's requestId for this query — identifies this research task
+            // in the JSONL file for targeted retrieval by fast brain
+            let sdkRequestId = null;
+            const onQueryRequestId = (data) => {
+                if (!sdkRequestId && data.requestId) {
+                    sdkRequestId = data.requestId;
+                    console.log(`📋 [research] SDK requestId: ${sdkRequestId}`);
+                }
+            };
             realtimeClaudeHandler.events.on('tool_use', onToolUse);
             realtimeClaudeHandler.events.on('tool_result', onToolResult);
             realtimeClaudeHandler.events.on('assistant_text', onText);
+            realtimeClaudeHandler.events.on('query_request_id', onQueryRequestId);
             const cleanupListeners = () => {
                 realtimeClaudeHandler?.events.off('tool_use', onToolUse);
                 realtimeClaudeHandler?.events.off('tool_result', onToolResult);
                 realtimeClaudeHandler?.events.off('assistant_text', onText);
+                realtimeClaudeHandler?.events.off('query_request_id', onQueryRequestId);
             };
+            // Create AbortController for this research task — abort on disconnect/cleanup
+            const researchAbortController = new AbortController();
             // Track active research — updates drain when model enters 'listening' state
-            activeResearch = {
+            const thisResearch = {
                 researchLog,
                 pendingUpdates,
                 cleanup: cleanupListeners,
                 voiceUpdateCount: 0,
+                abortController: researchAbortController,
             };
+            activeResearch = thisResearch;
             // Start proactive conversational loop
             const proactiveSid = currentLLM?.sessionId || resumeSessionId;
             if (proactiveSid) {
                 startProactiveLoop(task, proactiveSid);
             }
             // Run research in the background (non-blocking)
+            // Pass AbortController so research can be stopped on disconnect
             const researchPromise = (async () => {
                 const stream = realtimeClaudeHandler.chat({
                     chatCtx: {
                         items: [{ type: 'message', role: 'user', content: [task] }],
                     },
+                    abortController: researchAbortController,
                 });
                 let result = '';
                 for await (const chunk of stream) {
@@ -1037,7 +1313,17 @@ async function main() {
             })();
             // Handle completion asynchronously
             researchPromise.then(async (result) => {
-                console.log(`✅ [realtime] Research complete (${result.length} chars)`);
+                // Check if aborted — empty result means clean abort, skip pipeline
+                if (researchAbortController.signal.aborted || !result.trim()) {
+                    console.log(`🛑 [realtime] Research aborted or empty: ${task.substring(0, 60)}`);
+                    cleanupListeners();
+                    if (activeResearch === thisResearch) {
+                        activeResearch = null;
+                    }
+                    return;
+                }
+                const isStillCurrent = activeResearch === thisResearch;
+                console.log(`✅ [realtime] Research complete (${result.length} chars${isStillCurrent ? '' : ', superseded by newer task'})`);
                 // Clean up
                 cleanupListeners();
                 // Send raw result to frontend as a log entry (not assistant_response — that's reserved
@@ -1047,72 +1333,74 @@ async function main() {
                     ? result.substring(0, 150) + '...'
                     : result;
                 await sendToFrontend({ type: 'task_completed', task, resultPreview });
-                // Build enhanced return with research log
-                const logSummary = researchLog.length > 0
-                    ? `\n\n[RESEARCH LOG]\n${researchLog.slice(0, 25).join('\n')}`
-                    : '';
-                // Extract priority content — preserves URLs, code blocks, and key details (4000 char limit)
-                const resultForVoice = extractPriorityContent(result);
-                const fullResult = (resultForVoice + logSummary) || 'Research completed successfully.';
-                // Clear active research and timers before injecting final results
-                if (researchBatchTimer) {
-                    clearTimeout(researchBatchTimer);
-                    researchBatchTimer = null;
+                // Only modify global state if we're still the current research task.
+                // If a newer task replaced us, don't clobber its timers/state.
+                if (isStillCurrent) {
+                    if (researchBatchTimer) {
+                        clearTimeout(researchBatchTimer);
+                        researchBatchTimer = null;
+                    }
+                    stopProactiveLoop();
                 }
-                stopProactiveLoop();
-                activeResearch = null;
-                // Send final results to frontend for visibility
+                // Preserve research context for follow-up questions
+                lastCompletedResearch = {
+                    task,
+                    researchLog: [...researchLog],
+                    completedAt: Date.now(),
+                };
+                // Only clear activeResearch if we're still the current task
+                if (isStillCurrent) {
+                    activeResearch = null;
+                }
+                // Send research_task_complete to frontend for inline chat tracking
                 await sendToFrontend({
-                    type: 'claude_output',
-                    text: `[Research Complete] Injecting findings into voice model (${fullResult.length} chars)`,
-                    isStreaming: false,
-                    agentRole: 'research-progress',
+                    type: 'research_task_complete',
+                    task,
+                    summary: result.substring(0, 500),
                 });
-                // Route through fast brain for context augmentation before voice injection
-                // Fast brain adds spec context but does NOT summarize — passes details through verbatim
+                // Route through fast brain to generate a teleprompter script from the findings
+                // Fast brain reads full JSONL and writes a spoken monologue
                 const voiceSid = currentLLM?.sessionId || resumeSessionId;
-                console.log(`📡 [realtime] Augmenting results via fast brain (${fullResult.length} chars, agentState: ${agentState})`);
+                const chatHistory = getChatHistory(10);
+                console.log(`📡 [realtime] Generating teleprompter script via fast brain (result: ${result.length} chars, agentState: ${agentState})`);
+                // Create sendToChat for research completion to send structured data to frontend
+                const completionSendToChat = (text) => {
+                    sendToFrontend({ type: 'assistant_response', text });
+                };
                 if (voiceSid) {
-                    augmentResearchResult(workingDir, voiceSid, task, fullResult)
-                        .then(augmented => {
-                        queueVoiceInjection(getResearchCompleteInjection(task, augmented));
+                    processResearchCompletion(workingDir, voiceSid, task, result, chatHistory, completionSendToChat, sessionBaseDir)
+                        .then(script => {
+                        queueVoiceInjection(getScriptInjection(script));
                     })
                         .catch(() => {
-                        // Fallback: use result directly if fast brain fails
-                        queueVoiceInjection(getResearchCompleteInjection(task, fullResult));
+                        // Fallback: use truncated result directly if fast brain fails
+                        queueVoiceInjection(getScriptInjection(result.substring(0, 500)));
                     });
                 }
                 else {
-                    queueVoiceInjection(getResearchCompleteInjection(task, fullResult));
+                    queueVoiceInjection(getScriptInjection(result.substring(0, 500)));
                 }
-                // Inject FULL untruncated result into ChatCtx so voice model can answer
-                // follow-up questions ("tell me more", "what were those links?") from memory
-                injectIntoChatCtx(`[FULL RESEARCH DETAILS for "${task}"]\n${result}`);
                 // Fire-and-forget JSONL-based refinement pass via fast brain
                 // Reads FULL untruncated data from JSONL — no content buffer, no truncation
                 const postResearchSessionId = currentLLM?.sessionId || resumeSessionId;
                 if (postResearchSessionId) {
-                    updateSpecFromJSONL(workingDir, postResearchSessionId, task, researchLog)
+                    updateSpecFromJSONL(workingDir, postResearchSessionId, task, researchLog, sessionBaseDir)
                         .then(updateResult => {
                         if (!updateResult)
                             return;
                         // Notify frontend about spec.md update
                         if (updateResult.spec) {
-                            const specPath = `${workingDir}/.osborn/sessions/${postResearchSessionId}/spec.md`;
+                            const specPath = `${sessionBaseDir}/.osborn/sessions/${postResearchSessionId}/spec.md`;
                             sendToFrontend({
                                 type: 'research_artifact_updated',
                                 filePath: specPath,
                                 fileName: 'spec.md',
                             });
-                            const truncated = getSpecForVoiceModel(workingDir, postResearchSessionId);
-                            if (truncated) {
-                                injectIntoChatCtx(`[UPDATED SESSION SPEC]\n${truncated}`);
-                                console.log(`📋 Re-injected spec.md into ChatCtx after fast brain update (${truncated.length} chars)`);
-                            }
+                            // Voice model is a teleprompter — fast brain reads spec directly, no ChatCtx injection needed
                         }
                         // Notify frontend about each library file written by the fast brain
                         for (const libFile of updateResult.libraryFiles) {
-                            const libPath = `${workingDir}/.osborn/sessions/${postResearchSessionId}/library/${libFile}`;
+                            const libPath = `${sessionBaseDir}/.osborn/sessions/${postResearchSessionId}/library/${libFile}`;
                             sendToFrontend({
                                 type: 'research_artifact_updated',
                                 filePath: libPath,
@@ -1122,217 +1410,148 @@ async function main() {
                     });
                 }
             }).catch(async (err) => {
-                console.error(`❌ [realtime] Research failed:`, err);
                 // Clean up
                 cleanupListeners();
-                if (researchBatchTimer) {
-                    clearTimeout(researchBatchTimer);
-                    researchBatchTimer = null;
+                const isStillCurrent = activeResearch === thisResearch;
+                if (isStillCurrent) {
+                    if (researchBatchTimer) {
+                        clearTimeout(researchBatchTimer);
+                        researchBatchTimer = null;
+                    }
+                    stopProactiveLoop();
+                    activeResearch = null;
                 }
-                stopProactiveLoop();
-                activeResearch = null;
+                // If aborted (user disconnected), log quietly
+                if (researchAbortController.signal.aborted) {
+                    console.log(`🛑 [realtime] Research aborted: ${task.substring(0, 60)}`);
+                    return;
+                }
+                console.error(`❌ [realtime] Research failed:`, err);
                 // Queue error notification — will be spoken when model is available
-                queueVoiceInjection(`[NOTIFICATION] The research task encountered an error: ${err.message}. Let the user know briefly and ask if they want to try again. Do NOT call any tools.`);
+                queueVoiceInjection(getNotificationInjection(`Research encountered an error: ${err.message}. You could try asking again.`));
             });
             // Return immediately to unblock the voice model
             return 'Research started. I\'ll relay findings as they come in — you can keep talking to the user while I work.';
         }
         // Create tools for the realtime voice LLM
-        const askAgentTool = llm.tool({
-            description: `Delegate a task to your backend agent (Claude), which has full research, analysis, reasoning, and coding capabilities.
-
-Use for:
-- Researching topics, technologies, concepts, or ideas in depth
-- Fetching and analyzing web pages, articles, blog posts, YouTube transcripts
-- Reading and summarizing documentation, papers, or reference materials
-- Exploring and analyzing codebases, configs, architecture
-- Comparing options, tools, approaches — with tradeoffs and recommendations
-- Running bash commands, testing implementations
-- Using MCP tools (GitHub, YouTube, and other external tools)
-- Saving findings to the session library and updating the spec
-- Any question requiring research, analysis, verification, or deeper reasoning
-
-Reformulate the user's spoken request into a clear, specific task.
-The more context you include (topic, constraints, what they want to learn), the better the results.
-If the user wants specific details (examples, URLs, comparisons, step-by-step breakdown), mention that in your request.`,
-            parameters: z.object({
-                request: z.string().describe('The task or question to delegate to the agent'),
-            }),
-            execute: async ({ request: task }) => {
-                console.log(`\n🔨 [realtime] Task: "${task}"`);
-                // Guard: if ask_haiku is currently handling a similar question, skip ask_agent
-                // This prevents the double-calling pattern where Gemini fires both in rapid succession
-                if (haikuInFlight && (Date.now() - haikuInFlight.time) < 8000) {
-                    console.log(`⏭️ Skipping ask_agent — ask_haiku is already handling: "${haikuInFlight.question.substring(0, 60)}"`);
-                    return 'The fast brain is already looking into this. Wait for its answer first.';
-                }
-                // Deduplication guard: prevent re-execution of same task within 10s
-                const now = Date.now();
-                if (task === lastTaskRequest && (now - lastTaskTime) < 10000) {
-                    console.log('⏭️ Skipping duplicate task (within 10s window)');
-                    return 'This task was just completed. The results were already relayed.';
-                }
-                lastTaskRequest = task;
-                lastTaskTime = now;
-                return executeResearch(task);
-            },
-        });
-        const respondPermissionTool = llm.tool({
-            description: `Respond to a permission request. Call after hearing user's response.`,
-            parameters: z.object({
-                response: z.enum(['allow', 'deny', 'always_allow']),
-            }),
-            execute: async ({ response }) => {
-                if (!realtimeClaudeHandler?.hasPendingPermission()) {
-                    return 'No pending permission.';
-                }
-                const pending = realtimeClaudeHandler.getPendingPermission();
-                const allow = response === 'allow' || response === 'always_allow';
-                realtimeClaudeHandler.respondToPermission(allow);
-                await sendToFrontend({ type: 'permission_response', response, toolName: pending?.toolName });
-                return `Permission ${response} for ${pending?.toolName || 'tool'}.`;
-            },
-        });
-        const readSpecTool = llm.tool({
-            description: `Read the session spec (spec.md) — shared state between you and your backend agent.
-Use when: checking decisions, reading open questions to ask the user, understanding architecture/context, seeing what research has been saved. Updated by your backend agent during research.`,
-            parameters: z.object({}),
-            execute: async () => {
-                const sessionId = currentLLM?.sessionId || resumeSessionId;
-                if (!sessionId)
-                    return 'No session spec yet — session is still initializing.';
-                const specContent = readSessionSpec(workingDir, sessionId);
-                if (!specContent)
-                    return 'Spec is empty — no research done yet.';
-                const libraryFiles = listLibraryFiles(workingDir, sessionId);
-                const libSection = libraryFiles.length > 0
-                    ? `\n\n[LIBRARY FILES: ${libraryFiles.join(', ')}]`
-                    : '';
-                const MAX = 4000;
-                const content = specContent.length > MAX
-                    ? specContent.substring(0, MAX) + '\n\n[... truncated]'
-                    : specContent;
-                return content + libSection;
-            },
-        });
-        const askHaikuTool = llm.tool({
-            description: `Ask your fast brain — a quick knowledge assistant with access to session files and web search (~2 seconds).
-
-Use for:
-- Questions answerable from the session spec or research library (much faster than ask_agent)
-- Quick web lookups for simple factual questions (definitions, current versions, basic how-to)
-- Recording user decisions: "User decided: [decision]. Update the spec."
-- Recording user preferences: "User prefers: [preference]. Update the spec."
-- Checking what research has been done on a topic
-- Reading specific library files for details
-
-Do NOT use for: deep research, code analysis, multi-file codebase exploration, complex investigations → use ask_agent.
-If the fast brain responds with NEEDS_DEEPER_RESEARCH, tell the user you need to look deeper, then call ask_agent with the context it provides.`,
+        // The realtime model is a thin teleprompter — only 2 tools:
+        // 1. ask_fast_brain: ALL user questions route here (the fast brain decides everything)
+        // 2. respond_permission: voice permission flow for Claude SDK blocked operations
+        const askFastBrainTool = llm.tool({
+            description: `Ask your brain. Call this for EVERY user message — greetings, questions, decisions, requests, everything. No exceptions. Returns what you should say.`,
             parameters: z.object({
-                question: z.string().describe('The question to ask or instruction to execute'),
+                question: z.string().describe('The user\'s question or statement'),
             }),
             execute: async ({ question }) => {
-                const sessionId = currentLLM?.sessionId || resumeSessionId;
-                if (!sessionId)
-                    return 'Session not ready yet. Try ask_agent instead.';
+                // INJECTION BYPASS: When Gemini receives a system injection via generateReply(),
+                // it calls ask_fast_brain with the injection content (Gemini always calls tools).
+                // For Gemini: this is the INTENDED path — we deliberately don't set toolChoice:'none'
+                //   so the tool call goes through and we return the content as a tool response.
+                // For OpenAI: this is a fallback guard — OpenAI normally speaks instructions directly
+                //   with toolChoice:'none', but if it somehow calls the tool, we handle it here.
+                const injectionMatch = question.match(/\[(SCRIPT|PROACTIVE|NOTIFICATION)\]\s*([\s\S]*)/);
+                if (injectionMatch) {
+                    const content = injectionMatch[2].trim();
+                    console.log(`⚡ [fast brain] BYPASS: injection [${injectionMatch[1]}] → returning content directly (${content.length} chars)`);
+                    return content || question;
+                }
+                // Use pending sessionId for fresh sessions where SDK hasn't assigned one yet
+                const sessionId = currentLLM?.sessionId || currentResumeSessionId || resumeSessionId || 'pending';
                 console.log(`🧠 [fast brain] Question: "${question.substring(0, 80)}..."`);
-                // Track in-flight state to prevent ask_agent double-calling
+                // Track in-flight state
                 haikuInFlight = { question, time: Date.now() };
-                // Build live research context if the agent is actively researching
-                // This is a READ of the existing researchLog array — safe, no race conditions
+                // Build research context — from active research or last completed research
                 let researchContext;
                 if (activeResearch && activeResearch.researchLog.length > 0) {
                     const recentLog = activeResearch.researchLog.slice(-15);
                     researchContext = `Research topic: "${lastTaskRequest || 'unknown'}"\nSteps completed (${activeResearch.researchLog.length} total, showing last ${recentLog.length}):\n${recentLog.join('\n')}`;
                 }
+                else if (lastCompletedResearch && (Date.now() - lastCompletedResearch.completedAt) < 600000) {
+                    // Include context from last completed research (within 10 minutes)
+                    const recentLog = lastCompletedResearch.researchLog.slice(-15);
+                    researchContext = `[COMPLETED RESEARCH] Topic: "${lastCompletedResearch.task}"\nSteps completed (${lastCompletedResearch.researchLog.length} total, showing last ${recentLog.length}):\n${recentLog.join('\n')}\n\n(Research completed — results are in JSONL and spec.md. Answer from those, do NOT trigger new research on this topic.)`;
+                }
+                const callbacks = {
+                    triggerResearch: (task) => {
+                        // Deduplication guard
+                        const now = Date.now();
+                        if (task === lastTaskRequest && (now - lastTaskTime) < 10000) {
+                            console.log('⏭️ Skipping duplicate research task (within 10s window)');
+                            return;
+                        }
+                        lastTaskRequest = task;
+                        lastTaskTime = now;
+                        executeResearch(task);
+                    },
+                    queueVoice: (script) => {
+                        queueVoiceInjection(getScriptInjection(script));
+                    },
+                    sendToFrontend: (data) => {
+                        sendToFrontend(data);
+                    },
+                };
                 try {
                     const chatHistory = getChatHistory(20);
-                    const answer = await askHaiku(workingDir, sessionId, question, researchContext, chatHistory);
-                    haikuInFlight = null; // Clear in-flight state
-                    console.log(`🧠 [fast brain] Answer (${answer.length} chars)`);
-                    // Notify frontend if the fast brain likely wrote to spec.md
-                    // (fast brain writes bypass the SDK tool system, so no tool_result event fires)
-                    if (answer.includes('Written: spec.md') || question.toLowerCase().includes('update the spec') || question.toLowerCase().includes('user decided') || question.toLowerCase().includes('user prefers')) {
-                        const specPath = `${workingDir}/.osborn/sessions/${sessionId}/spec.md`;
-                        sendToFrontend({
-                            type: 'research_artifact_updated',
-                            filePath: specPath,
-                            fileName: 'spec.md',
-                        });
+                    const result = await askFastBrain(workingDir, sessionId, question, {
+                        chatHistory,
+                        researchContext,
+                        callbacks,
+                        sessionBaseDir,
+                    });
+                    haikuInFlight = null;
+                    // Voice queue items may have been held while fast brain was in flight — retry now
+                    if (voiceQueue.length > 0) {
+                        setTimeout(() => processVoiceQueue(), 500);
                     }
-                    // If research is active and this was a user decision/direction,
-                    // also queue it for the agent SDK so it picks up the context
-                    // when its queue reaches the next query
-                    if (activeResearch && (question.toLowerCase().includes('user decided') ||
-                        question.toLowerCase().includes('user prefers') ||
-                        question.toLowerCase().includes('update the spec') ||
-                        question.toLowerCase().includes('also check') ||
+                    console.log(`🧠 [fast brain] Response type: ${result.type}, script: ${result.script.length} chars`);
+                    // If this was a user direction during active research,
+                    // pass it to the agent SDK so it picks up the context
+                    if (activeResearch && result.type === 'recorded' && (question.toLowerCase().includes('decided') ||
+                        question.toLowerCase().includes('prefers') ||
                         question.toLowerCase().includes('focus on') ||
                         question.toLowerCase().includes('redirect'))) {
-                        console.log(`📨 [fast brain] Passing user direction to agent SDK queue: "${question.substring(0, 60)}..."`);
-                        // Queue as a lightweight context update — agent reads spec.md
-                        // at the start of its next query and will see the updated direction
-                        executeResearch(`[USER DIRECTION during active research] ${question}. The user's spec.md has been updated with this. Acknowledge briefly and incorporate into your current research context.`);
+                        console.log(`📨 [fast brain] Passing user direction to agent SDK queue`);
+                        executeResearch(`[USER DIRECTION during active research] ${question}. The user's spec.md has been updated. Acknowledge briefly and incorporate.`);
                     }
-                    return answer;
+                    return result.script;
                 }
                 catch (err) {
-                    haikuInFlight = null; // Clear in-flight state on error
+                    haikuInFlight = null;
+                    // Voice queue items may have been held while fast brain was in flight — retry now
+                    if (voiceQueue.length > 0) {
+                        setTimeout(() => processVoiceQueue(), 500);
+                    }
                     console.error('❌ Fast brain failed:', err);
-                    return 'Fast brain lookup failed. Try ask_agent for a deeper search.';
+                    return 'I\'m having trouble processing that. Could you try again?';
                 }
             },
         });
-        const generateDocumentTool = llm.tool({
-            description: `Generate a visual document (comparison table, Mermaid diagram, structured analysis, summary) from research findings. Saved to the session library as a markdown file.
-
-Use when the user asks for:
-- "Compare X and Y" → type: 'comparison' (markdown table with features, pros, cons)
-- "Draw a diagram" / "Show the architecture" / "Map out the flow" → type: 'diagram' (Mermaid flowchart/sequence/architecture)
-- "Analyze the tradeoffs" / "Break down the options" → type: 'analysis' (structured pros/cons, decision matrix)
-- "Summarize what we found" / "Give me an overview document" → type: 'summary' (organized findings with key takeaways)
-
-For actual images (photos, illustrations, screenshots), use ask_agent instead — this tool generates text-based visual documents only.`,
+        const respondPermissionTool = llm.tool({
+            description: `Respond to a permission request. Call after hearing user's response.`,
             parameters: z.object({
-                request: z.string().describe('What to generate — be specific about the topic and what aspects to cover'),
-                type: z.enum(['comparison', 'diagram', 'analysis', 'summary']).describe('Document type'),
+                response: z.enum(['allow', 'deny', 'always_allow']),
             }),
-            execute: async ({ request, type }) => {
-                const sid = currentLLM?.sessionId || resumeSessionId;
-                if (!sid)
-                    return 'Session not ready yet.';
-                console.log(`📊 [generate_document] Type: ${type}, Request: "${request.substring(0, 60)}..."`);
-                try {
-                    const result = await generateVisualDocument(workingDir, sid, request, type);
-                    if (!result)
-                        return 'Could not generate document — not enough research context available.';
-                    const fullPath = `${workingDir}/.osborn/sessions/${sid}/library/${result.fileName}`;
-                    sendToFrontend({
-                        type: 'research_artifact_updated',
-                        filePath: fullPath,
-                        fileName: result.fileName,
-                    });
-                    return `Generated: ${result.fileName} (${result.content.length} chars) — saved to session library. The document contains a ${type} with the requested information.`;
-                }
-                catch (err) {
-                    console.error('❌ Document generation failed:', err);
-                    return 'Document generation failed. Try asking the research agent for a more detailed analysis.';
+            execute: async ({ response }) => {
+                if (!realtimeClaudeHandler?.hasPendingPermission()) {
+                    return 'No pending permission.';
                 }
+                const pending = realtimeClaudeHandler.getPendingPermission();
+                const allow = response === 'allow' || response === 'always_allow';
+                realtimeClaudeHandler.respondToPermission(allow);
+                await sendToFrontend({ type: 'permission_response', response, toolName: pending?.toolName });
+                return `Permission ${response} for ${pending?.toolName || 'tool'}.`;
             },
         });
         // Instructions for realtime voice LLM
         const realtimeInstructions = getRealtimeInstructions(workingDir);
         // Create realtime model
         const realtimeModel = createRealtimeModelFromConfig(rtConfig, realtimeInstructions);
-        // Create the Agent with realtime model and tools
+        // Create the Agent with MINIMAL tools — fast brain handles all routing
         const agent = new voice.Agent({
             instructions: realtimeInstructions,
             llm: realtimeModel,
             tools: {
-                ask_agent: askAgentTool,
-                ask_haiku: askHaikuTool,
-                read_spec: readSpecTool,
-                generate_document: generateDocumentTool,
+                ask_fast_brain: askFastBrainTool,
                 respond_permission: respondPermissionTool,
             },
         });
@@ -1352,35 +1571,51 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
         // Clean up active research and voice queue
         voiceQueue.length = 0;
         isProcessingQueue = false;
+        currentSpeechHandle = null;
+        lastInterruption = null;
         if (researchBatchTimer) {
             clearTimeout(researchBatchTimer);
             researchBatchTimer = null;
         }
         stopProactiveLoop();
         if (activeResearch) {
+            activeResearch.abortController.abort();
             activeResearch.cleanup();
             activeResearch = null;
         }
+        lastCompletedResearch = null;
         currentSession = null;
         currentAgent = null;
         currentLLM = null;
-        clearFastBrainHistory();
+        clearFastBrainSession();
+        clearPipelineFastBrainSession();
     });
     room.on(RoomEvent.ParticipantConnected, async (participant) => {
         console.log(`\n👤 User joined: ${participant.identity}`);
+        // Wait for previous session's byte stream handler to fully deregister.
+        // Quick reconnects (< ~6s) crash with "byte stream handler already set" without this.
+        if (pendingSessionClose) {
+            console.log('⏳ Waiting for previous session to fully close...');
+            await pendingSessionClose;
+        }
         // Clean up any existing session before creating a new one
         voiceQueue.length = 0;
         isProcessingQueue = false;
+        currentSpeechHandle = null;
+        lastInterruption = null;
         if (researchBatchTimer) {
             clearTimeout(researchBatchTimer);
             researchBatchTimer = null;
         }
         stopProactiveLoop();
-        clearFastBrainHistory();
+        clearFastBrainSession();
+        clearPipelineFastBrainSession();
         if (activeResearch) {
+            activeResearch.abortController.abort();
             activeResearch.cleanup();
             activeResearch = null;
         }
+        lastCompletedResearch = null;
         if (currentSession) {
             console.log('🧹 Cleaning up previous session...');
             try {
@@ -1403,7 +1638,7 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
         try {
             const metadata = JSON.parse(participant.metadata || '{}');
             console.log(`📋 Participant metadata:`, metadata);
-            if (metadata.voiceArch === 'realtime' || metadata.voiceArch === 'direct') {
+            if (metadata.voiceArch === 'realtime' || metadata.voiceArch === 'direct' || metadata.voiceArch === 'pipeline') {
                 sessionVoiceMode = metadata.voiceArch;
                 console.log(`🎙️ Using voice mode from frontend: ${sessionVoiceMode}`);
             }
@@ -1420,6 +1655,15 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                 preSelectedSessionId = metadata.sessionId;
                 console.log(`📂 Pre-selected session from frontend: ${preSelectedSessionId}`);
             }
+            // Read working directory override from frontend
+            if (metadata.workingDirectory && typeof metadata.workingDirectory === 'string' && metadata.workingDirectory.length > 0) {
+                workingDir = metadata.workingDirectory;
+                console.log(`📂 Working directory from frontend: ${workingDir}`);
+            }
+            else {
+                // Reset to default for new connections (in case previous session changed it)
+                workingDir = defaultWorkingDir;
+            }
         }
         catch (err) {
             console.log('⚠️ Could not parse participant metadata, using config voiceMode:', voiceMode);
@@ -1429,12 +1673,33 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
         currentProvider = sessionRealtimeProvider;
         // Resume session ID — only set when resuming an existing session
         const resumeSessionId = preSelectedSessionId || undefined;
+        currentResumeSessionId = resumeSessionId;
         if (resumeSessionId) {
             console.log(`🆔 Resuming session: ${resumeSessionId}`);
         }
         else {
             console.log(`🆔 New session (ID assigned by SDK)`);
         }
+        // Ensure Claude is authenticated before creating voice session
+        // In cloud deployments (Fly.io), this triggers OAuth flow on first boot:
+        // captures login URL → sends to frontend → user clicks → gets code → pastes in frontend → auth completes
+        try {
+            const authResult = await ensureClaudeAuth((type, payload) => {
+                sendToFrontend({ type, ...payload });
+            });
+            // If auth flow is running, store the submitCode handler for the DataReceived handler
+            if (authResult.submitCode && authResult.done) {
+                pendingAuthSubmitCode = authResult.submitCode;
+                await authResult.done;
+                pendingAuthSubmitCode = null;
+            }
+        }
+        catch (err) {
+            console.error('❌ Claude authentication failed:', err?.message);
+            sendToFrontend({ type: 'claude_auth_error', message: err?.message || 'Authentication failed' });
+            pendingAuthSubmitCode = null;
+            // Continue anyway — the agent SDK will use ANTHROPIC_API_KEY if available
+        }
         // Create session based on voice mode (from frontend or config)
         let session;
         let agent;
@@ -1446,6 +1711,46 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
             session = result.session;
             agent = result.agent;
         }
+        else if (sessionVoiceMode === 'pipeline') {
+            console.log(`🎯 PIPELINE MODE: Claude SDK + parallel Gemini fast brain observer`);
+            // Pipeline mode = direct mode underneath + parallel fast brain
+            // Fast brain runs in PipelineDirectLLM.chat() — fires Gemini alongside Claude
+            const { createPipelineDirectLLM } = await import('./pipeline-direct-llm.js');
+            const pipelineLLM = createPipelineDirectLLM({
+                workingDirectory: workingDir,
+                sessionBaseDir,
+                mcpServers,
+                resumeSessionId,
+                voiceMode: 'direct',
+                skipTTSQueue: true,
+                getChatHistory: () => getChatHistory(20).map(t => ({ role: t.role, content: t.text })),
+                getResearchContext: () => {
+                    if (activeResearch?.researchLog.length) {
+                        return `Research: "${lastTaskRequest}"\n${activeResearch.researchLog.slice(-15).join('\n')}`;
+                    }
+                    if (lastCompletedResearch && Date.now() - lastCompletedResearch.completedAt < 600000) {
+                        return `[COMPLETED] "${lastCompletedResearch.task}"\n${lastCompletedResearch.researchLog.slice(-15).join('\n')}`;
+                    }
+                },
+                getAndConsumeInterruptionContext,
+                onFastBrainResult: (result) => {
+                    console.log(`🧠⚡ [FAST_BRAIN ${result.type.toUpperCase()} +${result.elapsedMs}ms]: "${result.answer.substring(0, 60)}"`);
+                    sendToFrontend({
+                        type: 'fast_brain_response',
+                        text: result.answer,
+                        responseType: result.type,
+                        elapsedMs: result.elapsedMs,
+                        question: result.question,
+                        toolsUsed: result.toolsUsed,
+                        agentRole: 'pipeline-fast-brain',
+                    });
+                },
+            });
+            // Pass pipelineLLM to createDirectSession so it uses it instead of creating a new ClaudeLLM
+            const result = await createDirectSession(resumeSessionId, pipelineLLM);
+            session = result.session;
+            agent = result.agent;
+        }
         else {
             console.log(`🎯 DIRECT MODE: Claude Agent SDK with full coding capabilities`);
             const result = await createDirectSession(resumeSessionId);
@@ -1458,7 +1763,7 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
         // Session event wiring — extracted into function for auto-recovery
         // ============================================================
         let lastRecoveryTime = 0;
-        const MIN_RECOVERY_INTERVAL = 10000; // 10 seconds between recovery attempts
+        const MIN_RECOVERY_INTERVAL = 3000; // 3 seconds between recovery attempts
         function wireSessionEvents(sess, agt) {
             // Transcript dedup state (reset per wiring)
             let lastSentUserTranscript = '';
@@ -1471,6 +1776,10 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                     return;
                 if (normalized === '<noise>' || normalized.toLowerCase() === 'thank you')
                     return;
+                // Filter out voice injection content that appears as user transcript
+                // (Gemini v1.0.51: userInput in generateReply creates a user conversation item)
+                if (normalized.startsWith('[SCRIPT]') || normalized.startsWith('[PROACTIVE]') || normalized.startsWith('[NOTIFICATION]'))
+                    return;
                 console.log(`📝 User (${source}): "${transcript.substring(0, 60)}..."`);
                 sendToFrontend({ type: 'user_transcript', text: transcript });
                 lastSentUserTranscript = normalized;
@@ -1527,6 +1836,10 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
             sess.on('user_state_changed', (ev) => {
                 userState = ev.newState;
                 console.log(`👤 User state: ${ev.newState}`);
+                // When user stops speaking, retry voice queue — items may be waiting
+                if (ev.newState === 'listening' && voiceQueue.length > 0) {
+                    setTimeout(() => processVoiceQueue(), 500);
+                }
             });
             // FALLBACK: playout_completed
             sess.on('playout_completed', (ev) => {
@@ -1543,13 +1856,153 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                     console.log('⚠️ OpenAI active response collision — queue will retry on next listening state');
                     return;
                 }
+                // TTS abort from user interruption is normal — not an error
+                if (msg.includes('Request was aborted') || msg.includes('APIUserAbortError') || msg.includes('aborted')) {
+                    console.log('⚠️ LLM request aborted (user interrupted)');
+                    return;
+                }
                 console.error('❌ Session error:', ev.error);
             });
-            // Close handler with auto-recovery for Gemini 1008 crashes
+            // Capture voice mode at session creation — prevents state confusion
+            // if currentVoiceMode changes between session start and crash recovery
+            const sessionVoiceMode = currentVoiceMode;
+            // Close handler with auto-recovery for crashes (both realtime and direct modes)
             sess.on('close', async (ev) => {
                 console.log('🚪 Session closed:', ev.reason);
+                // TTS abort from user interruption — SDK already killed the session internally,
+                // so we MUST recover (can't just reset state — STT pipeline is dead).
+                // Log it distinctly so we know it's an interrupt recovery, not a real crash.
+                const errorMsg = ev.error?.message || ev.error?.error?.message || '';
+                const isTTSAbort = errorMsg.includes('aborted') || errorMsg.includes('APIUserAbortError');
+                if (isTTSAbort) {
+                    console.log('⚠️ TTS abort from user interruption — recovering session (SDK killed it internally)');
+                }
+                // Auto-recover from crashes in direct/pipeline mode (includes TTS abort)
+                if ((ev.reason === 'error' || ev.reason === 'disconnected') && (sessionVoiceMode === 'direct' || sessionVoiceMode === 'pipeline')) {
+                    const now = Date.now();
+                    if (now - lastRecoveryTime < MIN_RECOVERY_INTERVAL) {
+                        console.log(`⚠️ Recovery too frequent — scheduling retry in ${MIN_RECOVERY_INTERVAL}ms`);
+                        setTimeout(async () => {
+                            // Re-check: if session was already recovered or user left, skip
+                            if (currentSession || !room.remoteParticipants.size)
+                                return;
+                            console.log('🔄 Retrying direct mode recovery after guard interval...');
+                            // Trigger recovery by emitting a synthetic close
+                            sess.emit('close', { reason: 'error' });
+                        }, MIN_RECOVERY_INTERVAL);
+                        return;
+                    }
+                    lastRecoveryTime = now;
+                    console.log(`🔄 Auto-recovering direct mode session (reason: ${ev.reason})...`);
+                    // Clean up dead session — match realtime recovery's thoroughness
+                    try {
+                        sess.removeAllListeners();
+                    }
+                    catch { }
+                    currentSession = null;
+                    currentAgent = null;
+                    // Clear stale state from crashed session
+                    voiceQueue.length = 0;
+                    isProcessingQueue = false;
+                    haikuInFlight = null;
+                    if (researchBatchTimer) {
+                        clearTimeout(researchBatchTimer);
+                        researchBatchTimer = null;
+                    }
+                    stopProactiveLoop();
+                    if (activeResearch) {
+                        activeResearch.abortController.abort();
+                        activeResearch.cleanup();
+                        activeResearch = null;
+                    }
+                    try {
+                        // Reuse existing session ID so Claude SDK resumes where it left off
+                        const recoverySessionId = currentLLM?.sessionId || resumeSessionId;
+                        // Stop old index watcher if it exists
+                        if (currentLLM && 'stopIndexWatcher' in currentLLM) {
+                            currentLLM.stopIndexWatcher();
+                        }
+                        let result;
+                        if (sessionVoiceMode === 'pipeline') {
+                            // Pipeline mode: recreate PipelineDirectLLM wrapper with fast brain
+                            console.log('🔄 Rebuilding pipeline mode (PipelineDirectLLM + fast brain)...');
+                            const { createPipelineDirectLLM } = await import('./pipeline-direct-llm.js');
+                            const pipelineLLM = createPipelineDirectLLM({
+                                workingDirectory: workingDir,
+                                sessionBaseDir,
+                                mcpServers,
+                                resumeSessionId: recoverySessionId,
+                                voiceMode: 'direct',
+                                skipTTSQueue: true,
+                                getChatHistory: () => getChatHistory(20).map(t => ({ role: t.role, content: t.text })),
+                                getResearchContext: () => {
+                                    if (activeResearch?.researchLog.length) {
+                                        return `Research: "${lastTaskRequest}"\n${activeResearch.researchLog.slice(-15).join('\n')}`;
+                                    }
+                                    if (lastCompletedResearch && Date.now() - lastCompletedResearch.completedAt < 600000) {
+                                        return `[COMPLETED] "${lastCompletedResearch.task}"\n${lastCompletedResearch.researchLog.slice(-15).join('\n')}`;
+                                    }
+                                },
+                                getAndConsumeInterruptionContext,
+                                onFastBrainResult: (r) => {
+                                    console.log(`🧠⚡ [FAST_BRAIN ${r.type.toUpperCase()} +${r.elapsedMs}ms]: "${r.answer.substring(0, 60)}"`);
+                                    sendToFrontend({
+                                        type: 'fast_brain_response', text: r.answer, responseType: r.type,
+                                        elapsedMs: r.elapsedMs, question: r.question, toolsUsed: r.toolsUsed,
+                                        agentRole: 'pipeline-fast-brain',
+                                    });
+                                },
+                            });
+                            result = await createDirectSession(recoverySessionId, pipelineLLM);
+                        }
+                        else {
+                            result = await createDirectSession(recoverySessionId);
+                        }
+                        const newSession = result.session;
+                        const newAgent = result.agent;
+                        currentSession = newSession;
+                        currentAgent = newAgent;
+                        // Re-wire event listeners on the new session
+                        wireSessionEvents(newSession, newAgent);
+                        await newSession.start({ agent: newAgent, room });
+                        // Sync state
+                        agentState = 'listening';
+                        sendToFrontend({ type: 'agent_state', state: 'listening' });
+                        // Resume Claude session if one was active
+                        if (currentLLM?.sessionId) {
+                            currentLLM.setContinueSession(true);
+                        }
+                        console.log('✅ Direct mode auto-recovery complete');
+                        // Notify user via TTS
+                        try {
+                            const recoveredId = currentLLM?.sessionId || recoverySessionId;
+                            if (recoveredId) {
+                                const conversationHistory = await getConversationHistory(recoveredId, workingDir, 10);
+                                const historyForScript = conversationHistory.map(e => ({ role: e.role, text: e.content }));
+                                const script = await prepareRecoveryScript(historyForScript);
+                                // Direct mode: use session.say() for recovery notification
+                                newSession.say(script, { allowInterruptions: true });
+                            }
+                            else {
+                                newSession.say('Voice session was briefly interrupted but I\'m back. What were we working on?', { allowInterruptions: true });
+                            }
+                        }
+                        catch (err) {
+                            console.log('⚠️ Failed to generate recovery script:', err);
+                            try {
+                                newSession.say('I\'m back after a brief interruption. What were we working on?', { allowInterruptions: true });
+                            }
+                            catch { }
+                        }
+                    }
+                    catch (err) {
+                        console.error('❌ Direct mode auto-recovery failed:', err);
+                        sendToFrontend({ type: 'agent_state', state: 'error' });
+                    }
+                    return;
+                }
                 // Auto-recover from crashes in realtime mode
-                if (ev.reason === 'error' && currentVoiceMode === 'realtime') {
+                if (ev.reason === 'error' && sessionVoiceMode === 'realtime') {
                     const now = Date.now();
                     if (now - lastRecoveryTime < MIN_RECOVERY_INTERVAL) {
                         console.log('⚠️ Recovery too frequent — skipping to prevent loop');
@@ -1574,6 +2027,7 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                     }
                     stopProactiveLoop();
                     if (activeResearch) {
+                        activeResearch.abortController.abort();
                         activeResearch.cleanup();
                         activeResearch = null;
                     }
@@ -1597,29 +2051,23 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                         if (currentLLM?.sessionId) {
                             currentLLM.setContinueSession(true);
                         }
-                        // Inject conversation context into the recovered session
+                        // Generate recovery script via fast brain
                         const recoveredSessionId = currentLLM?.sessionId || recoverySessionId;
                         if (recoveredSessionId) {
                             try {
-                                const summary = await getSessionSummary(recoveredSessionId, workingDir);
-                                const conversationHistory = await getConversationHistory(recoveredSessionId, workingDir, 30);
-                                if (summary && conversationHistory.length > 0) {
-                                    const contextBriefing = buildContextBriefing(summary, conversationHistory, currentProvider);
-                                    queueVoiceInjection(`[SESSION RECOVERED] The voice session crashed and was auto-recovered. Here's the conversation context from before the crash:\n${contextBriefing}\n\nBriefly tell the user the connection was interrupted and you still have context from the conversation. Ask if they can hear you and what they'd like to continue with. Do NOT call any tools.`);
-                                    console.log('📋 Injected conversation context into recovered session');
-                                }
-                                else {
-                                    queueVoiceInjection('[NOTIFICATION] The voice session was briefly interrupted but has been recovered. Ask the user if they can hear you and continue where you left off. Do NOT call any tools.');
-                                }
+                                const conversationHistory = await getConversationHistory(recoveredSessionId, workingDir, 10);
+                                const historyForScript = conversationHistory.map(e => ({ role: e.role, text: e.content }));
+                                const script = await prepareRecoveryScript(historyForScript);
+                                queueVoiceInjection(getScriptInjection(script));
+                                console.log('📋 Injected recovery script into recovered session');
                             }
                             catch (err) {
-                                console.log('⚠️ Failed to load conversation context for recovery:', err);
-                                queueVoiceInjection('[NOTIFICATION] The voice session was briefly interrupted but has been recovered. Ask the user if they can hear you and continue where you left off. Do NOT call any tools.');
+                                console.log('⚠️ Failed to generate recovery script:', err);
+                                queueVoiceInjection(getNotificationInjection('Voice session was briefly interrupted but I\'m back. What were we working on?'));
                             }
                         }
                         else {
-                            // No session ID — generic notification
-                            queueVoiceInjection('[NOTIFICATION] The voice session was briefly interrupted but has been recovered. Ask the user if they can hear you and continue where you left off. Do NOT call any tools.');
+                            queueVoiceInjection(getNotificationInjection('Voice session was briefly interrupted but I\'m back. What were we working on?'));
                         }
                         console.log('✅ Auto-recovery complete');
                     }
@@ -1667,6 +2115,8 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                     preSelectedSessionId,
                     mcpServers: getMcpServerStatusList(config),
                     enabledMcpServers: enabledMcpNames,
+                    workingDirectory: workingDir,
+                    skills: loadSkillsList(sessionBaseDir),
                 });
             };
             const readyInterval = setInterval(sendReady, 2000);
@@ -1685,8 +2135,8 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
             // For direct mode: use say() which goes through the configured TTS
             const greetViaVoice = async (text) => {
                 if (sessionVoiceMode === 'realtime') {
-                    // Realtime models handle their own speech generation
-                    await session.generateReply({ userInput: text });
+                    // Use instructions (not userInput) to avoid system text appearing as user transcript
+                    await session.generateReply({ instructions: getScriptInjection(text) });
                 }
                 else {
                     await session.say(text);
@@ -1707,7 +2157,7 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                         success: true,
                     });
                     // Send existing workspace artifacts to frontend (session-scoped)
-                    const preArtifacts = listWorkspaceArtifacts(workingDir, preSelectedSessionId);
+                    const preArtifacts = listWorkspaceArtifacts(sessionBaseDir, preSelectedSessionId);
                     if (preArtifacts.length > 0) {
                         console.log(`📁 Sending ${preArtifacts.length} workspace artifacts to frontend`);
                         await sendToFrontend({
@@ -1721,18 +2171,14 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                             }))
                         });
                     }
-                    // Load full session history into realtime model's context
+                    // Generate briefing script via fast brain
                     if (summary) {
                         loadSessionHistoryIntoChatCtx(currentAgent, conversationHistory, currentProvider);
-                        const contextBriefing = buildContextBriefing(summary, conversationHistory, currentProvider);
-                        const specContent = getSpecForVoiceModel(workingDir, preSelectedSessionId);
-                        const specSection = specContent
-                            ? `\n\n=== SESSION SPEC ===\n${specContent}\n=== END SPEC ===\nCheck "Open Questions" — if any are unanswered, ask the user about them.`
-                            : '';
                         try {
                             if (sessionVoiceMode === 'realtime') {
-                                const contextPrompt = `[SESSION RESUMED] The user chose to continue a previous research session. Here's the context:\n${contextBriefing}${specSection}\n\nBriefly acknowledge the previous session. If there are open questions in the spec, ask the most important one. Otherwise ask what they'd like to continue with.`;
-                                await session.generateReply({ instructions: contextPrompt });
+                                const historyForScript = conversationHistory.map(e => ({ role: e.role, text: e.content }));
+                                const script = await prepareBriefingScript(sessionBaseDir, preSelectedSessionId, historyForScript);
+                                await session.generateReply({ instructions: getScriptInjection(script) });
                             }
                             else {
                                 await session.say("Welcome back! Ready to continue our previous conversation.");
@@ -1752,7 +2198,7 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                 // No sessions at all (or new session chosen) — greet as new user
                 try {
                     console.log('👋 Sending greeting...');
-                    await greetViaVoice("The user just connected for the first time. Briefly greet them as Osborn and ask what they're working on.");
+                    await greetViaVoice("Hey! I'm Osborn, your AI research assistant. What are you working on today?");
                     console.log('✅ Greeting sent');
                 }
                 catch (err) {
@@ -1766,11 +2212,41 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
     });
     room.on(RoomEvent.ParticipantDisconnected, (participant) => {
         console.log(`👋 User left: ${participant.identity}`);
+        // Full cleanup — stop all background work to avoid accumulating API usage
+        voiceQueue.length = 0;
+        isProcessingQueue = false;
+        currentSpeechHandle = null;
+        lastInterruption = null;
+        if (researchBatchTimer) {
+            clearTimeout(researchBatchTimer);
+            researchBatchTimer = null;
+        }
+        stopProactiveLoop();
+        if (activeResearch) {
+            activeResearch.abortController.abort();
+            activeResearch.cleanup();
+            activeResearch = null;
+        }
         if (currentSession) {
-            currentSession.removeAllListeners();
+            const sessionToClose = currentSession;
             currentSession = null;
-            currentLLM = null;
+            // Track async close so new connections can wait for byte stream handler to be released
+            pendingSessionClose = (async () => {
+                try {
+                    await sessionToClose.close();
+                }
+                catch { }
+                try {
+                    sessionToClose.removeAllListeners();
+                }
+                catch { }
+                pendingSessionClose = null;
+            })();
         }
+        currentAgent = null;
+        currentLLM = null;
+        clearFastBrainSession();
+        clearPipelineFastBrainSession();
         console.log('⏳ Waiting for new user...\n');
     });
     room.on(RoomEvent.DataReceived, async (payload, participant, kind, topic) => {
@@ -1779,10 +2255,20 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
         try {
             const data = JSON.parse(new TextDecoder().decode(payload));
             console.log('📨 Data:', data.type);
-            if (data.type === 'permission_response') {
+            if (data.type === 'claude_auth_code' && pendingAuthSubmitCode) {
+                console.log('🔑 Received auth code from frontend');
+                sendToFrontend({ type: 'claude_auth_submitting', message: 'Submitting code to Claude CLI...' });
+                pendingAuthSubmitCode(data.code);
+            }
+            else if (data.type === 'permission_response') {
                 // Handle permission response for direct mode
                 if (currentLLM && currentLLM.hasPendingPermission?.()) {
                     const allow = data.response === 'allow' || data.response === 'always_allow';
+                    // Track always_allow paths for this session so future requests auto-approve
+                    if (data.response === 'always_allow' && data.filePath) {
+                        sessionAlwaysAllowPaths.add(String(data.filePath));
+                        console.log(`🔒 Always-allow added for session: ${data.filePath}`);
+                    }
                     currentLLM.respondToPermission(allow);
                     console.log(`✅ Permission: ${data.response}`);
                 }
@@ -1833,6 +2319,7 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                 const sessionId = data.sessionId;
                 if (sessionId && sessionExists(sessionId, workingDir)) {
                     currentLLM.setResumeSessionId(sessionId);
+                    currentResumeSessionId = sessionId;
                     console.log(`🔄 Will resume session: ${sessionId}`);
                     await sendToFrontend({
                         type: 'session_resume_set',
@@ -1840,7 +2327,7 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                         success: true,
                     });
                     // Send existing session artifacts to frontend (session-scoped)
-                    const artifacts = listWorkspaceArtifacts(workingDir, sessionId);
+                    const artifacts = listWorkspaceArtifacts(sessionBaseDir, sessionId);
                     if (artifacts.length > 0) {
                         console.log(`📁 Sending ${artifacts.length} session artifacts to frontend`);
                         await sendToFrontend({
@@ -1869,6 +2356,7 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                 const recentId = await getMostRecentSessionId(workingDir);
                 if (recentId) {
                     currentLLM.setResumeSessionId(recentId);
+                    currentResumeSessionId = recentId;
                     console.log(`🔄 Continuing most recent session: ${recentId}`);
                     const summary = await getSessionSummary(recentId, workingDir);
                     const conversationHistory = await getConversationHistory(recentId, workingDir, 30);
@@ -1878,7 +2366,7 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                         success: true,
                     });
                     // Send existing session artifacts to frontend (session-scoped)
-                    const artifacts = listWorkspaceArtifacts(workingDir, recentId);
+                    const artifacts = listWorkspaceArtifacts(sessionBaseDir, recentId);
                     if (artifacts.length > 0) {
                         console.log(`📁 Sending ${artifacts.length} session artifacts to frontend`);
                         await sendToFrontend({
@@ -1894,16 +2382,12 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                     }
                     if (currentSession && summary) {
                         loadSessionHistoryIntoChatCtx(currentAgent, conversationHistory, currentProvider);
-                        const contextBriefing = buildContextBriefing(summary, conversationHistory, currentProvider);
-                        const specContent = getSpecForVoiceModel(workingDir, recentId);
-                        const specSection = specContent
-                            ? `\n\n=== SESSION SPEC ===\n${specContent}\n=== END SPEC ===\nCheck "Open Questions" — if any are unanswered, ask the user about them.`
-                            : '';
                         console.log('📋 Injecting session context into voice agent...');
                         try {
                             if (currentVoiceMode === 'realtime') {
-                                const contextPrompt = `[SESSION RESUMED] The user chose to continue their most recent research session. Here's the context:\n${contextBriefing}${specSection}\n\nBriefly acknowledge the previous session. If there are open questions in the spec, ask the most important one. Otherwise ask what they'd like to continue with.`;
-                                await currentSession.generateReply({ instructions: contextPrompt });
+                                const historyForScript = conversationHistory.map(e => ({ role: e.role, text: e.content }));
+                                const script = await prepareBriefingScript(sessionBaseDir, recentId, historyForScript);
+                                await currentSession.generateReply({ instructions: getScriptInjection(script) });
                             }
                             else {
                                 await currentSession.say("Continuing where we left off.");
@@ -1934,7 +2418,9 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                     // Step 2: Reset LLM state and configure for new session
                     currentLLM.resetForSessionSwitch();
                     currentLLM.setResumeSessionId(sessionId);
-                    clearFastBrainHistory();
+                    currentResumeSessionId = sessionId;
+                    clearFastBrainSession();
+                    clearPipelineFastBrainSession();
                     console.log(`🔄 Switched to session: ${sessionId}`);
                     // Step 3: Send full context to frontend (including conversation history)
                     await sendToFrontend({
@@ -1945,7 +2431,7 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                         conversationHistory,
                     });
                     // Step 3.5: Send existing session artifacts to frontend (session-scoped)
-                    const switchArtifacts = listWorkspaceArtifacts(workingDir, sessionId);
+                    const switchArtifacts = listWorkspaceArtifacts(sessionBaseDir, sessionId);
                     if (switchArtifacts.length > 0) {
                         console.log(`📁 Sending ${switchArtifacts.length} session artifacts to frontend`);
                         await sendToFrontend({
@@ -1959,14 +2445,14 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                             }))
                         });
                     }
-                    // Step 4: Voice agent acknowledges context
+                    // Step 4: Voice agent acknowledges context via fast brain
                     if (currentSession && summary) {
                         loadSessionHistoryIntoChatCtx(currentAgent, conversationHistory, currentProvider);
-                        const contextBriefing = buildContextBriefing(summary, conversationHistory, currentProvider);
                         try {
                             if (currentVoiceMode === 'realtime') {
-                                const contextPrompt = `[SESSION SWITCHED] The user switched to a different research session. Here's the context:\n${contextBriefing}\n\nBriefly acknowledge the switch and summarize what was being worked on.`;
-                                await currentSession.generateReply({ instructions: contextPrompt });
+                                const historyForScript = conversationHistory.map(e => ({ role: e.role, text: e.content }));
+                                const briefingScript = await prepareBriefingScript(sessionBaseDir, sessionId, historyForScript, 'switch');
+                                queueVoiceInjection(getScriptInjection(briefingScript));
                             }
                             else {
                                 const acknowledgment = summary.lastMessages.length > 0
@@ -2000,7 +2486,7 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
             else if (data.type === 'get_session_artifacts') {
                 const sessionId = data.sessionId;
                 if (sessionId) {
-                    const artifacts = listWorkspaceArtifacts(workingDir, sessionId);
+                    const artifacts = listWorkspaceArtifacts(sessionBaseDir, sessionId);
                     console.log(`📁 Sending ${artifacts.length} session artifacts for ${sessionId.substring(0, 8)}`);
                     await sendToFrontend({
                         type: 'session_artifacts',
@@ -2136,12 +2622,79 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                     enabledKeys,
                 });
             }
+            else if (data.type === 'get_skills') {
+                await sendToFrontend({
+                    type: 'skills_status',
+                    skills: loadSkillsList(sessionBaseDir),
+                });
+            }
+            else if (data.type === 'skill_add') {
+                const skillName = (data.name || '').trim().toLowerCase().replace(/[^a-z0-9-]/g, '-');
+                const skillContent = (data.content || '').trim();
+                if (!skillName || !skillContent) {
+                    await sendToFrontend({ type: 'skill_add_result', success: false, error: 'Name and content are required' });
+                }
+                else {
+                    try {
+                        const skillDir = join(sessionBaseDir, '.claude', 'skills', skillName);
+                        mkdirSync(skillDir, { recursive: true });
+                        writeFileSync(join(skillDir, 'SKILL.md'), skillContent, 'utf-8');
+                        console.log(`📚 Skill added: ${skillName}`);
+                        const skills = loadSkillsList(sessionBaseDir);
+                        await sendToFrontend({ type: 'skill_add_result', success: true, skills });
+                    }
+                    catch (err) {
+                        console.error('❌ Failed to add skill:', err);
+                        await sendToFrontend({ type: 'skill_add_result', success: false, error: String(err) });
+                    }
+                }
+            }
+            else if (data.type === 'join_meeting') {
+                const meetingUrl = data.url;
+                if (meetingUrl) {
+                    const recallJoin = getRecallClient();
+                    if (!recallJoin) {
+                        await sendToFrontend({ type: 'meeting_error', message: 'Recall.ai not configured — set RECALL_API_KEY in .env' });
+                    }
+                    else {
+                        try {
+                            const webhookBase = process.env.FLY_APP_NAME
+                                ? `https://${process.env.FLY_APP_NAME}.fly.dev`
+                                : `http://localhost:${apiPort}`;
+                            await sendToFrontend({ type: 'meeting_joining', message: 'Osborn is joining your meeting...' });
+                            const botId = await recallJoin.joinMeeting(meetingUrl, webhookBase);
+                            const sessionId = currentLLM?.sessionId || currentResumeSessionId || 'default';
+                            recallJoin.registerBot(botId, sessionId);
+                            await sendToFrontend({ type: 'meeting_joined', botId, message: 'Osborn has joined the meeting' });
+                        }
+                        catch (err) {
+                            console.error('❌ Recall.ai join error:', err);
+                            await sendToFrontend({ type: 'meeting_error', message: err.message });
+                        }
+                    }
+                }
+            }
+            else if (data.type === 'leave_meeting') {
+                const botId = data.botId;
+                const recallLeave = getRecallClient();
+                if (recallLeave && botId) {
+                    try {
+                        await recallLeave.leaveMeeting(botId);
+                        await sendToFrontend({ type: 'meeting_left', botId });
+                    }
+                    catch (err) {
+                        console.error('❌ Recall.ai leave error:', err);
+                        await sendToFrontend({ type: 'meeting_error', message: err.message });
+                    }
+                }
+            }
             else if (data.type === 'session_selected') {
                 const sessionId = data.sessionId;
                 console.log(`🚪 Session gate completed: ${sessionId ? `resume ${sessionId}` : 'fresh start'}`);
                 if (sessionId && currentLLM && sessionExists(sessionId, workingDir)) {
                     // Resume the selected session
                     currentLLM.setResumeSessionId(sessionId);
+                    currentResumeSessionId = sessionId;
                     console.log(`🔄 Resuming session: ${sessionId}`);
                     // Fetch context and greet with it
                     const summary = await getSessionSummary(sessionId, workingDir);
@@ -2152,7 +2705,7 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                         success: true,
                     });
                     // Send existing session artifacts to frontend (session-scoped)
-                    const gateArtifacts = listWorkspaceArtifacts(workingDir, sessionId);
+                    const gateArtifacts = listWorkspaceArtifacts(sessionBaseDir, sessionId);
                     if (gateArtifacts.length > 0) {
                         console.log(`📁 Sending ${gateArtifacts.length} session artifacts to frontend`);
                         await sendToFrontend({
@@ -2166,18 +2719,14 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                             }))
                         });
                     }
-                    // Load full session history and greet with context
+                    // Load full session history and greet with context via fast brain
                     if (currentSession && summary) {
                         loadSessionHistoryIntoChatCtx(currentAgent, conversationHistory, currentProvider);
-                        const contextBriefing = buildContextBriefing(summary, conversationHistory, currentProvider);
-                        const specContent = getSpecForVoiceModel(workingDir, sessionId);
-                        const specSection = specContent
-                            ? `\n\n=== SESSION SPEC ===\n${specContent}\n=== END SPEC ===\nCheck "Open Questions" — if any are unanswered, ask the user about them.`
-                            : '';
                         try {
                             if (currentVoiceMode === 'realtime') {
-                                const contextPrompt = `[SESSION RESUMED] The user chose to continue a previous research session. Here's the context:\n${contextBriefing}${specSection}\n\nBriefly acknowledge the previous session. If there are open questions in the spec, ask the most important one. Otherwise ask what they'd like to continue with.`;
-                                await currentSession.generateReply({ instructions: contextPrompt });
+                                const historyForScript = conversationHistory.map(e => ({ role: e.role, text: e.content }));
+                                const briefingScript = await prepareBriefingScript(sessionBaseDir, sessionId, historyForScript, 'resume');
+                                queueVoiceInjection(getScriptInjection(briefingScript));
                             }
                             else {
                                 await currentSession.say("Welcome back! Ready to continue our previous conversation.");
@@ -2189,12 +2738,13 @@ For actual images (photos, illustrations, screenshots), use ask_agent instead
                     }
                 }
                 else {
-                    // Fresh start - just greet normally
+                    // Fresh start - greet via voice queue (not userInput, which creates a user transcript)
+                    currentResumeSessionId = undefined;
                     console.log('🆕 Starting fresh session');
                     if (currentSession) {
                         try {
                             if (currentVoiceMode === 'realtime') {
-                                await currentSession.generateReply({ userInput: "The user just connected and chose to start a fresh session. Briefly greet them as Osborn and ask what they're working on." });
+                                queueVoiceInjection(getScriptInjection("Hey! I'm Osborn, your AI research assistant. What are you working on today?"));
                             }
                             else {
                                 await currentSession.say("Hey! I'm Osborn. What are you working on?");