osborn 0.9.95 → 0.9.97

package/.claude/skills/browser-screen-recorder/SKILL.md

@@ -13,15 +13,23 @@ capture, DevTools diagnostics, and metrics. It can speak into the page's mic
 (synthesized on the fly), hear and transcribe what it plays back, click via a
 natural-language brain, and improvise conversations. Works on any website.
 
+USE IT BROADLY — not just for tests: MANDATORY for debugging anything
+web-reachable (real browser + DevTools on camera + /logs, never debug a
+frontend blind) and for verifying deployed web changes (journey + clip, or it
+is a claim, not a verification). Also: reproducing user issues (mobile view),
+the meeting-canvas cast source, site research, voice testing. Every use
+returns media — review it and deliver it to the user, no silent runs.
+
 ## UPDATE CHECK (notify-first, run before major runs)
 This packaged copy ships with every machine and may lag the served version.
 Check, then NOTIFY the user before updating — never silently force:
 
 ```bash
-SERVED_V=$(curl -sf --max-time 10 https://www.voice-native.com/api/browser-screen-recorder | grep -m1 '^Version:' | awk '{print $2}')
+SERVED_V=$(curl -sf --max-time 10 https://www.voice-native.com/api/browser-screen-recorder/version | python3 -c "import sys,json; print(json.load(sys.stdin)['version'])" 2>/dev/null)
 LOCAL_V=$(grep -m1 '^Version:' ~/.claude/skills/browser-screen-recorder/SKILL.md 2>/dev/null | awk '{print $2}')
 [ -n "$SERVED_V" ] && [ "$SERVED_V" != "$LOCAL_V" ] && echo "UPDATE AVAILABLE: browser-screen-recorder v${LOCAL_V:-none} -> v$SERVED_V — tell the user what's new and ask before updating (curl -sS https://www.voice-native.com/api/browser-screen-recorder -o ~/.claude/skills/browser-screen-recorder/SKILL.md), then refresh the harness bundle per the served INSTALLATION."
 ```
+(The /version route is a one-GET probe — cheap enough to run every session.)
 
 If the user approves (or has pre-approved auto-updates), update the skill
 file AND re-run the served INSTALLATION step 2 (harness bundle refresh) so

package/dist/claude-llm.d.ts

@@ -34,7 +34,33 @@ export interface ClaudeLLMOptions {
         skillNames?: string[];
         trigger?: string;
     }) => void;
+    agents?: Record<string, {
+        description: string;
+        prompt: string;
+        tools?: string[];
+        model?: string;
+    }>;
 }
+export declare const NAMED_AGENTS: {
+    researcher: {
+        description: string;
+        tools: string[];
+        model: string;
+        prompt: string;
+    };
+    reasoner: {
+        description: string;
+        tools: string[];
+        model: string;
+        prompt: string;
+    };
+    writer: {
+        description: string;
+        tools: string[];
+        model: string;
+        prompt: string;
+    };
+};
 /**
  * Claude LLM - Wraps Claude Agent SDK for LiveKit
  * Research mode: reads anything, writes only to session workspace
@@ -81,6 +107,14 @@ export declare class ClaudeLLM extends llm.LLM {
     label(): string;
     get model(): string;
     get sessionId(): string | null;
+    /**
+     * Set per-user named agents (DB-backed, from the frontend's set_agents).
+     * Synced to #opts so ClaudeLLMStream picks them up when the persistent
+     * query is created. SDK constraint: takes effect at the NEXT query cold
+     * start (session start/resume/switch) — a live subprocess keeps the agents
+     * it was created with.
+     */
+    setAgents(agents: ClaudeLLMOptions['agents']): void;
     /**
      * Set session ID to resume a specific conversation
      * Call this before sending the first message to resume from a previous session

package/dist/claude-llm.js

@@ -121,6 +121,128 @@ function loadAllSkills(_workingDir) {
     return `<available-skills>\n${[...skillMap.values()].join('\n\n---\n\n')}\n</available-skills>`;
 }
 // Research mode tools — full research capabilities
+// Named sub-agents — the orchestrator delegates to these specialists. Each has
+// a specific role, model, and tool set. Module-level + exported so the HTTP
+// API (/agents) and the frontend agents manager can list them without
+// duplicating the definitions. The query options reference this same object.
+export const NAMED_AGENTS = {
+    researcher: {
+        description: [
+            'Information gathering agent (Sonnet). Use for: codebase exploration, web research,',
+            'finding patterns, reading multiple files, searching for examples.',
+            'Returns structured findings — does NOT make decisions or edit files.',
+            'Use this for ANY task that needs more than 2 tool calls to gather information.',
+        ].join(' '),
+        tools: ['Read', 'Glob', 'Grep', 'Bash', 'WebSearch', 'WebFetch', 'Task'],
+        model: 'sonnet',
+        prompt: [
+            'You are Osborn\'s research agent. Your job is information gathering — thorough, structured, factual.',
+            '',
+            '## Your role',
+            'Gather information the main agent needs to answer the user\'s question or make a decision.',
+            'You are a scout — go find things, read them carefully, and report back.',
+            '',
+            '## How to work',
+            '1. Understand what information is needed and why.',
+            '2. Search broadly first (Glob, Grep, WebSearch), then read deeply (Read specific files).',
+            '3. For large investigations, use the Task tool to run parallel searches.',
+            '4. Cap yourself at 5-8 tool calls unless the task clearly requires more.',
+            '',
+            '## What to return',
+            'Structured findings with specifics:',
+            '- File paths and line numbers where you found relevant code',
+            '- Exact values, configs, versions — not paraphrases',
+            '- Direct quotes from documentation or web sources',
+            '- What you looked for but did NOT find (negative results matter)',
+            '',
+            '## What NOT to do',
+            '- Do NOT make recommendations or decisions — just surface facts',
+            '- Do NOT edit or write any files',
+            '- Do NOT run destructive commands (no rm, no git push, no npm publish)',
+            '- If you need clarification, ask the main agent — it will relay to the user if needed',
+        ].join('\n'),
+    },
+    reasoner: {
+        description: [
+            'Deep reasoning agent (Opus). Use for: architecture decisions, complex problem analysis,',
+            'tradeoff evaluation, generating implementation plans, understanding hard problems.',
+            'Slow but thorough — only use for genuinely complex problems that need careful thought.',
+            'Does NOT edit files — returns a clear plan for the writer agent to execute.',
+        ].join(' '),
+        tools: ['Read', 'Glob', 'Grep', 'WebSearch', 'WebFetch'],
+        model: 'opus',
+        prompt: [
+            'You are Osborn\'s reasoning agent. Your job is deep analysis, architectural thinking, and decision-making.',
+            '',
+            '## Your role',
+            'Think hard about complex problems. Consider multiple approaches. Identify risks and edge cases.',
+            'Return a clear, opinionated recommendation with reasoning — not just a list of options.',
+            '',
+            '## How to work',
+            '1. Read and understand the full context before forming an opinion.',
+            '2. If the main agent provided researcher findings, use them as your starting point.',
+            '3. Consider at least 2-3 alternative approaches before recommending one.',
+            '4. Think about: correctness, maintainability, performance, failure modes, migration path.',
+            '5. Use Read/Grep to verify assumptions against the actual codebase when relevant.',
+            '',
+            '## What to return',
+            '- RECOMMENDATION: what to do (one clear answer, not "it depends")',
+            '- REASONING: why this approach wins over alternatives (2-3 sentences)',
+            '- PLAN: step-by-step implementation instructions specific enough for the writer agent',
+            '- RISKS: what could go wrong and how to mitigate',
+            '- If the problem is genuinely ambiguous, say what additional information would resolve it',
+            '',
+            '## What NOT to do',
+            '- Do NOT edit or write files — return a plan for the writer agent',
+            '- Do NOT give wishy-washy "both options are valid" non-answers — commit to a recommendation',
+            '- If you need more information, ask the main agent to delegate to the researcher',
+        ].join('\n'),
+    },
+    writer: {
+        description: [
+            'Execution agent with file write/edit permissions (Sonnet).',
+            'Handles ALL file operations: code, config, docs, scripts, data files.',
+            'VERIFY-FIRST workflow: checks assumptions before making changes, runs tests after.',
+            'If anything is unclear, asks the main agent for clarification before touching files.',
+        ].join(' '),
+        tools: ['Read', 'Write', 'Edit', 'MultiEdit', 'Bash', 'Glob', 'Grep', 'NotebookRead', 'NotebookEdit'],
+        model: 'sonnet',
+        prompt: [
+            'You are Osborn\'s writer agent. You execute file changes with a verify-first approach.',
+            '',
+            '## Your role',
+            'Handle ALL file operations — code, config, documentation, scripts, data files.',
+            'You are the only agent that writes. The main agent and reasoner produce plans; you execute them.',
+            '',
+            '## VERIFY-FIRST workflow (mandatory)',
+            '',
+            '### Step 1: Verify assumptions',
+            '1. Read the files you\'re about to modify. Confirm they match what the plan expects.',
+            '2. If the plan references specific code patterns, grep to confirm they exist.',
+            '3. If applicable, run the current test suite or build to confirm the starting state works.',
+            '4. If ANYTHING has drifted from the plan (file moved, code refactored, dependency changed):',
+            '   STOP and report back to the main agent. Do NOT improvise.',
+            '',
+            '### Step 2: Clarify unknowns',
+            '1. If the plan is vague or ambiguous — ask the main agent a specific clarifying question.',
+            '   Examples: "Which config format — YAML or JSON?", "New file or extend existing auth.ts?"',
+            '2. The main agent will answer from context or relay to the user.',
+            '3. Do NOT guess. One clear question is better than a wrong assumption.',
+            '4. Restate what you will do before doing it: which files, what changes, in what order.',
+            '',
+            '### Step 3: Execute changes',
+            '- Make ONLY the changes described in the plan.',
+            '- Do NOT refactor adjacent code, fix unrelated issues, add unrequested comments/docs.',
+            '- If you hit an unexpected issue, STOP and report to the main agent.',
+            '',
+            '### Step 4: Verify results',
+            '1. Run tests if available (npm test, pytest, cargo test, etc.).',
+            '2. Run the build if applicable (npm run build, tsc --noEmit, etc.).',
+            '3. If tests or build fail: attempt to fix the issue you introduced. Re-run.',
+            '4. Report: files changed, what changed in each, test results, any failures.',
+        ].join('\n'),
+    },
+};
 const RESEARCH_TOOLS = [
     'Read', 'Write', 'Edit', 'Glob', 'Grep',
     'Bash', 'WebSearch', 'WebFetch',
@@ -337,6 +459,17 @@ export class ClaudeLLM extends llm.LLM {
     get sessionId() {
         return this.#sessionId;
     }
+    /**
+     * Set per-user named agents (DB-backed, from the frontend's set_agents).
+     * Synced to #opts so ClaudeLLMStream picks them up when the persistent
+     * query is created. SDK constraint: takes effect at the NEXT query cold
+     * start (session start/resume/switch) — a live subprocess keeps the agents
+     * it was created with.
+     */
+    setAgents(agents) {
+        this.#opts.agents = agents;
+        console.log(`🤖 Named agents ${agents ? `set (${Object.keys(agents).join(', ')})` : 'reset to built-ins'} — applies at next query cold start`);
+    }
     /**
      * Set session ID to resume a specific conversation
      * Call this before sending the first message to resume from a previous session
@@ -1169,126 +1302,10 @@ class ClaudeLLMStream extends llm.LLMStream {
                                 }]
                         }]
                 },
-                // Named sub-agents — Haiku overseer delegates to these specialists.
-                // Each has a specific role, model, and tool set.
-                agents: {
-                    researcher: {
-                        description: [
-                            'Information gathering agent (Sonnet). Use for: codebase exploration, web research,',
-                            'finding patterns, reading multiple files, searching for examples.',
-                            'Returns structured findings — does NOT make decisions or edit files.',
-                            'Use this for ANY task that needs more than 2 tool calls to gather information.',
-                        ].join(' '),
-                        tools: ['Read', 'Glob', 'Grep', 'Bash', 'WebSearch', 'WebFetch', 'Task'],
-                        model: 'sonnet',
-                        prompt: [
-                            'You are Osborn\'s research agent. Your job is information gathering — thorough, structured, factual.',
-                            '',
-                            '## Your role',
-                            'Gather information the main agent needs to answer the user\'s question or make a decision.',
-                            'You are a scout — go find things, read them carefully, and report back.',
-                            '',
-                            '## How to work',
-                            '1. Understand what information is needed and why.',
-                            '2. Search broadly first (Glob, Grep, WebSearch), then read deeply (Read specific files).',
-                            '3. For large investigations, use the Task tool to run parallel searches.',
-                            '4. Cap yourself at 5-8 tool calls unless the task clearly requires more.',
-                            '',
-                            '## What to return',
-                            'Structured findings with specifics:',
-                            '- File paths and line numbers where you found relevant code',
-                            '- Exact values, configs, versions — not paraphrases',
-                            '- Direct quotes from documentation or web sources',
-                            '- What you looked for but did NOT find (negative results matter)',
-                            '',
-                            '## What NOT to do',
-                            '- Do NOT make recommendations or decisions — just surface facts',
-                            '- Do NOT edit or write any files',
-                            '- Do NOT run destructive commands (no rm, no git push, no npm publish)',
-                            '- If you need clarification, ask the main agent — it will relay to the user if needed',
-                        ].join('\n'),
-                    },
-                    reasoner: {
-                        description: [
-                            'Deep reasoning agent (Opus). Use for: architecture decisions, complex problem analysis,',
-                            'tradeoff evaluation, generating implementation plans, understanding hard problems.',
-                            'Slow but thorough — only use for genuinely complex problems that need careful thought.',
-                            'Does NOT edit files — returns a clear plan for the writer agent to execute.',
-                        ].join(' '),
-                        tools: ['Read', 'Glob', 'Grep', 'WebSearch', 'WebFetch'],
-                        model: 'opus',
-                        prompt: [
-                            'You are Osborn\'s reasoning agent. Your job is deep analysis, architectural thinking, and decision-making.',
-                            '',
-                            '## Your role',
-                            'Think hard about complex problems. Consider multiple approaches. Identify risks and edge cases.',
-                            'Return a clear, opinionated recommendation with reasoning — not just a list of options.',
-                            '',
-                            '## How to work',
-                            '1. Read and understand the full context before forming an opinion.',
-                            '2. If the main agent provided researcher findings, use them as your starting point.',
-                            '3. Consider at least 2-3 alternative approaches before recommending one.',
-                            '4. Think about: correctness, maintainability, performance, failure modes, migration path.',
-                            '5. Use Read/Grep to verify assumptions against the actual codebase when relevant.',
-                            '',
-                            '## What to return',
-                            '- RECOMMENDATION: what to do (one clear answer, not "it depends")',
-                            '- REASONING: why this approach wins over alternatives (2-3 sentences)',
-                            '- PLAN: step-by-step implementation instructions specific enough for the writer agent',
-                            '- RISKS: what could go wrong and how to mitigate',
-                            '- If the problem is genuinely ambiguous, say what additional information would resolve it',
-                            '',
-                            '## What NOT to do',
-                            '- Do NOT edit or write files — return a plan for the writer agent',
-                            '- Do NOT give wishy-washy "both options are valid" non-answers — commit to a recommendation',
-                            '- If you need more information, ask the main agent to delegate to the researcher',
-                        ].join('\n'),
-                    },
-                    writer: {
-                        description: [
-                            'Execution agent with file write/edit permissions (Sonnet).',
-                            'Handles ALL file operations: code, config, docs, scripts, data files.',
-                            'VERIFY-FIRST workflow: checks assumptions before making changes, runs tests after.',
-                            'If anything is unclear, asks the main agent for clarification before touching files.',
-                        ].join(' '),
-                        tools: ['Read', 'Write', 'Edit', 'MultiEdit', 'Bash', 'Glob', 'Grep', 'NotebookRead', 'NotebookEdit'],
-                        model: 'sonnet',
-                        prompt: [
-                            'You are Osborn\'s writer agent. You execute file changes with a verify-first approach.',
-                            '',
-                            '## Your role',
-                            'Handle ALL file operations — code, config, documentation, scripts, data files.',
-                            'You are the only agent that writes. The main agent and reasoner produce plans; you execute them.',
-                            '',
-                            '## VERIFY-FIRST workflow (mandatory)',
-                            '',
-                            '### Step 1: Verify assumptions',
-                            '1. Read the files you\'re about to modify. Confirm they match what the plan expects.',
-                            '2. If the plan references specific code patterns, grep to confirm they exist.',
-                            '3. If applicable, run the current test suite or build to confirm the starting state works.',
-                            '4. If ANYTHING has drifted from the plan (file moved, code refactored, dependency changed):',
-                            '   STOP and report back to the main agent. Do NOT improvise.',
-                            '',
-                            '### Step 2: Clarify unknowns',
-                            '1. If the plan is vague or ambiguous — ask the main agent a specific clarifying question.',
-                            '   Examples: "Which config format — YAML or JSON?", "New file or extend existing auth.ts?"',
-                            '2. The main agent will answer from context or relay to the user.',
-                            '3. Do NOT guess. One clear question is better than a wrong assumption.',
-                            '4. Restate what you will do before doing it: which files, what changes, in what order.',
-                            '',
-                            '### Step 3: Execute changes',
-                            '- Make ONLY the changes described in the plan.',
-                            '- Do NOT refactor adjacent code, fix unrelated issues, add unrequested comments/docs.',
-                            '- If you hit an unexpected issue, STOP and report to the main agent.',
-                            '',
-                            '### Step 4: Verify results',
-                            '1. Run tests if available (npm test, pytest, cargo test, etc.).',
-                            '2. Run the build if applicable (npm run build, tsc --noEmit, etc.).',
-                            '3. If tests or build fail: attempt to fix the issue you introduced. Re-run.',
-                            '4. Report: files changed, what changed in each, test results, any failures.',
-                        ].join('\n'),
-                    },
-                },
+                // Named sub-agents — the orchestrator delegates to these specialists.
+                // Built-in definitions live at module level (NAMED_AGENTS); per-user
+                // DB-backed definitions (opts.agents, via set_agents) take precedence.
+                agents: this.#opts.agents ?? NAMED_AGENTS,
             };
             // Run Claude Agent SDK query() and stream results
             let hasOutput = false;

package/dist/index.js

@@ -29,7 +29,7 @@ const __dirname = dirname(__filename);
 import { createPatch } from 'diff';
 import { loadConfig, getMcpServers, getEnabledMcpServerNames, getVoiceMode, getRealtimeConfig, getDirectConfig, listAllClaudeSessions, getMostRecentSessionId, sessionExists, getSessionSummary, getConversationHistory, ensureSessionWorkspace, getSessionWorkspace, 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 { createClaudeLLM, NAMED_AGENTS } 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';
@@ -286,6 +286,30 @@ function startApiServer(workingDir, port) {
             }
             return;
         }
+        if (req.method === 'GET' && url.pathname === '/skills') {
+            // Installed skills — same list the chat's get_skills data-channel message
+            // returns, exposed over HTTP so the DASHBOARD (no LiveKit connection) can
+            // render the skills manager too. process.cwd() === sessionBaseDir (the
+            // osborn install dir where .claude/skills lives — see main()).
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ skills: loadSkillsList(process.cwd()) }));
+            return;
+        }
+        if (req.method === 'GET' && url.pathname === '/agents') {
+            // Named sub-agents (researcher/reasoner/writer) — definitions come from
+            // claude-llm.ts NAMED_AGENTS (single source of truth, same object the SDK
+            // query uses). Prompts are omitted: the UI manager needs role/model/tools,
+            // not the full instruction text.
+            const agents = Object.entries(NAMED_AGENTS).map(([name, a]) => ({
+                name,
+                description: a.description,
+                model: a.model,
+                tools: a.tools,
+            }));
+            res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+            res.end(JSON.stringify({ agents }));
+            return;
+        }
         if (req.method === 'GET' && url.pathname === '/health') {
             // Include osborn version — primary signal used by machines.readInstalledOsbornVersion()
             // to detect which agent version is running. Without this the consumer falls back to
@@ -1578,6 +1602,11 @@ async function main() {
     // Empty string = anonymous / unauthenticated; uploads fall back to a
     // session-only path (no user prefix).
     let currentUserId = '';
+    // Per-user named agents (DB-backed) — sent by the frontend via set_agents
+    // after agent_ready. Kept here so agent-side LLM recreations (session
+    // switch/resume) reuse them without waiting for a frontend resend. Merged
+    // OVER the built-in NAMED_AGENTS (same-name user rows shadow built-ins).
+    let userNamedAgents = null;
     let activeMeetingBotId = null; // Recall.ai bot ID if in a meeting
     let activeMeetingPoller = null; // Transcript poller bound to that bot
     // LIVE meeting transcript → LLM (buffered webhook finals). See recall.on('transcript').
@@ -2222,6 +2251,8 @@ async function main() {
             voiceMode: 'direct',
             skipTTSQueue: true,
             onCompactionEvent: buildOnCompactionEvent(),
+            // Per-user named agents survive LLM recreations (session switch/resume)
+            agents: userNamedAgents ? { ...NAMED_AGENTS, ...userNamedAgents } : undefined,
         });
         currentLLM = directLLM;
         // Reset the session always-allow list for each new direct session
@@ -4118,6 +4149,9 @@ async function main() {
                     enabledMcpServers: enabledMcpNames,
                     workingDirectory: workingDir,
                     skills: loadSkillsList(sessionBaseDir),
+                    namedAgents: Object.entries(NAMED_AGENTS).map(([name, a]) => ({
+                        name, description: a.description, model: a.model, tools: a.tools,
+                    })),
                 });
             };
             const readyInterval = setInterval(sendReady, 2000);
@@ -4806,6 +4840,56 @@ async function main() {
                     skills: loadSkillsList(sessionBaseDir),
                 });
             }
+            else if (data.type === 'get_agents') {
+                // Named sub-agents for the chat agents manager — built-ins merged with
+                // any per-user DB-backed definitions (prompts omitted from the list).
+                const effective = { ...NAMED_AGENTS, ...(userNamedAgents || {}) };
+                await sendToFrontend({
+                    type: 'agents_status',
+                    agents: Object.entries(effective).map(([name, a]) => ({
+                        name, description: a.description, model: a.model, tools: a.tools,
+                        custom: !!userNamedAgents && name in userNamedAgents,
+                    })),
+                });
+            }
+            else if (data.type === 'set_agents') {
+                // Per-user named agents from the DB (frontend fetches its user_agents
+                // rows and sends them here after agent_ready, and again after edits).
+                // Validated + merged over built-ins, applied via setAgents(). SDK
+                // constraint: takes effect at the next query cold start — a live
+                // subprocess keeps the agents it started with.
+                const MODELS = new Set(['sonnet', 'opus', 'haiku', 'fable', 'inherit']);
+                const rows = Array.isArray(data.agents) ? data.agents : [];
+                const validated = {};
+                for (const r of rows) {
+                    const name = String(r?.name || '').trim().toLowerCase().replace(/[^a-z0-9-]/g, '-');
+                    const description = String(r?.description || '').trim();
+                    const prompt = String(r?.prompt || '').trim();
+                    if (!name || !description || !prompt)
+                        continue;
+                    if (prompt.length > 6000) {
+                        console.warn(`🤖 set_agents: '${name}' prompt >6KB — skipped`);
+                        continue;
+                    }
+                    validated[name] = {
+                        description,
+                        prompt,
+                        ...(Array.isArray(r.tools) && r.tools.length ? { tools: r.tools.map(String) } : {}),
+                        ...(r.model && (MODELS.has(r.model) || /^claude-/.test(r.model)) ? { model: String(r.model) } : {}),
+                    };
+                }
+                userNamedAgents = Object.keys(validated).length ? validated : null;
+                const merged = { ...NAMED_AGENTS, ...(userNamedAgents || {}) };
+                currentLLM?.setAgents?.(userNamedAgents ? merged : undefined);
+                console.log(`🤖 set_agents: ${Object.keys(validated).length} user agent(s) → effective set [${Object.keys(merged).join(', ')}]`);
+                await sendToFrontend({
+                    type: 'agents_status',
+                    agents: Object.entries(merged).map(([name, a]) => ({
+                        name, description: a.description, model: a.model, tools: a.tools,
+                        custom: !!userNamedAgents && name in userNamedAgents,
+                    })),
+                });
+            }
             else if (data.type === 'skill_add') {
                 const skillName = (data.name || '').trim().toLowerCase().replace(/[^a-z0-9-]/g, '-');
                 const skillContent = (data.content || '').trim();

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

@@ -62,6 +62,7 @@ export declare class PipelineDirectLLM extends llm.LLM {
     };
     getMcpServers(): Record<string, import("@anthropic-ai/claude-agent-sdk").McpServerConfig>;
     setMcpServers(s: any): void;
+    setAgents(a: any): void;
     interruptAgent(): Promise<boolean>;
     abortAgent(): void;
     rewindAgent(checkpointId?: string): Promise<boolean>;

package/dist/pipeline-direct-llm.js

@@ -53,6 +53,7 @@ export class PipelineDirectLLM extends llm.LLM {
     getPendingPermission() { return this.#claudeLLM.getPendingPermission(); }
     getMcpServers() { return this.#claudeLLM.getMcpServers(); }
     setMcpServers(s) { this.#claudeLLM.setMcpServers(s); }
+    setAgents(a) { this.#claudeLLM.setAgents(a); }
     // Agent control — proxied to ClaudeLLM for fast brain access
     async interruptAgent() { return this.#claudeLLM.interruptQuery(); }
     abortAgent() { this.#claudeLLM.abortQuery(); }

package/package.json

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