osborn 0.9.54 → 0.9.58

package/.claude/skills/bug-reporter/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: bug-reporter
+description: |
+  File a bug report or feature request when the user describes a problem with
+  Osborn itself (voice glitches, agent freezes, audio echo, session crashes,
+  interrupt issues) or asks for a new Osborn feature. Posts to a local agent
+  endpoint that hands the report off to the frontend, which writes it to
+  Supabase. Use whenever the user describes something wrong with Osborn —
+  NOT for questions about their own project code.
+---
+
+# Bug Reporter Skill
+
+File bug reports and feature requests from inside a voice session, without
+breaking the conversation. Reports land in the dev team's Supabase table for
+triage from a separate Claude Code session.
+
+## When to use this
+
+Trigger when the user describes any of these (or similar):
+
+**Bugs:**
+- Voice quality issues — "the audio cut out", "I can't hear you", "you keep echoing", "you interrupted yourself"
+- Agent malfunctions — "the agent froze", "it crashed", "it stopped responding", "you're stuck"
+- Session issues — "session disconnected", "the room keeps closing", "I had to restart"
+- Memory/state issues — "you don't remember", "you lost context"
+- Interrupt problems — "you keep cutting yourself off", "the interrupt isn't working"
+- Direct asks — "this is a bug", "file this", "report this", "let me know when it's fixed"
+
+**Feature requests:**
+- "I wish Osborn could…", "can you add…", "it would be nice if…", "feature request:"
+
+## When NOT to use
+
+- The user has a coding question about THEIR project — that's normal research/coding work
+- The user mentions an error in code they're writing — not an Osborn bug
+- The user is debugging their own logs — they're working, not reporting
+
+## How to file
+
+### Step 1 — confirm with the user
+
+Don't silently file. Say something brief like:
+
+> "Sounds like a real bug — want me to file it so the team can dig in? I'll
+> include the recent logs."
+
+If they say yes, proceed. If unsure, ask whether it's worth filing.
+
+### Step 2 — POST to the local agent endpoint
+
+```bash
+curl -sS -X POST http://localhost:8741/report-bug \
+  -H "Content-Type: application/json" \
+  -d @- <<'JSON'
+{
+  "type": "bug",
+  "severity": "medium",
+  "title": "Voice cuts out mid-sentence in pipeline mode",
+  "description": "User reported that the agent stops speaking mid-sentence and resumes 5 minutes later. Happens repeatedly. Started after migrating to user_state_changed handler (May 21, 0.9.39).",
+  "reproduction_notes": "Speak to the agent, then go silent — audio cuts off at a sentence boundary and won't resume until mic is muted for ~2 seconds.",
+  "tags": ["voice-quality", "interrupt", "echo"]
+}
+JSON
+```
+
+The agent endpoint:
+- Generates a `reportId`
+- Tails `/workspace/osborn.log` (last 500 lines)
+- Pulls the last few turns from the current JSONL session
+- Sends everything to the frontend via the LiveKit data channel
+- Returns `{ reportId, status: "submitted" }` to you
+
+You don't need to attach logs yourself — the agent does that automatically.
+
+### Step 3 — confirm to the user
+
+Briefly:
+
+> "Filed. Bug `f4a2…` — the team will look. Want me to log anything else?"
+
+Use the first 4 chars of the returned `reportId` as a short reference.
+
+## Choosing severity
+
+- `critical` — voice completely unusable, session crashes immediately, data loss
+- `high` — major friction (voice keeps cutting, frequent crashes, can't connect)
+- `medium` — annoying but workable (echo, occasional drops, minor UI glitches)
+- `low` — nice-to-have polish, edge cases, documentation gaps, feature requests
+
+Feature requests default to `low` unless the user describes blocking workflows.
+
+## Title writing
+
+Short, present-tense, specific. 6–10 words.
+
+Good:
+- "Voice cuts out mid-sentence in pipeline mode"
+- "Agent echoes own speech as user interrupt"
+- "Session orphaned after machine OOM auto-restart"
+
+Bad:
+- "voice bug" (too vague)
+- "When I was talking the agent stopped responding and I had to..." (use description)
+
+## What NOT to include in the description
+
+- Don't dump the full transcript — the agent attaches a `transcript_excerpt` automatically
+- Don't paste log lines — the agent attaches the `log_excerpt` automatically
+- Don't speculate about the fix unless the user explicitly suggested one
+- Don't include the user's API keys, OAuth tokens, or PII
+
+## Tags vocabulary
+
+Pick from these rough buckets (one or more):
+`echo, interrupt, crash, freeze, memory, voice-quality, audio, mode-specific,
+direct, pipeline, realtime, ui, sessions, fly, recall, meeting, deepgram, tts, stt`
+
+## Reading existing reports
+
+You don't query, list, or close reports from inside a voice session — that's
+the dev team's job from their own Claude Code session. If the user asks "is
+that bug fixed yet?", say "let me check" and use the same endpoint with `GET`:
+
+```bash
+curl -sS "http://localhost:8741/report-bug?id=${REPORT_ID}"
+```
+
+But typically the user won't ask, and you don't need to volunteer the status.

package/dist/index.js

@@ -1,7 +1,7 @@
 // Load environment variables FIRST before any other imports
 import 'dotenv/config';
 import { voice, initializeLogger } from '@livekit/agents';
-import { Room, RoomEvent, RemoteParticipant, } from '@livekit/rtc-node';
+import { Room, RoomEvent, } from '@livekit/rtc-node';
 import { AccessToken } from 'livekit-server-sdk';
 // Initialize logger before anything else
 initializeLogger({ pretty: true, level: 'info' });
@@ -14,6 +14,7 @@ import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, mkdtem
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { homedir, tmpdir } from 'node:os';
 import { PassThrough } from 'node:stream';
 import { createGunzip } from 'node:zlib';
@@ -189,6 +190,14 @@ const livekitState = {
 let intentionalLeave = false;
 let connectRoomHook = null;
 let leaveRoomHook = null;
+// Hook for the bug-reporter skill. The /report-bug HTTP endpoint validates the
+// payload + generates the reportId in the module-level handler, then delegates
+// to this hook which lives in main() (where sendToFrontend, currentVoiceMode,
+// and currentSession are in scope). The frontend listens for the data channel
+// message type 'bug_report' and writes the row to Supabase — same architecture
+// as the existing fetch-log/save-log flow so we don't ship Supabase credentials
+// to the Fly machine.
+let bugReportHook = null;
 function startApiServer(workingDir, port) {
     const server = createServer(async (req, res) => {
         // CORS headers for cloud frontend
@@ -332,6 +341,67 @@ function startApiServer(workingDir, port) {
             }
             return;
         }
+        // POST /report-bug — invoked by the bug-reporter skill (running inside Claude
+        // Code on this same machine) when the user describes an Osborn bug or
+        // requests a feature. We validate the payload, generate a reportId, and emit
+        // a data channel message via bugReportHook → sendToFrontend. The frontend
+        // owns the actual Supabase write (it already has the keys for the log-upload
+        // flow, no need to ship them to the Fly machine).
+        if (req.method === 'POST' && url.pathname === '/report-bug') {
+            let body = '';
+            req.on('data', (chunk) => { body += chunk.toString(); });
+            req.on('end', () => {
+                try {
+                    const parsed = JSON.parse(body || '{}');
+                    const errors = [];
+                    if (parsed.type !== 'bug' && parsed.type !== 'feature')
+                        errors.push('type must be "bug" or "feature"');
+                    if (!parsed.title || typeof parsed.title !== 'string' || parsed.title.length < 3)
+                        errors.push('title required (>= 3 chars)');
+                    if (!parsed.description || typeof parsed.description !== 'string')
+                        errors.push('description required');
+                    const sev = parsed.severity || 'medium';
+                    if (!['low', 'medium', 'high', 'critical'].includes(sev))
+                        errors.push('severity invalid');
+                    if (errors.length) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'invalid payload', details: errors }));
+                        return;
+                    }
+                    const reportId = randomUUID();
+                    const payload = {
+                        type: parsed.type,
+                        severity: sev,
+                        title: parsed.title.trim().slice(0, 200),
+                        description: parsed.description.trim().slice(0, 8000),
+                        reproduction_notes: typeof parsed.reproduction_notes === 'string'
+                            ? parsed.reproduction_notes.trim().slice(0, 4000)
+                            : undefined,
+                        tags: Array.isArray(parsed.tags)
+                            ? parsed.tags.filter((t) => typeof t === 'string').slice(0, 20)
+                            : undefined,
+                    };
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ reportId, status: 'submitted' }));
+                    if (bugReportHook) {
+                        try {
+                            bugReportHook(reportId, payload);
+                        }
+                        catch (e) {
+                            console.error('❌ bugReportHook threw:', e);
+                        }
+                    }
+                    else {
+                        console.warn('⚠️ /report-bug fired but no bugReportHook registered (frontend may not receive)');
+                    }
+                }
+                catch (e) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'invalid JSON', details: e.message }));
+                }
+            });
+            return;
+        }
         // POST /restart — graceful process restart (process manager will restart)
         if (req.method === 'POST' && url.pathname === '/restart') {
             res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -1205,16 +1275,6 @@ async function main() {
     // Session-level always-allow list: paths the user has approved for this session without prompting
     let sessionAlwaysAllowPaths = new Set();
     let userState = 'listening'; // Track user speech state for queue safety
-    // Self-echo guard for the TTS interrupt below. Updated by the
-    // ActiveSpeakersChanged listener registered near the other room.on(...) handlers.
-    // user_state_changed carries NO speaker identity (verified against the SDK type
-    // — UserStateChangedEvent has only oldState/newState/createdAt), so a separate
-    // remote-speaker timestamp is the only way to distinguish "real user spoke" from
-    // "agent's own TTS echoed through the mic". Independent producer: rtc-node
-    // emits activeSpeakersChanged from server WebRTC audio-level reports
-    // (room.js:213), with NO reference to AgentSession or STT — so there's no
-    // dependency loop with user_state_changed's STT-driven producer.
-    let lastRemoteSpeakerAt = 0;
     let currentVoiceMode = voiceMode; // Track active voice mode for data handlers
     let currentProvider = realtimeConfig.provider; // Track active realtime provider
     // Authenticated Supabase userId from participant metadata. Used to scope
@@ -2062,18 +2122,22 @@ async function main() {
                     minDelay: 500, // Wait 500ms after STT commits before generating reply
                     maxDelay: 2000, // Force end-of-turn after 2s to prevent hangs
                 },
-                // Echo-driven false-interrupt protection at the SDK level (1.2.x has these knobs,
-                // we just never set them — defaults are minDuration:500ms / minWords:0 which let
-                // through every short echo blip). Both knobs gate the SDK's internal
-                // interruptByAudioActivity() (agent_activity.js — runs on Deepgram interim
-                // transcripts AND speechDuration updates), which is the path that was firing
-                // even after our user_state_changed handler skipped the trigger.
+                // 0.9.57: bump falseInterruptionTimeout from default 2000ms → 3000ms.
+                // This is the silence-after-interrupt window the SDK waits before
+                // emitting agentFalseInterruption + resuming. Extending it gives the
+                // user a fuller breath between low-level audio activity moments to
+                // accumulate a clean silence, which helps when echo or ambient noise
+                // keeps resetting the 2s window. Other tunables in this same block
+                // (NOT changed yet — try the timeout first, escalate if needed):
+                //   - minDuration (default 500ms) — minimum sustained speech to count
+                //   - minWords (default 0) — minimum word count in interim transcript
+                //   - enabled (default true) — kept ON (auto-interrupt path active)
+                //   - resumeFalseInterruption (default true) — auto-resume kept ON
+                //   - discardAudioIfUninterruptible (default true)
                 interruption: {
-                    minDuration: 750, // 500 → 750: require 750ms of sustained audio activity
-                    minWords: 2, // 0 → 2: require ≥2 transcript words (filters single-word echo blips)
-                    // SDK defaults kept: enabled=true, resumeFalseInterruption=true,
-                    // falseInterruptionTimeout=2000ms (that 2s timer is what resumed your audio
-                    // exactly where it stopped — confirmed working as designed).
+                    falseInterruptionTimeout: 3000, // 2000 → 3000 (extra second of silence before resume)
+                    minDuration: 1000, // 500 → 1000 (need 1s sustained speech to count)
+                    minWords: 3, // 0 → 3 (interim transcript needs ≥3 words)
                 },
             },
         });
@@ -2612,20 +2676,6 @@ async function main() {
         // rather than hold it indefinitely. Cancelled in ParticipantConnected.
         armAloneTimer();
     });
-    // Self-echo guard producer. Server WebRTC audio-level reports drive this
-    // (rtc-node room.js:213, ~50-100ms latency from mic onset — faster than
-    // Deepgram STT classification, so by the time user_state_changed fires
-    // lastRemoteSpeakerAt is already current). Filter speakers to RemoteParticipant
-    // — LocalParticipant is the agent itself and including it would defeat the
-    // whole point (the echo we're guarding against IS the agent's local audio).
-    // This is the speaker-identity filter the removed ActiveSpeakersChanged
-    // handler had (May 21 / c345c98) — minus the interrupt() call, since the
-    // user_state_changed handler now owns interrupt firing.
-    room.on(RoomEvent.ActiveSpeakersChanged, (speakers) => {
-        if (speakers.some((s) => s instanceof RemoteParticipant)) {
-            lastRemoteSpeakerAt = Date.now();
-        }
-    });
     // NOTE: previously this section also had a RoomEvent.ActiveSpeakersChanged
     // handler that interrupted TTS on any sustained audio activity (~50ms after
     // mic onset). That fired too eagerly — coughs, paper rustles, the agent's
@@ -2991,25 +3041,15 @@ async function main() {
                 userState = ev.newState;
                 console.log(`👤 User state: ${prev} → ${ev.newState} (agent: ${agentState})`);
                 if (ev.newState === 'speaking' && agentState === 'speaking' && sessionVoiceMode !== 'realtime') {
-                    const now = Date.now();
-                    // Self-echo guard. Reject this trigger entirely if no remote
-                    // participant has been heard speaking in the last 500ms — at that
-                    // point user_state=speaking is almost certainly TTS bleeding through
-                    // the mic (Deepgram correctly identifies it as "speech", we add the
-                    // identity filter the high-level event lacks). 500ms is wider than
-                    // the ~50-300ms gap between ActiveSpeakersChanged and user_state_changed
-                    // firing, so a real user is comfortably inside the window.
-                    //
-                    // The 1s leading-edge debounce that used to live here was removed in
-                    // 0.9.54 — the SDK-side `turnHandling.interruption.minDuration:750` +
-                    // `minWords:2` now do the heavy lifting on echo filtering, and stacking
-                    // an extra cooldown on top risked masking the SDK's own resume timing.
-                    if (now - lastRemoteSpeakerAt > 500) {
-                        console.log('🔇 Skipping interrupt — no recent remote-speaker activity (self-echo guard)');
-                        return;
-                    }
+                    // Reverted to the simple post-May-22 (c345c98 / 0.9.39) shape in 0.9.56.
+                    // The self-echo guard via lastRemoteSpeakerAt was defeated by the same
+                    // physics it was trying to filter — TTS bleeds into the user's mic →
+                    // LiveKit registers their participant as a remote speaker → the guard
+                    // passes → we interrupt anyway. Verified in osbornojure logs 2026-06-16
+                    // (2 of 3 interrupts that session were from this handler firing on echo).
+                    // Echo prevention moved to browser AEC on the publisher side.
                     try {
-                        console.log('🎤 user_state_changed=speaking + agent speaking + remote-speaker confirmed → interrupting TTS');
+                        console.log('🎤 user_state_changed=speaking + agent speaking → interrupting TTS');
                         currentSession?.interrupt();
                     }
                     catch (err) {
@@ -4282,6 +4322,40 @@ async function main() {
             console.error('leave-room room.disconnect failed:', e);
         }
     };
+    // bug-reporter skill hook — forwards a validated bug payload to the frontend
+    // via the LiveKit data channel. Frontend (which holds the Supabase keys for
+    // the existing log-upload flow) is responsible for the actual Supabase write.
+    // Enriches with the agent-side facts the frontend doesn't already have on
+    // hand (voice_mode + sandbox_id from FLY_MACHINE_ID — version it can read
+    // from /health, session_id it tracks via preSelectedSessionId).
+    bugReportHook = (reportId, payload) => {
+        const sandboxId = process.env.FLY_MACHINE_ID || null;
+        let osbornVersion;
+        try {
+            for (const rel of ['../package.json', '../../package.json']) {
+                try {
+                    const pkg = JSON.parse(readFileSync(join(__dirname, rel), 'utf8'));
+                    if (pkg.name === 'osborn' && pkg.version) {
+                        osbornVersion = pkg.version;
+                        break;
+                    }
+                }
+                catch { /* try next */ }
+            }
+        }
+        catch { /* version optional */ }
+        console.log(`🪲 Bug report ${reportId.slice(0, 8)} (${payload.type}/${payload.severity}): ${payload.title}`);
+        sendToFrontend({
+            type: 'bug_report',
+            reportId,
+            payload,
+            context: {
+                voice_mode: currentVoiceMode,
+                sandbox_id: sandboxId,
+                osborn_version: osbornVersion,
+            },
+        }).catch((e) => console.error('❌ bugReportHook sendToFrontend failed:', e));
+    };
     // Fire and forget; the retry loop keeps the process alive on its own (so
     // we don't need the explicit `new Promise(() => {})` keepalive anymore).
     // Errors that escape the retry loop should never happen, but if they do,

package/package.json

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