osborn 0.9.94 → 0.9.95

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

@@ -0,0 +1,34 @@
+# 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.
+
+## 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/index.js

@@ -1619,6 +1619,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;
@@ -4195,20 +4253,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
@@ -4880,11 +4931,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 +4951,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.95",
   "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.