bloby-bot 0.53.9 → 0.54.10

package/supervisor/harnesses/codex.ts

@@ -42,7 +42,15 @@ export type { RecentMessage, AgentAttachment };
 
 const CLIENT_INFO = { name: 'bloby', title: 'Bloby', version: '1' };
 const REQUEST_TIMEOUT_MS = 60_000;
-const VALID_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh']);
+const VALID_EFFORTS = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh']);
+/**
+ * Per-turn watchdog. `turn/completed` is a NON-guaranteed notification — if the
+ * app-server stalls mid-turn without exiting, the RPC `exit` handler never fires
+ * and `busy` stays true forever (live: wedges the dashboard + defers backend
+ * restarts; one-shot: pins the WhatsApp/scheduler slot since bot:done never
+ * arrives). Claude's one-shot path has the same 5-min guard. Mirrors it here.
+ */
+const TURN_WATCHDOG_MS = 5 * 60_000;
 
 /**
  * Resolve the `codex` binary. We don't trust $PATH because Bloby may be
@@ -115,7 +123,7 @@ async function assembleBaseInstructions(
   recentMessages?: RecentMessage[],
 ): Promise<string> {
   const memoryFiles = readMemoryFiles();
-  const basePrompt = await assembleSystemPrompt(names?.botName, names?.humanName);
+  const basePrompt = await assembleSystemPrompt(names?.botName, names?.humanName, 'codex');
   let prompt = basePrompt;
   prompt += `\n\n---\n# Your Memory Files\n\n## MYSELF.md\n${memoryFiles.myself}\n\n## MYHUMAN.md\n${memoryFiles.myhuman}\n\n## MEMORY.md\n${memoryFiles.memory}\n\n---\n# Your Config Files\n\n## PULSE.json\n${memoryFiles.pulse}\n\n## CRONS.json\n${memoryFiles.crons}`;
 
@@ -326,6 +334,15 @@ interface CodexConversation {
   busy: boolean;
   /** True for one-shot queries — the conversation ends after the first turn completes. */
   oneShot: boolean;
+  /**
+   * Latest context occupancy from `thread/tokenUsage/updated` (codex does NOT
+   * report usage on `turn/completed` — Turn has no usage field). Emitted on
+   * `bot:turn-complete` so the orchestrator's proactive recycling can fire.
+   */
+  lastContextTokens: number;
+  lastContextWindow: number;
+  /** Active per-turn watchdog timer (see TURN_WATCHDOG_MS). */
+  turnWatchdog: NodeJS.Timeout | null;
 }
 
 const conversations = new Map<string, CodexConversation>();
@@ -353,17 +370,59 @@ function buildUserInput(text: string, savedFiles?: SavedFile[]): Array<Record<st
   return input;
 }
 
+function clearTurnWatchdog(conv: CodexConversation): void {
+  if (conv.turnWatchdog) {
+    clearTimeout(conv.turnWatchdog);
+    conv.turnWatchdog = null;
+  }
+}
+
+/**
+ * Arm the per-turn watchdog. On fire, unstick the conversation the same way a
+ * real `turn/completed` would (so the dashboard, `anyConversationBusy`, and the
+ * channel slot all release), then tear the conversation down — the next message
+ * cold-starts a fresh thread.
+ */
+function armTurnWatchdog(conv: CodexConversation): void {
+  clearTurnWatchdog(conv);
+  conv.turnWatchdog = setTimeout(() => {
+    conv.turnWatchdog = null;
+    log.warn(`[codex] turn watchdog fired (${TURN_WATCHDOG_MS}ms) — conv=${conv.id}; unsticking + tearing down`);
+    conv.busy = false;
+    conv.currentTurnId = null;
+    conv.onMessage('bot:error', { conversationId: conv.id, error: 'Codex turn timed out — no response from app-server.' });
+    if (conv.oneShot) {
+      conv.onMessage('bot:done', { conversationId: conv.id, usedFileTools: conv.usedFileTools });
+    } else {
+      conv.onMessage('bot:turn-complete', {
+        conversationId: conv.id,
+        usedFileTools: conv.usedFileTools,
+        contextTokens: conv.lastContextTokens || 0,
+        contextWindow: conv.lastContextWindow || 0,
+        idle: true,
+      });
+    }
+    teardownConversation(conv.id);
+  }, TURN_WATCHDOG_MS);
+}
+
 async function startTurn(conv: CodexConversation, content: string, savedFiles?: SavedFile[]): Promise<void> {
   const input = buildUserInput(content, savedFiles);
   conv.busy = true;
   conv.fullText = '';
   conv.usedFileTools = false;
   conv.onMessage('bot:typing', { conversationId: conv.id });
+  armTurnWatchdog(conv);
   try {
     const params: Record<string, any> = { threadId: conv.threadId, input };
     if (conv.effort) params.effort = conv.effort;
-    await conv.rpc.request('turn/start', params);
+    // turn/start resolves immediately with { turn }; seize the id now so a
+    // pushMessage arriving before the turn/started notification can steer
+    // instead of starting a second turn.
+    const res = await conv.rpc.request<{ turn?: { id?: string } }>('turn/start', params);
+    if (res?.turn?.id) conv.currentTurnId = res.turn.id;
   } catch (err: any) {
+    clearTurnWatchdog(conv);
     conv.busy = false;
     conv.currentTurnId = null;
     conv.onMessage('bot:error', { conversationId: conv.id, error: `turn/start failed: ${err.message}` });
@@ -385,11 +444,12 @@ async function steerOrQueue(conv: CodexConversation, content: string, savedFiles
   // Active turn — inject mid-flight.
   const input = buildUserInput(content, savedFiles);
   try {
-    await conv.rpc.request('turn/steer', {
+    const res = await conv.rpc.request<{ turnId?: string }>('turn/steer', {
       threadId: conv.threadId,
       expectedTurnId: conv.currentTurnId,
       input,
     });
+    if (res?.turnId) conv.currentTurnId = res.turnId;
     conv.onMessage('bot:typing', { conversationId: conv.id });
   } catch (err: any) {
     // expectedTurnId mismatch most likely means the turn just finished —
@@ -430,10 +490,11 @@ function handleNotification(conv: CodexConversation, n: { method: string; params
           });
           break;
         case 'mcpToolCall':
+          // ThreadItem.mcpToolCall fields are `server` + `tool` (no toolName/name/input).
           conv.onMessage('bot:tool', {
             conversationId: conv.id,
-            name: item.toolName || item.name || 'mcp_tool',
-            input: item.arguments || item.input || {},
+            name: item.tool ? (item.server ? `${item.server}/${item.tool}` : item.tool) : 'mcp_tool',
+            input: item.arguments || {},
           });
           break;
         case 'fileChange':
@@ -470,18 +531,34 @@ function handleNotification(conv: CodexConversation, n: { method: string; params
       break;
     }
 
+    case 'thread/tokenUsage/updated': {
+      // Codex's only token-usage signal. ThreadTokenUsage = { total, last, modelContextWindow };
+      // `last` is the current prompt occupancy (mirrors Claude's input+cacheRead+cacheCreation),
+      // the right basis for the recycle compare in supervisor/index.ts (fraction*window, not lifetime).
+      const tu = p.tokenUsage || {};
+      const last = tu.last || {};
+      conv.lastContextTokens = (last.inputTokens || 0) + (last.cachedInputTokens || 0);
+      if (typeof tu.modelContextWindow === 'number' && tu.modelContextWindow > 0) {
+        conv.lastContextWindow = tu.modelContextWindow;
+      }
+      break;
+    }
+
     case 'turn/completed': {
       const status: string = p.turn?.status || 'completed';
       const turnError = p.turn?.error;
 
+      clearTurnWatchdog(conv);
       conv.currentTurnId = null;
       conv.busy = false;
 
-      if (status === 'failed' || status === 'systemError') {
+      if (status === 'failed') {
         conv.onMessage('bot:error', {
           conversationId: conv.id,
           error: turnError?.message || 'Codex turn failed.',
         });
+      } else if (status === 'interrupted') {
+        // Interrupted turns carry no final answer — stay silent.
       } else if (conv.fullText) {
         conv.onMessage('bot:response', { conversationId: conv.id, content: conv.fullText });
       }
@@ -490,16 +567,17 @@ function handleNotification(conv: CodexConversation, n: { method: string; params
         conv.onMessage('bot:done', { conversationId: conv.id, usedFileTools: conv.usedFileTools });
         teardownConversation(conv.id);
       } else {
-        // Context-size signal for the orchestrator's proactive session recycling.
-        // The codex app-server reports token usage on turn/completed; field names vary
-        // across versions, so probe defensively (0 if absent → falls back to codex's
-        // own built-in auto-compaction).
-        const tu: any = p.turn?.usage || p.usage || {};
-        const contextTokens = tu.input_tokens ?? tu.inputTokens ?? tu.total_tokens ?? tu.totalTokens ?? tu.tokens ?? 0;
-        const contextWindow = tu.context_window ?? tu.contextWindow ?? 0;
-        // idle = no message queued behind this turn (the drain happens just below).
+        // Context-size signal for the orchestrator's proactive session recycling,
+        // sourced from the cached `thread/tokenUsage/updated` values above. 0 if codex
+        // never sent one this turn → falls back to codex's own in-thread auto-compaction.
         const idle = conv.pendingInputs.length === 0;
-        conv.onMessage('bot:turn-complete', { conversationId: conv.id, usedFileTools: conv.usedFileTools, contextTokens, contextWindow, idle });
+        conv.onMessage('bot:turn-complete', {
+          conversationId: conv.id,
+          usedFileTools: conv.usedFileTools,
+          contextTokens: conv.lastContextTokens || 0,
+          contextWindow: conv.lastContextWindow || 0,
+          idle,
+        });
 
         // Drain any messages that were submitted while we were busy.
         const next = conv.pendingInputs.shift();
@@ -509,6 +587,12 @@ function handleNotification(conv: CodexConversation, n: { method: string; params
     }
 
     case 'error': {
+      // ErrorNotification carries willRetry — codex will retry transient errors
+      // itself; don't surface those as a hard bot:error before the retry lands.
+      if (p.willRetry) {
+        log.info(`[codex] transient error (will retry): ${p.error?.message || 'unknown'}`);
+        break;
+      }
       const errMsg = p.error?.message || 'Codex error notification';
       conv.onMessage('bot:error', { conversationId: conv.id, error: errMsg });
       break;
@@ -522,6 +606,7 @@ function handleNotification(conv: CodexConversation, n: { method: string; params
 function teardownConversation(conversationId: string): void {
   const conv = conversations.get(conversationId);
   if (!conv) return;
+  clearTurnWatchdog(conv);
   conversations.delete(conversationId);
   try { conv.rpc.close(); } catch {}
   conv.onMessage('bot:conversation-ended', { conversationId });
@@ -531,7 +616,7 @@ async function spawnAndInitialize(
   conversationId: string,
   model: string,
   onMessage: OnAgentMessage,
-  baseInstructions: string,
+  instructions: string,
   oneShot: boolean,
 ): Promise<CodexConversation | null> {
   // Pre-flight: confirm we have valid OAuth tokens before spending time spawning.
@@ -560,6 +645,9 @@ async function spawnAndInitialize(
     pendingInputs: [],
     busy: false,
     oneShot,
+    lastContextTokens: 0,
+    lastContextWindow: 0,
+    turnWatchdog: null,
   };
 
   rpc.onNotification((n) => handleNotification(conv, n));
@@ -582,7 +670,13 @@ async function spawnAndInitialize(
     const startResult = await rpc.request<{ thread: { id: string } }>('thread/start', {
       cwd: WORKSPACE_DIR,
       model: modelId,
-      baseInstructions,
+      // Bloby's persona/workflow prompt rides developerInstructions (ADDITIVE),
+      // NOT baseInstructions. baseInstructions fully OVERRIDES codex's native base
+      // prompt — which carries the apply_patch FREEFORM spec + shell protocol the
+      // model needs to edit files. Leaving baseInstructions unset keeps that native
+      // scaffolding; developerInstructions layers Bloby's persona on top of it.
+      developerInstructions: instructions,
+      personality: 'pragmatic',
       // Bloby's posture matches Claude's bypassPermissions — the bot is
       // running on the user's own machine with their full consent. Skip the
       // approval prompts and give it write access to the workspace + beyond.
@@ -782,7 +876,7 @@ export async function runAgentQuery(req: AgentQueryRequest): Promise<AgentQueryR
       case 'item/started': {
         const item = p.item || {};
         if (item.type === 'commandExecution') usedTools.add('shell');
-        else if (item.type === 'mcpToolCall') usedTools.add(item.toolName || item.name || 'mcp_tool');
+        else if (item.type === 'mcpToolCall') usedTools.add(item.tool || 'mcp_tool');
         else if (item.type === 'fileChange') { usedTools.add('file_change'); usedFileTools = true; }
         else if (item.type === 'webSearch') usedTools.add('web_search');
         break;
@@ -798,13 +892,14 @@ export async function runAgentQuery(req: AgentQueryRequest): Promise<AgentQueryR
       }
       case 'turn/completed': {
         const status = p.turn?.status || 'completed';
-        if (status === 'failed' || status === 'systemError') {
+        if (status === 'failed') {
           turnError = p.turn?.error?.message || 'Codex turn failed.';
         }
         resolveTurn?.();
         break;
       }
       case 'error': {
+        if (p.willRetry) break; // transient — codex retries itself
         turnError = p.error?.message || 'Codex error';
         resolveTurn?.();
         break;
@@ -833,7 +928,7 @@ export async function runAgentQuery(req: AgentQueryRequest): Promise<AgentQueryR
         const r = await rpc.request<{ thread: { id: string } }>('thread/start', {
           cwd: WORKSPACE_DIR,
           model,
-          ...(req.systemPrompt ? { baseInstructions: req.systemPrompt } : {}),
+          ...(req.systemPrompt ? { developerInstructions: req.systemPrompt } : {}),
           approvalPolicy: 'never',
           sandbox: 'danger-full-access',
         });
@@ -843,7 +938,7 @@ export async function runAgentQuery(req: AgentQueryRequest): Promise<AgentQueryR
       const r = await rpc.request<{ thread: { id: string } }>('thread/start', {
         cwd: WORKSPACE_DIR,
         model,
-        ...(req.systemPrompt ? { baseInstructions: req.systemPrompt } : {}),
+        ...(req.systemPrompt ? { developerInstructions: req.systemPrompt } : {}),
         approvalPolicy: 'never',
         sandbox: 'danger-full-access',
       });

package/supervisor/harnesses/pi/index.ts

@@ -107,7 +107,7 @@ async function buildSystemPrompt(
   recentMessages?: RecentMessage[],
 ): Promise<string> {
   const memoryFiles = readMemoryFiles();
-  const basePrompt = await assembleSystemPrompt(names?.botName, names?.humanName);
+  const basePrompt = await assembleSystemPrompt(names?.botName, names?.humanName, 'pi');
   let systemPrompt = basePrompt;
   systemPrompt += LIVE_CONVERSATION_HINT;
   systemPrompt += `\n\n---\n# Your Memory Files\n\n## MYSELF.md\n${memoryFiles.myself}\n\n## MYHUMAN.md\n${memoryFiles.myhuman}\n\n## MEMORY.md\n${memoryFiles.memory}\n\n---\n# Your Config Files\n\n## PULSE.json\n${memoryFiles.pulse}\n\n## CRONS.json\n${memoryFiles.crons}`;
@@ -369,6 +369,12 @@ export async function startBlobyAgentQuery(
 
   const abortController = new AbortController();
   activeQueries.set(conversationId, abortController);
+  // Hard watchdog — a hung provider stream would otherwise pin this query forever (finally never
+  // runs, bot:done never fires). Abort after 5 min; cleared in the finally on normal completion.
+  const watchdog = setTimeout(() => {
+    log.warn(`[pi/bloby-agent] one-shot timed out (5m) — aborting conv=${conversationId}`);
+    abortController.abort();
+  }, 300_000);
 
   let systemPrompt: string;
   if (supportPrompt) {
@@ -425,6 +431,7 @@ export async function startBlobyAgentQuery(
       onMessage('bot:error', { conversationId, error: err?.message || String(err) });
     }
   } finally {
+    clearTimeout(watchdog);
     activeQueries.delete(conversationId);
     const FILE_TOOL_NAMES = ['Write', 'Edit', 'write', 'edit'];
     const usedFileTools = FILE_TOOL_NAMES.some((t) => usedTools.has(t));