onbuzz 5.4.0 → 5.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "5.4.0",
+  "version": "5.4.1",
   "description": "Loxia OnBuzz - Your AI Fleet",
   "type": "module",
   "main": "src/index.js",
@@ -31,9 +31,9 @@
     "electron:build:win": "npm run build:web-ui && electron-builder --win",
     "electron:build:mac": "npm run build:web-ui && electron-builder --mac",
     "electron:build:linux": "npm run build:web-ui && electron-builder --linux",
-    "electron:build:onbuzz:win": "cross-env VITE_BRAND=onbuzz npm run build:web-ui && cross-env LOXIA_BRAND=onbuzz electron-builder --win -c.productName=\"Loxia OnBuzz\" -c.appId=com.loxia.onbuzz",
-    "electron:build:onbuzz:mac": "cross-env VITE_BRAND=onbuzz npm run build:web-ui && cross-env LOXIA_BRAND=onbuzz electron-builder --mac -c.productName=\"Loxia OnBuzz\" -c.appId=com.loxia.onbuzz",
-    "electron:build:onbuzz:linux": "cross-env VITE_BRAND=onbuzz npm run build:web-ui && cross-env LOXIA_BRAND=onbuzz electron-builder --linux -c.productName=\"Loxia OnBuzz\" -c.appId=com.loxia.onbuzz"
+    "electron:build:onbuzz:win": "cross-env VITE_BRAND=onbuzz npm run build:web-ui && cross-env LOXIA_BRAND=onbuzz electron-builder --win -c.productName=\"Loxia OnBuzz\" -c.appId=com.loxia.onbuzz -c.executableName=loxia-onbuzz -c.win.icon=electron/icon-onbuzz.png",
+    "electron:build:onbuzz:mac": "cross-env VITE_BRAND=onbuzz npm run build:web-ui && cross-env LOXIA_BRAND=onbuzz electron-builder --mac -c.productName=\"Loxia OnBuzz\" -c.appId=com.loxia.onbuzz -c.executableName=loxia-onbuzz -c.mac.icon=electron/icon-onbuzz.png",
+    "electron:build:onbuzz:linux": "cross-env VITE_BRAND=onbuzz npm run build:web-ui && cross-env LOXIA_BRAND=onbuzz electron-builder --linux -c.productName=\"Loxia OnBuzz\" -c.appId=com.loxia.onbuzz -c.executableName=loxia-onbuzz -c.linux.icon=electron/icon-onbuzz.png"
   },
   "keywords": [
     "ai",

package/src/core/__tests__/agentPoolWakeOnMessage.test.js

@@ -10,7 +10,7 @@
  * regress again by patching one path and forgetting the others.
  */
 
-import { jest, describe, test, expect } from '@jest/globals';
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
 import { createMockLogger, createMockConfig, createMockStateManager } from '../../__test-utils__/mockFactories.js';
 
 // ── Mocks ───────────────────────────────────────────────────────────────────
@@ -36,8 +36,17 @@ jest.unstable_mockModule('../../services/visualEditorBridge.js', () => ({
   }),
 }));
 
+const mockCancelRequest = jest.fn().mockReturnValue({ success: true });
+jest.unstable_mockModule('../../services/promptService.js', () => ({
+  getPromptService: jest.fn().mockReturnValue({ cancelRequest: mockCancelRequest }),
+}));
+
 const { default: AgentPool } = await import('../agentPool.js');
 
+beforeEach(() => {
+  mockCancelRequest.mockClear().mockReturnValue({ success: true });
+});
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 function makePool(overrides = {}) {
   const config = createMockConfig(overrides.config);
@@ -278,7 +287,7 @@ describe('agentPool._wakeAgentForMessage (shared helper)', () => {
 
     const info = await pool._wakeAgentForMessage(agent, 'test');
 
-    expect(info).toEqual({ wasPaused: false, hadDelay: false, hadPausedUntil: false });
+    expect(info).toEqual({ wasPaused: false, hadDelay: false, hadPausedUntil: false, wasAwaitingInput: false });
     expect(agent.status).toBe('active');
     expect(agent.delayEndTime).toBeFalsy();
   });
@@ -310,6 +319,109 @@ describe('agentPool._wakeAgentForMessage (shared helper)', () => {
 
     const info = await pool._wakeAgentForMessage(null, 'test');
 
-    expect(info).toEqual({ wasPaused: false, hadDelay: false, hadPausedUntil: false });
+    expect(info).toEqual({ wasPaused: false, hadDelay: false, hadPausedUntil: false, wasAwaitingInput: false });
+  });
+});
+
+// ────────────────────────────────────────────────────────────────────────
+// awaitingUserInput deadlock breaker — an inbound user/inter-agent message
+// supersedes a pending (possibly orphaned) prompt so the agent can't sit
+// permanently skipped with queued messages piling up.
+// ────────────────────────────────────────────────────────────────────────
+
+const AWAITING = () => ({ type: 'user_prompt', requestId: 'prompt-req-1', startedAt: '2026-06-30T07:03:46.000Z' });
+
+describe('agentPool._wakeAgentForMessage — awaitingUserInput recovery', () => {
+  test('user-message clears awaitingUserInput and cancels the live prompt', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    agent.awaitingUserInput = AWAITING();
+
+    const info = await pool._wakeAgentForMessage(agent, 'user-message');
+
+    expect(info.wasAwaitingInput).toBe(true);
+    expect(agent.awaitingUserInput).toBeUndefined();
+    expect(mockCancelRequest).toHaveBeenCalledWith('prompt-req-1', expect.stringContaining('user-message'));
+  });
+
+  test('inter-agent-message also clears awaitingUserInput', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    agent.awaitingUserInput = AWAITING();
+
+    const info = await pool._wakeAgentForMessage(agent, 'inter-agent-message');
+
+    expect(info.wasAwaitingInput).toBe(true);
+    expect(agent.awaitingUserInput).toBeUndefined();
+    expect(mockCancelRequest).toHaveBeenCalled();
+  });
+
+  test('tool-result wake does NOT clear awaitingUserInput (internal)', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    agent.awaitingUserInput = AWAITING();
+
+    const info = await pool._wakeAgentForMessage(agent, 'tool-result');
+
+    expect(info.wasAwaitingInput).toBe(false);
+    expect(agent.awaitingUserInput).toBeDefined();
+    expect(mockCancelRequest).not.toHaveBeenCalled();
+  });
+
+  test('a non-user_prompt awaiting type is cleared but the prompt service is not touched', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    agent.awaitingUserInput = { type: 'credentials', siteId: 'github', startedAt: 'x' };
+
+    const info = await pool._wakeAgentForMessage(agent, 'user-message');
+
+    expect(info.wasAwaitingInput).toBe(true);
+    expect(agent.awaitingUserInput).toBeUndefined();
+    expect(mockCancelRequest).not.toHaveBeenCalled();
+  });
+
+  test('a user_prompt without a requestId is cleared without cancelling', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    agent.awaitingUserInput = { type: 'user_prompt', startedAt: 'x' }; // no requestId
+
+    await pool._wakeAgentForMessage(agent, 'user-message');
+
+    expect(agent.awaitingUserInput).toBeUndefined();
+    expect(mockCancelRequest).not.toHaveBeenCalled();
+  });
+
+  test('a throwing cancelRequest is swallowed and the flag is still cleared', async () => {
+    mockCancelRequest.mockImplementation(() => { throw new Error('service down'); });
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    agent.awaitingUserInput = AWAITING();
+
+    const info = await pool._wakeAgentForMessage(agent, 'user-message');
+
+    expect(info.wasAwaitingInput).toBe(true);
+    expect(agent.awaitingUserInput).toBeUndefined();
+  });
+
+  test('no awaitingUserInput → wasAwaitingInput false, no cancel', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+
+    const info = await pool._wakeAgentForMessage(agent, 'user-message');
+
+    expect(info.wasAwaitingInput).toBe(false);
+    expect(mockCancelRequest).not.toHaveBeenCalled();
+  });
+
+  test('end-to-end: addUserMessage revives an awaiting agent and queues the message', async () => {
+    const { pool } = makePool();
+    const agent = await pool.createAgent(agentCfg());
+    agent.awaitingUserInput = AWAITING();
+
+    await pool.addUserMessage(agent.id, { content: 'please continue' });
+
+    expect(agent.awaitingUserInput).toBeUndefined();
+    expect(agent.messageQueues.userMessages).toHaveLength(1);
+    expect(mockCancelRequest).toHaveBeenCalledWith('prompt-req-1', expect.any(String));
   });
 });

package/src/core/__tests__/stateManager.restoreRecovery.test.js

@@ -0,0 +1,71 @@
+/**
+ * stateManager.restoreAgent must clear a stale awaitingUserInput on load.
+ *
+ * An agent persisted mid-prompt (user_prompt / credentials) is otherwise reborn
+ * with awaitingUserInput set but a dead requestId — the scheduler then skips it
+ * forever, and queued messages pile up unprocessed (the exact 2-day-stuck agent
+ * this fixes). Restore should drop the flag so queued/new messages drive it.
+ */
+import { jest, describe, test, expect } from '@jest/globals';
+import StateManager from '../stateManager.js';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+const AGENT_INFO = { name: 'Intent hunter Clone', stateFile: 'a1.state.json', conversationsFile: 'a1.conversations.json' };
+
+function makeSM() {
+  const sm = new StateManager({ system: {} }, createMockLogger());
+  sm.getStateDir = () => '/tmp/state';
+  sm.validateModelConversations = jest.fn().mockResolvedValue(undefined);
+  sm.checkAgentPauseStatus = jest.fn().mockResolvedValue({ isPaused: false, pausedUntil: null });
+  return sm;
+}
+
+function stubLoad(sm, agentState) {
+  sm.loadJSONResilient = jest.fn(async (file) => {
+    if (String(file).includes('conversations')) {
+      return { data: { version: 2, agentId: 'a1', conversations: { full: { messages: [], lastUpdated: 'x' } } }, recovery: null };
+    }
+    return { data: { version: 2, agentId: 'a1', state: agentState }, recovery: null };
+  });
+}
+
+const baseState = (extra = {}) => ({
+  id: 'a1', name: 'Intent hunter Clone', mode: 'chat', status: 'active',
+  messageQueues: { userMessages: [{ content: 'please continue' }], interAgentMessages: [], toolResults: [] },
+  ...extra,
+});
+
+describe('stateManager.restoreAgent — awaitingUserInput recovery', () => {
+  test('clears a persisted awaitingUserInput (user_prompt) but keeps queued messages', async () => {
+    const sm = makeSM();
+    stubLoad(sm, baseState({
+      awaitingUserInput: { type: 'user_prompt', requestId: 'prompt-req-1', startedAt: '2026-06-30T07:03:46.000Z' },
+    }));
+
+    const agent = await sm.restoreAgent('a1', AGENT_INFO, '/proj');
+
+    expect(agent.awaitingUserInput).toBeUndefined();
+    expect(agent.isRestored).toBe(true);
+    // The queued messages that could never be processed are preserved so they
+    // drive the agent once it's schedulable again.
+    expect(agent.messageQueues.userMessages).toHaveLength(1);
+  });
+
+  test('clears a persisted awaitingUserInput of any type (e.g. credentials)', async () => {
+    const sm = makeSM();
+    stubLoad(sm, baseState({ awaitingUserInput: { type: 'credentials', siteId: 'github', startedAt: 'x' } }));
+
+    const agent = await sm.restoreAgent('a1', AGENT_INFO, '/proj');
+    expect(agent.awaitingUserInput).toBeUndefined();
+  });
+
+  test('leaves a normal agent (no awaitingUserInput) untouched', async () => {
+    const sm = makeSM();
+    stubLoad(sm, baseState());
+
+    const agent = await sm.restoreAgent('a1', AGENT_INFO, '/proj');
+    expect(agent.awaitingUserInput).toBeUndefined();
+    expect(agent.isRestored).toBe(true);
+    expect(agent.mode).toBe('chat');
+  });
+});

package/src/core/agentPool.js

@@ -20,6 +20,7 @@ import {
 } from '../utilities/constants.js';
 import DirectoryAccessManager from '../utilities/directoryAccessManager.js';
 import { getVisualEditorBridge } from '../services/visualEditorBridge.js';
+import { getPromptService } from '../services/promptService.js';
 
 /**
  * Capabilities that were once granted but whose backing tool has since been
@@ -1469,9 +1470,35 @@ class AgentPool {
    * @private
    */
   async _wakeAgentForMessage(agent, reason) {
-    const info = { wasPaused: false, hadDelay: false, hadPausedUntil: false };
+    const info = { wasPaused: false, hadDelay: false, hadPausedUntil: false, wasAwaitingInput: false };
     if (!agent) return info;
 
+    // A real inbound message (from the user or another agent) SUPERSEDES a
+    // pending awaiting-user-input wait. Without this, an agent whose prompt
+    // was orphaned — the modal is gone, the in-memory prompt promise died in a
+    // restart, or the user simply chose to reply in chat instead of the modal —
+    // stays permanently skipped by the scheduler (shouldAgentBeActive bails on
+    // awaitingUserInput before it ever looks at the queue), so every message the
+    // user sends just piles up unprocessed. Clear the flag so the message gets
+    // handled, and cancel the live prompt request (user_prompt only) so the
+    // tool's promise rejects cleanly instead of leaking. Tool-result wakes are
+    // internal and don't count — the prompt's own completion path clears the
+    // flag there.
+    const isInboundMessage = reason === 'user-message' || reason === 'inter-agent-message';
+    if (isInboundMessage && agent.awaitingUserInput) {
+      info.wasAwaitingInput = true;
+      const { type, requestId } = agent.awaitingUserInput;
+      delete agent.awaitingUserInput;
+      if (type === 'user_prompt' && requestId) {
+        try {
+          getPromptService(this.logger).cancelRequest(requestId, `superseded by ${reason}`);
+        } catch (err) {
+          this.logger?.warn?.(`Failed to cancel superseded prompt ${requestId}: ${err.message}`);
+        }
+      }
+      this.logger.info(`Agent ${agent.id} awaitingUserInput (${type}) cleared — ${reason} supersedes the pending prompt`);
+    }
+
     // Auto-resume explicitly paused agent.
     if (agent.status === AGENT_STATUS.PAUSED) {
       info.wasPaused = true;

package/src/core/stateManager.js

@@ -948,6 +948,20 @@ class StateManager {
         _restoreRecoveries: recoveries,
       };
 
+      // RECOVERY: an agent persisted mid-prompt is reborn with awaitingUserInput
+      // set, but the in-memory prompt promise died with the old process — the
+      // requestId now points at nothing, and the scheduler would skip this agent
+      // forever (queued messages included). Clear the stale flag so it can be
+      // driven again; any queued/new message picks it right back up. Mirrors
+      // agentPool.rehydrateFromState's recovery.
+      if (restoredAgent.awaitingUserInput) {
+        this.logger.warn(`Restored agent ${agentId} was awaiting user input (${restoredAgent.awaitingUserInput.type}) — clearing stale flag`, {
+          inputType: restoredAgent.awaitingUserInput.type,
+          startedAt: restoredAgent.awaitingUserInput.startedAt,
+        });
+        delete restoredAgent.awaitingUserInput;
+      }
+
       // CRITICAL: Restore interAgentTracking as a Map (it comes as plain object from JSON)
       if (!restoredAgent.interAgentTracking || typeof restoredAgent.interAgentTracking !== 'object') {
         restoredAgent.interAgentTracking = new Map();