onbuzz 4.1.0 → 4.3.0

package/src/core/agentPool.js

@@ -161,6 +161,16 @@ class AgentPool {
       status: AGENT_STATUS.ACTIVE,
       capabilities: config.capabilities || [],
       directoryAccess: directoryAccess, // Directory access configuration
+      // Per-tool configuration — keyed by tool id (e.g., 'terminal',
+      // 'filesystem'). When a tool is instantiated for this agent, the
+      // object under toolConfig[toolId] is merged into the tool's
+      // constructor config. Previously tools were constructed from global
+      // defaults only, so there was no way to set per-agent knobs like
+      // terminal allowed-commands, filesystem size limits, web stealth
+      // level, etc. See ToolManager integration in step 2.
+      toolConfig: (config.toolConfig && typeof config.toolConfig === 'object' && !Array.isArray(config.toolConfig))
+        ? { ...config.toolConfig }
+        : {},
       conversations: {
         full: {
           messages: [],
@@ -304,6 +314,24 @@ class AgentPool {
       });
     }
 
+    // Validate per-tool config if being updated. Must be a plain object
+    // keyed by tool id; each value is an object of config overrides that
+    // will be merged into the tool's constructor config at instantiation.
+    // We don't validate individual tool schemas here — that happens at
+    // tool construction time where the tool knows its own shape.
+    if (updates.toolConfig !== undefined) {
+      if (updates.toolConfig === null
+          || typeof updates.toolConfig !== 'object'
+          || Array.isArray(updates.toolConfig)) {
+        throw new Error('Invalid toolConfig: must be a plain object keyed by tool id');
+      }
+      for (const [toolId, cfg] of Object.entries(updates.toolConfig)) {
+        if (cfg !== null && (typeof cfg !== 'object' || Array.isArray(cfg))) {
+          throw new Error(`Invalid toolConfig.${toolId}: must be an object or null`);
+        }
+      }
+    }
+
     // If originalSystemPrompt is being updated (user edited the raw prompt), store it
     // and use it as the base for enhancement. Otherwise use the existing originalSystemPrompt.
     if (updates.originalSystemPrompt !== undefined) {
@@ -592,6 +620,7 @@ class AgentPool {
       platformProvided: agent.platformProvided,
       capabilities: agent.capabilities,
       directoryAccess: agent.directoryAccess,
+      toolConfig: agent.toolConfig || {},
       lastActivity: agent.lastActivity,
       isPaused: this._isAgentPaused(agent),
       pausedUntil: agent.pausedUntil,
@@ -1297,6 +1326,69 @@ class AgentPool {
   // Now using the new messageQueues system with AgentScheduler
   // Inter-agent messages are queued via addInterAgentMessage() method
 
+  /**
+   * Wake an agent out of any paused/delayed state because a message has
+   * arrived for it. Shared by addUserMessage / addInterAgentMessage /
+   * addToolResult — every inbound path MUST route through this to avoid
+   * the "silent queue into a delayed agent" bug where the recipient never
+   * wakes up and the message sits until the scheduler back-off naturally
+   * expires.
+   *
+   * Rationale: delays/pauses are "leave this agent alone" signals set by
+   * the scheduler on error back-off or by the agentDelayTool for timed
+   * waits. Any caller going to the trouble of actually addressing the
+   * agent is an explicit "act now" signal that overrides the wait.
+   *
+   * @param {Object} agent - Agent object (already fetched)
+   * @param {string} reason - Source label for logs (e.g. 'user-message',
+   *   'inter-agent-message', 'tool-result')
+   * @returns {Promise<{wasPaused:boolean, hadDelay:boolean, hadPausedUntil:boolean}>}
+   * @private
+   */
+  async _wakeAgentForMessage(agent, reason) {
+    const info = { wasPaused: false, hadDelay: false, hadPausedUntil: false };
+    if (!agent) return info;
+
+    // Auto-resume explicitly paused agent.
+    if (agent.status === AGENT_STATUS.PAUSED) {
+      info.wasPaused = true;
+      this.logger.info(`Auto-resuming paused agent ${agent.id} due to ${reason}`);
+      await this.resumeAgent(agent.id);
+    }
+
+    // Clear scheduler-enforced delay (rate-limit back-off, api-key delay,
+    // builtin webTool delay, etc.). Only clear if actually in the future;
+    // stale past values don't matter but shouldn't trigger a broadcast.
+    if (agent.delayEndTime && new Date(agent.delayEndTime).getTime() > Date.now()) {
+      info.hadDelay = true;
+      agent.delayEndTime = null;
+      this.logger.info(`Cleared scheduler delay for agent ${agent.id} — ${reason} takes precedence`);
+    }
+
+    // Defensive: if pausedUntil is set but status isn't PAUSED (shouldn't
+    // happen but protects against state drift), clear it too.
+    if (agent.pausedUntil && new Date(agent.pausedUntil).getTime() > Date.now()) {
+      info.hadPausedUntil = true;
+      agent.pausedUntil = null;
+    }
+
+    return info;
+  }
+
+  /**
+   * Broadcast a delay-clear to the WS so the UI's delay chip disappears
+   * immediately instead of waiting for the next scheduler tick.
+   * @private
+   */
+  async _broadcastWake(agentId, reason) {
+    if (!this.scheduler?.broadcastAgentStateUpdate) return;
+    try {
+      await this.scheduler.broadcastAgentStateUpdate(agentId, reason);
+    } catch (err) {
+      this.logger.warn(`Failed to broadcast wake for ${agentId}: ${err.message}`);
+    }
+  }
+
   /**
    * Add message to agent's user message queue
    * @param {string} agentId - Agent ID
@@ -1309,25 +1401,10 @@ class AgentPool {
       throw new Error(`Agent not found: ${agentId}`);
     }
 
-    // Auto-resume paused agent when user sends a message
-    if (agent.status === AGENT_STATUS.PAUSED) {
-      this.logger.info(`Auto-resuming paused agent ${agentId} due to user message`);
-      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`);
-    }
+    // Any inbound message — user, inter-agent, or tool-result — takes
+    // precedence over scheduler back-off and manual pauses. See
+    // _wakeAgentForMessage for the rationale.
+    const wakeInfo = await this._wakeAgentForMessage(agent, 'user-message');
 
     const queuedMessage = {
       ...message,
@@ -1348,12 +1425,8 @@ class AgentPool {
 
     // 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}`);
-      }
+    if (wakeInfo.hadDelay) {
+      await this._broadcastWake(agentId, 'user-message-clears-delay');
     }
 
     this.logger.info(`User message queued for agent: ${agentId}`, {
@@ -1374,6 +1447,11 @@ class AgentPool {
       throw new Error(`Agent not found: ${agentId}`);
     }
 
+    // An inter-agent ping from another agent is an explicit "act now"
+    // signal and must override any scheduler back-off or manual pause
+    // on the recipient. See _wakeAgentForMessage.
+    const wakeInfo = await this._wakeAgentForMessage(agent, 'inter-agent-message');
+
     const queuedMessage = {
       ...message,
       id: message.id || message.messageId || `inter-agent-msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
@@ -1400,6 +1478,10 @@ class AgentPool {
       });
     }
 
+    if (wakeInfo.hadDelay) {
+      await this._broadcastWake(agentId, 'inter-agent-message-clears-delay');
+    }
+
     this.logger.info(`Inter-agent message queued for agent: ${agentId}`, {
       messageId: queuedMessage.id,
       sender: message.sender || message.senderName,
@@ -1420,6 +1502,13 @@ class AgentPool {
       throw new Error(`Agent not found: ${agentId}`);
     }
 
+    // Tool results are "external async work finished — continue."
+    // If the agent is delayed or paused when a result arrives (e.g. a
+    // long image/video render completes while an unrelated rate-limit
+    // back-off is still in effect) we wake it so the result can be
+    // consumed immediately instead of sitting until the back-off expires.
+    const wakeInfo = await this._wakeAgentForMessage(agent, 'tool-result');
+
     const queuedResult = {
       ...toolResult,
       id: toolResult.id || `tool-result-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
@@ -1430,6 +1519,10 @@ class AgentPool {
     agent.messageQueues.toolResults.push(queuedResult);
     await this.persistAgentState(agentId);
 
+    if (wakeInfo.hadDelay) {
+      await this._broadcastWake(agentId, 'tool-result-clears-delay');
+    }
+
     this.logger.debug(`Tool result queued for agent: ${agentId}`, {
       toolId: toolResult.toolId,
       status: toolResult.status,

package/src/core/agentScheduler.js

@@ -2185,8 +2185,11 @@ class AgentScheduler {
               this._broadcastFlowProgress(sessionId, agentId, flowProgress, true);
             }
 
-            // Broadcast stream completion
-            this._broadcastStreamEvent(sessionId, {
+            // Broadcast stream completion. Reasoning fields are included
+            // only when present so non-reasoning models' broadcasts stay
+            // minimal; the web-UI treats undefined/empty as "no thinking
+            // panel to render." See utilities/reasoningContext patterns.
+            const streamCompleteEvent = {
               type: 'stream_complete',
               agentId,
               messageId: streamMessageId,
@@ -2200,7 +2203,14 @@ class AgentScheduler {
                 flowRunId: flowContext.flowRunId,
                 flowNodeId: flowContext.flowNodeId
               })
-            });
+            };
+            if (typeof result.reasoning === 'string' && result.reasoning.length > 0) {
+              streamCompleteEvent.reasoning = result.reasoning;
+            }
+            if (Number.isFinite(result.reasoningTokens) && result.reasoningTokens > 0) {
+              streamCompleteEvent.reasoningTokens = result.reasoningTokens;
+            }
+            this._broadcastStreamEvent(sessionId, streamCompleteEvent);
           },
           onError: (error) => {
             // Check if this is a model-related error that should show suggestions
@@ -2864,7 +2874,15 @@ class AgentScheduler {
       });
     }
 
-    // Create response message
+    // Create response message. Reasoning fields are only attached when
+    // there's something to attach — avoids cluttering every assistant
+    // message with null fields for non-reasoning models.
+    //   - `reasoning`: chain-of-thought text, when the provider exposed it
+    //     (DeepSeek-R1, Kimi K2 thinking, xAI reasoning, Claude thinking).
+    //   - `reasoningTokens`: token count spent thinking, surfaced even
+    //     when the text is opaque (OpenAI o-series, gpt-5-reasoning).
+    // See src/services/aiService.js — `_extractReasoningTokens` + the
+    // streaming/non-streaming handlers for the capture contract.
     const responseMessage = {
       id: `ai-response-${Date.now()}`,
       agentId: agentId,
@@ -2877,6 +2895,12 @@ class AgentScheduler {
       // Mark if tools will be executed (UI can show loading indicator)
       pendingToolExecution: hasTools
     };
+    if (typeof aiResponse.reasoning === 'string' && aiResponse.reasoning.length > 0) {
+      responseMessage.reasoning = aiResponse.reasoning;
+    }
+    if (Number.isFinite(aiResponse.reasoningTokens) && aiResponse.reasoningTokens > 0) {
+      responseMessage.reasoningTokens = aiResponse.reasoningTokens;
+    }
 
     const appended = await this.addMessageToConversation(agentId, responseMessage, false);
 

package/src/core/messageProcessor.js

@@ -467,9 +467,22 @@ class MessageProcessor {
           // Pass truncation info to tool for partial execution handling.
           // Re-derive projectDir from directoryAccess in case a previous tool
           // (e.g. terminal change-directory) updated the working directory.
+          //
+          // toolConfig is this tool's slice of the agent's per-tool config
+          // (from agent.toolConfig[toolId]) — null when the agent didn't
+          // override anything for this tool, in which case the tool uses
+          // its global defaults. Tools that want to support per-agent
+          // config read `context.toolConfig` and merge it with their own
+          // defaults; tools that ignore it get the same behaviour as
+          // before.
+          const perToolConfig = (context.agentToolConfig && command.toolId)
+            ? context.agentToolConfig[command.toolId] || null
+            : null;
+
           const toolContext = {
             ...context,
             projectDir: context.directoryAccess?.workingDirectory || context.projectDir,
+            toolConfig: perToolConfig,
             wasRepaired: command.wasRepaired || false,
             wasTruncated: command.wasTruncated || false
           };
@@ -823,7 +836,7 @@ class MessageProcessor {
       
       // Get agent to include its directoryAccess configuration
       const agent = await this.agentPool.getAgent(agentId);
-      
+
       // Execute tools with agent context including sessionId and directoryAccess
       const toolContext = {
         ...context,
@@ -831,6 +844,11 @@ class MessageProcessor {
         sessionId: context.sessionId, // Ensure sessionId is explicitly available for tools
         directoryAccess: agent?.directoryAccess, // Include agent's directory access configuration
         projectDir: agent?.directoryAccess?.workingDirectory || agent?.projectDir || context.projectDir, // Extract project directory from directoryAccess
+        // Per-agent tool configuration — keyed by tool id. Tools can read
+        // their own slice via `context.toolConfig` (injected per-tool in
+        // executeTools below) or inspect the full map here if they need
+        // cross-tool state. See agentPool.js for the schema contract.
+        agentToolConfig: (agent && agent.toolConfig) ? agent.toolConfig : {},
         agentPool: this.agentPool,
         contextManager: this.contextManager,
         aiService: this.aiService,

package/src/core/orchestrator.js

@@ -135,12 +135,19 @@ class Orchestrator {
     if (!agent) {
       throw new Error(`Agent not found: ${agentId}`);
     }
-    
-    // Check if agent is paused
-    if (agent.status === AGENT_STATUS.PAUSED && agent.pausedUntil && new Date() < new Date(agent.pausedUntil)) {
-      throw new Error(`Agent ${agentId} is paused until ${agent.pausedUntil}`);
-    }
-    
+
+    // NOTE: We deliberately do NOT short-circuit on agent.status === PAUSED
+    // here. A user message is an explicit "act now" signal and must
+    // override any pause/delay state. agentPool.addUserMessage() calls
+    // _wakeAgentForMessage() which resumes paused agents, clears
+    // scheduler-enforced delayEndTime, and clears pausedUntil — so by
+    // the time the message lands in the queue the agent is back to
+    // active status. Rejecting here would silently drop user intent
+    // (the symptom was: "agent is paused" toast, no processing, the
+    // agent happily napping while the user waits). See
+    // src/core/__tests__/orchestratorUserMessageOverridesPause.test.js
+    // for the regression guard.
+
     // Process message through message processor (NEW ARCHITECTURE: just queues message)
     const result = await this.messageProcessor.processMessage(agentId, message, context);
     

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

@@ -0,0 +1,219 @@
+/**
+ * Integration-style tests for /api/images + /api/gallery/images/:filename
+ * (and DELETE /api/images). The routes now delegate to GalleryService,
+ * so these tests build a fresh GalleryService pointed at a tmp dir and
+ * exercise the routes end-to-end.
+ */
+
+import { jest, describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
+import express from 'express';
+import { createServer } from 'http';
+import path from 'path';
+import { promises as fs } from 'fs';
+import os from 'os';
+
+// Redirect userDataDir into a tmp dir so the gallery's writes don't
+// touch the developer's real user data.
+let tmpRoot;
+jest.unstable_mockModule('../../utilities/userDataDir.js', () => ({
+  getUserDataDir: () => tmpRoot,
+  getUserDataPaths: () => ({
+    base: tmpRoot,
+    state: path.join(tmpRoot, 'state'),
+    agents: path.join(tmpRoot, 'state', 'agents'),
+    settings: path.join(tmpRoot, 'settings'),
+    attachments: path.join(tmpRoot, 'attachments'),
+    logs: path.join(tmpRoot, 'logs'),
+    cache: path.join(tmpRoot, 'cache'),
+    operations: path.join(tmpRoot, 'state', 'operations'),
+    models: path.join(tmpRoot, 'state', 'models'),
+    runtime: path.join(tmpRoot, 'runtime'),
+    skills: path.join(tmpRoot, 'state', 'skills'),
+    gallery: path.join(tmpRoot, 'gallery'),
+    galleryImages: path.join(tmpRoot, 'gallery', 'images'),
+    galleryVideos: path.join(tmpRoot, 'gallery', 'videos'),
+  }),
+  ensureUserDataDirs: async () => {},
+}));
+
+const { _resetGalleryServiceForTests, getGalleryService } = await import('../../services/galleryService.js');
+const { getUserDataPaths } = await import('../../utilities/userDataDir.js');
+
+const HTTP_STATUS = { OK: 200, BAD_REQUEST: 400, NOT_FOUND: 404, INTERNAL_SERVER_ERROR: 500 };
+
+function buildApp() {
+  const app = express();
+
+  app.get('/api/images', async (req, res) => {
+    try {
+      const gallery = getGalleryService();
+      const entries = await gallery.listImages({ agentId: req.query.agentId || undefined });
+      const images = entries.map(e => ({
+        ...e, size: e.bytes,
+        url: `/api/gallery/images/${encodeURIComponent(e.filename)}`,
+      }));
+      res.json({ success: true, images });
+    } catch (error) {
+      res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ success: false, error: error.message });
+    }
+  });
+
+  app.delete('/api/images', async (req, res) => {
+    try {
+      const { filename } = req.query;
+      if (!filename) return res.status(HTTP_STATUS.BAD_REQUEST).json({ success: false, error: 'filename is required' });
+      const ok = await getGalleryService().deleteImage(filename);
+      if (!ok) return res.status(HTTP_STATUS.NOT_FOUND).json({ success: false, error: 'Image not found' });
+      res.json({ success: true });
+    } catch (error) {
+      if (error.code === 'INVALID_FILENAME') return res.status(HTTP_STATUS.BAD_REQUEST).json({ success: false, error: 'Invalid filename' });
+      if (error.code === 'INVALID_EXT') return res.status(HTTP_STATUS.BAD_REQUEST).json({ success: false, error: 'Unsupported file extension' });
+      res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ success: false, error: error.message });
+    }
+  });
+
+  app.get('/api/gallery/images/:filename', async (req, res) => {
+    const filename = req.params.filename;
+    const normalized = path.basename(filename);
+    if (normalized !== filename || filename.includes('..')) {
+      return res.status(HTTP_STATUS.BAD_REQUEST).json({ success: false, error: 'Invalid filename' });
+    }
+    const ext = path.extname(normalized).toLowerCase();
+    if (!['.png', '.jpg', '.jpeg', '.webp', '.gif'].includes(ext)) {
+      return res.status(HTTP_STATUS.BAD_REQUEST).json({ success: false, error: 'Unsupported extension' });
+    }
+    const target = path.join(getUserDataPaths().galleryImages, normalized);
+    res.sendFile(target, (err) => {
+      if (err && !res.headersSent) res.status(HTTP_STATUS.NOT_FOUND).json({ success: false, error: 'Image not found' });
+    });
+  });
+
+  return app;
+}
+
+async function http(url, options = {}) {
+  const resp = await globalThis.fetch(url, options);
+  const body = resp.headers.get('content-type')?.includes('json') ? await resp.json() : await resp.text();
+  return { status: resp.status, body, headers: resp.headers };
+}
+
+describe('gallery routes (GalleryService-backed)', () => {
+  let server, baseUrl;
+
+  async function saveImg(meta = {}, content = 'PNG-DATA') {
+    const srcDir = path.join(tmpRoot, 'src');
+    await fs.mkdir(srcDir, { recursive: true });
+    const src = path.join(srcDir, `${meta.name || 'img'}.png`);
+    await fs.writeFile(src, content);
+    return await getGalleryService().saveImage({ sourcePath: src, metadata: meta });
+  }
+
+  beforeAll(async () => {
+    tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'gallery-routes-'));
+    const app = buildApp();
+    server = createServer(app);
+    await new Promise(r => server.listen(0, r));
+    baseUrl = `http://localhost:${server.address().port}`;
+  });
+
+  afterAll(async () => {
+    server?.close();
+    await fs.rm(tmpRoot, { recursive: true, force: true }).catch(() => {});
+  });
+
+  beforeEach(async () => {
+    _resetGalleryServiceForTests();
+    // Clean gallery dir between tests.
+    const dir = path.join(tmpRoot, 'gallery', 'images');
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  // ── GET /api/images ─────────────────────────────────────────
+
+  it('returns empty list when gallery has no entries', async () => {
+    const { status, body } = await http(`${baseUrl}/api/images`);
+    expect(status).toBe(200);
+    expect(body).toEqual({ success: true, images: [] });
+  });
+
+  it('lists saved gallery entries with sidecar metadata', async () => {
+    await saveImg({ name: 'fox', prompt: 'a fox', model: 'dall-e-3', agentId: 'a', agentName: 'Alice' });
+    const { body } = await http(`${baseUrl}/api/images`);
+    expect(body.images).toHaveLength(1);
+    const img = body.images[0];
+    expect(img.prompt).toBe('a fox');
+    expect(img.model).toBe('dall-e-3');
+    expect(img.agentId).toBe('a');
+    expect(img.url).toMatch(/^\/api\/gallery\/images\/.*fox\.png$/);
+  });
+
+  it('filters by agentId', async () => {
+    await saveImg({ name: 'a', agentId: 'agent-A' });
+    await saveImg({ name: 'b', agentId: 'agent-B' });
+    const { body } = await http(`${baseUrl}/api/images?agentId=agent-B`);
+    expect(body.images).toHaveLength(1);
+    expect(body.images[0].agentId).toBe('agent-B');
+  });
+
+  // ── DELETE /api/images ──────────────────────────────────────
+
+  it('rejects missing filename param', async () => {
+    const { status } = await http(`${baseUrl}/api/images`, { method: 'DELETE' });
+    expect(status).toBe(400);
+  });
+
+  it('rejects path traversal', async () => {
+    const { status, body } = await http(
+      `${baseUrl}/api/images?filename=..%2Fetc%2Fpasswd`,
+      { method: 'DELETE' }
+    );
+    expect(status).toBe(400);
+    expect(body.error).toMatch(/Invalid filename/);
+  });
+
+  it('rejects non-image extension', async () => {
+    const { status, body } = await http(
+      `${baseUrl}/api/images?filename=secret.txt`,
+      { method: 'DELETE' }
+    );
+    expect(status).toBe(400);
+    expect(body.error).toMatch(/Unsupported/);
+  });
+
+  it('returns 404 when the gallery entry does not exist', async () => {
+    const { status } = await http(`${baseUrl}/api/images?filename=ghost.png`, { method: 'DELETE' });
+    expect(status).toBe(404);
+  });
+
+  it('deletes an existing gallery entry + its sidecar', async () => {
+    const saved = await saveImg({ prompt: 'deleting' });
+    const { status, body } = await http(
+      `${baseUrl}/api/images?filename=${encodeURIComponent(saved.filename)}`,
+      { method: 'DELETE' }
+    );
+    expect(status).toBe(200);
+    expect(body.success).toBe(true);
+    await expect(fs.access(saved.path)).rejects.toBeTruthy();
+    await expect(fs.access(`${saved.path}.json`)).rejects.toBeTruthy();
+  });
+
+  // ── GET /api/gallery/images/:filename ──────────────────────
+
+  it('serves a gallery image by filename', async () => {
+    const saved = await saveImg({ prompt: 'serve-me' }, 'PNG-BYTES');
+    const resp = await globalThis.fetch(`${baseUrl}/api/gallery/images/${encodeURIComponent(saved.filename)}`);
+    expect(resp.status).toBe(200);
+    const buf = await resp.text();
+    expect(buf).toBe('PNG-BYTES');
+  });
+
+  it('serve route rejects path traversal', async () => {
+    const { status } = await http(`${baseUrl}/api/gallery/images/..%2Fetc%2Fshadow.png`);
+    expect(status).toBe(400);
+  });
+
+  it('serve route returns 404 for unknown filename', async () => {
+    const { status } = await http(`${baseUrl}/api/gallery/images/does-not-exist.png`);
+    expect(status).toBe(404);
+  });
+});