osborn 0.9.146 → 0.9.148

package/dist/claude-llm.d.ts

@@ -210,6 +210,12 @@ export declare class ClaudeLLM extends llm.LLM {
     setActiveQuery(q: any): void;
     /** Remove an active query (called from ClaudeLLMStream when query completes) */
     removeActiveQuery(q: any): void;
+    /**
+     * Stop a single dispatch flow by agent_id.
+     * Returns true if the agent was found and stopped; false if not found.
+     * Does NOT affect other active queries (use abortQuery() to kill all).
+     */
+    stopAgent(agentId: string): boolean;
     /** Whether a persistent session is alive and consuming messages */
     hasSession(): boolean;
     /**

package/dist/claude-llm.js

@@ -552,10 +552,17 @@ export class ClaudeLLM extends llm.LLM {
     // No JSONL replay after the first cold start.
     #persistentQuery = null;
     #messageChannel = null;
+    // Read-along tracking — per-turn message ID and chunk counter for TTS highlighting
+    #currentTurnMessageId = null;
+    #currentTurnChunkIndex = 0;
+    #currentTurnChunks = [];
     #backgroundConsumerRunning = false;
     // Active queries — multiple can be running (SDK queues them internally).
     // We keep ALL references so interrupt() can stop whatever is currently executing.
     #activeQueries = new Set();
+    // Per-agent-id query map — allows targeted stop of a single dispatch flow.
+    // Strictly additive; abortQuery/interruptQuery still iterate #activeQueries (kill-all).
+    #activeQueriesById = new Map();
     // Dedup guard — prevents double-firing reviewer/gate if SubagentStop fires
     // more than once for the same agent_id (e.g. retry edge cases).
     #dispatchedFor = new Set();
@@ -889,6 +896,7 @@ export class ClaudeLLM extends llm.LLM {
             catch { }
         }
         this.#activeQueries.clear();
+        this.#activeQueriesById.clear();
         console.log('🛑 All queries aborted (Ctrl+C equivalent)');
     }
     /**
@@ -943,6 +951,23 @@ export class ClaudeLLM extends llm.LLM {
     removeActiveQuery(q) {
         this.#activeQueries.delete(q);
     }
+    /**
+     * Stop a single dispatch flow by agent_id.
+     * Returns true if the agent was found and stopped; false if not found.
+     * Does NOT affect other active queries (use abortQuery() to kill all).
+     */
+    stopAgent(agentId) {
+        const q = this.#activeQueriesById.get(agentId);
+        if (!q)
+            return false;
+        try {
+            q.return?.();
+        }
+        catch { }
+        this.#activeQueriesById.delete(agentId);
+        this.#activeQueries.delete(q);
+        return true;
+    }
     // ============================================================
     // PERSISTENT SESSION — V1 query() with AsyncIterable<SDKUserMessage>
     // Single subprocess per voice session. First chat() does JSONL cold
@@ -1085,22 +1110,41 @@ export class ClaudeLLM extends llm.LLM {
                 }
                 // Stream assistant text → tts_say events
                 if (msg.type === 'assistant' && msg.message?.content) {
+                    // Assign a stable messageId for this turn (first block sets it, rest reuse)
+                    if (!this.#currentTurnMessageId) {
+                        this.#currentTurnMessageId = crypto.randomUUID();
+                        this.#currentTurnChunkIndex = 0;
+                        this.#currentTurnChunks = [];
+                    }
+                    const turnMessageId = this.#currentTurnMessageId;
                     for (const block of msg.message.content) {
                         if (block.type === 'text' && block.text) {
-                            callbacks.eventEmitter.emit('assistant_text', { text: block.text });
+                            const chunkIndex = this.#currentTurnChunkIndex;
+                            callbacks.eventEmitter.emit('assistant_text', { text: block.text, messageId: turnMessageId, chunkIndex });
                             const ttsChunk = stripMarkdownForTTS(block.text);
                             if (ttsChunk.trim()) {
+                                this.#currentTurnChunks.push(ttsChunk);
+                                this.#currentTurnChunkIndex++;
                                 console.log(`🔊 TTS say (${ttsChunk.length} chars): "${ttsChunk}"`);
-                                callbacks.eventEmitter.emit('tts_say', { text: ttsChunk });
+                                callbacks.eventEmitter.emit('tts_say', { text: ttsChunk, messageId: turnMessageId, chunkIndex });
                             }
                         }
                     }
                 }
                 // Result — marks end of a turn (but we keep consuming for next turn)
                 if (msg.type === 'result') {
+                    const turnMessageId = this.#currentTurnMessageId;
+                    const turnChunks = [...this.#currentTurnChunks];
                     if (msg.result) {
-                        callbacks.eventEmitter.emit('assistant_result', { text: msg.result });
+                        callbacks.eventEmitter.emit('assistant_result', { text: msg.result, messageId: turnMessageId });
+                    }
+                    if (turnMessageId && turnChunks.length > 0) {
+                        callbacks.eventEmitter.emit('tts_chunks', { messageId: turnMessageId, chunks: turnChunks });
                     }
+                    // Reset per-turn state for next turn
+                    this.#currentTurnMessageId = null;
+                    this.#currentTurnChunkIndex = 0;
+                    this.#currentTurnChunks = [];
                     console.log('✅ Claude turn complete (persistent session stays alive)');
                 }
             }
@@ -1200,6 +1244,7 @@ export class ClaudeLLM extends llm.LLM {
             console.log(`[DISPATCH] spawning reviewer for agentId=${agentId.slice(0, 8)}`);
             const reviewerQuery = query({ prompt, options: reviewerOptions });
             this.#activeQueries.add(reviewerQuery);
+            this.#activeQueriesById.set(agentId, reviewerQuery);
             let reviewerText = '';
             try {
                 for await (const msg of reviewerQuery) {
@@ -1211,6 +1256,7 @@ export class ClaudeLLM extends llm.LLM {
             }
             finally {
                 this.#activeQueries.delete(reviewerQuery);
+                this.#activeQueriesById.delete(agentId);
             }
             const verdictMatch = reviewerText.match(/VERDICT:\s*(ACCEPT|REJECT)/i);
             const verdict = verdictMatch ? verdictMatch[1].toUpperCase() : null;
@@ -1284,6 +1330,7 @@ export class ClaudeLLM extends llm.LLM {
             console.log(`[DISPATCH] spawning research-gate for agentId=${agentId.slice(0, 8)}`);
             const gateQuery = query({ prompt, options: gateOptions });
             this.#activeQueries.add(gateQuery);
+            this.#activeQueriesById.set(agentId, gateQuery);
             let review = '';
             try {
                 for await (const msg of gateQuery) {
@@ -1295,6 +1342,7 @@ export class ClaudeLLM extends llm.LLM {
             }
             finally {
                 this.#activeQueries.delete(gateQuery);
+                this.#activeQueriesById.delete(agentId);
             }
             const gateMatch = review.match(/GATE:\s*(PASS|NEEDS-MORE)/i);
             const gateVerdict = gateMatch ? gateMatch[1].toUpperCase() : null;
@@ -1781,6 +1829,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                             matcher: '.*',
                             hooks: [async (input) => {
                                     console.log('[LIFECYCLE-PROBE] SubagentStart', JSON.stringify(input));
+                                    this.#eventEmitter.emit('agent_started', { agent_type: input?.agent_type, agent_id: input?.agent_id });
                                     return {};
                                 }]
                         }],
@@ -1792,6 +1841,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                                     const msg = String(input?.last_assistant_message ?? '');
                                     const aid = input?.agent_id ?? ('sa-' + Date.now());
                                     statusManager.upsertDispatch(aid, { subagentType: at, dispatchState: 'completed', artifact: msg });
+                                    this.#eventEmitter.emit('task_completed', { agent_type: at, agent_id: aid, last_assistant_message: String(msg).slice(0, 400) });
                                     // Infinite-loop guard — never re-dispatch the reviewer or reasoner.
                                     if (at === 'reviewer' || at === 'reasoner')
                                         return {};
@@ -1827,6 +1877,10 @@ class ClaudeLLMStream extends llm.LLMStream {
             // Run Claude Agent SDK query() and stream results
             let hasOutput = false;
             let fullResponse = ''; // Collect full response for frontend
+            // Per-turn read-along tracking (non-skipTTSQueue path)
+            let streamTurnMessageId = null;
+            let streamTurnChunkIndex = 0;
+            let streamTurnChunks = [];
             // DIRECT MODE OPTIMIZATION: When skipTTSQueue is true, we run the Claude query
             // in the background and return from run() immediately. This is critical because:
             //
@@ -1913,20 +1967,29 @@ class ClaudeLLMStream extends llm.LLMStream {
                     if (sdkRequestId) {
                         this.#eventEmitter.emit('query_request_id', { requestId: sdkRequestId });
                     }
+                    // Assign a stable messageId for this turn (first block sets it, rest reuse)
+                    if (!streamTurnMessageId) {
+                        streamTurnMessageId = crypto.randomUUID();
+                        streamTurnChunkIndex = 0;
+                        streamTurnChunks = [];
+                    }
                     for (const block of message.message.content) {
                         if (block.type === 'text' && block.text) {
                             hasOutput = true;
                             const rawText = block.text;
+                            const chunkIndex = streamTurnChunkIndex;
                             // Emit RAW text to frontend (for chat bubbles with full formatting)
-                            this.#eventEmitter.emit('assistant_text', { text: rawText });
+                            this.#eventEmitter.emit('assistant_text', { text: rawText, messageId: streamTurnMessageId, chunkIndex });
                             // Strip markdown for clean speech
                             const ttsChunk = stripMarkdownForTTS(rawText);
                             if (ttsChunk.trim()) {
+                                streamTurnChunks.push(ttsChunk);
+                                streamTurnChunkIndex++;
                                 if (this.#opts.skipTTSQueue) {
                                     // Direct mode: emit event for session.say() — bypasses LiveKit's
                                     // BufferedTokenStream which causes stuck/delayed/out-of-order audio
                                     console.log(`🔊 TTS say (${ttsChunk.length} chars): "${ttsChunk}"`);
-                                    this.#eventEmitter.emit('tts_say', { text: ttsChunk });
+                                    this.#eventEmitter.emit('tts_say', { text: ttsChunk, messageId: streamTurnMessageId, chunkIndex });
                                 }
                                 else {
                                     // Realtime mode: use LLM stream queue (framework handles TTS)
@@ -1944,7 +2007,15 @@ class ClaudeLLMStream extends llm.LLMStream {
                 if (message.type === 'result' && message.result) {
                     const rawResult = message.result;
                     // Emit RAW result to frontend
-                    this.#eventEmitter.emit('assistant_result', { text: rawResult });
+                    this.#eventEmitter.emit('assistant_result', { text: rawResult, messageId: streamTurnMessageId });
+                    // Emit ordered chunk list for frontend read-along
+                    if (streamTurnMessageId && streamTurnChunks.length > 0) {
+                        this.#eventEmitter.emit('tts_chunks', { messageId: streamTurnMessageId, chunks: streamTurnChunks });
+                    }
+                    // Reset per-turn state
+                    streamTurnMessageId = null;
+                    streamTurnChunkIndex = 0;
+                    streamTurnChunks = [];
                     if (!hasOutput) {
                         hasOutput = true;
                         const ttsText = stripMarkdownForTTS(rawResult);

package/dist/index.js

@@ -2814,6 +2814,8 @@ async function main() {
                 text: data.text,
                 isStreaming: true,
                 agentRole: 'direct',
+                messageId: data.messageId,
+                chunkIndex: data.chunkIndex,
             });
         });
         // Wire up Claude final result - RAW result goes to frontend
@@ -2825,6 +2827,15 @@ async function main() {
                 isStreaming: false,
                 isFinal: true,
                 agentRole: 'direct',
+                messageId: data.messageId,
+            });
+        });
+        // Wire up ordered TTS chunk list — emitted once per turn for read-along
+        directLLM.events.on('tts_chunks', (data) => {
+            sendToFrontend({
+                type: 'tts_chunks',
+                messageId: data.messageId,
+                chunks: data.chunks,
             });
         });
         // Wire up permission requests - sends to frontend for user approval
@@ -3001,6 +3012,15 @@ async function main() {
                             playbackStartedAt = Date.now();
                             console.log(`🔊 [${sayId}] audio first frame out (playbackStarted)`);
                             audioOutputRef.off('playbackStarted', onPlaybackStarted);
+                            // Notify frontend that this TTS chunk is now audibly playing
+                            if (data.messageId != null && data.chunkIndex != null) {
+                                sendToFrontend({
+                                    type: 'tts_chunk_playing',
+                                    messageId: data.messageId,
+                                    chunkIndex: data.chunkIndex,
+                                    text: data.text,
+                                });
+                            }
                         };
                         audioOutputRef.on('playbackStarted', onPlaybackStarted);
                     }
@@ -3096,6 +3116,19 @@ async function main() {
                 review: data.review,
             });
         });
+        // Dispatcher v1 — sub-agent completed → frontend (Feature A)
+        directLLM.events.on('task_completed', (d) => sendToFrontend({
+            type: 'task_completed',
+            agent_type: d.agent_type,
+            agent_id: d.agent_id,
+            last_assistant_message: d.last_assistant_message,
+        }));
+        // Dispatcher v1 — sub-agent started → frontend stop-key signal (Feature A2)
+        directLLM.events.on('agent_started', (d) => sendToFrontend({
+            type: 'agent_started',
+            agent_type: d.agent_type,
+            agent_id: d.agent_id,
+        }));
         // Create the Agent with instructions, STT, LLM, TTS
         // VAD (Silero ONNX) removed — caused 2-5s inference lag on CPU, making interruption detection worse
         // Turn detection is server-side (Deepgram endpointing), interruptions handled by STT
@@ -5515,6 +5548,10 @@ async function main() {
                     }
                 }
             }
+            // Feature B — per-flow stop (does NOT affect other running flows)
+            else if (data.type === 'stop_dispatch' && currentLLM) {
+                currentLLM.stopAgent?.(String(data.agentId));
+            }
             else if (data.type === 'join_meeting') {
                 const meetingUrl = data.url;
                 if (meetingUrl) {

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

@@ -67,6 +67,7 @@ export declare class PipelineDirectLLM extends llm.LLM {
     abortAgent(): void;
     rewindAgent(checkpointId?: string): Promise<boolean>;
     hasActiveAgent(): boolean;
+    stopAgent(agentId: string): boolean;
     /** Send a new prompt to Claude via direct chat() — event listeners stay attached */
     sendPrompt(prompt: string): void;
     enableMcpServer(k: string, c: any): void;

package/dist/pipeline-direct-llm.js

@@ -120,6 +120,7 @@ export class PipelineDirectLLM extends llm.LLM {
     abortAgent() { this.#claudeLLM.abortQuery(); }
     async rewindAgent(checkpointId) { return this.#claudeLLM.rewindToCheckpoint(checkpointId); }
     hasActiveAgent() { return this.#claudeLLM.hasActiveQuery(); }
+    stopAgent(agentId) { return this.#claudeLLM.stopAgent(agentId); }
     /** Send a new prompt to Claude via direct chat() — event listeners stay attached */
     sendPrompt(prompt) {
         console.log(`📋 [pipeline] Sending prompt to Claude (${prompt.length} chars)`);

package/package.json

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