osborn 0.9.131 → 0.9.133

package/dist/claude-llm.js

@@ -1132,7 +1132,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         // Writer agent: no longer auto-approved — falls through to canUseTool for permission dialog
                                         if (agentType === 'writer') {
                                             console.log(`✍️ Writer agent: deferring to canUseTool for permission`);
-                                            this.#eventEmitter.emit('tool_use', { name: toolName, input: toolInput });
+                                            this.#eventEmitter.emit('tool_use', { name: toolName, input: toolInput, agentRole: agentType || 'main' });
                                             return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'ask' } };
                                         }
                                         // All other agents (main, researcher, reasoner, etc.): workspace only
@@ -1144,7 +1144,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         }
                                     }
                                     console.log(`🔧 Claude: ${toolName}`);
-                                    this.#eventEmitter.emit('tool_use', { name: toolName, input: toolInput });
+                                    this.#eventEmitter.emit('tool_use', { name: toolName, input: toolInput, agentRole: agentType || 'main' });
                                     return {};
                                 }]
                         }],
@@ -1154,8 +1154,9 @@ class ClaudeLLMStream extends llm.LLMStream {
                                     const toolName = input?.tool_name || 'unknown';
                                     const toolInput = input?.tool_input || {};
                                     const toolResponse = input?.tool_response; // Capture actual tool output for fast brain processing
+                                    const agentTypePost = input?.agent_type || null;
                                     console.log(`✅ Done: ${toolName}`);
-                                    this.#eventEmitter.emit('tool_result', { name: toolName, input: toolInput, response: toolResponse });
+                                    this.#eventEmitter.emit('tool_result', { name: toolName, input: toolInput, response: toolResponse, agentRole: agentTypePost || 'main' });
                                     return {};
                                 }]
                         }],

package/dist/index.js

@@ -18,7 +18,7 @@ import { randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
 // 0.9.71: createRequire for resolving package.json versions inside ESM
 const __sdkVersionRequire = createRequire(import.meta.url);
-import { homedir, tmpdir } from 'node:os';
+import { homedir, tmpdir, totalmem, freemem } from 'node:os';
 import { PassThrough } from 'node:stream';
 import { createGunzip } from 'node:zlib';
 // Resolve __dirname for this ESM module so we can find sibling files (e.g.
@@ -518,6 +518,15 @@ function startApiServer(workingDir, port) {
                 }
             }
             catch { /* version optional */ }
+            // System memory snapshot — use os.totalmem/freemem for WHOLE-MACHINE
+            // stats (the OOM killer watches these, not per-process RSS). processRssMb
+            // is additive: useful for spotting leaks but never the headline number.
+            const totalMb = Math.round(totalmem() / 1024 / 1024);
+            const freeMb = Math.round(freemem() / 1024 / 1024);
+            const usedMb = totalMb - freeMb;
+            const availableMb = freeMb;
+            const usedPct = Math.round((usedMb / totalMb) * 100);
+            const processRssMb = Math.round(process.memoryUsage().rss / 1024 / 1024);
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({
                 status: 'ok',
@@ -538,6 +547,8 @@ function startApiServer(workingDir, port) {
                     attemptCount: livekitState.attemptCount,
                     lastAttemptAt: livekitState.lastAttemptAt,
                 },
+                // Whole-machine memory — what the OOM killer watches. All values in MB.
+                memory: { totalMb, usedMb, availableMb, usedPct, processRssMb },
             }));
             return;
         }
@@ -1678,6 +1689,8 @@ async function main() {
     let participantConnectedHandler = null;
     let currentAgent = null; // For updateChatCtx() context injection
     let currentLLM = null;
+    const slots = new Map();
+    let focusedSlotId = null; // reserved for future focused-slot wiring; not used yet
     // Agent-side "alone in room" leave timer (see Room-presence lifecycle note up
     // top). Armed in ParticipantDisconnected once a user has left; if no one
     // rejoins within the grace window the agent leaves LiveKit on its own.
@@ -1846,6 +1859,100 @@ async function main() {
             console.error(`❌ killCurrentLLM(${reason}) failed:`, err instanceof Error ? err.message : err);
         }
     }
+    // ============================================================
+    // SLICE 1: spawnBackgroundSession
+    // Creates a fully headless ClaudeLLM subprocess that resumes an
+    // existing session.  No AgentSession, no room, no TTS/voice.
+    // Output events are forwarded to the frontend data channel only,
+    // tagged with the slot id so the frontend can distinguish them.
+    // ============================================================
+    async function spawnBackgroundSession(sessionId, bgWorkingDir) {
+        // Hard cap: focused session + background slots must not exceed 3 total.
+        // slots Map holds ONLY background slots; focused session is separate.
+        if (slots.size >= 2) {
+            const msg = `Background session cap reached (${slots.size}/2 slots in use). Kill an existing background slot before spawning a new one.`;
+            console.warn(`⚠️ spawnBackgroundSession: ${msg}`);
+            await sendToFrontend({ type: 'background_session_error', slotId: sessionId, error: msg });
+            return;
+        }
+        const slotWorkingDir = bgWorkingDir || workingDir;
+        const slotId = sessionId; // use sessionId as the slot id for traceability
+        console.log(`🔲 Spawning background slot: sessionId=${slotId.substring(0, 8)} cwd=${slotWorkingDir}`);
+        // Create a headless LLM instance — reuse the same factory, no voice options.
+        // permissionMode bypassPermissions: no dialogs (headless — nobody to click Allow).
+        // No AgentSession, no room involvement.
+        const bgLLM = createClaudeLLM({
+            workingDirectory: slotWorkingDir,
+            sessionBaseDir: slotWorkingDir,
+            resumeSessionId: sessionId,
+            voiceMode: 'direct', // picks up the research system prompt
+            skipTTSQueue: false, // not going through TTS at all
+            permissionMode: 'bypassPermissions',
+        });
+        // Register slot BEFORE cold-starting so list_slots is accurate from the
+        // first moment even if the subprocess takes a few seconds to init.
+        const slot = { id: slotId, llm: bgLLM, isFocused: false, workingDir: slotWorkingDir };
+        slots.set(slotId, slot);
+        // Dedicated EventEmitter for this background slot's SDK events.
+        // Forwards every event to the frontend data channel tagged with slotId.
+        // NEVER touches session.say() / TTS / voice.
+        const { EventEmitter: SlotEventEmitter } = await import('node:events');
+        const bgEmitter = new SlotEventEmitter();
+        bgEmitter.on('assistant_text', ({ text }) => {
+            sendToFrontend({ type: 'claude_output', slotId, text }).catch(() => { });
+        });
+        bgEmitter.on('tool_use', ({ name, input, agentRole }) => {
+            sendToFrontend({ type: 'tool_use', slotId, name, input, agentRole }).catch(() => { });
+        });
+        bgEmitter.on('tool_result', ({ name, response, agentRole }) => {
+            sendToFrontend({ type: 'tool_result', slotId, name, response, agentRole }).catch(() => { });
+        });
+        bgEmitter.on('tool_blocked', ({ name, reason }) => {
+            sendToFrontend({ type: 'tool_blocked', slotId, name, reason }).catch(() => { });
+        });
+        bgEmitter.on('session_id', ({ sessionId: sid }) => {
+            sendToFrontend({ type: 'background_session_ready', slotId, sessionId: sid }).catch(() => { });
+        });
+        bgEmitter.on('session_resume_failed', ({ requestedSessionId, actualSessionId }) => {
+            console.error(`❌ Background slot ${slotId.substring(0, 8)}: resume failed — requested ${requestedSessionId?.substring(0, 8)} got ${actualSessionId?.substring(0, 8)}`);
+            sendToFrontend({ type: 'background_session_error', slotId, error: 'Session resume failed' }).catch(() => { });
+        });
+        // Wire up the LLM's internal EventEmitter so hook-emitted events also flow.
+        bgLLM.events.on('session_id', (data) => bgEmitter.emit('session_id', data));
+        bgLLM.events.on('tool_blocked', (data) => bgEmitter.emit('tool_blocked', data));
+        // Build minimal sdkOptions for the headless cold start.
+        // resume: sessionId brings up real prior context from JSONL.
+        // env: CLAUDE_CODE_DISABLE_AUTO_MEMORY prevents concurrent subprocesses
+        // from racing the shared ~/.claude/CLAUDE.md memory file.
+        // CLAUDE_CONFIG_DIR is intentionally NOT overridden — shared config is fine.
+        const bgEnv = {};
+        for (const [k, v] of Object.entries(process.env)) {
+            if (v !== undefined)
+                bgEnv[k] = v;
+        }
+        bgEnv['CLAUDE_CODE_DISABLE_AUTO_MEMORY'] = '1';
+        const bgSdkOptions = {
+            cwd: slotWorkingDir,
+            resume: sessionId,
+            permissionMode: 'bypassPermissions',
+            enableFileCheckpointing: false,
+            settingSources: ['project', 'user'],
+            env: bgEnv,
+        };
+        // Cold-start: deliver an init message so the subprocess actually spawns
+        // and begins consuming the session JSONL.
+        const KICKOFF_TEXT = '[BACKGROUND_INIT] You have been resumed in headless background mode. No voice session is active. Acknowledge receipt with a single brief line.';
+        bgLLM.pushMessage(KICKOFF_TEXT, bgSdkOptions, {
+            onSessionId: (sid) => {
+                console.log(`✅ Background slot ${slotId.substring(0, 8)}: session confirmed ${sid.substring(0, 8)}`);
+                bgEmitter.emit('session_id', { sessionId: sid });
+            },
+            onCheckpoint: (_ckpt) => { },
+            eventEmitter: bgEmitter,
+        });
+        console.log(`✅ Background slot registered: id=${slotId.substring(0, 8)} workingDir=${slotWorkingDir}`);
+        await sendToFrontend({ type: 'background_session_spawned', slotId, workingDir: slotWorkingDir });
+    }
     let localParticipant = null;
     let agentState = 'initializing';
     // Session-level always-allow list: paths the user has approved for this session without prompting
@@ -2214,7 +2321,7 @@ async function main() {
                 const { readSessionHistory } = await import('./session-access.js');
                 const history = readSessionHistory(sessionId, workingDir, {
                     lastN: 10,
-                    types: ['assistant', 'tool_use'], // tool_use entries also carry Claude's spoken text
+                    types: ['assistant'],
                 });
                 recentMessages = history
                     .filter((m) => m.text)
@@ -2230,14 +2337,8 @@ async function main() {
         // BEFORE the previous TTS completed, and we may have already suppressed in-flight
         // tts_say events that arrived during that overlap).
         const carriedSuppressed = lastInterruption?.suppressedText ?? '';
-        lastInterruption = {
-            spokenText: fullText,
-            recentMessages,
-            suppressedText: carriedSuppressed,
-            fullBlockText: fullBlockText && fullBlockText !== fullText ? fullBlockText : undefined,
-            timestamp: Date.now(),
-        };
-        console.log(`📋 Interruption context stored (text: ${fullText.length} chars, JSONL: ${recentMessages.length} chars, block: ${fullBlockText?.length ?? 0} chars, suppressed carried: ${carriedSuppressed.length} chars)`);
+        lastInterruption = { spokenText: fullText, recentMessages, suppressedText: carriedSuppressed, timestamp: Date.now() };
+        console.log(`📋 Interruption context stored (text: ${fullText.length} chars, JSONL: ${recentMessages.length} chars, suppressed carried: ${carriedSuppressed.length} chars)`);
     }
     /**
      * Append text the agent tried to say while the user was speaking, but which we
@@ -2277,7 +2378,6 @@ async function main() {
             spokenText: lastInterruption.spokenText,
             recentMessages: lastInterruption.recentMessages,
             suppressedText: lastInterruption.suppressedText,
-            fullBlockText: lastInterruption.fullBlockText,
         };
         lastInterruption = null;
         return ctx;
@@ -2689,11 +2789,11 @@ async function main() {
         // Wire up events from the Claude SDK wrapper to frontend
         directLLM.events.on('tool_use', (data) => {
             console.log(`🔧 Claude: ${data.name}`);
-            sendToFrontend(buildToolLogEvent(data.name, data.input, 'running', 'direct'));
+            sendToFrontend(buildToolLogEvent(data.name, data.input, 'running', data.agentRole || 'main'));
         });
         directLLM.events.on('tool_result', (data) => {
             console.log(`✅ Done: ${data.name}`);
-            sendToFrontend(buildToolLogEvent(data.name, data.input, 'completed', 'direct'));
+            sendToFrontend(buildToolLogEvent(data.name, data.input, 'completed', data.agentRole || 'main'));
             // Detect research artifact writes (session workspace or legacy research dir)
             if ((data.name === 'Write' || data.name === 'Edit') && data.input?.file_path) {
                 const fp = data.input.file_path;
@@ -3128,11 +3228,11 @@ async function main() {
         // Wire up Claude events to frontend
         realtimeClaudeHandler.events.on('tool_use', (data) => {
             console.log(`🔧 Claude: ${data.name}`);
-            sendToFrontend(buildToolLogEvent(data.name, data.input, 'running', 'realtime'));
+            sendToFrontend(buildToolLogEvent(data.name, data.input, 'running', data.agentRole || 'main'));
         });
         realtimeClaudeHandler.events.on('tool_result', (data) => {
             console.log(`✅ Done: ${data.name}`);
-            sendToFrontend(buildToolLogEvent(data.name, data.input, 'completed', 'realtime'));
+            sendToFrontend(buildToolLogEvent(data.name, data.input, 'completed', data.agentRole || 'main'));
             // Detect research artifact writes (session workspace or legacy research dir)
             if ((data.name === 'Write' || data.name === 'Edit') && data.input?.file_path) {
                 const fp = data.input.file_path;
@@ -5603,6 +5703,71 @@ async function main() {
                     }
                 }
             }
+            // ============================================================
+            // SLICE 1: HEADLESS BACKGROUND SESSION COMMANDS
+            // spawn_background_session — boot a second Claude subprocess that
+            //   resumes an existing session with NO voice involvement.
+            // list_slots — return all live slots (focused + background) so the
+            //   frontend can verify both are alive.
+            // ============================================================
+            else if (data.type === 'spawn_background_session') {
+                const targetSessionId = data.sessionId;
+                const bgDir = data.workingDir;
+                let resolvedSessionId = targetSessionId;
+                if (!resolvedSessionId) {
+                    // Pick the most recently modified session, excluding the focused one.
+                    const allSess = await listAllClaudeSessions(50);
+                    const focusedId = currentLLM?.sessionId || currentResumeSessionId || null;
+                    const candidate = allSess.find(s => s.sessionId !== focusedId);
+                    resolvedSessionId = candidate?.sessionId ?? undefined;
+                }
+                if (!resolvedSessionId) {
+                    await sendToFrontend({
+                        type: 'background_session_error',
+                        slotId: null,
+                        error: 'No eligible session found to spawn as background slot',
+                    });
+                }
+                else if (slots.has(resolvedSessionId)) {
+                    await sendToFrontend({
+                        type: 'background_session_error',
+                        slotId: resolvedSessionId,
+                        error: `Session ${resolvedSessionId.substring(0, 8)} is already running as a background slot`,
+                    });
+                }
+                else {
+                    spawnBackgroundSession(resolvedSessionId, bgDir).catch((err) => {
+                        console.error('❌ spawnBackgroundSession failed:', err instanceof Error ? err.message : err);
+                        sendToFrontend({
+                            type: 'background_session_error',
+                            slotId: resolvedSessionId,
+                            error: err instanceof Error ? err.message : String(err),
+                        }).catch(() => { });
+                    });
+                }
+            }
+            else if (data.type === 'list_slots') {
+                // Return all live slots: the focused session + every background slot.
+                const focusedId = currentLLM?.sessionId || currentResumeSessionId || null;
+                const focusedEntry = currentLLM
+                    ? [{
+                            id: focusedId || '(pending)',
+                            isFocused: true,
+                            workingDir,
+                            hasSession: currentLLM.hasSession?.() ?? false,
+                        }]
+                    : [];
+                const bgEntries = [...slots.values()].map(s => ({
+                    id: s.id,
+                    isFocused: s.isFocused,
+                    workingDir: s.workingDir,
+                    hasSession: s.llm.hasSession?.() ?? false,
+                }));
+                await sendToFrontend({
+                    type: 'slots_list',
+                    slots: [...focusedEntry, ...bgEntries],
+                });
+            }
         }
         catch { }
     };

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

@@ -21,8 +21,6 @@ export interface InterruptionContext {
      * and can re-articulate the relevant bits in its next response.
      */
     suppressedText: string;
-    /** Full text of the interrupted TTS block — fallback when JSONL read returns empty */
-    fullBlockText?: string;
 }
 export interface PipelineDirectOptions extends ClaudeLLMOptions {
     onFastBrainResult?: (result: FastBrainPanelResult) => void;

package/dist/pipeline-direct-llm.js

@@ -122,10 +122,7 @@ export class PipelineDirectLLM extends llm.LLM {
                     `Anything in "Your recent messages" below that appears AFTER the quoted heard text is content the user did not hear. The user has no memory of it.`,
                     ``,
                     `Your recent messages (full untruncated — you wrote these):`,
-                    interruptCtx.recentMessages
-                        || (interruptCtx.fullBlockText
-                            ? `(JSONL unavailable — full TTS block text follows)\n"${interruptCtx.fullBlockText}"`
-                            : '(no recent messages found)'),
+                    interruptCtx.recentMessages || '(no recent messages found)',
                     suppressedBlock,
                     ``,
                     `User's message: "${userText}"`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osborn",
-  "version": "0.9.131",
+  "version": "0.9.133",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {