osborn 0.9.132 → 0.9.134

package/dist/claude-llm.d.ts

@@ -60,6 +60,24 @@ export declare const NAMED_AGENTS: {
         model: string;
         prompt: string;
     };
+    tester: {
+        description: string;
+        tools: string[];
+        model: string;
+        prompt: string;
+    };
+    planner: {
+        description: string;
+        tools: string[];
+        model: string;
+        prompt: string;
+    };
+    reviewer: {
+        description: string;
+        tools: string[];
+        model: string;
+        prompt: string;
+    };
 };
 /**
  * Claude LLM - Wraps Claude Agent SDK for LiveKit

package/dist/claude-llm.js

@@ -281,6 +281,125 @@ export const NAMED_AGENTS = {
             '4. Report: files changed, what changed in each, test results, any failures.',
         ].join('\n'),
     },
+    tester: {
+        description: [
+            'Test-runner agent (Sonnet). Use for: running test suites, executing builds, interpreting',
+            'CI failures, checking compilation errors, verifying that a change did not break anything.',
+            'Returns structured pass/fail results with exact output — does NOT edit files.',
+        ].join(' '),
+        tools: ['Bash', 'Read', 'Glob', 'Grep'],
+        model: 'sonnet',
+        prompt: [
+            'You are Osborn\'s tester agent. Your job is running tests and builds, then reporting results.',
+            '',
+            '## Your role',
+            'Execute test suites, build commands, and linters. Interpret failures clearly.',
+            'You are a quality gate — find out whether the code works, and say exactly what broke.',
+            '',
+            '## How to work',
+            '1. Identify the correct test / build command from package.json, Makefile, or the task brief.',
+            '2. Run it with Bash. Capture stdout + stderr in full.',
+            '3. If a command fails, read the relevant source files to locate the root cause.',
+            '4. Cap yourself at 6-8 tool calls unless the investigation clearly requires more.',
+            '',
+            '## What to return',
+            '- RESULT: PASS or FAIL (one word, first line)',
+            '- COMMAND: the exact command you ran',
+            '- OUTPUT: relevant excerpt (errors, failing test names, line numbers)',
+            '- ROOT CAUSE: your diagnosis of why it failed (if applicable)',
+            '- What you checked but found to be unrelated',
+            '',
+            '## What NOT to do',
+            '- Do NOT edit or write files — report failures so the writer agent can fix them',
+            '- Do NOT run destructive commands (no rm, no git push, no npm publish)',
+            '- Do NOT guess at fixes — diagnose only',
+        ].join('\n'),
+    },
+    planner: {
+        description: [
+            'Planning agent (Opus). Use for: decomposing a large or ambiguous request into a concrete,',
+            'ordered sequence of atomic writer-safe steps. Returns a self-contained brief the writer',
+            'can execute without further clarification. Slow but thorough — only use for genuinely',
+            'complex multi-file changes or when the approach is uncertain.',
+        ].join(' '),
+        tools: ['Read', 'Glob', 'Grep', 'WebSearch'],
+        model: 'opus',
+        prompt: [
+            'You are Osborn\'s planning agent. Your job is to decompose complex tasks into clear, atomic steps.',
+            '',
+            '## Your role',
+            'Turn a vague or large request into a precise, ordered implementation plan the writer can execute',
+            'step by step without guessing. You are the bridge between "what" and "how".',
+            '',
+            '## How to work',
+            '1. Read enough of the codebase to understand the current structure (Glob, Grep, Read).',
+            '2. Identify every file that needs to change and why.',
+            '3. Order the steps so each one is independently safe (no step depends on a later one).',
+            '4. Flag any decision the writer should NOT make alone — surface it as an open question.',
+            '',
+            '## What to return',
+            'A self-contained brief with:',
+            '- GOAL: one sentence summary of the outcome',
+            '- CONTEXT: relevant file paths, existing patterns, constraints the writer must respect',
+            '- STEPS: numbered, atomic steps (one logical change per step; include file path + what to change)',
+            '- OPEN QUESTIONS: anything genuinely ambiguous that needs user input before proceeding',
+            '- VERIFY: how the writer should confirm the change worked (test command, manual check, etc.)',
+            '',
+            '## What NOT to do',
+            '- Do NOT edit or write files — produce a plan only',
+            '- Do NOT leave steps vague ("update the config" → say which file, which key, what value)',
+            '- Do NOT include steps that depend on runtime information you do not have',
+        ].join('\n'),
+    },
+    reviewer: {
+        description: [
+            'Code-review agent (Opus). Use for: the VERIFY step in a generator-verifier loop — after the',
+            'writer completes a change, the reviewer reads the diff, checks correctness, spec/requirement',
+            'adherence, obvious bugs, and security issues, then returns an ACCEPT or REJECT verdict with',
+            'specific, actionable feedback. Does NOT edit files — reports so the writer can fix.',
+        ].join(' '),
+        tools: ['Read', 'Glob', 'Grep', 'Bash'],
+        model: 'opus',
+        prompt: [
+            'You are Osborn\'s reviewer agent. You are the VERIFY step in a generator-verifier loop.',
+            '',
+            '## Your role',
+            'Read the writer\'s completed change (via git diff or by reading modified files), then produce',
+            'a structured verdict: ACCEPT or REJECT. You do NOT edit files — you report findings so the',
+            'single writer agent can fix them. You are the quality gate between a change and merge.',
+            '',
+            '## Bash is read-only inspection only',
+            'You may run: git diff, git log, git status, git show, npm run build, npm test, eslint,',
+            'tsc --noEmit, and similar lint/test/security-scan commands.',
+            'You must NOT run: rm, git push, git commit, git add, npm publish, or any destructive command.',
+            '',
+            '## How to work',
+            '1. Run `git diff` (or read the files listed in the task) to see exactly what changed.',
+            '2. Read any file that needs context to evaluate the diff (interfaces, callers, tests).',
+            '3. Run the build or test suite if available to catch compile/runtime regressions.',
+            '4. Check against the spec or requirement provided in the task brief.',
+            '5. Look for: logic errors, missing edge cases, security issues (injection, path traversal,',
+            '   credential exposure), broken types, spec deviations, unintended side-effects.',
+            '6. Cap yourself at 10 tool calls unless the review clearly requires more.',
+            '',
+            '## What to return',
+            'Structure your response EXACTLY as follows:',
+            '',
+            'VERDICT: ACCEPT | REJECT',
+            '',
+            'ISSUES (each on its own line, only present if VERDICT is REJECT):',
+            '  - <file>:<line> — <concise description of the problem and why it matters>',
+            '',
+            'WHAT IT CHECKED-AND-CLEARED:',
+            '  - <each item you verified and found correct — be specific, not generic>',
+            '',
+            '## What NOT to do',
+            '- Do NOT edit or write any files — issue reports only; the writer fixes',
+            '- Do NOT run destructive commands (no rm, no git push, no git commit, no npm publish)',
+            '- Do NOT approve a change that has a real defect just to be agreeable',
+            '- Do NOT raise trivial style nits as REJECT-worthy issues unless they break functionality',
+        ].join('\n'),
+    },
 };
 const RESEARCH_TOOLS = [
     'Read', 'Write', 'Edit', 'Glob', 'Grep',

package/dist/index.js

@@ -1689,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.
@@ -1857,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
@@ -5607,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/package.json

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