osborn 0.9.141 → 0.9.142

package/dist/claude-llm.js

@@ -10,6 +10,7 @@ import { llm, shortuuid, DEFAULT_API_CONNECT_OPTIONS } from '@livekit/agents';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { EventEmitter } from 'events';
 import { saveSessionMetadata, getSessionWorkspace } from './config.js';
+import { statusManager } from './status-manager.js';
 import { getResearchSystemPrompt, getDirectModeResearchPrompt } from './prompts.js';
 import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
@@ -505,6 +506,9 @@ export class ClaudeLLM extends llm.LLM {
     // 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();
+    // Dispatcher v1 — maps tool_use_id → subagent_type for Task tool_use blocks
+    // so that when task_summary fires we know which agent type just finished.
+    #dispatchAgentTypes = new Map();
     constructor(opts = {}) {
         super();
         // Session resume/continue options
@@ -1039,6 +1043,29 @@ export class ClaudeLLM extends llm.LLM {
                                 callbacks.eventEmitter.emit('tts_say', { text: ttsChunk });
                             }
                         }
+                        // Dispatcher v1 — record Task tool_use blocks so we can correlate
+                        // the matching task_summary message to the subagent type.
+                        if (block.type === 'tool_use' && block.name === 'Task') {
+                            console.log('[DISPATCH-PROBE] task tool_use', JSON.stringify({ id: block.id, subagent_type: block.input?.subagent_type }));
+                            this.#dispatchAgentTypes.set(block.id, block.input?.subagent_type);
+                            statusManager.upsertDispatch(block.id, {
+                                owner: 'orchestrator',
+                                subagentType: block.input?.subagent_type,
+                                dispatchState: 'running',
+                            });
+                        }
+                    }
+                }
+                // Dispatcher v1 — catch sub-agent completion signals
+                if (msg.type === 'system' && msg.subtype === 'task_summary') {
+                    console.log('[DISPATCH-PROBE] task_summary raw:', JSON.stringify(msg).slice(0, 500));
+                    const tuid = msg.tool_use_id ?? msg.toolUseId;
+                    const output = msg.summary ?? msg.result ?? msg.output ?? '';
+                    const subType = tuid ? this.#dispatchAgentTypes.get(tuid) : undefined;
+                    statusManager.upsertDispatch(tuid ?? `ts-${Date.now()}`, { subagentType: subType, dispatchState: 'completed', artifact: String(output) });
+                    console.log(`[DISPATCH] completed type=${subType ?? '?'} tuid=${(tuid ?? '?').slice(0, 8)} len=${String(output).length}`);
+                    if (subType === 'writer' && output) {
+                        this.#spawnReviewer(tuid, String(output), callbacks.eventEmitter);
                     }
                 }
                 // Result — marks end of a turn (but we keep consuming for next turn)
@@ -1067,6 +1094,56 @@ export class ClaudeLLM extends llm.LLM {
             console.log('🔒 Persistent session background consumer exited');
         }
     }
+    /**
+     * Dispatcher v1 — auto-spawn a reviewer after a writer sub-agent completes.
+     * Runs a one-shot query() with the reviewer agent and emits dispatch_rejected
+     * if the verdict is REJECT. A reviewer failure must never crash the consumer.
+     */
+    async #spawnReviewer(tuid, writerOutput, emitter) {
+        try {
+            const prompt = [
+                'Use the reviewer sub-agent to review this writer output for correctness/spec-adherence/obvious bugs.',
+                'End your reply with exactly `VERDICT: ACCEPT` or `VERDICT: REJECT`.',
+                '',
+                '<writer_output>',
+                writerOutput.slice(0, 8000),
+                '</writer_output>',
+            ].join('\n');
+            const reviewerOptions = {
+                cwd: this.#opts.workingDirectory,
+                permissionMode: 'default',
+                agents: NAMED_AGENTS,
+            };
+            console.log(`[DISPATCH] spawning reviewer for tuid=${tuid.slice(0, 8)}`);
+            const reviewerQuery = query({ prompt, options: reviewerOptions });
+            this.#activeQueries.add(reviewerQuery);
+            let reviewerText = '';
+            try {
+                for await (const msg of reviewerQuery) {
+                    const m = msg;
+                    if (m.type === 'result' && m.result) {
+                        reviewerText = String(m.result);
+                    }
+                }
+            }
+            finally {
+                this.#activeQueries.delete(reviewerQuery);
+            }
+            const verdictMatch = reviewerText.match(/VERDICT:\s*(ACCEPT|REJECT)/i);
+            const verdict = verdictMatch ? verdictMatch[1].toUpperCase() : null;
+            if (verdict === 'REJECT') {
+                console.log(`[DISPATCH] review REJECT for tuid=${tuid.slice(0, 8)}`);
+                statusManager.upsertDispatch(tuid, { dispatchState: 'rejected', artifact: reviewerText });
+                emitter.emit('dispatch_rejected', { tuid, verdict: 'REJECT', review: reviewerText });
+            }
+            else {
+                console.log(`[DISPATCH] review ACCEPT for tuid=${tuid.slice(0, 8)}`);
+            }
+        }
+        catch (err) {
+            console.error('[DISPATCH] reviewer spawn failed (non-fatal):', err);
+        }
+    }
     chat({ chatCtx, toolCtx, connOptions = DEFAULT_API_CONNECT_OPTIONS, abortController, }) {
         return new ClaudeLLMStream(this, {
             chatCtx,

package/dist/index.js

@@ -3086,6 +3086,16 @@ async function main() {
                 checkpointId: data.checkpointId,
             });
         });
+        // Dispatcher v1 — writer reviewer rejected verdict → frontend
+        directLLM.events.on('dispatch_rejected', (data) => {
+            console.log(`[DISPATCH] dispatch_rejected tuid=${(data.tuid ?? '').slice(0, 8)} sending to frontend`);
+            sendToFrontend({
+                type: 'task_review',
+                tuid: data.tuid,
+                verdict: data.verdict,
+                review: data.review,
+            });
+        });
         // 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

package/dist/status-manager.d.ts

@@ -18,6 +18,10 @@ export interface TaskStatus {
     progress?: number;
     progressUpdates: string[];
     lastUpdate?: string;
+    owner?: string;
+    subagentType?: string;
+    dispatchState?: 'pending' | 'running' | 'completed' | 'rejected' | 'failed';
+    artifact?: string;
 }
 export interface StatusUpdate {
     hasUpdates: boolean;
@@ -86,5 +90,16 @@ export declare class StatusManager {
      * Get context summary for the brain
      */
     getContextSummary(): 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
+     * can upsert without a prior registerTask() call.
+     */
+    upsertDispatch(id: string, fields: {
+        owner?: string;
+        subagentType?: string;
+        dispatchState?: TaskStatus['dispatchState'];
+        artifact?: string;
+    }): void;
 }
 export declare const statusManager: StatusManager;

package/dist/status-manager.js

@@ -182,6 +182,48 @@ export class StatusManager {
     getContextSummary() {
         return this.conversationContext.slice(-5).join(' | ');
     }
+    /**
+     * 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
+     * can upsert without a prior registerTask() call.
+     */
+    upsertDispatch(id, fields) {
+        if (!this.tasks.has(id)) {
+            this.tasks.set(id, {
+                id,
+                type: 'execute',
+                // Use an empty query so narration never speaks a bogus "dispatch:<id>" string.
+                // Dispatch progress is tracked exclusively via dispatchState; status starts as
+                // 'pending' (not 'running') so getStatusUpdate() runningTasks narration is skipped.
+                query: '',
+                status: 'pending',
+                startedAt: Date.now(),
+                progressUpdates: [],
+            });
+        }
+        const task = this.tasks.get(id);
+        if (fields.owner !== undefined)
+            task.owner = fields.owner;
+        if (fields.subagentType !== undefined)
+            task.subagentType = fields.subagentType;
+        if (fields.dispatchState !== undefined)
+            task.dispatchState = fields.dispatchState;
+        if (fields.artifact !== undefined)
+            task.artifact = fields.artifact;
+        // Mirror dispatchState into the base status field so existing getStatusUpdate() callers see it.
+        // 'rejected' is also terminal — map it to 'failed' so the GC and readers treat it as finished.
+        if (fields.dispatchState === 'completed')
+            task.status = 'completed';
+        if (fields.dispatchState === 'failed' || fields.dispatchState === 'rejected')
+            task.status = 'failed';
+        // Fix: set completedAt when entering any terminal state so the task is GC-eligible via
+        // clearReportedTasks() and correctly surfaces in hasCompletedTasks() / getStatusUpdate().
+        // Without this the tasks Map grows unbounded (memory leak).
+        const isTerminal = task.status === 'completed' || task.status === 'failed';
+        if (isTerminal && !task.completedAt)
+            task.completedAt = Date.now();
+        console.log(`[Dispatch] upsertDispatch id=${id.slice(0, 8)} state=${fields.dispatchState ?? '-'} type=${fields.subagentType ?? '-'}`);
+    }
 }
 // Singleton instance
 export const statusManager = new StatusManager();

package/package.json

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