osborn 0.9.120 → 0.9.122

package/dist/index.js

@@ -235,42 +235,71 @@ let meetingAgentSpeakingText = '';
 // Prepended to the next flush: what the bot was cut off saying + who interrupted
 // (same pattern as voice-native interruptions).
 let meetingInterruptContext = '';
+// Meeting speech QUEUE (0.9.121): serialize output_audio so replies never
+// overlap — the Recall-sink equivalent of session.say's SpeechHandle queue.
+// Recall's output_audio POST returns on ACCEPT, not on finish, so without this
+// two replies (from two flushes, or a streamed multi-chunk reply) play ON TOP
+// of each other — the "another voice over it" the user heard. Each utterance
+// waits for the prior one's estimated playback before it plays; a generation
+// counter (bumped on human interruption / a superseding turn) discards anything
+// still queued so the bot never talks over itself or a human.
+let meetingSpeakChain = Promise.resolve();
+let meetingSpeakGen = 0;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// Estimated playback duration of a spoken line: ~2.5 words/sec + ~0.8s Recall
+// buffer. Used to hold the speech queue so the next utterance doesn't overlap.
+function estimatedSpeechMs(text) {
+    const words = text.split(/\s+/).filter(Boolean).length;
+    return Math.min(30_000, 800 + (words / 2.5) * 1000);
+}
+// Interrupt all meeting speech: bump the generation (drops queued + in-synth
+// utterances) and stop any output_audio Recall is currently playing.
+function interruptMeetingSpeech(reason) {
+    meetingSpeakGen++;
+    meetingAgentSpeaking = false;
+    if (meetingSpeakClearTimer) {
+        clearTimeout(meetingSpeakClearTimer);
+        meetingSpeakClearTimer = null;
+    }
+    const recall = getRecallClient();
+    const botId = recall?.getActiveBotIds?.()[0];
+    if (recall && botId)
+        void recall.stopOutputAudio(botId);
+    console.log(`✋ meeting speech interrupted (${reason}) — queue cleared + output_audio stopped`);
+}
 // Synthesize speech as MP3 (Deepgram fast path, OpenAI fallback) — for
 // Recall native output_audio, which requires mp3.
 async function synthMp3(text) {
     const t0 = Date.now();
-    const dgKey = process.env.DEEPGRAM_API_KEY;
-    if (dgKey) {
-        try {
-            const dg = await fetch('https://api.deepgram.com/v1/speak?model=aura-2-asteria-en&encoding=mp3&bit_rate=48000', {
-                method: 'POST',
-                headers: { 'Authorization': `Token ${dgKey}`, 'Content-Type': 'application/json' },
-                body: JSON.stringify({ text: text.slice(0, 4000) }),
-                signal: AbortSignal.timeout(12000),
-            });
-            if (dg.ok) {
-                const buf = Buffer.from(await dg.arrayBuffer());
-                console.log(`🗣️ synthMp3 deepgram ${buf.length}b in ${Date.now() - t0}ms`);
-                return buf;
-            }
-        }
-        catch (e) {
-            console.warn(`⚠️ synthMp3 deepgram: ${e.message}`);
-        }
-    }
     const oa = process.env.OPENAI_API_KEY;
-    if (oa) {
-        try {
-            const r = await fetch('https://api.openai.com/v1/audio/speech', {
-                method: 'POST',
-                headers: { 'Authorization': `Bearer ${oa}`, 'Content-Type': 'application/json' },
-                body: JSON.stringify({ model: 'gpt-4o-mini-tts', voice: 'alloy', input: text.slice(0, 4000), response_format: 'mp3' }),
-                signal: AbortSignal.timeout(15000),
-            });
-            if (r.ok)
-                return Buffer.from(await r.arrayBuffer());
+    if (!oa) {
+        console.warn('⚠️ synthMp3: no OPENAI_API_KEY — meeting has no voice');
+        return null;
+    }
+    // Meeting voice = the SAME OpenAI model/voice as the website's regular TTS
+    // (DIRECT_MODE_TTS), so the bot sounds IDENTICAL on both fronts (user directive
+    // 2026-08-04: Deepgram aura sounded "cheap and inconsistent"). Deepgram removed
+    // from the meeting path entirely. Pulls model/voice from DIRECT_MODE_TTS when
+    // it's an OpenAI config so the two never drift.
+    const model = DIRECT_MODE_TTS.provider === 'openai' ? (DIRECT_MODE_TTS.model || 'tts-1-hd') : 'tts-1-hd';
+    const voice = DIRECT_MODE_TTS.provider === 'openai' ? (DIRECT_MODE_TTS.voice || 'fable') : 'fable';
+    try {
+        const r = await fetch('https://api.openai.com/v1/audio/speech', {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${oa}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ model, voice, input: text.slice(0, 4000), response_format: 'mp3' }),
+            signal: AbortSignal.timeout(20000),
+        });
+        if (r.ok) {
+            const buf = Buffer.from(await r.arrayBuffer());
+            console.log(`🗣️ synthMp3 openai ${model}/${voice} ${buf.length}b in ${Date.now() - t0}ms`);
+            return buf;
         }
-        catch { /* fall through */ }
+        const e = await r.text().catch(() => '');
+        console.warn(`⚠️ synthMp3 openai ${r.status}: ${e.slice(0, 120)}`);
+    }
+    catch (e) {
+        console.warn(`⚠️ synthMp3 openai: ${e.message}`);
     }
     return null;
 }
@@ -282,21 +311,43 @@ async function synthMp3(text) {
 // bot's camera shows what it's saying — no double-audio. output_audio +
 // canvas camera coexist (confirmed: user heard output_audio while the canvas
 // was showing). Falls back to canvas 'say' (audio) only if output_audio fails.
-async function speakIntoMeeting(text) {
-    const recall = getRecallClient();
-    const botId = recall?.getActiveBotIds?.()[0];
-    if (recall && botId) {
-        const mp3 = await synthMp3(text);
-        if (mp3 && await recall.outputAudio(botId, mp3)) {
-            console.log(`📢 spoke via Recall output_audio (${mp3.length}b): "${text.slice(0, 60)}"`);
-            pushCanvas({ kind: 'caption', text }); // visual only, no audio
-            markMeetingSpeaking(text);
+function speakIntoMeeting(text) {
+    if (!text?.trim())
+        return Promise.resolve();
+    // Capture the generation at ENQUEUE time. If an interrupt (or a superseding
+    // turn) bumps the gen before this item runs — or mid-synth — we drop it, so
+    // the bot never plays a reply the conversation has already moved past.
+    const gen = meetingSpeakGen;
+    const run = meetingSpeakChain.then(async () => {
+        if (gen !== meetingSpeakGen) {
+            console.log(`🔇 meeting speech superseded — dropping: "${text.slice(0, 40)}"`);
             return;
         }
-    }
-    console.log(`📽️ falling back to canvas say (audio): "${text.slice(0, 50)}"`);
-    pushCanvas({ kind: 'say', text });
-    markMeetingSpeaking(text);
+        const recall = getRecallClient();
+        const botId = recall?.getActiveBotIds?.()[0];
+        if (recall && botId) {
+            const mp3 = await synthMp3(text);
+            if (gen !== meetingSpeakGen) {
+                console.log(`🔇 meeting speech interrupted mid-synth — dropping: "${text.slice(0, 40)}"`);
+                return;
+            }
+            if (mp3 && await recall.outputAudio(botId, mp3)) {
+                console.log(`📢 spoke via Recall output_audio (${mp3.length}b): "${text.slice(0, 60)}"`);
+                pushCanvas({ kind: 'caption', text }); // visual only, no audio
+                markMeetingSpeaking(text);
+                // Hold the queue for the estimated playback so the NEXT utterance
+                // doesn't start on top of this one (POST returns on accept, not finish).
+                await sleep(estimatedSpeechMs(text));
+                return;
+            }
+        }
+        console.log(`📽️ falling back to canvas say (audio): "${text.slice(0, 50)}"`);
+        pushCanvas({ kind: 'say', text });
+        markMeetingSpeaking(text);
+        await sleep(estimatedSpeechMs(text));
+    }).catch((e) => { console.warn(`⚠️ meeting speak failed: ${e.message}`); });
+    meetingSpeakChain = run;
+    return run;
 }
 function markMeetingSpeaking(text) {
     meetingAgentSpeaking = true;
@@ -656,46 +707,23 @@ function startApiServer(workingDir, port) {
                 return;
             }
             const t0 = Date.now();
-            // Deepgram FIRST (2026-08-01 latency fix): same TTS family the regular
-            // voice pipeline uses — ~3-6x faster than the OpenAI full-file synth this
-            // endpoint used before (measured 2-4s of the meeting reply lag). OpenAI
-            // stays as fallback.
-            const dgKey = process.env.DEEPGRAM_API_KEY;
-            if (dgKey) {
-                try {
-                    // WAV/linear16, not mp3: mp3 files carry encoder padding (leading/
-                    // trailing silence + boundary click) — back-to-back sentence clips
-                    // were heard as "cracking". WAV is gapless-safe and cheaper to decode.
-                    const dg = await fetch('https://api.deepgram.com/v1/speak?model=aura-2-asteria-en&encoding=linear16&sample_rate=48000&container=wav', {
-                        method: 'POST',
-                        headers: { 'Authorization': `Token ${dgKey}`, 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ text }),
-                    });
-                    if (dg.ok) {
-                        const buf = Buffer.from(await dg.arrayBuffer());
-                        console.log(`🗣️ /tts deepgram wav ${buf.length}b in ${Date.now() - t0}ms (${text.length} chars) t=${new Date().toISOString()}`);
-                        res.writeHead(200, { 'Content-Type': 'audio/wav', 'Cache-Control': 'no-store', 'Content-Length': buf.length });
-                        res.end(buf);
-                        return;
-                    }
-                    console.warn(`⚠️ /tts deepgram ${dg.status} — falling back to OpenAI`);
-                }
-                catch (e) {
-                    console.warn(`⚠️ /tts deepgram error: ${e.message} — falling back to OpenAI`);
-                }
-            }
-            const voice = url.searchParams.get('voice') || 'alloy';
+            // Meeting voice = the SAME OpenAI model/voice as the website's regular TTS
+            // (DIRECT_MODE_TTS) — user directive 2026-08-04: Deepgram aura removed, it
+            // sounded cheap/inconsistent. Consistency over the ~2-4s latency Deepgram
+            // saved. mp3 out (the canvas <audio> element plays it into the meeting).
             const key = process.env.OPENAI_API_KEY;
             if (!key) {
                 res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'no TTS provider keys' }));
+                res.end(JSON.stringify({ error: 'no OPENAI_API_KEY' }));
                 return;
             }
+            const model = DIRECT_MODE_TTS.provider === 'openai' ? (DIRECT_MODE_TTS.model || 'tts-1-hd') : 'tts-1-hd';
+            const voice = url.searchParams.get('voice') || (DIRECT_MODE_TTS.provider === 'openai' ? (DIRECT_MODE_TTS.voice || 'fable') : 'fable');
             try {
                 const tts = await fetch('https://api.openai.com/v1/audio/speech', {
                     method: 'POST',
                     headers: { 'Authorization': `Bearer ${key}`, 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ model: 'gpt-4o-mini-tts', voice, input: text, response_format: 'mp3' }),
+                    body: JSON.stringify({ model, voice, input: text, response_format: 'mp3' }),
                 });
                 if (!tts.ok) {
                     const e = await tts.text().catch(() => '');
@@ -704,7 +732,7 @@ function startApiServer(workingDir, port) {
                     return;
                 }
                 const buf = Buffer.from(await tts.arrayBuffer());
-                console.log(`🗣️ /tts openai ${buf.length}b in ${Date.now() - t0}ms t=${new Date().toISOString()}`);
+                console.log(`🗣️ /tts openai ${model}/${voice} ${buf.length}b in ${Date.now() - t0}ms t=${new Date().toISOString()}`);
                 res.writeHead(200, { 'Content-Type': 'audio/mpeg', 'Cache-Control': 'no-store', 'Content-Length': buf.length });
                 res.end(buf);
             }
@@ -1775,13 +1803,14 @@ async function main() {
             // from muting the audio path. Reset by endMeeting.
             meetingAddressedUntil = Date.now() + 6 * 60 * 60 * 1000;
         }
-        // PROMPT PARITY (user directive 2026-08-01): addressed turns carry ONLY a
-        // minimal tag — no behavioral re-instruction. The agent replies exactly as
-        // it would to a regular voice turn; the tts_say→canvas redirect handles
-        // where the words go. Same agent, same behavior, both fronts.
-        const header = addressed
-            ? `[MEETING — ${botId}] (addressed — reply is spoken into the meeting):`
-            : `[MEETING — ${botId}]:`;
+        // NO meeting-specific reply coaching (user directive 2026-08-04): the reply
+        // must be exactly what the main Claude Code agent would say — no brevity
+        // rules, no "spoken out loud" framing. Just a bare [MEETING — id] routing
+        // tag, which is all the plumbing needs: PipelineDirectLLM keys
+        // suppressMeetingTTS off the `[MEETING` prefix, and whether the reply is
+        // SPOKEN is decided in CODE (activeMeetingBotId + meetingAddressedUntil),
+        // not by any prompt instruction. Addressed vs observer is the code boolean.
+        const header = `[MEETING — ${botId}]:`;
         // Prepend + consume any interruption context (bot was cut off mid-sentence).
         const interrupt = meetingInterruptContext ? `${meetingInterruptContext}\n` : '';
         meetingInterruptContext = '';
@@ -1806,8 +1835,33 @@ async function main() {
             meetingFlushTimer = null;
             console.log('📓 Meeting flush timer stopped');
         }
+        if (addressedFlushTimer) {
+            clearTimeout(addressedFlushTimer);
+            addressedFlushTimer = null;
+        }
         meetingTranscriptBuffer.length = 0;
     };
+    // TURN-DEBOUNCED addressed flush (0.9.121): Recall closes a transcript
+    // segment on every pause, so flushing on each final made the bot reply to
+    // FRAGMENTS mid-thought (and multiple times per utterance). Instead we
+    // debounce: each new transcript final resets a short timer; we only flush
+    // (= reply) after the speaker has actually paused, so one turn = one reply.
+    // speech_off (a hard silence boundary) can flush sooner via a smaller delay.
+    let addressedFlushTimer = null;
+    const ADDRESSED_DEBOUNCE_MS = 1400;
+    const scheduleAddressedFlush = (botId, delayMs = ADDRESSED_DEBOUNCE_MS) => {
+        if (addressedFlushTimer)
+            clearTimeout(addressedFlushTimer);
+        addressedFlushTimer = setTimeout(() => {
+            addressedFlushTimer = null;
+            if (!meetingTranscriptBuffer.length)
+                return;
+            // A fresh human turn supersedes anything the bot was still saying about
+            // the previous one — interrupt stale queued/playing speech before we reply.
+            interruptMeetingSpeech('new addressed turn');
+            flushMeetingBuffer(botId, true);
+        }, delayMs);
+    };
     // ── 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
@@ -1969,8 +2023,12 @@ async function main() {
                 }
                 const oneOnOne = meetingSpeakers.size <= 1;
                 if (oneOnOne || /\b(osborne?|oz\s?born|os\s?born|was born|is born|ozborn|osbourne?|austin\b.{0,8}(hear|there|can you))/i.test(text)) {
-                    console.log(`📓 Addressed (${oneOnOne ? '1:1 meeting' : 'by name'}) — immediate flush for a response`);
-                    flushMeetingBuffer(botId, true);
+                    // DEBOUNCED (0.9.121): don't reply to this fragment — wait for the
+                    // speaker to actually pause. Each new final resets the timer, so one
+                    // continuous thought (even across Recall's mid-sentence segment splits)
+                    // becomes ONE reply instead of several talking over each other.
+                    console.log(`📓 Addressed (${oneOnOne ? '1:1 meeting' : 'by name'}) — turn debounced (~${ADDRESSED_DEBOUNCE_MS}ms)`);
+                    scheduleAddressedFlush(botId);
                 }
             }
         });
@@ -1982,12 +2040,16 @@ async function main() {
                 // bot's audio and record what it was cut off saying so the next flush can
                 // tell it what it missed (same pattern as voice-native interruptions).
                 if (meetingAgentSpeaking && !isBot) {
-                    console.log(`✋ Interruption — ${participant} spoke while bot was talking. Stopping bot audio.`);
-                    pushCanvas({ kind: 'stop' });
+                    console.log(`✋ Interruption — ${participant} spoke while bot was talking.`);
+                    // Capture what got cut off BEFORE interrupting (same interruption-
+                    // context ledger as the website path — the next flush tells the agent
+                    // it was cut off + what the human likely didn't hear).
                     meetingInterruptContext = `[MEETING — interrupted] You were speaking ("${meetingAgentSpeakingText.slice(0, 140)}") when ${participant} started talking and cut you off. They likely didn't hear the rest. When you respond, briefly acknowledge and adapt — don't just repeat.`;
-                    meetingAgentSpeaking = false;
-                    if (meetingSpeakClearTimer)
-                        clearTimeout(meetingSpeakClearTimer);
+                    // Actually STOP the voice: canvas stop + Recall output_audio stop +
+                    // queue-generation bump (drops anything still queued). Before 0.9.121
+                    // only the canvas was stopped — the real output_audio kept playing.
+                    pushCanvas({ kind: 'stop' });
+                    interruptMeetingSpeech(`human ${participant} barged in`);
                 }
             }
             else {
@@ -1998,7 +2060,15 @@ async function main() {
                 // (user directive 2026-08-01).
                 if (!isBot && meetingTranscriptBuffer.length) {
                     const latchOpen = Date.now() < meetingAddressedUntil || meetingSpeakers.size <= 1;
-                    flushMeetingBuffer(botId, latchOpen);
+                    if (latchOpen) {
+                        // Hard silence boundary → the speaker really finished. Flush sooner
+                        // than the transcript debounce (still debounced so back-to-back
+                        // speakers coalesce into one turn).
+                        scheduleAddressedFlush(botId, 450);
+                    }
+                    else {
+                        flushMeetingBuffer(botId, false); // silent observer note-taking batch
+                    }
                 }
             }
         });
@@ -5257,19 +5327,22 @@ async function main() {
                             recallJoin.registerBot(botId, sessionId);
                             activeMeetingBotId = botId;
                             await sendToFrontend({ type: 'meeting_joined', botId, message: 'Osborn has joined the meeting' });
-                            // System injection so the LLM knows it's in a meeting and which
-                            // skill to apply. The meetings skill (agent/.claude/skills/meetings/SKILL.md)
-                            // teaches the agent: don't speak in response to [MEETING — *]:
-                            // messages, keep meeting-todos.md updated in the workspace, etc.
+                            // Minimal awareness injection (user directive 2026-08-04): tell the
+                            // LLM it's in a meeting and how transcripts are tagged — nothing
+                            // more. NO "do NOT speak / silent observer" coaching (that fought
+                            // the goal of the reply being exactly the main agent's response).
+                            // The agent responds to meeting turns the same way it responds on
+                            // the website; note-taking is an optional background task, not a
+                            // replacement for responding.
                             if (currentLLM) {
                                 try {
                                     const sysCtx = new llm.ChatContext();
                                     sysCtx.addMessage({
                                         role: 'user',
-                                        content: `[SYSTEM] You are now in a meeting (Recall bot ID: ${botId}, URL: ${meetingUrl}). Transcript chunks will arrive every ~30 seconds tagged \`[MEETING — ${botId}]:\`. Follow the meetings skill: do NOT speak in response (no TTS output), instead maintain meeting-todos.md in the session workspace, optionally trigger background research silently. The voice-native user can still interact normally — only the meeting-tagged messages are the silent-observer path. Acknowledge by writing the initial meeting-todos.md skeleton.`,
+                                        content: `[SYSTEM] You are now in a meeting (Recall bot ID: ${botId}, URL: ${meetingUrl}). Live transcript arrives tagged \`[MEETING — ${botId}]:\`. Respond to what's said exactly as you naturally would — same as on the website, no special meeting phrasing. You may keep meeting-todos.md updated in the workspace in the background, but responding comes first.`,
                                     });
                                     currentLLM.chat({ chatCtx: sysCtx });
-                                    console.log('📓 Meeting system injection sent to LLM');
+                                    console.log('📓 Meeting awareness injection sent to LLM');
                                 }
                                 catch (sysErr) {
                                     console.warn('⚠️ Meeting system injection failed:', sysErr.message);

package/dist/recall-client.d.ts

@@ -110,6 +110,14 @@ export declare class RecallClient extends EventEmitter {
      * was "barely bearable"; this is the direct loud path.)
      */
     outputAudio(botId: string, mp3: Buffer): Promise<boolean>;
+    /**
+     * Stop the bot's currently-playing output_audio (barge-in / interruption).
+     * Recall exposes DELETE on the same endpoint to clear in-progress playback.
+     * Best-effort: returns true on 2xx, false otherwise (older bots / no active
+     * audio may 404 — harmless, the speech queue's generation bump still halts
+     * anything queued). Mirrors the website path's TTS interrupt on barge-in.
+     */
+    stopOutputAudio(botId: string): Promise<boolean>;
     getBotStatus(botId: string): Promise<string>;
     handleWebhook(payload: TranscriptPayload): void;
     registerBot(botId: string, sessionId: string): void;

package/dist/recall-client.js

@@ -165,6 +165,31 @@ export class RecallClient extends EventEmitter {
         }
         return true;
     }
+    /**
+     * Stop the bot's currently-playing output_audio (barge-in / interruption).
+     * Recall exposes DELETE on the same endpoint to clear in-progress playback.
+     * Best-effort: returns true on 2xx, false otherwise (older bots / no active
+     * audio may 404 — harmless, the speech queue's generation bump still halts
+     * anything queued). Mirrors the website path's TTS interrupt on barge-in.
+     */
+    async stopOutputAudio(botId) {
+        try {
+            const res = await fetch(`${RECALL_BASE_URL}/bot/${botId}/output_audio/`, {
+                method: 'DELETE',
+                headers: { 'Authorization': `Token ${this.#apiKey}` },
+            });
+            if (!res.ok) {
+                const e = await res.text().catch(() => '');
+                console.warn(`⚠️ Recall stop output_audio ${res.status}: ${e.slice(0, 120)}`);
+                return false;
+            }
+            return true;
+        }
+        catch (err) {
+            console.warn(`⚠️ Recall stop output_audio failed: ${err.message}`);
+            return false;
+        }
+    }
     async getBotStatus(botId) {
         const res = await fetch(`${RECALL_BASE_URL}/bot/${botId}`, {
             headers: { 'Authorization': `Token ${this.#apiKey}` },

package/package.json

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