osborn 0.9.230 → 0.9.232

package/dist/claude-llm.js

@@ -896,9 +896,12 @@ export const VERIFIER_CHAIN = {
             'at most 2 fix rounds, after which surface the outcome to the user rather than looping.',
     },
     researcher: {
-        afterReminder: 'The researcher sub-agent just finished. Before you finalize, use the Task tool to dispatch the ' +
-            '`reasoner` gate to judge whether the research is complete and well-sourced for the original ' +
-            'question. If it returns NEEDS-MORE, send the researcher back — at most 2 rounds, then surface.',
+        afterReminder: 'The researcher sub-agent just finished. Before you finalize, you MUST now use the Task tool to ' +
+            'dispatch the `reasoner` GATE to judge whether the research is complete and well-sourced for the ' +
+            'original question — it returns GATE: PASS or GATE: NEEDS-MORE. ' +
+            'If it returns NEEDS-MORE, dispatch the `researcher` again with the gaps it named and then re-gate — ' +
+            'at most 2 rounds, after which surface the outcome to the user rather than looping. ' +
+            "This is the research analogue of writer→reviewer: don't rely on the findings until an independent agent has vetted them.",
     },
 };
 const RESEARCH_TOOLS = [

package/dist/index.js

@@ -2014,6 +2014,10 @@ async function main() {
     let currentLLM = null;
     const slots = new Map();
     let focusedSlotId = null; // reserved for future focused-slot wiring; not used yet
+    // P1 host-agent anchor: the dashboard-started session that owns the room's env + keeps it alive.
+    let hostActive = false;
+    let hostSessionId = null;
+    let hostWorkingDir = null;
     // Agent-side "alone in room" leave timer (see Room-presence lifecycle note up
     // top). Armed in ParticipantDisconnected once a user has left; if no one
     // rejoins within the grace window the agent leaves LiveKit on its own.
@@ -2028,7 +2032,31 @@ async function main() {
     // ParticipantDisconnected (covers a finished session). Cancelled the moment a
     // user joins. Net invariant: the agent never holds an empty room beyond
     // ALONE_GRACE_MS, in any scenario — the root cause of the 25h burn.
+    // P1: room stays alive while the host anchor is active or any background slot
+    // is running. Teardown timers below early-return on this so a dashboard-started
+    // session + its background dispatches aren't killed by the empty-room grace.
+    const agentsActive = () => hostActive || slots.size > 0;
+    // Release the host anchor + hard-kill background slots at a genuine session-end
+    // boundary so the room can idle-exit (agentsActive → false). Idempotent. MUST be
+    // called before arming idle-exit on EVERY path where the session ends, or the
+    // empty-room billing burn returns — the keep-alive guard is only as safe as its
+    // release sites (endMeeting / intentional-leave / destroyRoomSession / disconnect).
+    const releaseAgents = () => {
+        hostActive = false;
+        hostSessionId = null;
+        hostWorkingDir = null;
+        for (const [, s] of slots) {
+            try {
+                s.llm.abortQuery?.();
+                s.llm.abortAgent?.();
+            }
+            catch { }
+        }
+        slots.clear();
+    };
     const armAloneTimer = () => {
+        if (agentsActive())
+            return;
         if (aloneTimer)
             clearTimeout(aloneTimer);
         aloneTimer = null;
@@ -2054,6 +2082,8 @@ async function main() {
     let fastLeaveTimer = null;
     const POST_LEAVE_GRACE_MS = 20 * 1000;
     const armFastLeaveTimer = () => {
+        if (agentsActive())
+            return;
         if (fastLeaveTimer)
             clearTimeout(fastLeaveTimer);
         fastLeaveTimer = null;
@@ -2099,7 +2129,7 @@ async function main() {
             idleExitTimer = null;
             const stillIdle = livekitState.status === 'idle' || livekitState.status === 'failed';
             const empty = !activeRoom || activeRoom.remoteParticipants.size === 0;
-            if (stillIdle && empty) {
+            if (stillIdle && empty && !agentsActive()) {
                 console.log(`⏻ [IDLE-EXIT] still idle after grace — exiting 0 so Fly stops the machine (billing stops; next Resume boots it)`);
                 // Give the log tee a beat to flush, then stop the machine.
                 setTimeout(() => process.exit(0), 2000);
@@ -2229,6 +2259,25 @@ async function main() {
             console.error(`❌ Background slot ${slotId.substring(0, 8)}: resume failed — requested ${requestedSessionId?.substring(0, 8)} got ${actualSessionId?.substring(0, 8)}`);
             sendToFrontend({ type: 'background_session_error', slotId, error: 'Session resume failed' }).catch(() => { });
         });
+        // P1: a real dispatch finished — notify the frontend. The [BACKGROUND_INIT]
+        // ack also fires assistant_result, so gate on dispatchInFlight to skip it.
+        bgEmitter.on('assistant_result', ({ text }) => {
+            const slot = slots.get(slotId);
+            if (!slot)
+                return;
+            // The [BACKGROUND_INIT] kickoff also fires assistant_result and, on the cold-spawn
+            // dispatch path, can arrive AFTER dispatchInFlight was set. Consume that first result
+            // as the kickoff ack so it's never mis-reported as (and never clobbers) the dispatch's
+            // real answer.
+            if (!slot.kickoffDone) {
+                slot.kickoffDone = true;
+                return;
+            }
+            if (!slot.dispatchInFlight)
+                return; // only notify for a real dispatched instruction
+            slot.dispatchInFlight = false;
+            sendToFrontend({ type: 'background_update', sessionId: slotId, stage: 'done', summary: (text || '').trim().slice(0, 500) }).catch(() => { });
+        });
         // Wire up the LLM's internal EventEmitter so hook-emitted events also flow.
         bgLLM.events.on('session_id', (data) => bgEmitter.emit('session_id', data));
         bgLLM.events.on('tool_blocked', (data) => bgEmitter.emit('tool_blocked', data));
@@ -2251,6 +2300,12 @@ async function main() {
             settingSources: ['project', 'user'],
             env: bgEnv,
         };
+        // P1: persist the cold-start emitter + sdkOptions on the slot so a later
+        // dispatch_background can reuse them. CRITICAL: pushMessage's fast path
+        // ignores the callbacks/emitter arg once the subprocess exists, so a
+        // dispatch MUST reuse THIS emitter — otherwise its output goes nowhere.
+        slot.emitter = bgEmitter;
+        slot.sdkOptions = bgSdkOptions;
         // Cold-start: deliver an init message so the subprocess actually spawns
         // and begins consuming the session JSONL.
         const KICKOFF_TEXT = '[BACKGROUND_INIT] You have been resumed in headless background mode. No voice session is active. Acknowledge receipt with a single brief line.';
@@ -2451,6 +2506,7 @@ async function main() {
             currentLLM = null;
             clearPipelineFastBrainSession();
             clearPipelineFastBrainSession();
+            releaseAgents(); // session over → clear host + kill slots so idle-exit can fire
             armIdleExitTimer(`meeting ended (${reason}), no user`);
         }
     };
@@ -3254,6 +3310,15 @@ async function main() {
         // PipelineDirectLLM (llmOverride path) wraps its own ClaudeLLM and may not expose setTurbo.
         directLLM?.setTurbo?.(turboMode);
         currentLLM = directLLM;
+        // P1 host-agent anchor: this dashboard-started session owns the room's env
+        // and keeps it alive (agentsActive → true) so background dispatches survive.
+        // Keep-alive keys off the hostActive boolean, NOT a session_id event;
+        // hostSessionId is best-effort (the focused id is otherwise resolved as
+        // currentLLM?.sessionId || currentResumeSessionId).
+        hostActive = true;
+        hostWorkingDir = workingDir;
+        if (resumeSessionId)
+            hostSessionId = resumeSessionId;
         // Reset the session always-allow list for each new direct session
         sessionAlwaysAllowPaths = new Set();
         // For resumed sessions, eagerly create workspace (we know the real ID)
@@ -3884,6 +3949,7 @@ async function main() {
             console.log('🕊️ Left LiveKit room intentionally — idle, awaiting /connect-room (no auto-rejoin)');
             // 0.9.73: idle machines must not bill forever — stop the Fly machine
             // after the grace window unless a /connect-room revives us first.
+            releaseAgents(); // session over → clear host + kill slots so idle-exit can fire
             armIdleExitTimer('intentional leave → idle');
             return;
         }
@@ -4843,6 +4909,12 @@ async function main() {
             currentLLM = null;
             clearPipelineFastBrainSession();
             clearPipelineFastBrainSession();
+            // P1 (CRITICAL FOR COST): the human left a non-meeting session. Clear the
+            // host anchor AND hard-kill every background slot so their subprocesses
+            // stop burning tokens. agentsActive() keeps the room alive on the host +
+            // slots, so this is the ONLY safe place to release them — leaving a slot
+            // alive here would defeat the empty-room teardown timers entirely.
+            releaseAgents();
             // Auto-leave path for a NON-meeting session. 0.9.83: a real session just
             // ended → use the FAST leave (~20s), not the 3-min alone grace. Fires even
             // on an abrupt tab close; cancelled if a user rejoins within the grace.
@@ -5747,6 +5819,39 @@ async function main() {
                     });
                 }
             }
+            else if (data.type === 'dispatch_background') {
+                // P1: push an instruction into a background slot (spawning it cold-start
+                // first if needed), then notify the frontend when the turn completes.
+                const targetSessionId = data.targetSessionId;
+                const instruction = data.instruction;
+                if (!targetSessionId || !instruction) {
+                    await sendToFrontend({ type: 'background_session_error', slotId: targetSessionId ?? null, error: 'dispatch_background requires targetSessionId + instruction' });
+                }
+                else {
+                    const focusedId = currentLLM?.sessionId || currentResumeSessionId || null;
+                    if (targetSessionId === focusedId) {
+                        await sendToFrontend({ type: 'background_session_error', slotId: targetSessionId, error: 'Target is the focused session — use the normal path' });
+                    }
+                    else {
+                        const doDispatch = () => {
+                            const slot = slots.get(targetSessionId);
+                            if (!slot || !slot.emitter || !slot.sdkOptions) {
+                                void sendToFrontend({ type: 'background_session_error', slotId: targetSessionId, error: 'Slot not ready' });
+                                return;
+                            }
+                            slot.dispatchInFlight = true;
+                            // Reuse the cold-start emitter — pushMessage's fast path ignores a
+                            // fresh emitter once the subprocess exists (see spawnBackgroundSession).
+                            slot.llm.pushMessage(instruction, slot.sdkOptions, { onSessionId: () => { }, onCheckpoint: () => { }, eventEmitter: slot.emitter });
+                            void sendToFrontend({ type: 'background_dispatched', sessionId: targetSessionId, instruction });
+                        };
+                        if (slots.has(targetSessionId))
+                            doDispatch();
+                        else
+                            spawnBackgroundSession(targetSessionId).then(doDispatch).catch((err) => { void sendToFrontend({ type: 'background_session_error', slotId: targetSessionId, error: err instanceof Error ? err.message : String(err) }); });
+                    }
+                }
+            }
             else if (data.type === 'list_slots') {
                 // Return all live slots: the focused session + every background slot.
                 const focusedId = currentLLM?.sessionId || currentResumeSessionId || null;
@@ -5925,6 +6030,7 @@ async function main() {
         if (!activeRoom) {
             // Already idle — still ensure billing backstop is armed.
             livekitState.status = 'idle';
+            releaseAgents(); // ensure no lingering host/slots keep the machine alive
             armIdleExitTimer(`destroyRoomSession(${reason}) — already idle`);
             return;
         }
@@ -5957,6 +6063,7 @@ async function main() {
         livekitState.status = 'idle';
         livekitState.error = null;
         livekitState.errorCode = null;
+        releaseAgents(); // session torn down → clear host + kill slots so idle-exit can fire
         armIdleExitTimer(`destroyRoomSession(${reason})`);
         destroyingRoomSession = false;
     };

package/dist/prompts/direct-mode-research.md

@@ -113,9 +113,9 @@ THE SUB-AGENTS:
   · NEVER use the SDK's built-in 'general-purpose' agent — it is not configured for this project and will hit write blocks. Always pick researcher, reasoner, writer, tester, or reviewer explicitly.
 
 DIVISION OF LABOR — follow this chain by default for any substantive or code task:
-  researcher (gather facts) → planner (step plan for multi-step work) → THEN dispatch writer AND tester IN THE SAME STEP, in parallel: the writer executes the plan while the tester writes tests from the spec, blind to the implementation (TDD) → after the writer returns, RUN the tester's tests against the new code AND dispatch the reviewer on the diff → on test-FAIL or REJECT, send the writer back to fix and re-verify (at most 2 rounds) → you synthesize and speak.
-For a quick factual query: researcher only → you speak.
-NEVER skip the tester+reviewer verification after a code change — and dispatch the tester IN PARALLEL with the writer (not after), so tests are written independently of the code.
+  researcher (gather facts) → after the researcher returns on a substantive question, dispatch the `reasoner` GATE to judge whether the research is complete and well-sourced (GATE: PASS / NEEDS-MORE); on NEEDS-MORE send the researcher back with the named gaps and re-gate (at most 2 rounds) → planner (step plan for multi-step work) → THEN dispatch writer AND tester IN THE SAME STEP, in parallel: the writer executes the plan while the tester writes tests from the spec, blind to the implementation (TDD) → after the writer returns, RUN the tester's tests against the new code AND dispatch the reviewer on the diff → on test-FAIL or REJECT, send the writer back to fix and re-verify (at most 2 rounds) → you synthesize and speak.
+For a quick factual lookup: researcher only → you speak (a trivial lookup needs no gate).
+NEVER skip verification — it is symmetric across both flows: the reasoner GATE after substantive research, and the tester+reviewer after a code change. Both are the same pattern (generate → an INDEPENDENT agent verifies before you rely on it). Dispatch the tester IN PARALLEL with the writer (not after) so tests are written independently of the code.
 You may OVERRIDE this chain at any time — stop a running agent, inject, or reorder — because you can see each task's live state. The chain is the default, not a cage.
 Surfacing findings and communicating to the user is YOUR job, not a sub-agent's.
 </turn-shape>

package/package.json

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