bloby-bot 0.70.10 → 0.70.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.70.10",
+  "version": "0.70.12",
   "releaseNotes": [
     "1. Fix: agent self-update ",
     "1",

package/supervisor/channels/manager.ts

@@ -542,6 +542,16 @@ export class ChannelManager {
     eventData: any,
     botName: string,
   ): void {
+    // Synthetic turns (background-task continuation turns the harness injects
+    // with no matching user push — currently only the pi harness tags these)
+    // are INVISIBLE to channel routing: they enqueued no routing target, so
+    // consuming/flushing/draining here would steal a concurrently-queued
+    // channel message's route and cross-wire replies. They are dashboard-
+    // broadcast + DB-persist only. consumedThisTurn/chunkBuf are deliberately
+    // untouched — synthetic tokens never enter the chunk buffer, and the
+    // surrounding real turns' accounting stays intact.
+    if (eventData?.synthetic) return;
+
     const convId = eventData?.conversationId as string | undefined;
 
     if (type === 'bot:token' && eventData?.token) {

package/supervisor/harnesses/pi/index.ts

@@ -62,6 +62,15 @@ interface LiveConversation {
    *  after the user hears "Done!", mirroring claude's usedTools capture of
    *  sub-agent tool_use blocks. */
   taskUsedFileTools: boolean;
+  /** Origin of each queued message, FIFO-aligned with inputQueue: 'user' for
+   *  pushMessage, 'synthetic' for task-completion injections. Shifted on
+   *  turn_started so the turn's events can be tagged synthetic — the channel
+   *  routing FIFO must skip turns that never enqueued a routing target
+   *  (Phase B review PI-B-1: an untagged continuation turn would steal a
+   *  concurrently-queued channel message's route). */
+  turnOrigins: ('user' | 'synthetic')[];
+  /** True while the in-flight turn originated from pushSyntheticMessage. */
+  currentTurnSynthetic: boolean;
   loopDone: Promise<void> | null;
 }
 
@@ -72,9 +81,18 @@ interface RunningTask {
   abortController: AbortController;
   /** True when stopped via user:stop-task or conversation teardown. */
   stopped: boolean;
+  /** True when the wall-clock task watchdog aborted it. */
+  timedOut: boolean;
   startedAt: number;
 }
 
+/** Hard wall-clock cap per background task. Bounds the housekeeping wedge
+ *  (idle:false defers recycling; anyConversationBusy defers restarts and
+ *  self-updates) if a child ever hangs in a way the stream timeouts and the
+ *  Bash exit-settle can't catch. Generous: a 50-round coder task fits well
+ *  inside it. */
+const TASK_WALL_CLOCK_MS = 30 * 60_000;
+
 const liveConversations = new Map<string, LiveConversation>();
 
 /**
@@ -253,15 +271,18 @@ function resolveAuth(): { ok: true; auth: PiSessionAuth } | { ok: false; error:
 // ── Background sub-agents (Phase B — audit D4-1) ───────────────────────────
 
 /** Inject a system-originated message into the parent's queue (task completion).
- *  Mirrors the Claude SDK's self-prompted continuation turn: no routing target
- *  is enqueued (channelManager only wraps USER pushes), so the continuation's
- *  bot:response meets an empty routing FIFO and falls through to the dashboard
- *  broadcast — exactly claude's behavior. pendingCount/busy are maintained so
- *  idle stays accurate and the recycler can't fire mid-continuation. No
- *  bot:typing (claude's continuation turns emit none either). */
+ *  Mirrors the Claude SDK's self-prompted continuation turn, with one
+ *  improvement: the resulting turn's events are tagged `synthetic: true`
+ *  (origin tracked via conv.turnOrigins) so the channel routing FIFO ignores
+ *  them entirely — a continuation enqueues no routing target, and an untagged
+ *  bot:response would steal a concurrently-queued channel message's route
+ *  (review PI-B-1). Synthetic turns are dashboard-broadcast + DB-persist only.
+ *  pendingCount/busy are maintained so idle stays accurate and the recycler
+ *  can't fire mid-continuation. No bot:typing (claude parity). */
 function pushSyntheticMessage(conv: LiveConversation, text: string): void {
   conv.busy = true;
   conv.pendingCount += 1;
+  conv.turnOrigins.push('synthetic');
   conv.inputQueue.push({ role: 'user', content: [{ type: 'text', text }] });
 }
 
@@ -310,10 +331,21 @@ function createTaskHost(conv: LiveConversation, getAuth: () => PiSessionAuth): P
         subagentType: req.subagentType,
         abortController,
         stopped: false,
+        timedOut: false,
         startedAt: Date.now(),
       };
       conv.tasks.set(taskId, task);
 
+      // Wall-clock backstop: a hung child would otherwise pin idle:false and
+      // anyConversationBusy forever, deferring recycling/restarts/self-updates
+      // indefinitely (review PI-B lifecycle finding). Cleared in the finally.
+      const watchdog = setTimeout(() => {
+        if (!conv.tasks.has(taskId)) return;
+        log.warn(`[pi/task] Task ${taskId} hit the ${TASK_WALL_CLOCK_MS / 60_000}-minute wall clock — aborting`);
+        task.timedOut = true;
+        abortController.abort();
+      }, TASK_WALL_CLOCK_MS);
+
       // Honor the agent config's tool restrictions (claude applies these via
       // the SDK's tools/disallowedTools options — e.g. a future researcher
       // agent with disallowedTools: ['Write','Edit']).
@@ -330,6 +362,13 @@ function createTaskHost(conv: LiveConversation, getAuth: () => PiSessionAuth): P
       let errorText = '';
       let usedFileTools = false;
       let toolUses = 0;
+      // Outcome from the session's turn_complete — the error EVENT is
+      // suppressed when partial text streamed (D6-2 precedence), so these are
+      // how the host learns a child that streamed text still failed
+      // (review PI-B-CHILD-1: such tasks must not be reported 'completed').
+      let childErrored = false;
+      let childErrorMsg = '';
+      let childCapHit = false;
       let lastUsage: { inputTokens?: number; outputTokens?: number; cacheReadTokens?: number; cacheCreationTokens?: number } | undefined;
 
       const session = createPiSession({
@@ -361,6 +400,11 @@ function createTaskHost(conv: LiveConversation, getAuth: () => PiSessionAuth): P
             case 'turn_complete':
               usedFileTools = usedFileTools || evt.usedFileTools;
               if (evt.usage) lastUsage = evt.usage;
+              if (evt.errored) {
+                childErrored = true;
+                childErrorMsg = evt.errorMsg || childErrorMsg;
+              }
+              if (evt.roundCapHit) childCapHit = true;
               break;
           }
         },
@@ -388,9 +432,21 @@ function createTaskHost(conv: LiveConversation, getAuth: () => PiSessionAuth): P
         } catch (err: any) {
           errorText = errorText || err?.message || String(err);
         } finally {
+          clearTimeout(watchdog);
           conv.tasks.delete(taskId);
-          const status = task.stopped ? 'stopped' : (errorText && !summaryText ? 'failed' : 'completed');
-          const summary = summaryText || errorText || '(the agent produced no output)';
+          // Honest status (review PI-B-CHILD-1): an error or round-cap exit is
+          // 'failed' even when partial text streamed — the parent must not
+          // relay half-done work as success.
+          const failed = task.timedOut || childErrored || childCapHit || !!errorText || !summaryText;
+          const status = task.stopped ? 'stopped' : failed ? 'failed' : 'completed';
+          let summary = summaryText || errorText || '(the agent produced no output)';
+          if (task.timedOut) {
+            summary += `\n\n[The task was aborted after ${TASK_WALL_CLOCK_MS / 60_000} minutes — work is incomplete.]`;
+          } else if (childCapHit) {
+            summary += '\n\n[The task hit its tool-round limit before finishing — work may be incomplete.]';
+          } else if (childErrored && summaryText) {
+            summary += `\n\n[The task hit an error before finishing: ${childErrorMsg || errorText || 'unknown error'}]`;
+          }
           const u = lastUsage;
           const totalTokens = u
             ? (u.inputTokens || 0) + (u.outputTokens || 0) + (u.cacheReadTokens || 0) + (u.cacheCreationTokens || 0)
@@ -497,11 +553,20 @@ export async function startConversation(
     onMessage,
     busy: false,
     pendingCount: 0,
-    batcher: createTokenBatcher((text) => onMessage('bot:token', { conversationId, token: text })),
+    batcher: null as unknown as TokenBatcher, // set right below (needs conv for the synthetic tag)
     tasks: new Map(),
     taskUsedFileTools: false,
+    turnOrigins: [],
+    currentTurnSynthetic: false,
     loopDone: null,
   };
+  conv.batcher = createTokenBatcher((text) =>
+    onMessage('bot:token', {
+      conversationId,
+      token: text,
+      ...(conv.currentTurnSynthetic ? { synthetic: true } : {}),
+    }),
+  );
   liveConversations.set(conversationId, conv);
 
   // Re-resolve auth on every provider round so a key/model fix in the wizard
@@ -560,19 +625,26 @@ function translateAndEmit(conv: LiveConversation, evt: PiSessionEvent) {
   // invariant both depend on it.
   conv.batcher.flush();
 
+  // Synthetic tag for every event of a continuation turn (origin shifted at
+  // turn_started): the channel routing FIFO must treat these turns as
+  // invisible — they enqueued no routing target, so consuming one would steal
+  // a queued channel message's route (review PI-B-1).
+  const syn = conv.currentTurnSynthetic ? { synthetic: true } : {};
+
   switch (evt.type) {
     case 'turn_started':
+      conv.currentTurnSynthetic = conv.turnOrigins.shift() === 'synthetic';
       // No bloby event for this — `bot:typing` is already emitted by pushMessage().
       break;
     case 'text_end':
-      conv.onMessage('bot:response', { conversationId: conv.id, content: evt.text });
+      conv.onMessage('bot:response', { conversationId: conv.id, content: evt.text, ...syn });
       break;
     case 'tool_use': {
       // House vocabulary: claude's delegation tool is named Task; the pi
       // prompt's 'Agent' alias resolves to the same tool — normalize the
       // event so consumers see one name.
       const toolName = evt.name === 'Agent' || evt.name === 'agent' ? 'Task' : evt.name;
-      conv.onMessage('bot:tool', { conversationId: conv.id, name: toolName, input: evt.input });
+      conv.onMessage('bot:tool', { conversationId: conv.id, name: toolName, input: evt.input, ...syn });
       break;
     }
     case 'tool_result':
@@ -605,6 +677,7 @@ function translateAndEmit(conv: LiveConversation, evt: PiSessionEvent) {
         contextTokens,
         contextWindow: evt.contextWindow || 0,
         idle,
+        ...syn,
       });
       log.info(`[pi/conversation] ──── TURN COMPLETE ────  busy=false ctx=${contextTokens}/${evt.contextWindow || 'n/a'} idle=${idle} tasks=${conv.tasks.size}`);
       break;
@@ -619,7 +692,7 @@ function translateAndEmit(conv: LiveConversation, evt: PiSessionEvent) {
         : evt.kind === 'auth'
           ? ' I\'ll reconnect with the new key as soon as it\'s saved.'
           : '';
-      conv.onMessage('bot:error', { conversationId: conv.id, error: `${evt.error}${remedy}` });
+      conv.onMessage('bot:error', { conversationId: conv.id, error: `${evt.error}${remedy}`, ...syn });
       if (fatal) {
         // Unrecoverable for this session (audit D6-4): an over-window history
         // would re-fail on every future turn, and a dead key has no business
@@ -649,6 +722,7 @@ export function pushMessage(
   log.info(`[pi/conversation] ──── PUSH MESSAGE ──── busy=${conv.busy} pending=${conv.pendingCount + 1}`);
   conv.busy = true;
   conv.pendingCount += 1;
+  conv.turnOrigins.push('user');
   conv.inputQueue.push(buildUserMessage(content, attachments, savedFiles));
   conv.onMessage('bot:typing', { conversationId });
   return true;

package/supervisor/harnesses/pi/session.ts

@@ -46,7 +46,22 @@ export type PiSessionEvent =
   | { type: 'text_end'; text: string }
   | { type: 'tool_use'; id: string; name: string; input: any }
   | { type: 'tool_result'; toolUseId: string; name: string; isError?: boolean }
-  | { type: 'turn_complete'; usedFileTools: boolean; usage?: PiUsage; contextWindow?: number }
+  | {
+      type: 'turn_complete';
+      usedFileTools: boolean;
+      usage?: PiUsage;
+      contextWindow?: number;
+      /** True when the turn ended on a provider error. NOTE: the `error` EVENT
+       *  is suppressed when partial text streamed (D6-2 response-over-error
+       *  precedence, designed for the watched parent stream) — these fields
+       *  are how an UNwatched consumer (the task host) learns the turn failed,
+       *  so a child that streamed text then died isn't reported 'completed'. */
+      errored?: boolean;
+      errorKind?: PiErrorKind;
+      errorMsg?: string;
+      /** True when the turn was cut off by the tool-round budget mid-task. */
+      roundCapHit?: boolean;
+    }
   | { type: 'error'; error: string; kind?: PiErrorKind };
 
 /** Everything the providers need that can change while a session is alive. */
@@ -230,8 +245,11 @@ export function createPiSession(init: PiSessionInit): PiSession {
     let turnErrorKind: PiErrorKind | undefined;
 
     const maxRounds = Math.max(1, init.maxToolRounds ?? MAX_TOOL_ROUNDS);
+    // True only when the for-loop runs out of rounds with the model still
+    // mid-task — every intentional exit (done, errored, aborted) clears it.
+    let roundCapHit = true;
     for (let round = 0; round < maxRounds; round++) {
-      if (init.abortController.signal.aborted) break;
+      if (init.abortController.signal.aborted) { roundCapHit = false; break; }
       // The separator condition is decided BEFORE the round so the round can
       // emit it ahead of its first token (claude.ts ordering — see runOneRound).
       const needsSeparator = accumulatedText.length > 0 && !accumulatedText.endsWith('\n');
@@ -289,6 +307,7 @@ export function createPiSession(init: PiSessionInit): PiSession {
         turnErrored = true;
         turnErrorMsg = res.errorMsg;
         turnErrorKind = res.errorKind;
+        roundCapHit = false;
         break;
       }
 
@@ -313,7 +332,7 @@ export function createPiSession(init: PiSessionInit): PiSession {
       }
 
       // No tool calls ⇒ the model is done with this turn.
-      if (toolUses.length === 0) break;
+      if (toolUses.length === 0) { roundCapHit = false; break; }
     }
 
     // Turn-end emission order (audit D6-2, mirrors claude.ts:394-401):
@@ -337,7 +356,16 @@ export function createPiSession(init: PiSessionInit): PiSession {
         init.onEvent({ type: 'error', error: turnErrorMsg || 'Provider turn failed', kind: turnErrorKind });
       }
       const usedFileTools = Array.from(usedTools).some((t) => FILE_TOOL_NAMES.has(t));
-      init.onEvent({ type: 'turn_complete', usedFileTools, usage: lastUsage, contextWindow: lastContextWindow });
+      init.onEvent({
+        type: 'turn_complete',
+        usedFileTools,
+        usage: lastUsage,
+        contextWindow: lastContextWindow,
+        errored: turnErrored || undefined,
+        errorKind: turnErrorKind,
+        errorMsg: turnErrorMsg,
+        roundCapHit: roundCapHit || undefined,
+      });
     }
   }
 
@@ -354,7 +382,14 @@ export function createPiSession(init: PiSessionInit): PiSession {
           // 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, usage: lastUsage, contextWindow: lastContextWindow });
+            init.onEvent({
+              type: 'turn_complete',
+              usedFileTools: false,
+              usage: lastUsage,
+              contextWindow: lastContextWindow,
+              errored: true,
+              errorMsg: err?.message || String(err),
+            });
           }
         }
       }

package/supervisor/harnesses/pi/tools/bash.ts

@@ -38,12 +38,26 @@ export const bashTool: PiTool = {
       let timedOut = false;
       let settled = false;
 
+      // detached:true gives the child its own process group so kills reach
+      // grandchildren too — a SIGKILLed direct child can leave orphans holding
+      // the stdio pipes, and 'close' (which waits for the pipes) then never
+      // fires, hanging the tool promise and wedging the whole turn.
       const child = spawn('bash', ['-lc', command], {
         cwd: ctx.cwd,
         env: process.env,
         stdio: ['ignore', 'pipe', 'pipe'],
+        detached: true,
       });
 
+      const killTree = () => {
+        try {
+          if (child.pid) process.kill(-child.pid, 'SIGKILL');
+          else child.kill('SIGKILL');
+        } catch {
+          try { child.kill('SIGKILL'); } catch {}
+        }
+      };
+
       const append = (chunk: Buffer) => {
         if (truncated) return;
         const remaining = OUTPUT_CAP_BYTES - Buffer.byteLength(out, 'utf-8');
@@ -65,23 +79,15 @@ export const bashTool: PiTool = {
 
       const timer = setTimeout(() => {
         timedOut = true;
-        try { child.kill('SIGKILL'); } catch {}
+        killTree();
       }, timeout);
 
       const onAbort = () => {
-        try { child.kill('SIGKILL'); } catch {}
+        killTree();
       };
       ctx.signal?.addEventListener('abort', onAbort);
 
-      child.on('error', (err) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        ctx.signal?.removeEventListener('abort', onAbort);
-        resolve({ output: `Failed to spawn command: ${err.message}`, isError: true });
-      });
-
-      child.on('close', (code, signal) => {
+      const finish = (code: number | null, signal: NodeJS.Signals | null) => {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
@@ -103,6 +109,23 @@ export const bashTool: PiTool = {
             isError: true,
           });
         }
+      };
+
+      child.on('error', (err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        ctx.signal?.removeEventListener('abort', onAbort);
+        resolve({ output: `Failed to spawn command: ${err.message}`, isError: true });
+      });
+
+      // 'close' is the normal settle point (all output drained). But orphaned
+      // grandchildren can inherit the stdio pipes and keep them open after the
+      // direct child died — settle from 'exit' after a short drain grace so the
+      // tool promise can never hang the turn on a pipe that won't close.
+      child.on('close', (code, signal) => finish(code, signal));
+      child.on('exit', (code, signal) => {
+        setTimeout(() => finish(code, signal), 1500);
       });
     });
   },

package/supervisor/index.ts

@@ -3236,8 +3236,12 @@ ${alreadyLinked ? '' : `
     return async (type: string, eventData: any) => {
       // Capture surface BEFORE routeWaStreamEvent consumes the routing target on bot:response.
       // Used below to suppress chat-bubble broadcasts for non-dashboard turns.
+      // Synthetic turns (background-task continuations — see routeWaStreamEvent's
+      // guard) never own a routing target; the FIFO head, if any, belongs to a
+      // QUEUED channel message, so peeking it would misclassify the turn.
+      // They are always dashboard turns.
       const triggerSurface = channelManager.peekCurrentSurface(convId);
-      const isDashboardTurn = !triggerSurface || triggerSurface === 'workspace' || triggerSurface === 'chat';
+      const isDashboardTurn = eventData?.synthetic === true || !triggerSurface || triggerSurface === 'workspace' || triggerSurface === 'chat';
 
       if (type === 'bot:typing') {
         currentStreamConvId = convId;