onbuzz 5.1.0 → 5.4.0

package/src/interfaces/attachmentRoutes.js

@@ -0,0 +1,56 @@
+/**
+ * Chat attachment ingest route.
+ *
+ * POST /api/agents/:agentId/attachments
+ *   - { fileName, dataBase64, mode? } → binary-safe upload of raw bytes
+ *   - { filePath, mode?, fileName? }  → ingest a file already on the server
+ *
+ * Mounted with its OWN higher-limit JSON parser so base64 uploads aren't capped
+ * by the global 10 MB body limit (base64 inflates ~33%, so 50 MB ≈ a ~37 MB
+ * file). Extracted into a register helper so it mounts on a bare Express app
+ * for testing — same idiom as registerScheduleRoutes. The ingestion service is
+ * read through a thunk because it's wired after routes are registered at boot.
+ *
+ * NOTE: true multipart/streaming (busboy) is a future optimization for very
+ * large files; base64 ingestion is dependency-free, binary-correct, and covers
+ * the practical size range.
+ */
+import express from 'express';
+
+export function registerAttachmentRoutes(app, { getIngestionService, logger, jsonLimit = '50mb' } = {}) {
+  if (!app) return;
+  const svc = () => (typeof getIngestionService === 'function' ? getIngestionService() : null);
+  const log = logger || { error() {} };
+  const bigJson = express.json({ limit: jsonLimit });
+
+  app.post('/api/agents/:agentId/attachments', bigJson, async (req, res) => {
+    try {
+      const ingestion = svc();
+      if (!ingestion) {
+        return res.status(503).json({ success: false, error: 'Attachment ingestion not available' });
+      }
+      const { agentId } = req.params;
+      /* istanbul ignore next: bigJson always populates req.body on this route; the ||{} is a pure safety net */
+      const { fileName, dataBase64, filePath, mode, scope, conversationId } = req.body || {};
+
+      let attachment;
+      if (dataBase64) {
+        attachment = await ingestion.ingestUpload({ agentId, fileName, dataBase64, mode, scope, conversationId });
+      } else if (filePath) {
+        attachment = await ingestion.ingestServerPath({ agentId, filePath, mode, fileName, scope, conversationId });
+      } else {
+        return res.status(400).json({
+          success: false,
+          error: 'Provide dataBase64 (upload) or filePath (server file)',
+        });
+      }
+
+      res.json({ success: true, attachment });
+    } catch (error) {
+      log.error('Attachment ingest failed', { agentId: req.params.agentId, error: error.message });
+      res.status(400).json({ success: false, error: error.message });
+    }
+  });
+}
+
+export default registerAttachmentRoutes;

package/src/interfaces/scheduleRoutes.js

@@ -0,0 +1,128 @@
+/**
+ * Scheduled-tasks HTTP API.
+ *
+ * Extracted from webServer.setupRoutes so the whole /api/schedules surface
+ * (list, presets, create, read, update, delete, trigger, toggle) can be
+ * mounted on a bare Express app and tested without standing up the full
+ * server — same pattern as registerSchedulerRoutes.
+ *
+ * scheduleService is read through a thunk (getScheduleService) because the
+ * orchestrator wires it in AFTER routes are registered at boot; a handler
+ * that captured a null reference at registration time would 400/404 forever.
+ *
+ * Behavior (status codes + response shapes) mirrors the original inline
+ * handlers exactly — see scheduleRoutes.test.js for the locked contract.
+ */
+
+export function registerScheduleRoutes(app, { getScheduleService, logger } = {}) {
+  if (!app) return;
+  const svc = () => (typeof getScheduleService === 'function' ? getScheduleService() : null);
+  const log = logger || { error() {}, warn() {}, info() {} };
+
+  // List all schedules — degrades to an empty list when the service is absent.
+  app.get('/api/schedules', async (req, res) => {
+    try {
+      const s = svc();
+      if (!s) return res.json({ success: true, schedules: [] });
+      res.json({ success: true, schedules: s.listSchedules() });
+    } catch (error) {
+      log.error('Failed to list schedules', { error: error.message });
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  // Cron presets — registered BEFORE /:id so "presets" isn't captured as an id.
+  app.get('/api/schedules/presets', async (req, res) => {
+    try {
+      const s = svc();
+      if (!s) return res.json({ success: true, presets: {} });
+      res.json({ success: true, presets: s.getPresets() });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  // Create
+  app.post('/api/schedules', async (req, res) => {
+    try {
+      const s = svc();
+      if (!s) return res.status(400).json({ success: false, error: 'Schedule service not available' });
+      const schedule = await s.createSchedule(req.body);
+      res.json({ success: true, schedule });
+    } catch (error) {
+      log.error('Failed to create schedule', { error: error.message });
+      res.status(400).json({ success: false, error: error.message });
+    }
+  });
+
+  // Read one
+  app.get('/api/schedules/:id', async (req, res) => {
+    try {
+      const s = svc();
+      if (!s) return res.status(404).json({ success: false, error: 'Schedule service not available' });
+      const schedule = s.getSchedule(req.params.id);
+      if (!schedule) return res.status(404).json({ success: false, error: 'Schedule not found' });
+      res.json({ success: true, schedule });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  // Update
+  app.put('/api/schedules/:id', async (req, res) => {
+    try {
+      const s = svc();
+      if (!s) return res.status(400).json({ success: false, error: 'Schedule service not available' });
+      const schedule = await s.updateSchedule(req.params.id, req.body);
+      res.json({ success: true, schedule });
+    } catch (error) {
+      log.error('Failed to update schedule', { error: error.message });
+      res.status(400).json({ success: false, error: error.message });
+    }
+  });
+
+  // Delete
+  app.delete('/api/schedules/:id', async (req, res) => {
+    try {
+      const s = svc();
+      if (!s) return res.status(400).json({ success: false, error: 'Schedule service not available' });
+      await s.deleteSchedule(req.params.id);
+      res.json({ success: true });
+    } catch (error) {
+      log.error('Failed to delete schedule', { error: error.message });
+      res.status(400).json({ success: false, error: error.message });
+    }
+  });
+
+  // Force-trigger immediately (used by the Run-now button + CLI trigger-schedule)
+  app.post('/api/schedules/:id/trigger', async (req, res) => {
+    try {
+      const s = svc();
+      if (!s) return res.status(400).json({ success: false, error: 'Schedule service not available' });
+      if (!s.getSchedule(req.params.id)) {
+        return res.status(404).json({ success: false, error: 'Schedule not found' });
+      }
+      const schedule = await s.triggerSchedule(req.params.id);
+      res.json({ success: true, scheduleName: schedule.name, lastRunStatus: schedule.lastRunStatus });
+    } catch (error) {
+      log.error('Failed to trigger schedule', { error: error.message });
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  // Toggle enabled/disabled
+  app.post('/api/schedules/:id/toggle', async (req, res) => {
+    try {
+      const s = svc();
+      if (!s) return res.status(400).json({ success: false, error: 'Schedule service not available' });
+      const current = s.getSchedule(req.params.id);
+      if (!current) return res.status(404).json({ success: false, error: 'Schedule not found' });
+      const schedule = await s.updateSchedule(req.params.id, { enabled: !current.enabled });
+      res.json({ success: true, schedule });
+    } catch (error) {
+      res.status(400).json({ success: false, error: error.message });
+    }
+  });
+}
+
+export default registerScheduleRoutes;

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/transcribeProxy.js

@@ -0,0 +1,72 @@
+/**
+ * Speech-to-text proxy logic for the web-ui mic / dictation.
+ *
+ * Why this exists: the browser's webkitSpeechRecognition has NO working backend
+ * inside Electron (Chromium's speech service is provisioned only for official
+ * Chrome builds), so dictation silently fails in the desktop binary. The fix is
+ * to record audio in the renderer (MediaRecorder works in Electron) and POST it
+ * here; the local server attaches the platform key and forwards to the remote
+ * Loxia `/llm/transcribe` (Azure AI Foundry STT) — the same endpoint the
+ * Telegram voice-note path uses.
+ *
+ * Kept as a pure, fetch-injectable function so it's fully unit-testable without
+ * standing up the whole web server. Returns { status, body } for the route to
+ * relay verbatim.
+ */
+
+const DEFAULT_BACKEND = 'https://loxia-api-g7hrb8bxdae8a2h7.z02.azurefd.net';
+
+export async function proxyTranscribe({
+  audioBase64,
+  mimeType,
+  filename,
+  durationSeconds,
+  apiKey,
+  backendBaseUrl,
+  fetchImpl = (typeof fetch !== 'undefined' ? fetch : null),
+  logger,
+} = {}) {
+  if (!audioBase64 || typeof audioBase64 !== 'string') {
+    return { status: 400, body: { error: 'audioBase64 (string) is required' } };
+  }
+  if (!apiKey) {
+    return { status: 401, body: { error: 'No API key configured. Please configure your Loxia API key in Settings.' } };
+  }
+  if (typeof fetchImpl !== 'function') {
+    return { status: 500, body: { error: 'No fetch implementation available' } };
+  }
+
+  const base = backendBaseUrl || DEFAULT_BACKEND;
+  let response;
+  try {
+    response = await fetchImpl(`${base}/llm/transcribe`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify({
+        audioBase64,
+        mimeType: mimeType || 'audio/webm',
+        filename: filename || 'dictation.webm',
+        ...(typeof durationSeconds === 'number' && { durationSeconds }),
+      }),
+    });
+  } catch (err) {
+    logger?.error?.('[transcribe] backend request failed', { error: err.message });
+    return { status: 502, body: { error: 'Transcription request failed: ' + err.message } };
+  }
+
+  if (response.status === 503) {
+    return { status: 503, body: { error: 'Voice transcription is not configured on the backend.' } };
+  }
+  if (!response.ok) {
+    let detail = '';
+    try { detail = await response.text(); } catch { /* ignore */ }
+    logger?.warn?.('[transcribe] backend non-OK', { status: response.status });
+    return { status: response.status, body: { error: `Transcription failed (${response.status})`, details: String(detail).slice(0, 300) } };
+  }
+
+  let data = {};
+  try { data = await response.json(); } catch { /* tolerate empty/non-JSON */ }
+  return { status: 200, body: { text: (data?.text || '').trim() } };
+}
+
+export default { proxyTranscribe };

package/src/interfaces/transcribeRoute.js

@@ -0,0 +1,45 @@
+/**
+ * Speech-to-text proxy route (POST /api/llm/transcribe).
+ *
+ * Extracted from webServer.setupRoutes so the API-key resolution ladder
+ * (Bearer header → apiKeyManager → config/env) and the status relay are
+ * unit-testable without standing up the full server. The heavy lifting —
+ * audio validation, backend dispatch, error mapping — lives in
+ * proxyTranscribe (already fully covered); this layer only resolves the key
+ * and forwards.
+ *
+ * apiKeyManager is read through a thunk (getApiKeyManager) because it is
+ * attached after routes are registered at boot.
+ */
+import { proxyTranscribe } from './transcribeProxy.js';
+
+/** Resolve the platform API key for a transcribe request (pure, testable). */
+export function resolveTranscribeApiKey({ authHeader, apiKeyManager, sessionId, config }) {
+  if (authHeader && authHeader.startsWith('Bearer ')) return authHeader.substring(7);
+  if (apiKeyManager) {
+    const keys = apiKeyManager.getKeysForRequest?.(sessionId || null, { platformProvided: true });
+    if (keys?.loxiaApiKey) return keys.loxiaApiKey;
+  }
+  return config?.loxiaApiKey || process.env.LOXIA_API_KEY || null;
+}
+
+export function registerTranscribeRoute(app, { getApiKeyManager, config, logger, proxyImpl = proxyTranscribe } = {}) {
+  if (!app) return;
+  app.post('/api/llm/transcribe', async (req, res) => {
+    const { audioBase64, mimeType, filename, durationSeconds, sessionId } = req.body || {};
+    const apiKeyManager = typeof getApiKeyManager === 'function' ? getApiKeyManager() : null;
+    const apiKey = resolveTranscribeApiKey({
+      authHeader: req.headers.authorization,
+      apiKeyManager, sessionId, config,
+    });
+
+    const result = await proxyImpl({
+      audioBase64, mimeType, filename, durationSeconds, apiKey,
+      backendBaseUrl: config?.backend?.baseUrl,
+      logger,
+    });
+    res.status(result.status).json(result.body);
+  });
+}
+
+export default registerTranscribeRoute;

package/src/interfaces/webServer.js

@@ -33,6 +33,13 @@ import composioService from '../services/composioService.js';
 import { getUserDataPaths } from '../utilities/userDataDir.js';
 import { projectActiveRuns } from '../utilities/flowRunFilters.js';
 import { recordOAuthResult, recordResolvedUser, projectAuthStatus, isAuthExpired } from '../utilities/authCache.js';
+import { registerTranscribeRoute } from './transcribeRoute.js';
+import { registerScheduleRoutes } from './scheduleRoutes.js';
+import { registerAttachmentRoutes } from './attachmentRoutes.js';
+import { AttachmentIngestionService } from '../services/attachments/attachmentIngestionService.js';
+import { DocumentStore } from '../services/documents/documentStore.js';
+import { DocumentMemory } from '../services/documents/documentMemory.js';
+import { DocumentIndexer } from '../services/embeddings/indexers/documentIndexer.js';
 import AuthCacheStore from '../services/authCacheStore.js';
 import { createAccountRouter } from './accountRoutes.js';
 import { createMarketplaceRouter } from './marketplaceRoutes.js';
@@ -1842,6 +1849,16 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       }
     });
 
+    // Speech-to-text proxy → remote /llm/transcribe (Azure AI Foundry STT).
+    // Powers web-ui dictation, especially in the Electron build where the
+    // browser's webkitSpeechRecognition has no working backend. Extracted to
+    // transcribeRoute.js so the key-resolution ladder is unit-testable.
+    registerTranscribeRoute(this.app, {
+      getApiKeyManager: () => this.apiKeyManager,
+      config: this.config,
+      logger: this.logger,
+    });
+
     // LLM Models endpoint - proxy to Loxia Azure backend
     this.app.get('/api/llm/models', async (req, res) => {
       try {
@@ -2938,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 {
@@ -6446,129 +6495,41 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
     // =====================================================
     // Scheduled Tasks API
     // =====================================================
-
-    // List all schedules
-    this.app.get('/api/schedules', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.json({ success: true, schedules: [] });
-        }
-        const schedules = this.scheduleService.listSchedules();
-        res.json({ success: true, schedules });
-      } catch (error) {
-        this.logger.error('Failed to list schedules', { error: error.message });
-        res.status(500).json({ success: false, error: error.message });
-      }
-    });
-
-    // Get cron presets
-    this.app.get('/api/schedules/presets', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.json({ success: true, presets: {} });
-        }
-        res.json({ success: true, presets: this.scheduleService.getPresets() });
-      } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
-      }
-    });
-
-    // Create a schedule
-    this.app.post('/api/schedules', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        const schedule = await this.scheduleService.createSchedule(req.body);
-        res.json({ success: true, schedule });
-      } catch (error) {
-        this.logger.error('Failed to create schedule', { error: error.message });
-        res.status(400).json({ success: false, error: error.message });
-      }
-    });
-
-    // Get a single schedule
-    this.app.get('/api/schedules/:id', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(404).json({ success: false, error: 'Schedule service not available' });
-        }
-        const schedule = this.scheduleService.getSchedule(req.params.id);
-        if (!schedule) {
-          return res.status(404).json({ success: false, error: 'Schedule not found' });
-        }
-        res.json({ success: true, schedule });
-      } catch (error) {
-        res.status(500).json({ success: false, error: error.message });
-      }
-    });
-
-    // Update a schedule
-    this.app.put('/api/schedules/:id', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        const schedule = await this.scheduleService.updateSchedule(req.params.id, req.body);
-        res.json({ success: true, schedule });
-      } catch (error) {
-        this.logger.error('Failed to update schedule', { error: error.message });
-        res.status(400).json({ success: false, error: error.message });
-      }
-    });
-
-    // Delete a schedule
-    this.app.delete('/api/schedules/:id', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        await this.scheduleService.deleteSchedule(req.params.id);
-        res.json({ success: true });
-      } catch (error) {
-        this.logger.error('Failed to delete schedule', { error: error.message });
-        res.status(400).json({ success: false, error: error.message });
-      }
-    });
-
-    // Force-trigger a schedule immediately (used by CLI trigger-schedule command)
-    this.app.post('/api/schedules/:id/trigger', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        const schedule = this.scheduleService.getSchedule(req.params.id);
-        if (!schedule) {
-          return res.status(404).json({ success: false, error: 'Schedule not found' });
-        }
-        // Execute immediately regardless of cron timing
-        await this.scheduleService._executeSchedule(schedule);
-        schedule.lastRun = new Date().toISOString();
-        schedule.runCount++;
-        schedule.updatedAt = new Date().toISOString();
-        await this.scheduleService._saveSchedules();
-        res.json({ success: true, scheduleName: schedule.name, lastRunStatus: schedule.lastRunStatus });
-      } catch (error) {
-        this.logger.error('Failed to trigger schedule', { error: error.message });
-        res.status(500).json({ success: false, error: error.message });
-      }
+    // Extracted to scheduleRoutes.js so the whole surface is unit-testable.
+    // scheduleService is passed via a thunk: the orchestrator attaches it
+    // after routes are registered at boot.
+    registerScheduleRoutes(this.app, {
+      getScheduleService: () => this.scheduleService,
+      logger: this.logger,
     });
 
-    // Toggle schedule enabled/disabled
-    this.app.post('/api/schedules/:id/toggle', async (req, res) => {
-      try {
-        if (!this.scheduleService) {
-          return res.status(400).json({ success: false, error: 'Schedule service not available' });
-        }
-        const current = this.scheduleService.getSchedule(req.params.id);
-        if (!current) {
-          return res.status(404).json({ success: false, error: 'Schedule not found' });
+    // =====================================================
+    // Chat attachment ingest (binary-safe). The ingestion service is built
+    // lazily from the orchestrator's FileAttachmentService (wired post-boot).
+    // =====================================================
+    registerAttachmentRoutes(this.app, {
+      getIngestionService: () => {
+        const fas = this.orchestrator?.fileAttachmentService;
+        if (!fas) return null;
+        if (!this._attachmentIngestion || this._attachmentIngestion.fileAttachmentService !== fas) {
+          // DocumentMemory lets large text/PDF attachments be indexed for
+          // semantic recall (shares the on-disk store with the agent scheduler's
+          // recall). Best-effort: if embeddings aren't configured the store
+          // still saves and the builder falls back to inline content.
+          let documentMemory = null;
+          try {
+            const embed = this.orchestrator?.aiService?.getEmbeddingService?.() || null;
+            documentMemory = new DocumentMemory({
+              store: new DocumentStore({ logger: this.logger }),
+              indexer: new DocumentIndexer({ embeddingService: embed, logger: this.logger }),
+              logger: this.logger,
+            });
+          } catch { documentMemory = null; }
+          this._attachmentIngestion = new AttachmentIngestionService({ fileAttachmentService: fas, documentMemory, logger: this.logger });
         }
-        const schedule = await this.scheduleService.updateSchedule(req.params.id, { enabled: !current.enabled });
-        res.json({ success: true, schedule });
-      } catch (error) {
-        res.status(400).json({ success: false, error: error.message });
-      }
+        return this._attachmentIngestion;
+      },
+      logger: this.logger,
     });
 
     // =====================================================

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__/aiService.editImage.test.js

@@ -0,0 +1,69 @@
+/**
+ * aiService.editImage — request payload assembly.
+ *
+ * Covers the single vs multi-reference image edit: imagesBase64[] is included
+ * only when more than one source is supplied; the first image is always sent
+ * positionally as imageBase64 (so an older backend degrades to a single-image
+ * edit). Also locks the endpoint + bearer + response mapping.
+ */
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import AIService from '../aiService.js';
+
+const logger = { info() {}, warn() {}, error() {}, debug() {} };
+function svc() {
+  return new AIService({ backend: { baseUrl: 'https://test.example' }, timeout: 1000 }, logger, null, null);
+}
+const bodyOf = (call) => JSON.parse(call[1].body);
+
+let fetchMock;
+beforeEach(() => {
+  fetchMock = jest.fn().mockResolvedValue({
+    ok: true,
+    status: 200,
+    statusText: 'OK',
+    json: async () => ({ images: [{ b64_json: 'edited' }], model: 'gpt-image-1.5' }),
+  });
+  global.fetch = fetchMock;
+});
+afterEach(() => { delete global.fetch; });
+
+describe('editImage payload', () => {
+  test('single source → imageBase64 set, no imagesBase64', async () => {
+    await svc().editImage('edit', 'AAA', { apiKey: 'k' });
+    const body = bodyOf(fetchMock.mock.calls[0]);
+    expect(body.imageBase64).toBe('AAA');
+    expect(body.imagesBase64).toBeUndefined();
+  });
+
+  test('multiple sources → imagesBase64 array forwarded, first also positional', async () => {
+    await svc().editImage('compose', 'AAA', { apiKey: 'k', imagesBase64: ['AAA', 'BBB', 'CCC'] });
+    const body = bodyOf(fetchMock.mock.calls[0]);
+    expect(body.imageBase64).toBe('AAA');
+    expect(body.imagesBase64).toEqual(['AAA', 'BBB', 'CCC']);
+  });
+
+  test('a single-element imagesBase64 is NOT forwarded (legacy single path)', async () => {
+    await svc().editImage('edit', 'AAA', { apiKey: 'k', imagesBase64: ['AAA'] });
+    expect(bodyOf(fetchMock.mock.calls[0]).imagesBase64).toBeUndefined();
+  });
+
+  test('forwards the mask when provided', async () => {
+    await svc().editImage('edit', 'AAA', { apiKey: 'k', maskBase64: 'MASK', imagesBase64: ['AAA', 'BBB'] });
+    const body = bodyOf(fetchMock.mock.calls[0]);
+    expect(body.maskBase64).toBe('MASK');
+    expect(body.imagesBase64).toHaveLength(2);
+  });
+
+  test('POSTs to /llm/edit-image with a bearer token and returns the b64_json', async () => {
+    const res = await svc().editImage('edit', 'AAA', { apiKey: 'k' });
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toContain('/llm/edit-image');
+    expect(init.method).toBe('POST');
+    expect(init.headers.Authorization).toBe('Bearer k');
+    expect(res.b64_json).toBe('edited');
+  });
+
+  test('rejects when no source image is supplied', async () => {
+    await expect(svc().editImage('edit', '', { apiKey: 'k' })).rejects.toThrow(/requires a source image/i);
+  });
+});