osborn 0.9.246 → 0.9.248

package/dist/claude-llm.js

@@ -2022,7 +2022,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                                             // the permission dialog; adversarial agents (reviewer/tester) do
                                             // NOT emit here — parity with the prior hardcoded branches.
                                             if (agentType === 'writer') {
-                                                this.#eventEmitter.emit('tool_use', { name: toolName, input: toolInput, agentRole: agentType || 'main' });
+                                                this.#eventEmitter.emit('tool_use', { name: toolName, input: toolInput, agentRole: agentType || 'main', agentId: input?.agent_id });
                                             }
                                             return { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'ask' } };
                                         }
@@ -2038,7 +2038,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         if (st && d)
                                             this.#pendingTaskByType.set(st, d);
                                     }
-                                    this.#eventEmitter.emit('tool_use', { name: toolName, input: toolInput, agentRole: agentType || 'main' });
+                                    this.#eventEmitter.emit('tool_use', { name: toolName, input: toolInput, agentRole: agentType || 'main', agentId: input?.agent_id });
                                     return {};
                                 }]
                         }],
@@ -2054,7 +2054,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         const agentId = input?.tool_input?.agent_id ?? input?.tool_input?.id ?? undefined;
                                         console.log('[LIFECYCLE-PROBE] PostToolUse on', toolName, 'agent_id=', agentId, 'ts=', Date.now());
                                     }
-                                    this.#eventEmitter.emit('tool_result', { name: toolName, input: toolInput, response: toolResponse, agentRole: agentTypePost || 'main' });
+                                    this.#eventEmitter.emit('tool_result', { name: toolName, input: toolInput, response: toolResponse, agentRole: agentTypePost || 'main', agentId: input?.agent_id });
                                     // Pattern #1 verifier chaining has MOVED to the SubagentStop hook below. Reason:
                                     // sub-agents run with run_in_background:true, so PostToolUse-on-Task fires at
                                     // DISPATCH (placeholder tool_response), not completion — injecting the "now verify"

package/dist/index.js

@@ -60,8 +60,10 @@ import { llm } from '@livekit/agents';
 // any field that can't be derived is simply omitted and the card degrades to
 // the tool name. `input` is the raw tool arguments already carried on the
 // tool_use/tool_result events emitted by claude-llm.
-function buildToolLogEvent(name, input, status, agentRole) {
-    const ev = { type: 'tool_use', tool: name, status, agentRole };
+function buildToolLogEvent(name, input, status, agentRole, agentId) {
+    // agentId is the sub-agent's id (present only for sub-agent tool calls) — lets the
+    // frontend tie this activity to its Running row, not just the Log feed.
+    const ev = { type: 'tool_use', tool: name, status, agentRole, agentId };
     const inp = input || {};
     const basename = (p) => String(p).split('/').pop() || String(p);
     const fp = inp.file_path || inp.path || inp.notebook_path;
@@ -3392,11 +3394,11 @@ async function main() {
         // Wire up events from the Claude SDK wrapper to frontend
         directLLM.events.on('tool_use', (data) => {
             console.log(`🔧 Claude: ${data.name}`);
-            sendToFrontend(buildToolLogEvent(data.name, data.input, 'running', data.agentRole || 'main'));
+            sendToFrontend(buildToolLogEvent(data.name, data.input, 'running', data.agentRole || 'main', data.agentId));
         });
         directLLM.events.on('tool_result', (data) => {
             console.log(`✅ Done: ${data.name}`);
-            sendToFrontend(buildToolLogEvent(data.name, data.input, 'completed', data.agentRole || 'main'));
+            sendToFrontend(buildToolLogEvent(data.name, data.input, 'completed', data.agentRole || 'main', data.agentId));
             // Detect research artifact writes (session workspace or legacy research dir)
             if ((data.name === 'Write' || data.name === 'Edit') && data.input?.file_path) {
                 const fp = data.input.file_path;
@@ -3754,6 +3756,7 @@ async function main() {
             type: 'agent_started',
             agent_type: d.agent_type,
             agent_id: d.agent_id,
+            task: d.task, // forward the dispatch instruction so the Running row can label itself
         }));
         // Create the Agent with instructions, STT, LLM, TTS
         // VAD (Silero ONNX) removed — caused 2-5s inference lag on CPU, making interruption detection worse

package/dist/pipeline-direct-llm.js

@@ -12,6 +12,7 @@ import { llm, DEFAULT_API_CONNECT_OPTIONS } from '@livekit/agents';
 import { ClaudeLLM } from './claude-llm.js';
 import { askPipelineFastBrain } from './pipeline-fastbrain.js';
 import { storeExists, openStore, recentRows } from './session-store.js';
+import { statusManager } from './status-manager.js';
 // ============================================================
 // SESSION TAIL — compact recent-conversation block prepended to every user turn
 // so the orchestrator never loses the thread across context compaction.
@@ -185,6 +186,22 @@ export class PipelineDirectLLM extends llm.LLM {
                 // Actual mid-TTS interruption — keep the full [INTERRUPTED] template
                 console.log(`🔇 [pipeline] Enriching: interrupt (spoken=${interruptCtx.spokenText.length} chars, suppressed=${interruptCtx.suppressedText.length} chars)`);
                 this.#claudeLLM.interruptQuery().catch(() => { });
+                // An interrupt/cutoff SEVERS in-flight background Task sub-agents — the SDK's
+                // interrupt() kills run_in_background Task children and they never fire SubagentStop,
+                // so the agent gets NO signal they died and they can't be resumed. statusManager still
+                // lists them (start-tracked, never stopped) = the authoritative orphan set. Name them
+                // so the agent re-dispatches the necessary ones; mark them terminal so the tracker +
+                // Running panel don't leave them stuck "running" forever.
+                const orphanedSubagents = statusManager.getActiveDispatches();
+                const subagentReminder = orphanedSubagents.length
+                    ? `SUB-AGENTS SEVERED BY THE CUTOFF: your in-flight background sub-agents were killed by the interrupt and will NOT report back (no completion signal, cannot be resumed): ${orphanedSubagents.map(o => o.subagentType || 'agent').join(', ')}. Check which of these you still need and RE-DISPATCH them fresh — do not wait on them.`
+                    : `SUB-AGENTS: if you had any background Task sub-agents in flight, an interrupt severs them silently (no completion signal, no resume) — check and re-dispatch any still needed rather than waiting on them.`;
+                for (const o of orphanedSubagents) {
+                    try {
+                        statusManager.upsertDispatch(o.id, { dispatchState: 'failed' });
+                    }
+                    catch { }
+                }
                 enrichedMessage = [
                     `[INTERRUPTED] The user interrupted your response mid-speech.`,
                     ``,
@@ -206,6 +223,8 @@ export class PipelineDirectLLM extends llm.LLM {
                     `CONTEXT PRESERVATION (READ THIS):`,
                     `The user has NO memory of unheard content. If any of it bears on their current message — answers a question they just asked, sets up a follow-up they're now asking about, or shows a knowledge gap and fills in a detail they're reacting to — you MUST surface it. Briefly is fine if their message is off-topic or explores a direction they haven't asked about yet. But never assume they remember what they never heard.`,
                     ``,
+                    subagentReminder,
+                    ``,
                     `RESPOND with speech first, then act:`,
                     `- ALWAYS reply with at least one spoken sentence before doing any tool calls`,
                     `- If it's a quick side question, answer it then continue where you left off`,

package/dist/status-manager.d.ts

@@ -102,6 +102,16 @@ export declare class StatusManager {
      * stale row from the dead process is reconciled away on the next poll.
      */
     getActiveDispatchIds(): string[];
+    /**
+     * Non-terminal dispatches with their type — the set considered "in flight". Used on
+     * a voice interrupt to name the sub-agents that were just severed: an interrupt kills
+     * in-flight Task sub-agents (SDK regression) and they never fire SubagentStop, so they
+     * linger here as the authoritative orphan list until we mark them terminal.
+     */
+    getActiveDispatches(): Array<{
+        id: string;
+        subagentType?: string;
+    }>;
     /**
      * Dispatcher v1 — create or update a dispatch entry keyed by tool_use_id.
      * Creates a minimal TaskStatus shell if the id doesn't yet exist so callers

package/dist/status-manager.js

@@ -201,6 +201,20 @@ export class StatusManager {
             t.dispatchState !== 'rejected')
             .map(t => t.id);
     }
+    /**
+     * Non-terminal dispatches with their type — the set considered "in flight". Used on
+     * a voice interrupt to name the sub-agents that were just severed: an interrupt kills
+     * in-flight Task sub-agents (SDK regression) and they never fire SubagentStop, so they
+     * linger here as the authoritative orphan list until we mark them terminal.
+     */
+    getActiveDispatches() {
+        return Array.from(this.tasks.values())
+            .filter(t => !!t.subagentType &&
+            t.dispatchState !== 'completed' &&
+            t.dispatchState !== 'failed' &&
+            t.dispatchState !== 'rejected')
+            .map(t => ({ id: t.id, subagentType: t.subagentType }));
+    }
     /**
      * Dispatcher v1 — create or update a dispatch entry keyed by tool_use_id.
      * Creates a minimal TaskStatus shell if the id doesn't yet exist so callers

package/package.json

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