onbuzz 5.3.0 → 5.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "5.3.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
@@ -144,7 +145,8 @@ class AgentPool {
             layered: config.layeredToolDescriptions || false,
             includeExamples: config.includeToolExamples !== false,
             includeUsageGuidelines: config.includeUsageGuidelines !== false,
-            includeSecurityNotes: config.includeSecurityNotes !== false
+            includeSecurityNotes: config.includeSecurityNotes !== false,
+            mode: config.mode  // gates the jobdone must-have (AGENT mode only)
           }
         );
         
@@ -429,7 +431,8 @@ class AgentPool {
             compact: agent.compactToolDescriptions || false,
             includeExamples: agent.includeToolExamples !== false,
             includeUsageGuidelines: agent.includeUsageGuidelines !== false,
-            includeSecurityNotes: agent.includeSecurityNotes !== false
+            includeSecurityNotes: agent.includeSecurityNotes !== false,
+            mode: updates.mode || agent.mode  // gates the jobdone must-have
           }
         );
 
@@ -1341,7 +1344,8 @@ class AgentPool {
           compact: options.compact || false,
           includeExamples: options.includeExamples !== false,
           includeUsageGuidelines: options.includeUsageGuidelines !== false,
-          includeSecurityNotes: options.includeSecurityNotes !== false
+          includeSecurityNotes: options.includeSecurityNotes !== false,
+          mode: agent.mode  // gates the jobdone must-have (AGENT mode only)
         }
       );
 
@@ -1466,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/agentScheduler.js

@@ -2513,7 +2513,7 @@ class AgentScheduler {
       // them back into the CLI's inline JSON-block format on the wire. For
       // chat-completion models the backend ignores this field and the model
       // uses the system prompt's inline-JSON instructions as before.
-      const toolSchemas = getToolSchemasForAgent(agent.capabilities || []);
+      const toolSchemas = getToolSchemasForAgent(agent.capabilities || [], agent.mode);
 
       if (streamingEnabled && this.aiService.sendMessageStream) {
         // Build flow context if this is part of a flow execution
@@ -2641,7 +2641,7 @@ class AgentScheduler {
       let rebuilt = registry.enhanceSystemPrompt(
         agent.originalSystemPrompt,
         agent.capabilities || [],
-        { apiType: 'responses' },
+        { apiType: 'responses', mode: agent.mode },
       );
 
       // Re-inject ASSIGNED SKILLS block if present (createAgent appends

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();

package/src/interfaces/__tests__/imageServing.test.js

@@ -226,3 +226,91 @@ describe('/api/images/:sessionId/:filename', () => {
     expect(body.error).toBe('Image not found');
   });
 });
+
+// ── /api/image?path=… (serve an image by absolute path) ─────────────
+
+function buildImageByPathApp() {
+  const app = express();
+  // Replicate the exact route from webServer.js
+  app.get('/api/image', async (req, res) => {
+    try {
+      const raw = req.query.path;
+      if (!raw || typeof raw !== 'string') {
+        return res.status(HTTP_STATUS.BAD_REQUEST).json({ success: false, error: 'path query is required' });
+      }
+      const resolved = path.resolve(raw);
+      const ext = path.extname(resolved).toLowerCase();
+      const ALLOWED = ['.png', '.jpg', '.jpeg', '.webp', '.gif', '.bmp', '.svg'];
+      if (!ALLOWED.includes(ext)) {
+        return res.status(HTTP_STATUS.BAD_REQUEST).json({ success: false, error: 'Unsupported image type' });
+      }
+      const stats = await fs.stat(resolved).catch(() => null);
+      if (!stats || !stats.isFile()) {
+        return res.status(HTTP_STATUS.NOT_FOUND).json({ success: false, error: 'Image not found' });
+      }
+      res.sendFile(resolved, (err) => {
+        if (err && !res.headersSent) {
+          res.status(HTTP_STATUS.NOT_FOUND).json({ success: false, error: 'Image not found' });
+        }
+      });
+    } catch (error) {
+      res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ success: false, error: error.message });
+    }
+  });
+  return app;
+}
+
+describe('/api/image?path=', () => {
+  let server, baseUrl, tmpDir, imgPath, txtPath;
+
+  beforeAll(async () => {
+    tmpDir = path.join(os.tmpdir(), `loxia-img-bypath-${Date.now()}`);
+    await fs.mkdir(tmpDir, { recursive: true });
+    imgPath = path.join(tmpDir, 'pic.png');
+    txtPath = path.join(tmpDir, 'notes.txt');
+    await fs.writeFile(imgPath, Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]));
+    await fs.writeFile(txtPath, 'not an image');
+
+    server = createServer(buildImageByPathApp());
+    await new Promise(resolve => server.listen(0, resolve));
+    baseUrl = `http://localhost:${server.address().port}`;
+  });
+
+  afterAll(async () => {
+    server?.close();
+    await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  it('400 when path is missing', async () => {
+    const { status, body } = await fetch(`${baseUrl}/api/image`);
+    expect(status).toBe(400);
+    expect(body.error).toMatch(/path query is required/);
+  });
+
+  it('400 for a non-image extension', async () => {
+    const { status, body } = await fetch(`${baseUrl}/api/image?path=${encodeURIComponent(txtPath)}`);
+    expect(status).toBe(400);
+    expect(body.error).toMatch(/Unsupported image type/);
+  });
+
+  it('404 for an image path that does not exist', async () => {
+    const missing = path.join(tmpDir, 'ghost.png');
+    const { status, body } = await fetch(`${baseUrl}/api/image?path=${encodeURIComponent(missing)}`);
+    expect(status).toBe(404);
+    expect(body.error).toBe('Image not found');
+  });
+
+  it('404 when the path is a directory, not a file', async () => {
+    // A directory named like an image so the extension check passes.
+    const dirLikeImage = path.join(tmpDir, 'folder.png');
+    await fs.mkdir(dirLikeImage, { recursive: true });
+    const { status } = await fetch(`${baseUrl}/api/image?path=${encodeURIComponent(dirLikeImage)}`);
+    expect(status).toBe(404);
+  });
+
+  it('serves an existing image by absolute path', async () => {
+    const { status, headers } = await fetch(`${baseUrl}/api/image?path=${encodeURIComponent(imgPath)}`);
+    expect(status).toBe(200);
+    expect(headers.get('content-type')).toMatch(/image|octet/);
+  });
+});

package/src/interfaces/terminal/config/agentEditorConstants.js

@@ -34,14 +34,18 @@ export const AVAILABLE_TOOLS = [
   { name: 'Web', value: 'web', description: 'Fetch, browse, and interact with web content' },
   // Browser tool is DEPRECATED - use Web tool instead
   { name: 'Image', value: 'image-gen', description: 'Generate and process images' },
-  { name: 'TaskManager', value: 'taskmanager', description: 'Manage and track tasks' },
+  // TaskManager is a MUST-HAVE tool — always advertised to every agent
+  // (see src/utilities/mustHaveCapabilities.js), so it is not user-selectable.
+  // { name: 'TaskManager', value: 'taskmanager', description: 'Manage and track tasks' },
   { name: 'StaticAnalysis', value: 'staticanalysis', description: 'Analyze code structure and patterns' },
   { name: 'DependencyResolver', value: 'dependency-resolver', description: 'Analyze and resolve dependencies' },
   { name: 'ImportAnalyzer', value: 'import-analyzer', description: 'Analyze import statements' },
   { name: 'CloneDetection', value: 'clonedetection', description: 'Detect code duplication' },
   { name: 'FileContentReplace', value: 'file-content-replace', description: 'Advanced find and replace' },
   { name: 'AgentCommunication', value: 'agentcommunication', description: 'Communicate with other agents' },
-  { name: 'JobDone', value: 'jobdone', description: 'Signal task completion in autonomous mode' },
+  // JobDone is a MUST-HAVE tool in AGENT mode — always advertised to autonomous
+  // agents (see src/utilities/mustHaveCapabilities.js), so it is not selectable.
+  // { name: 'JobDone', value: 'jobdone', description: 'Signal task completion in autonomous mode' },
   { name: 'AgentDelay', value: 'agentdelay', description: 'Pause agent activity for a duration' },
   { name: 'VisualEditor', value: 'visual-editor', description: 'Visual editing of web apps with element selection' },
   // TODO: Re-enable once Sora replacement is available

package/src/interfaces/webServer.js

@@ -2955,6 +2955,38 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       }
     });
 
+    // Serve an image file by absolute path. The filename-only endpoints below
+    // can't help the renderers: Vision analyzes arbitrary local images (they
+    // can live anywhere the user points), and the image tool saves to agent
+    // working dirs. A browser <img> can't load a local path directly, so the UI
+    // routes local paths through here. Gated to image extensions + existence;
+    // this is a localhost app whose agents already have filesystem access.
+    this.app.get('/api/image', async (req, res) => {
+      try {
+        const raw = req.query.path;
+        if (!raw || typeof raw !== 'string') {
+          return res.status(HTTP_STATUS.BAD_REQUEST).json({ success: false, error: 'path query is required' });
+        }
+        const resolved = path.resolve(raw);
+        const ext = path.extname(resolved).toLowerCase();
+        const ALLOWED = ['.png', '.jpg', '.jpeg', '.webp', '.gif', '.bmp', '.svg'];
+        if (!ALLOWED.includes(ext)) {
+          return res.status(HTTP_STATUS.BAD_REQUEST).json({ success: false, error: 'Unsupported image type' });
+        }
+        const stats = await fs.stat(resolved).catch(() => null);
+        if (!stats || !stats.isFile()) {
+          return res.status(HTTP_STATUS.NOT_FOUND).json({ success: false, error: 'Image not found' });
+        }
+        res.sendFile(resolved, (err) => {
+          if (err && !res.headersSent) {
+            res.status(HTTP_STATUS.NOT_FOUND).json({ success: false, error: 'Image not found' });
+          }
+        });
+      } catch (error) {
+        res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ success: false, error: error.message });
+      }
+    });
+
     // Image serving endpoint for generated images
     this.app.get('/api/images/:sessionId/:filename', async (req, res) => {
       try {

package/src/services/__tests__/agentActivityService.test.js

@@ -225,14 +225,27 @@ describe('agentActivityService', () => {
       expect(result.reason).toBe('has-inter-agent-messages');
     });
 
-    test('CHAT mode: inactive with only tool results', () => {
+    test('CHAT mode: ACTIVE with queued tool results (agentic continuation)', () => {
+      // A chat agent that fired a tool must wake when the result lands so it can
+      // read the output and answer — covers sync (scheduler push) and async
+      // (addToolResult) delivery identically, since both leave a result in the
+      // queue and this keys off queue state.
       const result = shouldAgentBeActive(makeAgent({
         mode: 'chat',
-        messageQueues: { toolResults: [{ id: 1 }] }
+        messageQueues: { toolResults: [{ id: 1 }, { id: 2 }] }
       }));
-      expect(result.active).toBe(false);
-      expect(result.reason).toBe('chat-mode-no-messages');
-      expect(result.details).toContain('tool results');
+      expect(result.active).toBe(true);
+      expect(result.reason).toBe('has-tool-results');
+      expect(result.details).toContain('2 tool result');
+    });
+
+    test('CHAT mode: user messages still take priority over tool results', () => {
+      const result = shouldAgentBeActive(makeAgent({
+        mode: 'chat',
+        messageQueues: { userMessages: [{ id: 1 }], toolResults: [{ id: 2 }] }
+      }));
+      expect(result.active).toBe(true);
+      expect(result.reason).toBe('has-user-messages');
     });
 
     test('CHAT mode: inactive with no messages', () => {

package/src/services/__tests__/promptService.test.js

@@ -46,6 +46,27 @@ describe('PromptService', () => {
     expect(service.pendingRequests.size).toBe(1);
   });
 
+  test('createPromptRequest with timeout:null sets no auto-timeout', () => {
+    const { requestInfo, promise } = service.createPromptRequest('agent-1', {
+      questions: [{ message: 'Q?' }]
+    }, { timeout: null });
+
+    expect(requestInfo.timeoutAt).toBeNull();
+    expect(requestInfo.timeoutMs).toBeNull();
+    // No timeout handle scheduled → advancing time does not reject the promise.
+    let settled = false;
+    promise.then(() => { settled = true; }, () => { settled = true; });
+    jest.advanceTimersByTime(60 * 60 * 1000);
+    expect(settled).toBe(false);
+    expect(service.pendingRequests.size).toBe(1);
+  });
+
+  test('createPromptRequest with timeout:0/undefined falls back to the default', () => {
+    const { requestInfo } = service.createPromptRequest('agent-1', { questions: [{ message: 'Q?' }] }, { timeout: 0 });
+    expect(requestInfo.timeoutMs).toBe(5 * 60 * 1000);
+    expect(requestInfo.timeoutAt).not.toBeNull();
+  });
+
   test('createPromptRequest normalizes questions with defaults', () => {
     const { requestInfo } = service.createPromptRequest('agent-1', {
       questions: [{ question: 'What color?', options: ['red', 'blue'] }]

package/src/services/__tests__/scheduleService.flow.test.js

@@ -208,6 +208,57 @@ describe('_executeAgentSchedule', () => {
       .rejects.toThrow(/Target agent not found/);
   });
 
+  test('load-on-fire: restores an on-disk target then dispatches', async () => {
+    const svc = newSvc();
+    const updateAgent = jest.fn().mockResolvedValue(undefined);
+    const addUserMessage = jest.fn().mockResolvedValue(undefined);
+    const importArchivedAgent = jest.fn().mockResolvedValue({ id: 'a1', name: 'Restored' });
+    svc.setAgentPool({ getAgent: jest.fn().mockResolvedValue(null), updateAgent, addUserMessage });
+    svc.setOrchestrator({ stateManager: { importArchivedAgent }, config: { project: { directory: '/proj' } } });
+
+    await svc._executeAgentSchedule({ id: 's', name: 'Nightly', targetId: 'a1', prompt: 'go' });
+
+    expect(importArchivedAgent).toHaveBeenCalledWith('a1', '/proj', expect.anything());
+    expect(addUserMessage).toHaveBeenCalledWith('a1', expect.objectContaining({ source: 'schedule' }));
+  });
+
+  test('load-on-fire: falls back to getAgent when import returns nothing but the agent is now resident', async () => {
+    const svc = newSvc();
+    const getAgent = jest.fn()
+      .mockResolvedValueOnce(null)              // first check: not resident
+      .mockResolvedValueOnce({ id: 'a1', name: 'NowHere' }); // after import: resident
+    const importArchivedAgent = jest.fn().mockResolvedValue(null);
+    svc.setAgentPool({ getAgent, updateAgent: jest.fn(), addUserMessage: jest.fn() });
+    svc.setOrchestrator({ stateManager: { importArchivedAgent }, config: {} });
+
+    await svc._executeAgentSchedule({ id: 's', name: 'N', targetId: 'a1', prompt: 'go' });
+    expect(importArchivedAgent).toHaveBeenCalled();
+  });
+
+  test('load-on-fire: still throws when the agent cannot be restored', async () => {
+    const svc = newSvc();
+    svc.setAgentPool({ getAgent: jest.fn().mockResolvedValue(null) });
+    svc.setOrchestrator({ stateManager: { importArchivedAgent: jest.fn().mockResolvedValue(null) }, config: {} });
+    await expect(svc._executeAgentSchedule({ id: 'x', targetId: 'gone' }))
+      .rejects.toThrow(/Target agent not found/);
+  });
+
+  test('load-on-fire: a restore error is swallowed (falls through to not-found)', async () => {
+    const svc = newSvc();
+    svc.setAgentPool({ getAgent: jest.fn().mockResolvedValue(null) });
+    svc.setOrchestrator({ stateManager: { importArchivedAgent: jest.fn().mockRejectedValue(new Error('disk')) }, config: {} });
+    await expect(svc._executeAgentSchedule({ id: 'x', targetId: 'gone' }))
+      .rejects.toThrow(/Target agent not found/);
+  });
+
+  test('load-on-fire: no-op when no orchestrator/stateManager is wired', async () => {
+    const svc = newSvc();
+    svc.setAgentPool({ getAgent: jest.fn().mockResolvedValue(null) });
+    // no setOrchestrator → _loadAgentFromDisk returns null immediately
+    await expect(svc._executeAgentSchedule({ id: 'x', targetId: 'gone' }))
+      .rejects.toThrow(/Target agent not found/);
+  });
+
   test('switches to agent mode and pushes the prompt, reusing a live session id', async () => {
     const svc = newSvc();
     const updateAgent = jest.fn().mockResolvedValue(undefined);