bloby-bot 0.53.1 → 0.53.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.53.1",
+  "version": "0.53.3",
   "releaseNotes": [
     "1. New Morphy animation system: config-driven sprites loaded from /morphy/*.json",
     "2. Swapped teleporting (splash) and headphones (bubble + chat) to the new format",

package/supervisor/backend.ts

@@ -131,21 +131,52 @@ export function stopBackend(): Promise<void> {
   const dying = child;
   child = null;
 
-  stopPromise = new Promise<void>((resolve) => {
-    dying.once('exit', () => {
-      stopPromise = null;
+  const promise = new Promise<void>((resolve) => {
+    let killTimer: ReturnType<typeof setTimeout> | null = null;
+    let finished = false;
+    const done = () => {
+      if (finished) return; // exit + SIGKILL paths can both fire; run once
+      finished = true;
+      if (killTimer) clearTimeout(killTimer);
+      // Only release the shared guard if it still points at THIS stop. A later stopBackend()
+      // may already have installed its own promise; the 3s safety timer (or a late exit) must
+      // never null a *different* stop's guard — that would make isBackendStopping() lie and let
+      // a concurrent spawn race the in-flight kill for the port.
+      if (stopPromise === promise) stopPromise = null;
       resolve();
-    });
+    };
+    dying.once('exit', done);
     dying.kill();
-    // Safety: force kill after 3s if SIGTERM doesn't work
-    setTimeout(() => {
-      try { dying.kill('SIGKILL'); } catch {}
-      stopPromise = null;
-      resolve();
-    }, 3000);
+    // Safety: force kill after 3s if SIGTERM doesn't land.
+    killTimer = setTimeout(() => { try { dying.kill('SIGKILL'); } catch {} done(); }, 3000);
   });
+  stopPromise = promise;
+
+  return promise;
+}
 
-  return stopPromise;
+let restartInFlight: Promise<void> | null = null;
+let rerunRequested = false;
+
+/** Serialized + coalescing backend restart — the single funnel for every deliberate restart
+ *  (file watcher, turn-complete, scheduler pulse, channel manager). Concurrent callers share
+ *  one in-flight restart; a request that arrives mid-restart triggers exactly one more
+ *  stop→spawn cycle afterward, so the final backend was spawned after the latest request. This
+ *  removes the double-spawn-onto-contended-port race of independent stopBackend().then(spawn) chains. */
+export function restartBackend(port: number): Promise<void> {
+  if (restartInFlight) {
+    rerunRequested = true;
+    return restartInFlight;
+  }
+  restartInFlight = (async () => {
+    do {
+      rerunRequested = false;
+      resetBackendRestarts();
+      await stopBackend();
+      spawnBackend(port);
+    } while (rerunRequested);
+  })().finally(() => { restartInFlight = null; });
+  return restartInFlight;
 }
 
 export function isBackendAlive(): boolean {

package/supervisor/bloby-agent.ts

@@ -86,6 +86,12 @@ export function isConversationBusy(conversationId: string): boolean {
   return Object.values(HARNESSES).some((h) => h.isConversationBusy(conversationId));
 }
 
+/** True if ANY conversation in ANY harness is mid-turn. Lets the supervisor defer backend
+ *  restarts during channel/Alexa turns, which don't set the dashboard's agentQueryActive flag. */
+export function anyConversationBusy(): boolean {
+  return Object.values(HARNESSES).some((h) => h.anyConversationBusy());
+}
+
 export async function stopSubAgentTask(conversationId: string, taskId: string): Promise<void> {
   for (const h of Object.values(HARNESSES)) {
     if (h.hasConversation(conversationId)) {

package/supervisor/harnesses/claude.ts

@@ -538,6 +538,13 @@ export function isConversationBusy(conversationId: string): boolean {
   return liveConversations.get(conversationId)?.busy || false;
 }
 
+/** True if ANY live conversation in this harness is mid-turn. Used by the supervisor to defer
+ *  backend restarts during channel/Alexa turns (which don't set the dashboard's agentQueryActive). */
+export function anyConversationBusy(): boolean {
+  for (const c of liveConversations.values()) if (c.busy) return true;
+  return false;
+}
+
 /** Stop a specific background sub-agent task */
 export async function stopSubAgentTask(conversationId: string, taskId: string): Promise<void> {
   const conv = liveConversations.get(conversationId);

package/supervisor/harnesses/codex.ts

@@ -365,7 +365,14 @@ async function startTurn(conv: CodexConversation, content: string, savedFiles?:
     await conv.rpc.request('turn/start', params);
   } catch (err: any) {
     conv.busy = false;
+    conv.currentTurnId = null;
     conv.onMessage('bot:error', { conversationId: conv.id, error: `turn/start failed: ${err.message}` });
+    // turn/start produced no turn, so no turn/completed will arrive to clear the supervisor's
+    // agentQueryActive (set on bot:typing above). Left as-is, that wedges true forever:
+    // backend auto-heal is deferred indefinitely and chat is stuck showing "typing". Tear the
+    // conversation down so bot:conversation-ended fires (which, unlike bot:turn-complete, does
+    // NOT trigger a backend restart) — the next user message cold-starts a fresh thread.
+    teardownConversation(conv.id);
   }
 }
 
@@ -633,6 +640,13 @@ export function isConversationBusy(conversationId: string): boolean {
   return conversations.get(conversationId)?.busy ?? false;
 }
 
+/** True if ANY live conversation in this harness is mid-turn. Used by the supervisor to defer
+ *  backend restarts during channel/Alexa turns (which don't set the dashboard's agentQueryActive). */
+export function anyConversationBusy(): boolean {
+  for (const c of conversations.values()) if (c.busy) return true;
+  return false;
+}
+
 export async function startConversation(
   conversationId: string,
   model: string,

package/supervisor/harnesses/pi/index.ts

@@ -320,6 +320,13 @@ export function isConversationBusy(conversationId: string): boolean {
   return liveConversations.get(conversationId)?.busy || false;
 }
 
+/** True if ANY live conversation in this harness is mid-turn. Used by the supervisor to defer
+ *  backend restarts during channel/Alexa turns (which don't set the dashboard's agentQueryActive). */
+export function anyConversationBusy(): boolean {
+  for (const c of liveConversations.values()) if (c.busy) return true;
+  return false;
+}
+
 /** Pi has no sub-agents yet; provided for interface compatibility. */
 export async function stopSubAgentTask(_conversationId: string, _taskId: string): Promise<void> {
   // no-op for Phase 1

package/supervisor/harnesses/pi/session.ts

@@ -220,8 +220,14 @@ export function createPiSession(init: PiSessionInit): PiSession {
       if (toolUses.length === 0 && !pendingInterleave) break;
     }
 
-    if (!turnErrored) {
-      if (accumulatedText) {
+    // Emit text_end only on a clean turn (don't persist a half-baked answer from an errored
+    // turn). But ALWAYS emit turn_complete on a non-aborted turn — including the errored path
+    // — so the supervisor clears agentQueryActive (set on turn_started). Skipping it on error
+    // wedged the flag true: backend auto-heal stayed deferred and chat stuck in "typing" until
+    // the next successful turn. The 'error' event was already emitted by runOneRound, so the
+    // user still sees the failure. Aborted turns are torn down via bot:conversation-ended.
+    if (!init.abortController.signal.aborted) {
+      if (!turnErrored && accumulatedText) {
         init.onEvent({ type: 'text_end', text: accumulatedText });
       }
       const usedFileTools = Array.from(usedTools).some((t) => FILE_TOOL_NAMES.has(t));
@@ -238,6 +244,12 @@ export function createPiSession(init: PiSessionInit): PiSession {
         } catch (err: any) {
           log.warn(`[pi/session] Turn failed: ${err?.message || err}`);
           init.onEvent({ type: 'error', error: err?.message || String(err) });
+          // A thrown turn emitted no turn_complete either — clear agentQueryActive so auto-heal
+          // and chat aren't wedged. Skip when aborting (teardown emits conversation-ended).
+          // usedFileTools=false is the safe default (it only governs whether to auto-restart now).
+          if (!init.abortController.signal.aborted) {
+            init.onEvent({ type: 'turn_complete', usedFileTools: false });
+          }
         }
       }
     },

package/supervisor/harnesses/types.ts

@@ -57,6 +57,8 @@ export interface Harness {
   endConversation(conversationId: string): void;
   endAllConversations(): void;
   isConversationBusy(conversationId: string): boolean;
+  /** True if ANY conversation in this harness is mid-turn (no id — used to defer backend restarts). */
+  anyConversationBusy(): boolean;
   stopSubAgentTask(conversationId: string, taskId: string): Promise<void>;
   warmUpForLiveConversation(
     model: string,

package/supervisor/index.ts

@@ -11,12 +11,12 @@ import { log } from '../shared/logger.js';
 import { startTunnel, stopTunnel, isTunnelAlive, restartTunnel, startNamedTunnel, restartNamedTunnel } from './tunnel.js';
 import { createWorkerApp } from '../worker/index.js';
 import { closeDb, getSession, getSetting } from '../worker/db.js';
-import { spawnBackend, stopBackend, getBackendPort, isBackendAlive, isBackendStopping, resetBackendRestarts, setBackendEnv } from './backend.js';
+import { spawnBackend, stopBackend, restartBackend, getBackendPort, isBackendAlive, isBackendStopping, setBackendEnv } from './backend.js';
 import { handleAgentQuery, type AgentQueryRequest } from './agent-api.js';
 import { updateTunnelUrl, startHeartbeat, stopHeartbeat, disconnect } from '../shared/relay.js';
 import {
   startConversation, hasConversation, endConversation, endAllConversations,
-  isConversationBusy, stopSubAgentTask,
+  isConversationBusy, anyConversationBusy, stopSubAgentTask,
   startBlobyAgentQuery, stopBlobyAgentQuery,
   warmUpForLiveConversation,
   type RecentMessage,
@@ -1271,8 +1271,7 @@ mint();
             const result = await handleAgentQuery(parsed);
 
             if (result.usedFileTools) {
-              resetBackendRestarts();
-              stopBackend().then(() => spawnBackend(backendPort));
+              void doRestart();
               broadcastBloby('app:hmr-update', {});
             }
 
@@ -1931,11 +1930,8 @@ mint();
         currentStreamBuffer = '';
 
         if (eventData.usedFileTools || pendingBackendRestart) {
-          log.info('[orchestrator] Restarting backend (file tools used)');
-          pendingBackendRestart = false;
-          if (backendRestartTimer) { clearTimeout(backendRestartTimer); backendRestartTimer = null; }
-          resetBackendRestarts();
-          stopBackend().then(() => spawnBackend(backendPort));
+          log.info('[orchestrator] Restarting backend (file tools used / pending watcher change)');
+          void doRestart();
         }
         if (pendingUpdate) {
           pendingUpdate = false;
@@ -2536,11 +2532,7 @@ mint();
   startScheduler({
     broadcastBloby,
     workerApi,
-    restartBackend: async () => {
-      resetBackendRestarts();
-      await stopBackend();
-      spawnBackend(backendPort);
-    },
+    restartBackend: () => doRestart(),
     getModel: () => loadConfig().ai.model,
   });
 
@@ -2548,11 +2540,7 @@ mint();
   const channelManager = new ChannelManager({
     broadcastBloby,
     workerApi,
-    restartBackend: async () => {
-      resetBackendRestarts();
-      await stopBackend();
-      spawnBackend(backendPort);
-    },
+    restartBackend: () => doRestart(),
     getModel: () => loadConfig().ai.model,
   });
 
@@ -2586,21 +2574,39 @@ mint();
   const backendDir = path.join(workspaceDir, 'backend');
   let backendRestartTimer: ReturnType<typeof setTimeout> | null = null;
 
+  /** Single funnel for every DELIBERATE backend restart (file watcher, turn-complete, agent-api
+   *  one-shot, scheduler pulse, channel manager). Clears the deferred-restart flag and the
+   *  debounce timer, then delegates to backend.ts's serialized + coalescing restartBackend so
+   *  concurrent triggers can never double-spawn onto the contended port. */
+  function doRestart(): Promise<void> {
+    pendingBackendRestart = false;
+    if (backendRestartTimer) { clearTimeout(backendRestartTimer); backendRestartTimer = null; }
+    return restartBackend(backendPort);
+  }
+
+  /** True while any surface is mid-turn. Dashboard chat sets agentQueryActive; WhatsApp/Alexa
+   *  turns instead set the harness conv.busy (they don't touch agentQueryActive), so we must
+   *  check both — otherwise an agent editing the backend over a channel would get the backend
+   *  restarted out from under it mid-turn. */
+  const aTurnIsActive = () => agentQueryActive || anyConversationBusy();
+
   function scheduleBackendRestart(reason: string) {
-    if (agentQueryActive) {
-      // Agent is working — don't restart now, flag it for bot:done
+    if (aTurnIsActive()) {
+      // A turn is working — don't restart now; flush at turn-complete (createSharedChatOnMessage)
+      // or via the channel manager's own post-turn restart.
       pendingBackendRestart = true;
       return;
     }
-    // Skip if a stop/restart is already in progress (bot:done handler owns the restart)
+    // Skip if a stop/restart is already in progress (that restart owns the spawn).
     if (isBackendStopping()) return;
     if (backendRestartTimer) clearTimeout(backendRestartTimer);
-    backendRestartTimer = setTimeout(async () => {
-      if (isBackendStopping()) return; // re-check after delay
+    backendRestartTimer = setTimeout(() => {
+      backendRestartTimer = null;
+      // Re-check at fire time: a turn may have started during the 1s debounce window.
+      if (aTurnIsActive()) { pendingBackendRestart = true; return; }
+      if (isBackendStopping()) return;
       log.info(`[watcher] ${reason} — restarting backend...`);
-      resetBackendRestarts();
-      await stopBackend();
-      spawnBackend(backendPort);
+      void doRestart();
     }, 1000);
   }
 
@@ -2610,12 +2616,22 @@ mint();
     scheduleBackendRestart(`Backend file changed: ${filename}`);
   });
 
-  // Watch workspace root for .env changes and .restart trigger
+  // Watch workspace root for .env, dependency, and .restart/.update changes
   const workspaceWatcher = fs.watch(workspaceDir, (_event, filename) => {
     if (!filename) return;
     if (filename === '.env') {
       scheduleBackendRestart('.env changed');
     }
+    if (filename === 'package.json' || filename === 'package-lock.json') {
+      // The agent ran `npm install` to add/fix a backend dependency. Neither watcher otherwise
+      // covers workspace-root deps (backendWatcher only watches backend/; node_modules is huge
+      // and intentionally unwatched). Without this, an install done to fix an ENOENT crash — where
+      // the import already exists so no Write tool fires and usedFileTools stays false — never
+      // restarts the backend, leaving it broken until some unrelated edit. npm install runs inside
+      // the agent's turn, so this defers (like every trigger) and lands at turn-complete, after
+      // the install has fully written package.json + node_modules.
+      scheduleBackendRestart(`workspace dependencies changed (${filename})`);
+    }
     if (filename === '.restart') {
       // Consume the trigger file
       try { fs.unlinkSync(path.join(workspaceDir, '.restart')); } catch {}