osborn 0.9.245 → 0.9.247

package/dist/claude-llm.js

@@ -1817,6 +1817,10 @@ class ClaudeLLMStream extends llm.LLMStream {
     #abortController;
     #llmRef;
     #approvedWriterToolUseIds = new Set();
+    // Last Task/Agent dispatch description per subagent_type, captured at PreToolUse so
+    // SubagentStart can label the Running row with WHAT the sub-agent is doing even if the
+    // SDK hook input omits the prompt. Cleared when consumed by the matching start.
+    #pendingTaskByType = new Map();
     constructor(llmInstance, { chatCtx, toolCtx, connOptions, opts, sessionId, onSessionId, eventEmitter, onCheckpoint, onPermissionRequest, abortController, }) {
         super(llmInstance, { chatCtx, toolCtx, connOptions });
         this.#llmRef = llmInstance;
@@ -2026,6 +2030,14 @@ class ClaudeLLMStream extends llm.LLMStream {
                                         // tool_use, returns {} → canUseTool workspace auto-approve).
                                     }
                                     console.log(`🔧 Claude: ${toolName}`);
+                                    // Capture the dispatch description/prompt per subagent_type so SubagentStart
+                                    // can show WHAT a sub-agent is working on (see #pendingTaskByType).
+                                    if (toolName === 'Task' || toolName === 'Agent') {
+                                        const st = String(toolInput?.subagent_type || toolInput?.agent_type || '');
+                                        const d = String(toolInput?.description || toolInput?.prompt || '');
+                                        if (st && d)
+                                            this.#pendingTaskByType.set(st, d);
+                                    }
                                     this.#eventEmitter.emit('tool_use', { name: toolName, input: toolInput, agentRole: agentType || 'main' });
                                     return {};
                                 }]
@@ -2395,7 +2407,16 @@ 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 });
+                                    // Surface WHAT the sub-agent was dispatched to do (not just its type) so the
+                                    // Running panel shows the task while it's in flight, before any result lands.
+                                    // The SDK hook may carry the initial prompt/description; fall back to the last
+                                    // Task/Agent dispatch of this type captured at PreToolUse. Best-effort.
+                                    const at0 = input?.agent_type;
+                                    const rawTask = input?.prompt ?? input?.description ?? (at0 ? this.#pendingTaskByType.get(String(at0)) : undefined);
+                                    if (at0)
+                                        this.#pendingTaskByType.delete(String(at0));
+                                    const task = rawTask ? String(rawTask).replace(/\s+/g, ' ').trim().slice(0, 160) : undefined;
+                                    this.#eventEmitter.emit('agent_started', { agent_type: input?.agent_type, agent_id: input?.agent_id, task });
                                     // Record the dispatch as LIVE so the frontend can reconcile orphaned
                                     // "running" rows against statusManager.getActiveDispatchIds(). Without a
                                     // start-time entry the manager only knew about dispatches at completion,

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.245",
+  "version": "0.9.247",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {