osborn 0.9.240 → 0.9.242

package/dist/claude-llm.js

@@ -2321,6 +2321,16 @@ class ClaudeLLMStream extends llm.LLMStream {
                             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 });
+                                    // 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,
+                                    // so a reconcile had no authoritative live set to diff against.
+                                    if (input?.agent_id) {
+                                        try {
+                                            statusManager.upsertDispatch(input.agent_id, { subagentType: input?.agent_type, dispatchState: 'running' });
+                                        }
+                                        catch { }
+                                    }
                                     return {};
                                 }]
                         }],

package/dist/index.js

@@ -39,6 +39,7 @@ import { createSTT, createTTS } from './voice-io.js';
 import { createClaudeLLM, NAMED_AGENTS, applyTurbo } from './claude-llm.js';
 import { clearPipelineFastBrainSession, prewarmBM25Index } from './pipeline-fastbrain.js';
 import { ensureClaudeAuth, applyAuthFallback, replayInFlightAuth } from './claude-auth.js';
+import { statusManager } from './status-manager.js';
 import { createSmitheryProxy, destroySmitheryProxy, parseSmitheryUrl, isSmitheryUrl, SmitheryAuthorizationError } from './smithery-proxy.js';
 import { DIRECT_MODE_PROMPT } from './prompts.js';
 import { MCP_CATALOG } from './config.js';
@@ -2299,6 +2300,16 @@ async function main() {
                 bgEnv[k] = v;
         }
         bgEnv['CLAUDE_CODE_DISABLE_AUTO_MEMORY'] = '1';
+        // Claude Code refuses bypassPermissions / --dangerously-skip-permissions when the
+        // process runs as root — and every Fly machine runs Osborn as root, so without this
+        // EVERY headless background spawn dies on launch. IS_SANDBOX=1 is Claude Code's
+        // sanctioned "this is an isolated container, root is acceptable" signal — accurate
+        // for a per-user Fly VM. Set on the CHILD's env copy ONLY (bgEnv); the main voice
+        // agent's process.env is never touched. Panel-spawned instances are user-initiated
+        // and intentionally run on the machine's Claude subscription (Tier 1), same as the
+        // foreground session — the "never use the subscription" rule is reserved for the
+        // future autonomous cron/event background primitive, not these.
+        bgEnv['IS_SANDBOX'] = '1';
         const bgSdkOptions = {
             cwd: slotWorkingDir,
             resume: sessionId,
@@ -5851,6 +5862,17 @@ async function main() {
                         error: `Session ${resolvedSessionId.substring(0, 8)} is already running as a background slot`,
                     });
                 }
+                else if (resolvedSessionId === (currentLLM?.sessionId || currentResumeSessionId)) {
+                    // Never background the session that's LIVE in the foreground. Pre-IS_SANDBOX this
+                    // failed harmlessly on the root check; post-fix it would SUCCEED, putting two
+                    // Claude processes appending to the same session JSONL concurrently → transcript
+                    // corruption. Refuse it explicitly.
+                    await sendToFrontend({
+                        type: 'background_session_error',
+                        slotId: resolvedSessionId,
+                        error: `Session ${resolvedSessionId.substring(0, 8)} is the active foreground session — pick a different session to background`,
+                    });
+                }
                 else {
                     spawnBackgroundSession(resolvedSessionId, bgDir).catch((err) => {
                         console.error('❌ spawnBackgroundSession failed:', err instanceof Error ? err.message : err);
@@ -5952,6 +5974,12 @@ async function main() {
                         processes: topProcesses,
                         totalCount,
                         memory: { usedMb, totalMb, freeMb },
+                        // Authoritative set of still-live sub-agent dispatches. The frontend
+                        // reconciles its "running" background-flow rows against this and clears
+                        // any orphan whose completion/stop event was lost (or belonged to a
+                        // now-dead agent process — this list is per-process, so it's empty
+                        // after a restart and every stale row gets swept on the next poll).
+                        activeDispatchIds: statusManager.getActiveDispatchIds(),
                     });
                 }
                 catch (err) {

package/dist/status-manager.d.ts

@@ -90,6 +90,18 @@ export declare class StatusManager {
      * Get context summary for the brain
      */
     getContextSummary(): string;
+    /**
+     * Dispatcher reconciliation — the agent_ids of dispatches that are still LIVE
+     * (a real sub-agent dispatch, i.e. has a subagentType, whose dispatchState has
+     * not reached a terminal 'completed'/'failed'/'rejected'). The frontend
+     * cross-checks its "running" background-flow rows against this authoritative
+     * set on each process_list poll and clears any row NOT present — self-healing
+     * the orphaned "running" cards left when a task_completed / agent_stopped event
+     * was lost to a disconnect. Because this manager is a per-process singleton, an
+     * agent restart (the common session-drop case) resets it to empty, so every
+     * stale row from the dead process is reconciled away on the next poll.
+     */
+    getActiveDispatchIds(): 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

@@ -182,6 +182,25 @@ export class StatusManager {
     getContextSummary() {
         return this.conversationContext.slice(-5).join(' | ');
     }
+    /**
+     * Dispatcher reconciliation — the agent_ids of dispatches that are still LIVE
+     * (a real sub-agent dispatch, i.e. has a subagentType, whose dispatchState has
+     * not reached a terminal 'completed'/'failed'/'rejected'). The frontend
+     * cross-checks its "running" background-flow rows against this authoritative
+     * set on each process_list poll and clears any row NOT present — self-healing
+     * the orphaned "running" cards left when a task_completed / agent_stopped event
+     * was lost to a disconnect. Because this manager is a per-process singleton, an
+     * agent restart (the common session-drop case) resets it to empty, so every
+     * stale row from the dead process is reconciled away on the next poll.
+     */
+    getActiveDispatchIds() {
+        return Array.from(this.tasks.values())
+            .filter(t => !!t.subagentType &&
+            t.dispatchState !== 'completed' &&
+            t.dispatchState !== 'failed' &&
+            t.dispatchState !== 'rejected')
+            .map(t => t.id);
+    }
     /**
      * 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.240",
+  "version": "0.9.242",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {