osborn 0.5.3 → 0.5.5

package/dist/claude-llm.js

@@ -10,7 +10,9 @@ import { llm, shortuuid, DEFAULT_API_CONNECT_OPTIONS } from '@livekit/agents';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { EventEmitter } from 'events';
 import { saveSessionMetadata } from './config.js';
-import { getResearchSystemPrompt } from './prompts.js';
+import { getResearchSystemPrompt, getDirectModeResearchPrompt } from './prompts.js';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 /**
  * Strip markdown formatting for TTS (text-to-speech)
  * Removes **bold**, ##headers, ```code```, etc. so TTS doesn't read them literally
@@ -47,40 +49,30 @@ function stripMarkdownForTTS(text) {
         .trim();
 }
 /**
- * Summarize text for TTS - create short spoken summaries
- * Full output goes to frontend, this condensed version is spoken
+ * Load skill files from agent/.claude/skills/{name}/SKILL.md
+ * Injects into system prompt so Claude sees them as available capabilities.
+ * Skills execute via Bash — no SDK settingSources needed.
  */
-function summarizeForTTS(text, maxLength = 500) {
-    // First strip markdown
-    let summary = stripMarkdownForTTS(text);
-    // Remove file paths (keep just filename)
-    summary = summary.replace(/\/[\w\-\.\/]+\/([\w\-\.]+)/g, '$1');
-    // Remove code block placeholders if too many
-    const codeBlockCount = (summary.match(/\[code block\]/g) || []).length;
-    if (codeBlockCount > 1) {
-        summary = summary.replace(/\[code block\]/g, '').replace(/\s+/g, ' ');
-        summary = summary.trim() + ` I've included ${codeBlockCount} code examples.`;
-    }
-    // If still too long, take first sentence(s) up to maxLength
-    if (summary.length > maxLength) {
-        // Try to break at sentence boundaries
-        const sentences = summary.match(/[^.!?]+[.!?]+/g) || [summary];
-        let result = '';
-        for (const sentence of sentences) {
-            if ((result + sentence).length <= maxLength) {
-                result += sentence;
+function loadSkillsFromDir(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)) {
+                skills.push(readFileSync(skillFile, 'utf-8').trim());
             }
-            else {
-                break;
-            }
-        }
-        // If no complete sentence fits, truncate with ellipsis
-        if (!result) {
-            result = summary.substring(0, maxLength - 3) + '...';
         }
-        summary = result.trim();
     }
-    return summary || 'Done.';
+    catch (err) {
+        console.warn('⚠️ Failed to load skills:', err);
+    }
+    if (skills.length === 0)
+        return '';
+    console.log(`📚 Loaded ${skills.length} skill(s) from ${skillsDir}`);
+    return `<available-skills>\n${skills.join('\n\n---\n\n')}\n</available-skills>`;
 }
 // Research mode tools — full research capabilities
 const RESEARCH_TOOLS = [
@@ -104,6 +96,10 @@ export class ClaudeLLM extends llm.LLM {
     #latestCheckpoint = null;
     // Pending permission request (for voice approval flow)
     #pendingPermission = null;
+    // Persistent session: single process, no JSONL replay on follow-up messages
+    // Active queries — multiple can be running (SDK queues them internally).
+    // We keep ALL references so interrupt() can stop whatever is currently executing.
+    #activeQueries = new Set();
     constructor(opts = {}) {
         super();
         // Session resume/continue options
@@ -113,15 +109,21 @@ export class ClaudeLLM extends llm.LLM {
         this.#mcpServers = opts.mcpServers || {};
         this.#opts = {
             workingDirectory: opts.workingDirectory || process.cwd(),
+            sessionBaseDir: opts.sessionBaseDir || opts.workingDirectory || process.cwd(),
             permissionMode: opts.permissionMode || 'default',
             allowedTools: opts.allowedTools || RESEARCH_TOOLS,
             resumeSessionId: this.#resumeSessionId || undefined,
             continueSession: this.#continueSession,
             mcpServers: this.#mcpServers,
+            voiceMode: opts.voiceMode || 'realtime',
+            skipTTSQueue: opts.skipTTSQueue || false,
         };
         this.#eventEmitter = opts.eventEmitter || new EventEmitter();
         console.log('🟠 ClaudeLLM initialized (Research Mode)');
-        console.log(`   📁 Working dir: ${this.#opts.workingDirectory}`);
+        console.log(`   📁 Working dir (cwd): ${this.#opts.workingDirectory}`);
+        if (this.#opts.sessionBaseDir !== this.#opts.workingDirectory) {
+            console.log(`   📁 Session base dir: ${this.#opts.sessionBaseDir}`);
+        }
         console.log(`   🔧 Allowed tools: ${this.#opts.allowedTools?.join(', ')}`);
         const mcpCount = Object.keys(this.#mcpServers).length;
         if (mcpCount > 0) {
@@ -335,13 +337,98 @@ export class ClaudeLLM extends llm.LLM {
     hasCheckpoints() {
         return this.#checkpoints.length > 0;
     }
-    chat({ chatCtx, toolCtx, connOptions = DEFAULT_API_CONNECT_OPTIONS, }) {
+    // ============================================================
+    // AGENT CONTROL — interrupt, abort, rewind (for fast brain)
+    // ============================================================
+    /**
+     * Interrupt the current Claude query gracefully (like pressing Esc).
+     * Stops current tool execution but keeps the process alive.
+     * Returns true if interrupted, false if no active query.
+     */
+    async interruptQuery() {
+        if (this.#activeQueries.size === 0)
+            return false;
+        let interrupted = false;
+        // Interrupt ALL active queries — stops the current task + any queued ones
+        for (const q of this.#activeQueries) {
+            if (typeof q.interrupt === 'function') {
+                try {
+                    await q.interrupt();
+                    interrupted = true;
+                }
+                catch (err) {
+                    console.error('⚠️ Interrupt failed:', err?.message);
+                }
+            }
+        }
+        if (interrupted) {
+            console.log(`🛑 Interrupted ${this.#activeQueries.size} active query(s) (Esc equivalent)`);
+        }
+        return interrupted;
+    }
+    /**
+     * Hard abort all active queries (like Ctrl+C).
+     * Kills subprocesses. Next message will spawn new processes.
+     */
+    abortQuery() {
+        for (const q of this.#activeQueries) {
+            try {
+                q.return?.();
+            }
+            catch { }
+        }
+        this.#activeQueries.clear();
+        console.log('🛑 All queries aborted (Ctrl+C equivalent)');
+    }
+    /**
+     * Rewind file changes to a specific checkpoint.
+     * Uses the most recently added query (most likely to have the rewind capability).
+     */
+    async rewindToCheckpoint(checkpointId) {
+        const id = checkpointId || this.#latestCheckpoint;
+        if (!id) {
+            console.log('⚠️ No checkpoint available for rewind');
+            return false;
+        }
+        // Try rewind on the latest query
+        const queries = [...this.#activeQueries];
+        const latest = queries[queries.length - 1];
+        if (latest && typeof latest.rewindFiles === 'function') {
+            try {
+                await latest.rewindFiles(id);
+                console.log(`🔄 Files rewound to checkpoint: ${id.substring(0, 8)}...`);
+                return true;
+            }
+            catch (err) {
+                console.error('⚠️ Rewind failed:', err?.message);
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if there are active queries that can be interrupted
+     */
+    hasActiveQuery() {
+        return this.#activeQueries.size > 0;
+    }
+    /** Add an active query (called from ClaudeLLMStream when query starts) */
+    setActiveQuery(q) {
+        if (q) {
+            this.#activeQueries.add(q);
+        }
+    }
+    /** Remove an active query (called from ClaudeLLMStream when query completes) */
+    removeActiveQuery(q) {
+        this.#activeQueries.delete(q);
+    }
+    chat({ chatCtx, toolCtx, connOptions = DEFAULT_API_CONNECT_OPTIONS, abortController, }) {
         return new ClaudeLLMStream(this, {
             chatCtx,
             toolCtx,
             connOptions,
             opts: this.#opts,
             sessionId: this.#sessionId,
+            abortController,
             onSessionId: (id) => {
                 const isFirst = !this.#sessionId;
                 this.#sessionId = id;
@@ -375,17 +462,22 @@ class ClaudeLLMStream extends llm.LLMStream {
     #eventEmitter;
     #onPermissionRequest;
     #onCheckpoint;
-    constructor(llmInstance, { chatCtx, toolCtx, connOptions, opts, sessionId, onSessionId, eventEmitter, onCheckpoint, onPermissionRequest, }) {
+    #abortController;
+    #llmRef;
+    constructor(llmInstance, { chatCtx, toolCtx, connOptions, opts, sessionId, onSessionId, eventEmitter, onCheckpoint, onPermissionRequest, abortController, }) {
         super(llmInstance, { chatCtx, toolCtx, connOptions });
+        this.#llmRef = llmInstance;
         this.#opts = opts;
         this.#sessionId = sessionId;
         this.#onSessionId = onSessionId;
         this.#eventEmitter = eventEmitter;
         this.#onCheckpoint = onCheckpoint;
         this.#onPermissionRequest = onPermissionRequest;
+        this.#abortController = abortController;
     }
     async run() {
         const requestId = `claude_${shortuuid()}`;
+        let activeQuery = null;
         try {
             // Extract user's message from chat context
             // ChatContext has .items which are ChatItem[] (ChatMessage | FunctionCall | FunctionCallOutput)
@@ -415,20 +507,16 @@ class ClaudeLLMStream extends llm.LLMStream {
             // Build Claude Agent SDK options
             const resumeSessionId = this.#opts.resumeSessionId;
             const continueSession = this.#opts.continueSession;
-            // Session workspace path for system prompt — only available after SDK assigns a real session ID
+            // Session workspace path for system prompt — uses sessionBaseDir (not cwd) so
+            // workspace always lives in the Osborn install dir regardless of cwd setting
             const sessionId = this.#sessionId || this.#opts.resumeSessionId || null;
+            const baseDir = this.#opts.sessionBaseDir || this.#opts.workingDirectory;
             const workspacePath = sessionId
-                ? (this.#opts.workingDirectory
-                    ? `${this.#opts.workingDirectory}/.osborn/sessions/${sessionId}/`
+                ? (baseDir
+                    ? `${baseDir}/.osborn/sessions/${sessionId}/`
                     : `.osborn/sessions/${sessionId}/`)
                 : null;
-            // Build allowedTools with MCP wildcard patterns
-            const mcpKeys = Object.keys(this.#opts.mcpServers || {});
-            const mcpPatterns = mcpKeys.map(key => `mcp__${key}__*`);
-            const allowedTools = [
-                ...(this.#opts.allowedTools || []),
-                ...mcpPatterns,
-            ];
+            const allowedTools = this.#opts.allowedTools || [];
             const sdkOptions = {
                 cwd: this.#opts.workingDirectory,
                 permissionMode: this.#opts.permissionMode,
@@ -436,21 +524,18 @@ class ClaudeLLMStream extends llm.LLMStream {
                 model: this.#opts.model || 'claude-sonnet-4-6',
                 enableFileCheckpointing: true,
                 extraArgs: { 'replay-user-messages': null },
+                ...(this.#abortController && { abortController: this.#abortController }),
                 ...(resumeSessionId && { resume: resumeSessionId }),
                 ...(continueSession && !resumeSessionId && { continue: true }),
                 ...(this.#sessionId && !resumeSessionId && !continueSession && { resume: this.#sessionId }),
-                ...(mcpKeys.length > 0 && {
-                    mcpServers: this.#opts.mcpServers,
-                }),
-                ...(mcpKeys.length > 0 && (() => {
-                    for (const [key, cfg] of Object.entries(this.#opts.mcpServers || {})) {
-                        const cfgType = cfg.type || 'stdio';
-                        console.log(`🔌 SDK query MCP: ${key} [type=${cfgType}]`);
-                    }
-                    return {};
-                })()),
-                // Research mode system prompt — always injected
-                systemPrompt: getResearchSystemPrompt(workspacePath),
+                // System prompt — direct mode gets speech-optimized prompt, realtime gets structured research prompt
+                // Skills from agent/.claude/skills/ are appended if present
+                systemPrompt: [
+                    this.#opts.voiceMode === 'direct'
+                        ? getDirectModeResearchPrompt(workspacePath)
+                        : getResearchSystemPrompt(workspacePath),
+                    loadSkillsFromDir(this.#opts.sessionBaseDir || this.#opts.workingDirectory || process.cwd()),
+                ].filter(Boolean).join('\n\n'),
                 canUseTool: async (toolName, input, _options) => {
                     // Auto-approve writes to session workspace (but block spec.md and library/ — fast brain manages those)
                     if (toolName === 'Write' || toolName === 'Edit') {
@@ -515,7 +600,129 @@ class ClaudeLLMStream extends llm.LLMStream {
             // Run Claude Agent SDK query() and stream results
             let hasOutput = false;
             let fullResponse = ''; // Collect full response for frontend
-            for await (const message of query({ prompt: userText, options: sdkOptions })) {
+            // DIRECT MODE OPTIMIZATION: When skipTTSQueue is true, we run the Claude query
+            // in the background and return from run() immediately. This is critical because:
+            //
+            // LiveKit's main speech loop (agent_activity.ts) processes one SpeechHandle at a time.
+            // The LLM's SpeechHandle blocks the queue until run() returns (which closes the queue
+            // → pipeline completes → _markGenerationDone()). If we await the full query() here,
+            // the pipeline is blocked for the entire duration of tool execution (10-30s).
+            // Meanwhile, session.say() SpeechHandles queue up but can't play.
+            //
+            // By returning early, the pipeline completes in milliseconds. The say() handles
+            // created by tts_say events get processed by the main loop immediately.
+            // The query continues in the background — text arrives via tts_say, tools via hooks.
+            if (this.#opts.skipTTSQueue) {
+                const bgAbortController = this.#abortController;
+                const bgEventEmitter = this.#eventEmitter;
+                const bgOpts = this.#opts;
+                const bgOnSessionId = this.#onSessionId;
+                const bgOnCheckpoint = this.#onCheckpoint;
+                const self = this;
+                (async () => {
+                    // Declare outside try so finally can access it
+                    const activeQuery = query({ prompt: userText, options: sdkOptions });
+                    self.#llmRef.setActiveQuery(activeQuery);
+                    try {
+                        for await (const message of activeQuery) {
+                            // Abort check
+                            if (bgAbortController?.signal.aborted)
+                                break;
+                            // Session ID capture (same as synchronous path)
+                            if (message.type === 'system' && message.subtype === 'init') {
+                                const mcpServers = message.mcp_servers;
+                                if (mcpServers && Array.isArray(mcpServers)) {
+                                    for (const s of mcpServers) {
+                                        const status = s.status === 'connected' ? '✅' : '❌';
+                                        console.log(`${status} MCP server ${s.name}: ${s.status}`);
+                                        if (s.status !== 'connected') {
+                                            console.log(`   🔍 MCP error:`, JSON.stringify(s));
+                                        }
+                                    }
+                                }
+                                const newSessionId = message.session_id;
+                                if (newSessionId) {
+                                    bgOnSessionId(newSessionId);
+                                    const isNewSession = !self.#sessionId;
+                                    if (isNewSession)
+                                        console.log(`📋 New session: ${newSessionId}`);
+                                    self.#sessionId = newSessionId;
+                                    if (isNewSession && bgOpts.workingDirectory) {
+                                        saveSessionMetadata(bgOpts.workingDirectory, {
+                                            sessionId: newSessionId,
+                                            lastUpdated: new Date().toISOString(),
+                                            projectPath: bgOpts.workingDirectory,
+                                        });
+                                    }
+                                    const requestedResumeId = bgOpts.resumeSessionId;
+                                    if (requestedResumeId && newSessionId !== requestedResumeId) {
+                                        console.error(`❌ Session resume FAILED: Expected ${requestedResumeId.substring(0, 8)}..., got ${newSessionId.substring(0, 8)}...`);
+                                        bgEventEmitter.emit('session_resume_failed', { requestedSessionId: requestedResumeId, actualSessionId: newSessionId });
+                                    }
+                                    else if (requestedResumeId && newSessionId === requestedResumeId) {
+                                        console.log(`✅ Session resumed successfully: ${newSessionId.substring(0, 8)}...`);
+                                    }
+                                }
+                            }
+                            // Checkpoint capture
+                            if (message.type === 'user' && message.uuid) {
+                                bgOnCheckpoint(message.uuid);
+                            }
+                            // Stream text → tts_say events (the whole point of background mode)
+                            if (message.type === 'assistant' && message.message?.content) {
+                                const sdkRequestId = message.requestId;
+                                if (sdkRequestId)
+                                    bgEventEmitter.emit('query_request_id', { requestId: sdkRequestId });
+                                for (const block of message.message.content) {
+                                    if (block.type === 'text' && block.text) {
+                                        hasOutput = true;
+                                        bgEventEmitter.emit('assistant_text', { text: block.text });
+                                        const ttsChunk = stripMarkdownForTTS(block.text);
+                                        if (ttsChunk.trim()) {
+                                            console.log(`🔊 TTS say (${ttsChunk.length} chars): "${ttsChunk.substring(0, 60)}..."`);
+                                            bgEventEmitter.emit('tts_say', { text: ttsChunk });
+                                        }
+                                    }
+                                }
+                            }
+                            // Final result
+                            if (message.type === 'result' && message.result) {
+                                bgEventEmitter.emit('assistant_result', { text: message.result });
+                                if (!hasOutput) {
+                                    hasOutput = true;
+                                    const ttsText = stripMarkdownForTTS(message.result);
+                                    if (ttsText.trim()) {
+                                        console.log(`🔊 TTS say result (${ttsText.length} chars): "${ttsText.substring(0, 60)}..."`);
+                                        bgEventEmitter.emit('tts_say', { text: ttsText });
+                                    }
+                                }
+                            }
+                        }
+                        if (!hasOutput) {
+                            bgEventEmitter.emit('tts_say', { text: 'Done.' });
+                        }
+                        console.log('✅ Claude response complete (background)');
+                    }
+                    catch (error) {
+                        if (bgAbortController?.signal.aborted) {
+                            console.log('🛑 Claude Agent SDK query aborted (background)');
+                            return;
+                        }
+                        console.error('❌ Claude Agent SDK error (background):', error);
+                        bgEventEmitter.emit('tts_say', { text: 'Sorry, I encountered an error.' });
+                    }
+                    finally {
+                        self.#llmRef.removeActiveQuery(activeQuery);
+                    }
+                })();
+                // Return immediately — queue closes, pipeline completes, say() handles play
+                console.log('🚀 Direct mode: Claude query running in background, pipeline released');
+                return;
+            }
+            // Store active query for interrupt/rewind access
+            activeQuery = query({ prompt: userText, options: sdkOptions });
+            this.#llmRef.setActiveQuery(activeQuery);
+            for await (const message of activeQuery) {
                 // Capture session ID for context continuity
                 if (message.type === 'system' && message.subtype === 'init') {
                     // Log MCP server connection status
@@ -565,53 +772,102 @@ class ClaudeLLMStream extends llm.LLMStream {
                     const checkpointId = message.uuid;
                     this.#onCheckpoint(checkpointId);
                 }
-                // Stream text chunks
+                // Stream text chunks — send each assistant text block to TTS
                 if (message.type === 'assistant' && message.message?.content) {
+                    // Emit SDK requestId on first assistant message — identifies this query()
+                    // in the JSONL for tracking which research task produced which output
+                    const sdkRequestId = message.requestId;
+                    if (sdkRequestId) {
+                        this.#eventEmitter.emit('query_request_id', { requestId: sdkRequestId });
+                    }
                     for (const block of message.message.content) {
                         if (block.type === 'text' && block.text) {
                             hasOutput = true;
                             const rawText = block.text;
                             // Emit RAW text to frontend (for chat bubbles with full formatting)
                             this.#eventEmitter.emit('assistant_text', { text: rawText });
-                            // Collect for final TTS summary
-                            fullResponse += rawText + ' ';
+                            // Strip markdown for clean speech
+                            const ttsChunk = stripMarkdownForTTS(rawText);
+                            if (ttsChunk.trim()) {
+                                if (this.#opts.skipTTSQueue) {
+                                    // Direct mode: emit event for session.say() — bypasses LiveKit's
+                                    // BufferedTokenStream which causes stuck/delayed/out-of-order audio
+                                    console.log(`🔊 TTS say (${ttsChunk.length} chars): "${ttsChunk.substring(0, 60)}..."`);
+                                    this.#eventEmitter.emit('tts_say', { text: ttsChunk });
+                                }
+                                else {
+                                    // Realtime mode: use LLM stream queue (framework handles TTS)
+                                    console.log(`🔊 TTS stream (${ttsChunk.length} chars): "${ttsChunk.substring(0, 60)}..."`);
+                                    this.queue.put({
+                                        id: requestId,
+                                        delta: { role: 'assistant', content: ttsChunk },
+                                    });
+                                }
+                            }
                         }
                     }
                 }
-                // Final result
+                // Final result — only speak if no text blocks were streamed already
                 if (message.type === 'result' && message.result) {
                     const rawResult = message.result;
                     // Emit RAW result to frontend
                     this.#eventEmitter.emit('assistant_result', { text: rawResult });
                     if (!hasOutput) {
-                        fullResponse = rawResult;
                         hasOutput = true;
+                        const ttsText = stripMarkdownForTTS(rawResult);
+                        if (ttsText.trim()) {
+                            if (this.#opts.skipTTSQueue) {
+                                console.log(`🔊 TTS say result (${ttsText.length} chars): "${ttsText.substring(0, 60)}..."`);
+                                this.#eventEmitter.emit('tts_say', { text: ttsText });
+                            }
+                            else {
+                                console.log(`🔊 TTS result (${ttsText.length} chars): "${ttsText.substring(0, 60)}..."`);
+                                this.queue.put({
+                                    id: requestId,
+                                    delta: { role: 'assistant', content: ttsText },
+                                });
+                            }
+                        }
                     }
                 }
             }
-            // Send SUMMARIZED output to TTS (spoken)
-            if (hasOutput && fullResponse.trim()) {
-                const ttsText = summarizeForTTS(fullResponse.trim());
-                console.log(`🔊 TTS (summarized ${fullResponse.length} → ${ttsText.length} chars): "${ttsText.substring(0, 80)}..."`);
-                this.queue.put({
-                    id: requestId,
-                    delta: { role: 'assistant', content: ttsText },
-                });
+            // If Claude produced no output at all, say "Done."
+            if (!hasOutput) {
+                if (this.#opts.skipTTSQueue) {
+                    this.#eventEmitter.emit('tts_say', { text: 'Done.' });
+                }
+                else {
+                    this.queue.put({
+                        id: requestId,
+                        delta: { role: 'assistant', content: 'Done.' },
+                    });
+                }
+            }
+            console.log('✅ Claude response complete');
+        }
+        catch (error) {
+            // AbortError = clean abort (disconnect, new research, recovery) — don't push
+            // garbage text that would flow through the post-research pipeline
+            if (this.#abortController?.signal.aborted) {
+                console.log('🛑 Claude Agent SDK query aborted');
+                if (!this.#opts.skipTTSQueue) {
+                    this.queue.put({ id: requestId, delta: { role: 'assistant', content: '' } });
+                }
+                return;
+            }
+            console.error('❌ Claude Agent SDK error:', error);
+            if (this.#opts.skipTTSQueue) {
+                this.#eventEmitter.emit('tts_say', { text: 'Sorry, I encountered an error.' });
             }
             else {
                 this.queue.put({
                     id: requestId,
-                    delta: { role: 'assistant', content: 'Done.' },
+                    delta: { role: 'assistant', content: 'Sorry, I encountered an error.' },
                 });
             }
-            console.log('✅ Claude response complete');
         }
-        catch (error) {
-            console.error('❌ Claude Agent SDK error:', error);
-            this.queue.put({
-                id: requestId,
-                delta: { role: 'assistant', content: 'Sorry, I encountered an error.' },
-            });
+        finally {
+            this.#llmRef.removeActiveQuery(activeQuery);
         }
     }
 }

package/dist/config.d.ts

@@ -1,5 +1,5 @@
 import type { McpServerConfig } from './claude-handler.js';
-export type VoiceMode = 'direct' | 'realtime';
+export type VoiceMode = 'direct' | 'realtime' | 'pipeline';
 export type EditMode = 'read-only' | 'edit';
 export type AgentMode = 'plan' | 'execute' | 'research';
 export type RealtimeProvider = 'openai' | 'gemini';
@@ -25,6 +25,9 @@ export interface DirectConfig {
         voice?: string;
     };
 }
+export interface PipelineDirectConfig extends DirectConfig {
+    enableCollisionGuard?: boolean;
+}
 export interface PipelinedConfig {
     stt?: {
         provider?: STTProvider;
@@ -49,6 +52,7 @@ export interface OsbornConfig {
     voiceMode?: VoiceMode;
     realtime?: RealtimeConfig;
     direct?: DirectConfig;
+    'pipeline-direct'?: PipelineDirectConfig;
     pipelined?: PipelinedConfig;
 }
 interface McpServerConfigYaml {

package/dist/config.js

@@ -58,7 +58,7 @@ const DEFAULT_CONFIG = {
         },
         tts: {
             provider: 'deepgram',
-            voice: 'aura-asteria-en',
+            voice: 'aura-2-asteria-en',
         },
     },
     mcpServers: {
@@ -863,6 +863,9 @@ function scanDirForArtifacts(dir) {
                     scan(fullPath);
                 }
                 else {
+                    // Skip internal index files and .index/ folder
+                    if (entry.startsWith('search-index') || entry === '.index')
+                        continue;
                     results.push({
                         fileName: entry,
                         filePath: fullPath,