onbuzz 3.9.10 → 4.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "3.9.10",
+  "version": "4.0.1",
   "description": "Loxia OnBuzz - Your AI Fleet",
   "type": "module",
   "main": "src/index.js",

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

@@ -393,6 +393,66 @@ describe('AgentPool', () => {
     test('throws for non-existent agent', async () => {
       await expect(pool.addUserMessage('nonexistent', { content: 'hi' })).rejects.toThrow('Agent not found');
     });
+
+    test('clears a future scheduler-applied delayEndTime on user message', async () => {
+      // A user message is an explicit signal to act now — any back-off
+      // delay set by the scheduler (rate-limit, network error, builtin
+      // tool delay) should evaporate rather than making the user wait
+      // out the remainder.
+      const agent = await pool.createAgent(agentCfg());
+      agent.delayEndTime = new Date(Date.now() + 60_000).toISOString();
+
+      await pool.addUserMessage(agent.id, { content: 'please act now' });
+
+      expect(agent.delayEndTime).toBeNull();
+      expect(agent.messageQueues.userMessages).toHaveLength(1);
+    });
+
+    test('leaves a past/expired delayEndTime alone', async () => {
+      // Already-expired delays don't need clearing — the scheduler ignores
+      // them on the next tick anyway. We only act on actively-blocking delays.
+      const agent = await pool.createAgent(agentCfg());
+      const pastIso = new Date(Date.now() - 1_000).toISOString();
+      agent.delayEndTime = pastIso;
+
+      await pool.addUserMessage(agent.id, { content: 'go' });
+
+      expect(agent.delayEndTime).toBe(pastIso);
+    });
+
+    test('no-ops when delayEndTime is null', async () => {
+      const agent = await pool.createAgent(agentCfg());
+      agent.delayEndTime = null;
+
+      await pool.addUserMessage(agent.id, { content: 'go' });
+
+      expect(agent.delayEndTime).toBeNull();
+    });
+
+    test('broadcasts agent state update when a delay was cleared', async () => {
+      // The UI's delay chip listens for `agent_state_updated` — when we
+      // clear a delay we should surface it immediately so the chip
+      // disappears without a reload.
+      const agent = await pool.createAgent(agentCfg());
+      agent.delayEndTime = new Date(Date.now() + 30_000).toISOString();
+
+      const broadcast = jest.fn().mockResolvedValue(undefined);
+      pool.scheduler = { broadcastAgentStateUpdate: broadcast };
+
+      await pool.addUserMessage(agent.id, { content: 'now' });
+
+      expect(broadcast).toHaveBeenCalledWith(agent.id, 'user-message-clears-delay');
+    });
+
+    test('does not broadcast when no delay was set', async () => {
+      const agent = await pool.createAgent(agentCfg());
+      const broadcast = jest.fn().mockResolvedValue(undefined);
+      pool.scheduler = { broadcastAgentStateUpdate: broadcast };
+
+      await pool.addUserMessage(agent.id, { content: 'hi' });
+
+      expect(broadcast).not.toHaveBeenCalled();
+    });
   });
 
   describe('addInterAgentMessage', () => {

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

@@ -298,6 +298,135 @@ describe('AgentScheduler', () => {
 
       expect(ws.broadcastToSession).toHaveBeenCalled();
     });
+
+    test('clears hash history BEFORE persist/broadcast so a persist error cannot wedge the loop detector', async () => {
+      const agent = makeAgent({ id: 'agent-loop' });
+      agentPool.getAgent.mockResolvedValue(agent);
+      // Seed the history with threshold+ occurrences
+      scheduler.stateHashHistory.set('agent-loop', Array(5).fill({ hash: 'H', timestamp: Date.now() }));
+      // Force persistAgentState to throw
+      agentPool.persistAgentState.mockRejectedValue(new Error('disk full'));
+
+      // Should not re-throw — handler is crash-safe
+      await scheduler.handleRepetitiveLoop('agent-loop', { occurrences: 5, windowSize: 20 });
+
+      // History must be cleared even though persist threw.
+      expect(scheduler.stateHashHistory.has('agent-loop')).toBe(false);
+      // Mode must still be set to chat
+      expect(agent.mode).toBe('chat');
+    });
+  });
+
+  // ─── addMessageToConversation — empty-message drop signal ─────────────
+  describe('addMessageToConversation (empty-drop return value)', () => {
+    test('returns true when message is appended', async () => {
+      const agent = makeAgent();
+      agentPool.getAgent.mockResolvedValue(agent);
+      const ok = await scheduler.addMessageToConversation(agent.id, { role: 'assistant', content: 'hello' }, false);
+      expect(ok).toBe(true);
+      expect(agent.conversations.full.messages.length).toBe(1);
+    });
+
+    test('returns false when content is empty-string', async () => {
+      const agent = makeAgent();
+      agentPool.getAgent.mockResolvedValue(agent);
+      const ok = await scheduler.addMessageToConversation(agent.id, { role: 'assistant', content: '' }, false);
+      expect(ok).toBe(false);
+      expect(agent.conversations.full.messages.length).toBe(0);
+    });
+
+    test('returns false when content is whitespace-only', async () => {
+      const agent = makeAgent();
+      agentPool.getAgent.mockResolvedValue(agent);
+      const ok = await scheduler.addMessageToConversation(agent.id, { role: 'assistant', content: '   \n  \t' }, false);
+      expect(ok).toBe(false);
+      expect(agent.conversations.full.messages.length).toBe(0);
+    });
+  });
+
+  // ─── Empty-response stall circuit breaker ─────────────────────────────
+  describe('_trackEmptyResponse + _handleEmptyResponseStall', () => {
+    test('records empty responses without polluting stateHashHistory', async () => {
+      const agent = makeAgent({ id: 'agent-empty' });
+      agentPool.getAgent.mockResolvedValue(agent);
+
+      await scheduler._trackEmptyResponse('agent-empty');
+      await scheduler._trackEmptyResponse('agent-empty');
+      await scheduler._trackEmptyResponse('agent-empty');
+
+      const entry = scheduler._emptyResponseTracker.get('agent-empty');
+      expect(entry.count).toBe(3);
+      // Tracker is independent of the hash history
+      expect(scheduler.stateHashHistory.has('agent-empty')).toBe(false);
+    });
+
+    test('does NOT fire stall handler below threshold', async () => {
+      const agent = makeAgent({ id: 'agent-empty' });
+      agentPool.getAgent.mockResolvedValue(agent);
+
+      for (let i = 0; i < 4; i++) {
+        await scheduler._trackEmptyResponse('agent-empty');
+      }
+
+      // Agent mode untouched — stall handler did not fire
+      expect(agent.mode).toBe('chat');  // started as chat; unchanged
+      expect(scheduler._emptyResponseTracker.has('agent-empty')).toBe(true);
+    });
+
+    test('does NOT fire stall handler below time window even at high count', async () => {
+      const agent = makeAgent({ id: 'agent-empty', mode: 'agent' });
+      agentPool.getAgent.mockResolvedValue(agent);
+
+      // 6 calls in rapid succession — elapsed time < 60s
+      for (let i = 0; i < 6; i++) {
+        await scheduler._trackEmptyResponse('agent-empty');
+      }
+
+      // Stall handler only fires when BOTH count >= threshold AND elapsed >= window
+      expect(agent.mode).toBe('agent');
+      expect(scheduler._emptyResponseTracker.has('agent-empty')).toBe(true);
+    });
+
+    test('fires stall handler when count and time window both satisfied', async () => {
+      const agent = makeAgent({ id: 'agent-empty', mode: 'agent' });
+      agentPool.getAgent.mockResolvedValue(agent);
+
+      // Seed the tracker with an old firstAt so the time window is already exceeded
+      const oldFirstAt = Date.now() - 120 * 1000; // 2 min ago
+      scheduler._emptyResponseTracker.set('agent-empty', {
+        count: 4,
+        firstAt: oldFirstAt,
+        lastAt: oldFirstAt,
+      });
+
+      await scheduler._trackEmptyResponse('agent-empty'); // count -> 5
+
+      expect(agent.mode).toBe('chat');
+      expect(scheduler._emptyResponseTracker.has('agent-empty')).toBe(false);
+      // User-facing intervention message appended
+      const msgs = agent.conversations.full.messages;
+      expect(msgs.length).toBe(1);
+      expect(msgs[0].role).toBe('assistant');
+      expect(msgs[0].content).toContain('empty responses');
+    });
+
+    test('stall handler is crash-safe when persist throws', async () => {
+      const agent = makeAgent({ id: 'agent-empty', mode: 'agent' });
+      agentPool.getAgent.mockResolvedValue(agent);
+      agentPool.persistAgentState.mockRejectedValue(new Error('disk full'));
+      scheduler.stateHashHistory.set('agent-empty', [{ hash: 'x', timestamp: Date.now() }]);
+
+      // Trigger the stall directly to avoid fiddling with timing
+      await scheduler._handleEmptyResponseStall('agent-empty', {
+        count: 5, firstAt: Date.now() - 61000, lastAt: Date.now(),
+      });
+
+      // Hash history was cleared BEFORE persist, so even with persist throwing
+      // the scheduler cannot re-fire on next cycle.
+      expect(scheduler.stateHashHistory.has('agent-empty')).toBe(false);
+      // Mode change still applies in-memory
+      expect(agent.mode).toBe('chat');
+    });
   });
 
   // ─── clearHashHistory ──────────────────────────────────────────────────

package/src/core/agentPool.js

@@ -1306,6 +1306,20 @@ class AgentPool {
       await this.resumeAgent(agentId);
     }
 
+    // Clear any scheduler-enforced delay when the user explicitly addresses
+    // the agent. Delays are set by the scheduler as a back-off for
+    // rate-limit / network / api-key / builtin-tool-delay situations and
+    // only make sense while the agent is left alone — a new user message is
+    // an explicit signal to act NOW, and waiting out the remaining delay
+    // would feel unresponsive. We clear the field and let the scheduler
+    // pick the agent up on its next tick. Broadcast the state update so
+    // the UI's delay chip disappears immediately.
+    const hadDelay = !!(agent.delayEndTime && new Date(agent.delayEndTime).getTime() > Date.now());
+    if (hadDelay) {
+      agent.delayEndTime = null;
+      this.logger.info(`Cleared scheduler delay for agent ${agentId} — user message takes precedence`);
+    }
+
     const queuedMessage = {
       ...message,
       id: message.id || `user-msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
@@ -1323,6 +1337,16 @@ class AgentPool {
 
     await this.persistAgentState(agentId);
 
+    // If we cleared a delay, surface it on the WS so the delay chip in the
+    // chat header disappears without waiting for the next scheduler cycle.
+    if (hadDelay && this.scheduler?.broadcastAgentStateUpdate) {
+      try {
+        await this.scheduler.broadcastAgentStateUpdate(agentId, 'user-message-clears-delay');
+      } catch (err) {
+        this.logger.warn(`Failed to broadcast delay-clear for ${agentId}: ${err.message}`);
+      }
+    }
+
     this.logger.info(`User message queued for agent: ${agentId}`, {
       messageId: queuedMessage.id,
       queueSize: agent.messageQueues.userMessages.length