onbuzz 4.9.11 → 4.9.13

package/package.json

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

package/scripts/verify-optional-deps.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * Postinstall verifier for soft-required deps.
+ *
+ * Background: `npm audit fix --force` periodically nukes @composio/core
+ * because its dependency tree carries the loudest CVEs in our project
+ * (16 vulns last count — 2 critical, 3 high). When that happens, the
+ * Integrations page surfaces `@composio/core SDK is not installed` and
+ * we don't notice until a user complains.
+ *
+ * This script runs at the END of `postinstall` and shouts loudly if any
+ * required-but-fragile dep is missing, so the next install (audit-fix,
+ * fresh clone, CI build) catches the loss immediately. It does NOT
+ * auto-install — that would mask the underlying audit-fix decision and
+ * make the recurrence invisible.
+ *
+ * Exit code is 0 even when a dep is missing — we don't want CI to fail
+ * on a soft dep — but the loud banner is meant to be impossible to miss
+ * in install logs.
+ */
+
+import { createRequire } from 'node:module';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(__dirname, '..');
+const require = createRequire(import.meta.url);
+
+// Deps that are imported with try/catch dynamic-import patterns (runtime
+// keeps working without them) but the related UI flow breaks visibly.
+// Add to this list whenever you introduce another `await import('…')`
+// + try/catch + friendly-error pattern.
+const SOFT_REQUIRED = [
+  {
+    name: '@composio/core',
+    breaks: 'Integrations page (Composio toolkits/connections, agent composio tool)',
+    fixHint: 'npm install @composio/core@^0.6.11   # mirrors commit 1560691 — the previous restore',
+  },
+];
+
+const missing = [];
+for (const dep of SOFT_REQUIRED) {
+  try {
+    require.resolve(dep.name, { paths: [repoRoot] });
+  } catch {
+    missing.push(dep);
+  }
+}
+
+if (missing.length === 0) process.exit(0);
+
+const bar = '═'.repeat(72);
+process.stderr.write(`\n${bar}\n`);
+process.stderr.write(`  ⚠  Soft-required dependencies missing — Integrations & related UI\n`);
+process.stderr.write(`     surfaces will show "SDK not installed" errors.\n`);
+process.stderr.write(`${bar}\n`);
+for (const m of missing) {
+  process.stderr.write(`  • ${m.name}\n`);
+  process.stderr.write(`      breaks : ${m.breaks}\n`);
+  process.stderr.write(`      fix    : ${m.fixHint}\n`);
+}
+process.stderr.write(`${bar}\n`);
+process.stderr.write(`  Most common cause: \`npm audit fix --force\` nuked it as collateral.\n`);
+process.stderr.write(`  Restore the deps above, then commit the package.json + lockfile.\n`);
+process.stderr.write(`${bar}\n\n`);
+process.exit(0);  // never fail the install — just shout

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

@@ -0,0 +1,213 @@
+/**
+ * Tests for the empty-response stall path in _trackEmptyResponse +
+ * _handleEmptyResponseStall.
+ *
+ * Two contracts here:
+ *
+ *   1. EARLY ESCALATION FOR CHAT MODE WITH NO QUEUED MESSAGES.
+ *      The classic AND-condition (count >= 5 AND elapsed >= 60s) was
+ *      designed for autonomous agents that re-cycle. In chat mode without
+ *      further messages there IS no next cycle — count gets stuck at 1
+ *      and the agent silently hangs forever. Fix: a single empty response
+ *      in that state must escalate immediately.
+ *
+ *   2. THE STALL HANDLER PUSHES A VISIBLE ERROR TURN.
+ *      Pre-fix, _handleEmptyResponseStall flipped mode to CHAT and
+ *      broadcast a notification, but wrote NOTHING to the conversation
+ *      log. REST polling consumers (dashboard, shooting-range,
+ *      headless probes) saw an agent that just stopped. Fix: route
+ *      through _recordAgentFailure so the same { role:'assistant',
+ *      isError:true, classification, error } shape lands in
+ *      conversations.full.messages — same diagnostic-gap surface as
+ *      the classified-failure branches.
+ */
+
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+jest.unstable_mockModule('../../services/agentActivityService.js', () => ({
+  shouldAgentBeActive: jest.fn(() => ({ active: false, reason: 'idle' })),
+  getActiveAgents: jest.fn(() => []),
+  shouldSkipIteration: jest.fn(() => false),
+}));
+
+const { default: AgentScheduler } = await import('../agentScheduler.js');
+const { AGENT_MODES } = await import('../../utilities/constants.js');
+
+function makeAgent(overrides = {}) {
+  return {
+    id: 'a1',
+    name: 'TestAgent',
+    sessionId: 'sess-1',
+    currentModel: 'gpt-5.3-codex',
+    preferredModel: 'gpt-5.3-codex',
+    mode: AGENT_MODES.CHAT,
+    messageQueues: { toolResults: [], interAgentMessages: [], userMessages: [] },
+    conversations: {
+      full: { messages: [{ role: 'user', content: 'Say HI.' }], lastUpdated: null },
+      'gpt-5.3-codex': { messages: [{ role: 'user', content: 'Say HI.' }], lastUpdated: null },
+    },
+    ...overrides,
+  };
+}
+
+function makeScheduler(agent) {
+  const logger = createMockLogger();
+  const agentPool = {
+    getAgent: jest.fn().mockResolvedValue(agent),
+    persistAgentState: jest.fn().mockResolvedValue(undefined),
+    addToolResult: jest.fn().mockResolvedValue(undefined),
+  };
+  const aiService = { abortRequest: jest.fn() };
+  const scheduler = new AgentScheduler(agentPool, {}, aiService, logger);
+  scheduler.webSocketManager = { broadcastToSession: jest.fn() };
+  scheduler.broadcastAgentStateUpdate = jest.fn().mockResolvedValue(undefined);
+  scheduler.getAgentSession = jest.fn(() => 'sess-1');
+  // Mode-transition history requires this to be initialised on AgentScheduler
+  scheduler._transitionMode = jest.fn().mockResolvedValue(undefined);
+  return { scheduler, agentPool, agent };
+}
+
+// The empty-response detector calls _snapshotResponseShape on the AI
+// response. Mirror the production shape so the conversation-pushed error
+// carries the hint string verifiers can match against.
+function emptyAiResponse() {
+  return {
+    content: '',
+    finishReason: 'stop',
+    model: 'gpt-5.3-codex',
+  };
+}
+
+describe('_trackEmptyResponse — chat-mode early escalation', () => {
+
+  test('chat mode + no queued messages → escalates after ONE empty (not 5)', async () => {
+    const agent = makeAgent({ mode: AGENT_MODES.CHAT });
+    const { scheduler, agentPool } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    // Tracker should have been cleared after the stall handler ran.
+    expect(scheduler._emptyResponseTracker.has('a1')).toBe(false);
+    // Stall handler did its thing: lastError set + conversation push happened.
+    expect(agent.lastError).toBeDefined();
+    expect(agent.lastError.classification).toBe('empty-response-chat-stall');
+    expect(agentPool.persistAgentState).toHaveBeenCalledWith('a1');
+  });
+
+  test('autonomous mode → does NOT early-escalate (waits for normal 5/60s)', async () => {
+    const agent = makeAgent({ mode: AGENT_MODES.AGENT });
+    const { scheduler } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    // Tracker still has count: 1 — normal stall logic in effect.
+    const entry = scheduler._emptyResponseTracker.get('a1');
+    expect(entry).toBeDefined();
+    expect(entry.count).toBe(1);
+    // No conversation error yet.
+    expect(agent.lastError).toBeUndefined();
+  });
+
+  test('chat mode WITH a queued tool result → does NOT early-escalate', async () => {
+    // A pending tool result means the next cycle will produce work — the
+    // empty turn might just be the model awaiting its tool reply.
+    const agent = makeAgent({
+      mode: AGENT_MODES.CHAT,
+      messageQueues: {
+        toolResults: [{ id: 't1', result: 'ok' }],
+        interAgentMessages: [],
+        userMessages: [],
+      },
+    });
+    const { scheduler } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    expect(scheduler._emptyResponseTracker.get('a1')?.count).toBe(1);
+    expect(agent.lastError).toBeUndefined();
+  });
+
+  test('chat mode WITH a queued user message → does NOT early-escalate', async () => {
+    const agent = makeAgent({
+      mode: AGENT_MODES.CHAT,
+      messageQueues: {
+        toolResults: [],
+        interAgentMessages: [],
+        userMessages: [{ content: 'follow-up' }],
+      },
+    });
+    const { scheduler } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    expect(scheduler._emptyResponseTracker.get('a1')?.count).toBe(1);
+    expect(agent.lastError).toBeUndefined();
+  });
+});
+
+describe('_handleEmptyResponseStall — diagnostic-gap fix', () => {
+
+  test('pushes error turn into conversations.full so REST polling sees it', async () => {
+    const agent = makeAgent({ mode: AGENT_MODES.CHAT });
+    const { scheduler } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    const turn = agent.conversations.full.messages
+      .find(m => m.isError === true);
+    expect(turn).toBeDefined();
+    expect(turn.role).toBe('assistant');
+    expect(turn.classification).toBe('empty-response-chat-stall');
+    expect(turn.error).toContain('empty response');
+    expect(turn.model).toBe('gpt-5.3-codex');
+    // Content body for clients that just render `message.content`.
+    expect(turn.content).toContain('[empty-response-chat-stall]');
+  });
+
+  test('also pushes into the per-model conversation bucket', async () => {
+    const agent = makeAgent({ mode: AGENT_MODES.CHAT });
+    const { scheduler } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    const turn = agent.conversations['gpt-5.3-codex'].messages
+      .find(m => m.isError === true);
+    expect(turn).toBeDefined();
+  });
+
+  test('still flips mode to CHAT (preserves existing behaviour)', async () => {
+    const agent = makeAgent({ mode: AGENT_MODES.CHAT });
+    const { scheduler } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    expect(scheduler._transitionMode).toHaveBeenCalledWith(
+      'a1',
+      AGENT_MODES.CHAT,
+      'empty-response-chat-stall',
+      expect.objectContaining({ count: 1 })
+    );
+  });
+
+  test('classic 5-in-60s path still fires when count hits threshold', async () => {
+    // Drive the agent through 5 empty responses, each timestamped >12s
+    // apart so elapsed > 60s by the 5th. Autonomous mode so the early-
+    // escalation branch doesn't short-circuit.
+    const agent = makeAgent({ mode: AGENT_MODES.AGENT });
+    const { scheduler } = makeScheduler(agent);
+
+    // Seed the tracker manually so we don't have to await 60s of real time.
+    scheduler._emptyResponseTracker.set('a1', {
+      count: 4,
+      firstAt: Date.now() - 61_000,   // 61s ago
+      lastAt: Date.now() - 1000,
+      samples: [],
+    });
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    expect(scheduler._emptyResponseTracker.has('a1')).toBe(false);   // cleared
+    expect(agent.lastError?.classification).toBe('empty-response-stall');
+  });
+});

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

@@ -31,7 +31,19 @@ const { default: AgentScheduler } = await import('../agentScheduler.js');
 
 function makeScheduler() {
   const logger = createMockLogger();
-  const agent = { id: 'a1', name: 'TestAgent', sessionId: 'sess-1' };
+  // Agent must carry a conversations bucket so the diagnostic error-turn
+  // push (handleAIServiceFailure → _recordAgentFailure) lands somewhere
+  // REST consumers can see.
+  const agent = {
+    id: 'a1',
+    name: 'TestAgent',
+    sessionId: 'sess-1',
+    currentModel: 'test-model',
+    conversations: {
+      full: { messages: [], lastUpdated: null },
+      'test-model': { messages: [], lastUpdated: null },
+    },
+  };
   const agentPool = {
     getAgent: jest.fn().mockResolvedValue(agent),
     persistAgentState: jest.fn().mockResolvedValue(undefined),
@@ -75,10 +87,10 @@ const errorClasses = [
 
 describe('handleAIServiceFailure: error categorisation', () => {
   describe.each(errorClasses)('%s', (tc) => {
-    let scheduler, broadcasts;
+    let scheduler, broadcasts, agent;
     beforeEach(() => {
       jest.clearAllMocks();
-      ({ scheduler, broadcasts } = makeScheduler());
+      ({ scheduler, broadcasts, agent } = makeScheduler());
     });
 
     test(`"${tc.msg}" → broadcast=${tc.expectBroadcast}, state="${tc.label}"`, async () => {
@@ -98,6 +110,71 @@ describe('handleAIServiceFailure: error categorisation', () => {
   });
 });
 
+describe('handleAIServiceFailure: diagnostic conversation turn + lastError snapshot', () => {
+  // REST consumers (get_agent_conversations, get_agent_status) used to see
+  // the agent stuck "active" with only the user message because failures
+  // were broadcast over WebSocket but never written to the conversation
+  // log. Every classified branch must now push exactly one error turn
+  // and populate agent.lastError.
+  const classifiedBranches = [
+    { name: 'auth',              msg: 'HTTP 401 Unauthorized',          classification: 'api-key-error' },
+    { name: 'rate-limit',        msg: 'Rate limit exceeded',            classification: 'rate-limit' },
+    { name: 'provider-overload', msg: 'HTTP 529 Overloaded',            classification: 'provider-overload' },
+    { name: 'gateway',           msg: 'HTTP 503 Service Unavailable',   classification: 'gateway-error' },
+    { name: 'network',           msg: 'ECONNREFUSED 127.0.0.1',         classification: 'network-error' },
+    { name: 'unknown',           msg: 'Provider returned malformed JSON', classification: 'server-error' },
+  ];
+
+  describe.each(classifiedBranches)('$name branch', (tc) => {
+    test(`pushes one error turn into conversation + sets agent.lastError`, async () => {
+      const { scheduler, agent } = makeScheduler();
+      await scheduler.handleAIServiceFailure('a1', new Error(tc.msg));
+
+      // Conversation log: exactly one entry in `full`, flagged as error.
+      const fullMsgs = agent.conversations.full.messages;
+      expect(fullMsgs.length).toBe(1);
+      const turn = fullMsgs[0];
+      expect(turn.role).toBe('assistant');
+      expect(turn.isError).toBe(true);
+      expect(turn.error).toBe(tc.msg);
+      expect(turn.classification).toBe(tc.classification);
+      expect(turn.model).toBe('test-model');
+      expect(turn.timestamp).toEqual(expect.any(String));
+      expect(typeof turn.content).toBe('string');
+      expect(turn.content).toContain(tc.msg);
+
+      // Per-model bucket mirrors the same push (matches addMessageToConversation).
+      expect(agent.conversations['test-model'].messages.length).toBe(1);
+      expect(agent.conversations.full.lastUpdated).toEqual(expect.any(String));
+
+      // lastError snapshot for get_agent_status callers.
+      expect(agent.lastError).toEqual({
+        message: tc.msg,
+        classification: tc.classification,
+        at: expect.any(String),
+        model: 'test-model',
+      });
+    });
+  });
+
+  test('token-limit branch also records an error turn + lastError before handoff', async () => {
+    // Token-limit early-returns into compaction, but REST consumers still
+    // need a visible "we paused you" turn — assert it lands BEFORE the
+    // handler is invoked (and that lastError is set).
+    const { scheduler, agent } = makeScheduler();
+    scheduler.isTokenLimitError = jest.fn().mockReturnValue(true);
+    scheduler.handleTokenLimitError = jest.fn().mockImplementation(async () => {
+      // At hand-off time the error turn must already exist.
+      expect(agent.conversations.full.messages.length).toBe(1);
+      expect(agent.conversations.full.messages[0].classification).toBe('token-limit');
+      expect(agent.lastError?.classification).toBe('token-limit');
+    });
+
+    await scheduler.handleAIServiceFailure('a1', new Error('Context length exceeded'));
+    expect(scheduler.handleTokenLimitError).toHaveBeenCalled();
+  });
+});
+
 describe('handleAIServiceFailure: gateway 503 takes the network delay, not the rate-limit delay', () => {
   test('uses NETWORK_ERROR_DELAY_MS for 503 errors', async () => {
     const { scheduler, agentPool, agent } = makeScheduler();

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

@@ -0,0 +1,138 @@
+/**
+ * Tests for AgentScheduler._resolveFirstChunkTimeoutMs — the per-model
+ * pre-stream watchdog.
+ *
+ * Behavioural contract:
+ *   • When the catalog entry carries parameters.defaults.first_chunk_timeout_ms
+ *     as a positive integer, return that value.
+ *   • When the catalog entry has no override (or the value is invalid),
+ *     return the SCHEDULER_CONFIG.AI_PRESTREAM_TIMEOUT_MS fallback.
+ *   • When modelsService is unavailable, return the fallback and warn once.
+ *   • Repeated lookups within the TTL window must hit the cache — the
+ *     models list is walked at most once per (model, TTL window).
+ */
+
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+const mockShouldAgentBeActive = jest.fn(() => ({ active: false, reason: 'idle' }));
+const mockGetActiveAgents = jest.fn(() => []);
+const mockShouldSkipIteration = jest.fn(() => false);
+jest.unstable_mockModule('../../services/agentActivityService.js', () => ({
+  shouldAgentBeActive: mockShouldAgentBeActive,
+  getActiveAgents: mockGetActiveAgents,
+  shouldSkipIteration: mockShouldSkipIteration,
+}));
+
+const { default: AgentScheduler } = await import('../agentScheduler.js');
+const { SCHEDULER_CONFIG } = await import('../../utilities/constants.js');
+
+function makeScheduler({ models = [], modelsService = undefined } = {}) {
+  const logger = createMockLogger();
+  const agentPool = {
+    getAgent: jest.fn(),
+    persistAgentState: jest.fn().mockResolvedValue(undefined),
+  };
+  const aiService = { abortRequest: jest.fn() };
+  const scheduler = new AgentScheduler(agentPool, {}, aiService, logger);
+  // Allow the test to inject either an explicit service or a getModels() shim.
+  if (modelsService !== undefined) {
+    scheduler.modelsService = modelsService;
+  } else {
+    scheduler.modelsService = { getModels: jest.fn(() => models) };
+  }
+  return { scheduler, logger };
+}
+
+describe('AgentScheduler._resolveFirstChunkTimeoutMs', () => {
+  test('returns the catalog override when first_chunk_timeout_ms is set', async () => {
+    const { scheduler } = makeScheduler({
+      models: [
+        { name: 'gpt-5.4', parameters: { defaults: { first_chunk_timeout_ms: 180_000 } } },
+      ],
+    });
+    const ms = await scheduler._resolveFirstChunkTimeoutMs('gpt-5.4');
+    expect(ms).toBe(180_000);
+  });
+
+  test('falls back to AI_PRESTREAM_TIMEOUT_MS when override is missing', async () => {
+    const { scheduler } = makeScheduler({
+      models: [
+        { name: 'gpt-4o', parameters: { defaults: { reasoning_effort: 'medium' } } },
+      ],
+    });
+    const ms = await scheduler._resolveFirstChunkTimeoutMs('gpt-4o');
+    expect(ms).toBe(SCHEDULER_CONFIG.AI_PRESTREAM_TIMEOUT_MS);
+  });
+
+  test('falls back when the model is not in the catalog at all', async () => {
+    const { scheduler } = makeScheduler({ models: [] });
+    const ms = await scheduler._resolveFirstChunkTimeoutMs('mystery-model');
+    expect(ms).toBe(SCHEDULER_CONFIG.AI_PRESTREAM_TIMEOUT_MS);
+  });
+
+  test('falls back when the override value is invalid (string/zero/negative)', async () => {
+    const { scheduler } = makeScheduler({
+      models: [
+        { name: 'a', parameters: { defaults: { first_chunk_timeout_ms: '120000' } } },
+        { name: 'b', parameters: { defaults: { first_chunk_timeout_ms: 0 } } },
+        { name: 'c', parameters: { defaults: { first_chunk_timeout_ms: -5 } } },
+        { name: 'd', parameters: { defaults: { first_chunk_timeout_ms: 1.5 } } },
+      ],
+    });
+    for (const n of ['a', 'b', 'c', 'd']) {
+      const ms = await scheduler._resolveFirstChunkTimeoutMs(n);
+      expect(ms).toBe(SCHEDULER_CONFIG.AI_PRESTREAM_TIMEOUT_MS);
+    }
+  });
+
+  test('falls back and warns once when modelsService is unavailable', async () => {
+    const { scheduler, logger } = makeScheduler({ modelsService: null });
+    const a = await scheduler._resolveFirstChunkTimeoutMs('any-model');
+    const b = await scheduler._resolveFirstChunkTimeoutMs('other-model');
+    expect(a).toBe(SCHEDULER_CONFIG.AI_PRESTREAM_TIMEOUT_MS);
+    expect(b).toBe(SCHEDULER_CONFIG.AI_PRESTREAM_TIMEOUT_MS);
+    // Warn-once flag: only one warn call across two lookups.
+    expect(logger.warn).toHaveBeenCalledTimes(1);
+  });
+
+  test('falls back when getModels() throws', async () => {
+    const { scheduler } = makeScheduler({
+      modelsService: { getModels: () => { throw new Error('boom'); } },
+    });
+    const ms = await scheduler._resolveFirstChunkTimeoutMs('gpt-5.4');
+    expect(ms).toBe(SCHEDULER_CONFIG.AI_PRESTREAM_TIMEOUT_MS);
+  });
+
+  test('caches the lookup — subsequent calls do not re-walk the model list', async () => {
+    const getModels = jest.fn(() => [
+      { name: 'o3', parameters: { defaults: { first_chunk_timeout_ms: 240_000 } } },
+    ]);
+    const { scheduler } = makeScheduler({ modelsService: { getModels } });
+
+    const a = await scheduler._resolveFirstChunkTimeoutMs('o3');
+    const b = await scheduler._resolveFirstChunkTimeoutMs('o3');
+    const c = await scheduler._resolveFirstChunkTimeoutMs('o3');
+    expect(a).toBe(240_000);
+    expect(b).toBe(240_000);
+    expect(c).toBe(240_000);
+    expect(getModels).toHaveBeenCalledTimes(1);
+  });
+
+  test('cache is per-model — different models each trigger their own lookup', async () => {
+    const getModels = jest.fn(() => [
+      { name: 'o3', parameters: { defaults: { first_chunk_timeout_ms: 240_000 } } },
+      { name: 'gpt-4o', parameters: { defaults: {} } },
+    ]);
+    const { scheduler } = makeScheduler({ modelsService: { getModels } });
+
+    expect(await scheduler._resolveFirstChunkTimeoutMs('o3')).toBe(240_000);
+    expect(await scheduler._resolveFirstChunkTimeoutMs('gpt-4o'))
+      .toBe(SCHEDULER_CONFIG.AI_PRESTREAM_TIMEOUT_MS);
+    // Repeats both come from cache.
+    expect(await scheduler._resolveFirstChunkTimeoutMs('o3')).toBe(240_000);
+    expect(await scheduler._resolveFirstChunkTimeoutMs('gpt-4o'))
+      .toBe(SCHEDULER_CONFIG.AI_PRESTREAM_TIMEOUT_MS);
+    expect(getModels).toHaveBeenCalledTimes(2);
+  });
+});

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

@@ -356,7 +356,10 @@ describe('AgentScheduler', () => {
   // ─── Empty-response stall circuit breaker ─────────────────────────────
   describe('_trackEmptyResponse + _handleEmptyResponseStall', () => {
     test('records empty responses without polluting stateHashHistory', async () => {
-      const agent = makeAgent({ id: 'agent-empty' });
+      // Autonomous mode so the new chat-mode early-escalation branch
+      // doesn't short-circuit before count reaches 3. The chat-mode
+      // path is covered in agentScheduler.emptyResponseChatStall.test.js.
+      const agent = makeAgent({ id: 'agent-empty', mode: 'agent' });
       agentPool.getAgent.mockResolvedValue(agent);
 
       await scheduler._trackEmptyResponse('agent-empty');
@@ -369,8 +372,10 @@ describe('AgentScheduler', () => {
       expect(scheduler.stateHashHistory.has('agent-empty')).toBe(false);
     });
 
-    test('does NOT fire stall handler below threshold', async () => {
-      const agent = makeAgent({ id: 'agent-empty' });
+    test('does NOT fire stall handler below threshold (autonomous mode)', async () => {
+      // Use autonomous mode — chat mode now early-escalates on first empty
+      // (see agentScheduler.emptyResponseChatStall.test.js for that path).
+      const agent = makeAgent({ id: 'agent-empty', mode: 'agent' });
       agentPool.getAgent.mockResolvedValue(agent);
 
       for (let i = 0; i < 4; i++) {
@@ -378,7 +383,7 @@ describe('AgentScheduler', () => {
       }
 
       // Agent mode untouched — stall handler did not fire
-      expect(agent.mode).toBe('chat');  // started as chat; unchanged
+      expect(agent.mode).toBe('agent');
       expect(scheduler._emptyResponseTracker.has('agent-empty')).toBe(true);
     });
 
@@ -413,15 +418,22 @@ describe('AgentScheduler', () => {
       expect(agent.mode).toBe('chat');
       expect(scheduler._emptyResponseTracker.has('agent-empty')).toBe(false);
 
-      // NO chat-transcript bubble — the stall is surfaced via the
-      // `agent_mode_changed` broadcast's `humanReason`, not a fake
-      // assistant message in the conversation. Previously every stall
-      // posted the same "I've switched to chat mode" paragraph into the
-      // feed, which operators (reasonably) complained about.
-      expect(agent.conversations.full.messages.length).toBe(0);
-
-      // The transition, however, is recorded with count + elapsedSec
-      // interpolated into the human reason.
+      // The stall handler now ALSO pushes a visible error turn into the
+      // conversation log (diagnostic-gap fix) so REST polling consumers
+      // see the failure instead of an agent silently stuck "active".
+      // The previous "no transcript bubble" design left the shooting-
+      // range and dashboard unable to tell the difference between
+      // "model is thinking" and "model died". Same uniform shape as
+      // classified-failure branches use via _recordAgentFailure.
+      expect(agent.conversations.full.messages.length).toBe(1);
+      const turn = agent.conversations.full.messages[0];
+      expect(turn.role).toBe('assistant');
+      expect(turn.isError).toBe(true);
+      expect(turn.classification).toBe('empty-response-stall');
+      expect(turn.error).toMatch(/empty response/);
+
+      // The transition is still recorded with count + elapsedSec
+      // interpolated into the human reason (preserves existing UI).
       const history = scheduler._modeTransitionHistory.get('agent-empty');
       expect(history).toHaveLength(1);
       expect(history[0].reasonCode).toBe('empty-response-stall');