osborn 0.9.94 → 0.9.96

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

@@ -0,0 +1,41 @@
+# Browser Screen Recorder — drive any web app (voice, hands + a brain) and record proof
+
+## SKILL IDENTITY
+Name: browser-screen-recorder
+Version: 1 (packaged seed — the served copy at the URL below is source of truth)
+Served from: https://www.voice-native.com/api/browser-screen-recorder
+Landing page: https://www.voice-native.com/browser-screen-recorder
+(Formerly "voice-e2e". The old /api/test-skill URL still resolves to this skill.)
+
+Give a coding agent a web app + an intent and it drives the app in a REAL
+browser and records PROOF it did — per-action screenshots + video clips, audio
+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}')
+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."
+```
+
+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
+the accompanying files stay in lockstep with the skill.
+
+## FIRST USE
+Fetch the served copy and follow its INSTALLATION section — it materializes
+the harness (~/browser-screen-recorder-harness/), installs dependencies, and
+asks the user for a GOOGLE_API_KEY (required, Gemini brain) plus optional
+OPENAI/DEEPGRAM keys for the voice mouth and audible verification.

package/.claude/skills/meetings/SKILL.md

@@ -58,7 +58,15 @@ curl -sS -X POST http://localhost:8741/canvas -H 'Content-Type: application/json
 curl -sS -X POST http://localhost:8741/canvas -H 'Content-Type: application/json' \
   -d '{"kind":"show","mode":"notes","title":"...","items":["...","..."]}'
 ```
-`mode` = `idle` | `notes` (title+items) | `link` (url) | `web` (iframe url) | `text` (title+text).
+`mode` = `idle` | `notes` (title+items) | `link` (url) | `web` (iframe url) | `text` (title+text)
+| `stream` (url — renders `<img src="{url}/stream">`, a live MJPEG browser feed).
+
+**`stream` mode — NO TUNNELS policy:** the feed URL must be PUBLIC. Never
+tunnel a local browser engine to get one (ngrok's free tier burned its entire
+monthly bandwidth cap on one continuous-MJPEG demo — `ERR_NGROK_725`). Run the
+browser-screen-recorder engine on its Fly machine instead; its `:8080` MJPEG is
+already public at `https://<app>.fly.dev/`. See the browser-screen-recorder
+skill ("Casting the feed into a meeting") for details.
 
 **When to speak into the meeting:** By DEFAULT stay silent (observer) for
 `[MEETING — *]:` chunks — take notes, don't interrupt. Speak into the meeting

package/dist/claude-llm.d.ts

@@ -35,6 +35,26 @@ export interface ClaudeLLMOptions {
         trigger?: string;
     }) => void;
 }
+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

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',
@@ -1169,126 +1291,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.
+                // Definitions live at module level (NAMED_AGENTS) so the HTTP API and
+                // frontend agents manager can list them. See top of file.
+                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
@@ -1619,6 +1643,64 @@ async function main() {
         }
         meetingTranscriptBuffer.length = 0;
     };
+    // ── Meeting lifecycle (centralized teardown, 0.9.95) ──
+    // The bot's lifecycle FOLLOWS the voice session (deliberate coupling — a
+    // decoupled always-on bot means untracked background agents; revisit only
+    // with a status/tracking UI). endMeeting() is the single teardown path,
+    // fired by: (a) explicit leave_meeting, (b) user disconnect (auto-leave),
+    // (c) Recall reporting a terminal bot status (call_ended/done/fatal —
+    // detected on the poller's 30s tick; fixes stale bot state when the meeting
+    // ends naturally), or (d) the max-duration backstop below.
+    const MEETING_MAX_MS = Math.max(10, Number(process.env.OSBORN_MEETING_MAX_MIN) || 180) * 60 * 1000; // default 3h
+    let meetingMaxTimer = null;
+    const endMeeting = async (reason, opts = {}) => {
+        const botId = activeMeetingBotId;
+        if (!botId)
+            return;
+        console.log(`🏁 Meeting ended (${reason}) — bot ${botId}`);
+        // Stop inputs FIRST so no more chunks land mid-teardown.
+        stopMeetingFlush();
+        if (activeMeetingPoller) {
+            activeMeetingPoller.stop();
+            activeMeetingPoller = null;
+        }
+        if (meetingMaxTimer) {
+            clearTimeout(meetingMaxTimer);
+            meetingMaxTimer = null;
+        }
+        activeMeetingBotId = null;
+        // leaveBot=false when Recall itself reported the meeting over (bot already gone).
+        if (opts.leaveBot !== false) {
+            const recall = getRecallClient();
+            if (recall)
+                await recall.leaveMeeting(botId).catch((e) => console.warn(`⚠️ leaveMeeting failed: ${e?.message}`));
+        }
+        sendToFrontend({ type: 'meeting_left', botId, reason }).catch(() => { });
+        // Orphan cleanup: if no user is connected, the LLM subprocess was kept alive
+        // solely to serve the meeting — release it now and let idle-exit stop the
+        // machine (same billing discipline as 0.9.73, deferred until meeting end).
+        const userPresent = activeRoom && activeRoom.remoteParticipants.size > 0;
+        if (!userPresent && currentLLM) {
+            console.log('🏁 Meeting over with no user connected — releasing LLM + arming idle-exit');
+            killCurrentLLM(`meeting_ended(${reason})_no_user`);
+            currentLLM = null;
+            clearFastBrainSession();
+            clearPipelineFastBrainSession();
+            armIdleExitTimer(`meeting ended (${reason}), no user`);
+        }
+    };
+    const armMeetingMaxTimer = (botId) => {
+        if (meetingMaxTimer)
+            clearTimeout(meetingMaxTimer);
+        console.log(`⏲️ Meeting max-duration backstop armed: ${MEETING_MAX_MS / 60000} min (override OSBORN_MEETING_MAX_MIN)`);
+        meetingMaxTimer = setTimeout(() => {
+            meetingMaxTimer = null;
+            if (activeMeetingBotId === botId) {
+                console.log('⏲️ Meeting max duration reached — auto-leaving (backstop, not Recall-reported end)');
+                void endMeeting('max_duration_backstop');
+            }
+        }, MEETING_MAX_MS);
+    };
     // Track the active resume session ID across scopes (ParticipantConnected + DataReceived)
     // Updated by resume_session, session_selected, continue_session, switch_session handlers
     let currentResumeSessionId;
@@ -4060,6 +4142,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);
@@ -4195,20 +4280,13 @@ async function main() {
         currentLLM = null;
         clearFastBrainSession();
         clearPipelineFastBrainSession();
-        // Auto-leave any active meeting bot when user disconnects from the room
-        stopMeetingFlush();
-        if (activeMeetingPoller) {
-            activeMeetingPoller.stop();
-            activeMeetingPoller = null;
-        }
-        if (activeMeetingBotId) {
-            const recallDisconnect = getRecallClient();
-            if (recallDisconnect) {
-                console.log(`🤝 Auto-leaving meeting (bot ${activeMeetingBotId}) — user disconnected from room`);
-                recallDisconnect.leaveMeeting(activeMeetingBotId).catch(() => { });
-                activeMeetingBotId = null;
-            }
-        }
+        // Auto-leave any active meeting bot when user disconnects from the room.
+        // DELIBERATE COUPLING: the bot's lifecycle follows the voice session — a
+        // decoupled always-on meeting bot means untracked background agents (no
+        // status surface for them yet). Revisit only WITH a tracking UI.
+        // endMeeting() centralizes the teardown (flush, poller, max-timer, Recall
+        // leave, frontend notify).
+        void endMeeting('user_disconnected');
         // 0.9.83: a real session just ended → use the FAST leave (~20s), not the
         // 3-min alone grace. Runs on the agent, so it fires even on an abrupt tab
         // close. Cancelled if a user rejoins within the grace (handled where the
@@ -4755,6 +4833,16 @@ async function main() {
                     skills: loadSkillsList(sessionBaseDir),
                 });
             }
+            else if (data.type === 'get_agents') {
+                // Named sub-agents for the chat agents manager — same NAMED_AGENTS
+                // source as GET /agents (prompts omitted).
+                await sendToFrontend({
+                    type: 'agents_status',
+                    agents: Object.entries(NAMED_AGENTS).map(([name, a]) => ({
+                        name, description: a.description, model: a.model, tools: a.tools,
+                    })),
+                });
+            }
             else if (data.type === 'skill_add') {
                 const skillName = (data.name || '').trim().toLowerCase().replace(/[^a-z0-9-]/g, '-');
                 const skillContent = (data.content || '').trim();
@@ -4880,11 +4968,17 @@ async function main() {
                                         console.warn(`⚠️ Failed to forward meeting transcript to LLM: ${err.message}`);
                                     }
                                 },
+                                // Authoritative meeting-over signal: Recall's terminal bot status
+                                // (call_ended/done/fatal), checked on the same 30s tick. The bot
+                                // is already gone at that point, so don't re-issue leave.
+                                onMeetingEnd: (code) => { void endMeeting(`recall_status:${code}`, { leaveBot: false }); },
                             });
                             activeMeetingPoller.start();
                             // LIVE path: buffer webhook finals + flush to the LLM every 20s.
                             // (The poller above only lands data after the meeting ENDS.)
                             startMeetingFlush(botId);
+                            // Billing backstop: a forgotten meeting can't hold the machine forever.
+                            armMeetingMaxTimer(botId);
                         }
                         catch (err) {
                             console.error('❌ Recall.ai join error:', err);
@@ -4894,25 +4988,14 @@ async function main() {
                 }
             }
             else if (data.type === 'leave_meeting') {
-                const botId = data.botId;
-                const recallLeave = getRecallClient();
-                if (recallLeave && botId) {
-                    try {
-                        // Stop the transcript poller + live flush FIRST so no more chunks
-                        // get forwarded to the LLM during the leave.
-                        stopMeetingFlush();
-                        if (activeMeetingPoller) {
-                            activeMeetingPoller.stop();
-                            activeMeetingPoller = null;
-                        }
-                        await recallLeave.leaveMeeting(botId);
-                        activeMeetingBotId = null;
-                        await sendToFrontend({ type: 'meeting_left', botId });
-                    }
-                    catch (err) {
-                        console.error('❌ Recall.ai leave error:', err);
-                        await sendToFrontend({ type: 'meeting_error', message: err.message });
-                    }
+                // All teardown (flush, poller, max-timer, Recall leave, meeting_left,
+                // orphan LLM release) is centralized in endMeeting().
+                try {
+                    await endMeeting('user_leave_meeting');
+                }
+                catch (err) {
+                    console.error('❌ Recall.ai leave error:', err);
+                    await sendToFrontend({ type: 'meeting_error', message: err.message });
                 }
             }
             else if (data.type === 'session_selected') {

package/dist/meeting-transcript-poller.d.ts

@@ -41,6 +41,15 @@ export interface MeetingTranscriptPollerOptions {
     intervalMs?: number;
     /** Optional debug logger. */
     onError?: (err: Error) => void;
+    /**
+     * Called ONCE when Recall reports the meeting is over (bot status reaches a
+     * terminal code: call_ended / done / fatal). Rides the same 30s tick — no
+     * extra webhook subscription needed. The meeting-copilot lifecycle uses this
+     * as the authoritative "meeting ended" signal now that the bot is DECOUPLED
+     * from the voice session (a voice disconnect no longer drops the bot, so
+     * something must still end it — this is that something).
+     */
+    onMeetingEnd?: (statusCode: string) => void;
 }
 export declare class MeetingTranscriptPoller {
     #private;

package/dist/meeting-transcript-poller.js

@@ -27,6 +27,8 @@
  *   No backoff — Recall's transcript endpoint is stable enough that a 30s
  *   cadence makes "slow start" non-issues self-recover within one cycle.
  */
+/** Recall bot status codes that mean the meeting/bot is definitively over. */
+const TERMINAL_STATUS_CODES = new Set(['call_ended', 'done', 'fatal']);
 export class MeetingTranscriptPoller {
     #opts;
     #timer = null;
@@ -60,25 +62,43 @@ export class MeetingTranscriptPoller {
             return;
         this.#inFlight = true;
         try {
+            // Meeting-end detection first: if the bot has reached a terminal status,
+            // fire onMeetingEnd (once — stop() sets #stopped so later ticks no-op)
+            // AFTER one final transcript pull below, so the last turns aren't lost.
+            let endedCode = null;
+            if (this.#opts.onMeetingEnd) {
+                try {
+                    const code = await this.#opts.recall.getBotStatus(this.#opts.botId);
+                    if (TERMINAL_STATUS_CODES.has(code))
+                        endedCode = code;
+                }
+                catch { /* status probe is best-effort; transcript pull continues */ }
+            }
             const all = await this.#opts.recall.getTranscript(this.#opts.botId);
             const fresh = all.filter(t => {
                 const firstWordTs = t.words?.[0]?.start_timestamp?.relative;
                 return typeof firstWordTs === 'number' && firstWordTs > this.#cursor;
             });
-            if (fresh.length === 0)
-                return;
-            // Advance cursor to highest seen first-word ts (across all returned turns,
-            // not just the fresh ones — guards against Recall returning a paged subset).
-            for (const t of all) {
-                const ts = t.words?.[0]?.start_timestamp?.relative;
-                if (typeof ts === 'number' && ts > this.#cursor)
-                    this.#cursor = ts;
+            if (fresh.length > 0) {
+                // Advance cursor to highest seen first-word ts (across all returned turns,
+                // not just the fresh ones — guards against Recall returning a paged subset).
+                for (const t of all) {
+                    const ts = t.words?.[0]?.start_timestamp?.relative;
+                    if (typeof ts === 'number' && ts > this.#cursor)
+                        this.#cursor = ts;
+                }
+                const formatted = formatTurns(fresh);
+                if (formatted) {
+                    console.log(`📓 MeetingTranscriptPoller: ${fresh.length} new turn(s), cursor=${this.#cursor.toFixed(1)}s, chars=${formatted.length}`);
+                    await this.#opts.onTurns({ botId: this.#opts.botId, turns: fresh, formatted });
+                }
+            }
+            // Fire end-of-meeting AFTER the final transcript pull so the last turns land.
+            if (endedCode) {
+                console.log(`📓 MeetingTranscriptPoller: bot status '${endedCode}' — meeting ended`);
+                this.stop();
+                this.#opts.onMeetingEnd?.(endedCode);
             }
-            const formatted = formatTurns(fresh);
-            if (!formatted)
-                return; // pure-whitespace fresh batch — skip
-            console.log(`📓 MeetingTranscriptPoller: ${fresh.length} new turn(s), cursor=${this.#cursor.toFixed(1)}s, chars=${formatted.length}`);
-            await this.#opts.onTurns({ botId: this.#opts.botId, turns: fresh, formatted });
         }
         catch (err) {
             const e = err instanceof Error ? err : new Error(String(err));

package/package.json

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

package/.claude/skills/voice-e2e/SKILL.md

@@ -1,32 +0,0 @@
-# Voice-E2E — browser testing with ears, a mouth, hands and a brain
-
-## SKILL IDENTITY
-Name: voice-e2e
-Version: 1 (packaged seed — the served copy at the URL below is source of truth)
-Served from: https://www.voice-native.com/api/test-skill
-Landing page: https://www.voice-native.com/test-skill
-
-Agent-driven end-to-end testing for voice and web apps in a REAL browser:
-speak into the page's mic (synthesized on the fly), hear and transcribe what
-it plays back, click via a natural-language brain, improvise conversations,
-and get video + audio replays per run. Works on any website.
-
-## UPDATE CHECK (notify-first, run before major test/research 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/test-skill | grep -m1 '^Version:' | awk '{print $2}')
-LOCAL_V=$(grep -m1 '^Version:' ~/.claude/skills/voice-e2e/SKILL.md 2>/dev/null | awk '{print $2}')
-[ -n "$SERVED_V" ] && [ "$SERVED_V" != "$LOCAL_V" ] && echo "UPDATE AVAILABLE: voice-e2e 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/test-skill -o ~/.claude/skills/voice-e2e/SKILL.md), then refresh the harness bundle per the served INSTALLATION."
-```
-
-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
-the accompanying files stay in lockstep with the skill.
-
-## FIRST USE
-Fetch the served copy and follow its INSTALLATION section — it materializes
-the harness (~/voice-e2e-harness/), installs dependencies, and asks the user
-for a GOOGLE_API_KEY (required, Gemini brain) plus optional OPENAI/DEEPGRAM
-keys for the voice mouth and audible verification.