npm - onbuzz - Versions diffs - 4.3.0 → 4.5.0 - Mend

onbuzz 4.3.0 → 4.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (989) hide show

package/src/interfaces/__tests__/schedulerRoutes.test.js ADDED Viewed

@@ -0,0 +1,176 @@
+/**
+ * HTTP route tests for the scheduler visualizer.
+ *
+ * Mounts a real Express app + the production registerSchedulerRoutes helper
+ * — same shape webServer.js uses — so this catches the class of bug we hit
+ * with the widget routes (handler reading from the wrong owner).
+ *
+ * Coverage:
+ *   GET /api/scheduler/state — 200 happy path, 503 when scheduler missing,
+ *                              503 when scheduler has no getState method,
+ *                              500 on getState throw, late-attach via thunk.
+ *   GET /scheduler           — 200 + html content-type + body equals supplied html.
+ */
+import { jest, describe, it, expect, beforeAll, afterAll } from '@jest/globals';
+import express from 'express';
+import { createServer } from 'http';
+import { registerSchedulerRoutes } from '../schedulerRoutes.js';
+async function http(url, options = {}) {
+  const resp = await globalThis.fetch(url, options);
+  const ct = resp.headers.get('content-type') || '';
+  const body = ct.includes('json') ? await resp.json() : await resp.text();
+  return { status: resp.status, body, headers: resp.headers };
+}
+function startApp(deps) {
+  const app = express();
+  registerSchedulerRoutes(app, deps);
+  const server = createServer(app);
+  return new Promise(resolve => {
+    server.listen(0, () => {
+      const port = server.address().port;
+      resolve({ server, baseUrl: `http://localhost:${port}` });
+    });
+  });
+}
+describe('GET /api/scheduler/state — happy path', () => {
+  let server, baseUrl;
+  const SNAPSHOT = {
+    serverTime: '2026-04-25T10:00:00.000Z',
+    scheduler: { running: true, iterationDelayMs: 1000, maxConcurrent: 3, currentlyInFlight: 0, cycleCount: 7, cycleHistoryMax: 200 },
+    locks: [],
+    cycles: [{ n: 7, outcome: 'idle', at: '2026-04-25T10:00:00.000Z' }],
+    agents: [{ id: 'a1', name: 'A', activity: { active: true, reason: 'has-pending-tasks' } }],
+  };
+  beforeAll(async () => {
+    const fakeScheduler = { getState: jest.fn().mockResolvedValue(SNAPSHOT) };
+    ({ server, baseUrl } = await startApp({
+      getScheduler: () => fakeScheduler,
+      logger: { error: jest.fn() },
+      html: '<html>viz</html>',
+    }));
+  });
+  afterAll(() => server?.close());
+  it('returns 200 with the full snapshot shape', async () => {
+    const r = await http(`${baseUrl}/api/scheduler/state`);
+    expect(r.status).toBe(200);
+    expect(r.body).toEqual(SNAPSHOT);
+  });
+});
+describe('GET /api/scheduler/state — 503 paths (scheduler not attached / wrong shape)', () => {
+  it('503 when getScheduler() returns null (boot ordering)', async () => {
+    const { server, baseUrl } = await startApp({
+      getScheduler: () => null,
+      logger: { error: jest.fn() },
+      html: '<x/>',
+    });
+    try {
+      const r = await http(`${baseUrl}/api/scheduler/state`);
+      expect(r.status).toBe(503);
+      expect(r.body).toMatchObject({ error: expect.stringMatching(/not attached/) });
+    } finally { server.close(); }
+  });
+  it('503 when getScheduler() returns an object missing getState (defensive)', async () => {
+    const { server, baseUrl } = await startApp({
+      getScheduler: () => ({ /* no getState */ }),
+      logger: { error: jest.fn() },
+      html: '<x/>',
+    });
+    try {
+      const r = await http(`${baseUrl}/api/scheduler/state`);
+      expect(r.status).toBe(503);
+    } finally { server.close(); }
+  });
+  it('503 when no getScheduler dep is supplied at all', async () => {
+    const { server, baseUrl } = await startApp({ logger: { error: jest.fn() }, html: '<x/>' });
+    try {
+      const r = await http(`${baseUrl}/api/scheduler/state`);
+      expect(r.status).toBe(503);
+    } finally { server.close(); }
+  });
+});
+describe('GET /api/scheduler/state — 500 path', () => {
+  it('returns 500 with the error message when getState throws', async () => {
+    const errorLog = jest.fn();
+    const fakeScheduler = { getState: jest.fn().mockRejectedValue(new Error('boom')) };
+    const { server, baseUrl } = await startApp({
+      getScheduler: () => fakeScheduler,
+      logger: { error: errorLog },
+      html: '<x/>',
+    });
+    try {
+      const r = await http(`${baseUrl}/api/scheduler/state`);
+      expect(r.status).toBe(500);
+      expect(r.body).toMatchObject({ error: 'boom' });
+      expect(errorLog).toHaveBeenCalledWith(
+        expect.stringMatching(/scheduler state/i),
+        expect.objectContaining({ error: 'boom' }),
+      );
+    } finally { server.close(); }
+  });
+});
+describe('thunk semantics: scheduler attached AFTER route registration', () => {
+  it('first call 503s, then 200 once getScheduler() starts returning the scheduler', async () => {
+    let scheduler = null;
+    const { server, baseUrl } = await startApp({
+      getScheduler: () => scheduler,
+      logger: { error: jest.fn() },
+      html: '<x/>',
+    });
+    try {
+      const r1 = await http(`${baseUrl}/api/scheduler/state`);
+      expect(r1.status).toBe(503);
+      // Late-attach: this is the production-relevant scenario — webServer
+      // mounts routes before orchestrator has wired the scheduler in.
+      scheduler = { getState: jest.fn().mockResolvedValue({ ok: true, agents: [], cycles: [], locks: [], scheduler: {}, serverTime: 'x' }) };
+      const r2 = await http(`${baseUrl}/api/scheduler/state`);
+      expect(r2.status).toBe(200);
+      expect(r2.body).toMatchObject({ ok: true });
+    } finally { server.close(); }
+  });
+});
+describe('GET /scheduler — HTML viewer page', () => {
+  it('200 + text/html + supplied html body', async () => {
+    const html = '<!doctype html><title>UNIQUE-MARKER</title>';
+    const { server, baseUrl } = await startApp({
+      getScheduler: () => ({ getState: async () => ({}) }),
+      logger: { error: jest.fn() },
+      html,
+    });
+    try {
+      const r = await http(`${baseUrl}/scheduler`);
+      expect(r.status).toBe(200);
+      expect(r.headers.get('content-type')).toMatch(/html/);
+      expect(r.body).toBe(html);
+      expect(r.body).toContain('UNIQUE-MARKER');
+    } finally { server.close(); }
+  });
+  it('falls back to a built-in stub html when none is supplied (defensive)', async () => {
+    const { server, baseUrl } = await startApp({ getScheduler: () => null });
+    try {
+      const r = await http(`${baseUrl}/scheduler`);
+      expect(r.status).toBe(200);
+      expect(r.headers.get('content-type')).toMatch(/html/);
+      expect(typeof r.body).toBe('string');
+      expect(r.body.length).toBeGreaterThan(0);
+    } finally { server.close(); }
+  });
+});
+describe('registerSchedulerRoutes — defensive guards', () => {
+  it('no-ops when app is null/undefined (does not throw)', () => {
+    expect(() => registerSchedulerRoutes(null, {})).not.toThrow();
+    expect(() => registerSchedulerRoutes(undefined, {})).not.toThrow();
+  });
+});

package/src/interfaces/agentContextRoutes.js ADDED Viewed

@@ -0,0 +1,257 @@
+/**
+ * Agent context + memory routes.
+ *
+ * Powers the "Memory" tab in the AgentEditModal. Three concerns:
+ *
+ *   1. Memory catalog CRUD — backed by MemoryService.
+ *      GET    /api/agents/:agentId/memories
+ *      POST   /api/agents/:agentId/memories
+ *      PUT    /api/agents/:agentId/memories/:memoryId
+ *      DELETE /api/agents/:agentId/memories/:memoryId
+ *
+ *   2. Live "what would be sent to the model on the next turn" snapshot —
+ *      the full system prompt (with all tool/capability injections), the
+ *      message array assembled by agentPool.getMessagesForAI, and the
+ *      pending message queues that haven't been folded in yet.
+ *      GET /api/agents/:agentId/context-snapshot
+ *
+ *   3. Future: any other "lives inside the context window" data
+ *      (compaction state, working dir, persisted skills, …) gets added
+ *      here as a single read-only window into agent state.
+ *
+ * Extracted as a module (not inline in webServer.js) so the routes are
+ * testable in isolation against a fake express + injected dependencies,
+ * mirroring the schedulerRoutes / widget routes pattern.
+ */
+/**
+ * @param {object} app                 express app
+ * @param {object} deps
+ * @param {() => object|null} deps.getAgentPool   resolve agentPool at request time
+ * @param {(logger?) => object} deps.getMemoryService  memory service factory
+ * @param {object} [deps.logger]
+ */
+export function registerAgentContextRoutes(app, deps = {}) {
+  if (!app) return;
+  const getAgentPool = typeof deps.getAgentPool === 'function' ? deps.getAgentPool : () => null;
+  const getMemoryService = typeof deps.getMemoryService === 'function' ? deps.getMemoryService : null;
+  const logger = deps.logger || { error: () => {}, warn: () => {} };
+  if (!getMemoryService) {
+    // Module is wired up but no memory service available — bail gracefully.
+    // Routes will return 503 below; we don't even register them.
+    return;
+  }
+  // ── Memory CRUD ─────────────────────────────────────────────────────
+  // GET /api/agents/:agentId/memories — full memory objects (content + metadata).
+  app.get('/api/agents/:agentId/memories', async (req, res) => {
+    try {
+      const { agentId } = req.params;
+      if (!agentId) return res.status(400).json({ success: false, error: 'agentId is required' });
+      const svc = getMemoryService(logger);
+      const memories = await svc.loadMemories(agentId);
+      res.json({ success: true, count: memories.length, memories });
+    } catch (err) {
+      logger.error('[agentContext] list memories failed', { error: err?.message });
+      res.status(500).json({ success: false, error: err?.message || 'unknown' });
+    }
+  });
+  // POST /api/agents/:agentId/memories — add memory.
+  // Body: { title (required), description?, content (required), expiration? }
+  app.post('/api/agents/:agentId/memories', async (req, res) => {
+    try {
+      const { agentId } = req.params;
+      const { title, description, content, expiration } = req.body || {};
+      if (!agentId) return res.status(400).json({ success: false, error: 'agentId is required' });
+      if (typeof title !== 'string' || !title.trim()) {
+        return res.status(400).json({ success: false, error: 'title (non-empty string) is required' });
+      }
+      if (typeof content !== 'string' || !content.trim()) {
+        return res.status(400).json({ success: false, error: 'content (non-empty string) is required' });
+      }
+      const svc = getMemoryService(logger);
+      const memory = await svc.addMemory(agentId, {
+        title: title.trim(),
+        description: typeof description === 'string' ? description.trim() : '',
+        content,
+        expiration,
+      });
+      res.json({ success: true, memory });
+    } catch (err) {
+      logger.error('[agentContext] add memory failed', { error: err?.message });
+      res.status(500).json({ success: false, error: err?.message || 'unknown' });
+    }
+  });
+  // PUT /api/agents/:agentId/memories/:memoryId — update memory.
+  // Body: any subset of { title, description, content, expiration }.
+  app.put('/api/agents/:agentId/memories/:memoryId', async (req, res) => {
+    try {
+      const { agentId, memoryId } = req.params;
+      if (!agentId || !memoryId) {
+        return res.status(400).json({ success: false, error: 'agentId and memoryId are required' });
+      }
+      const updates = req.body || {};
+      const svc = getMemoryService(logger);
+      const memory = await svc.updateMemory(agentId, memoryId, updates);
+      if (!memory) return res.status(404).json({ success: false, error: `Memory not found: ${memoryId}` });
+      res.json({ success: true, memory });
+    } catch (err) {
+      logger.error('[agentContext] update memory failed', { error: err?.message });
+      res.status(500).json({ success: false, error: err?.message || 'unknown' });
+    }
+  });
+  // DELETE /api/agents/:agentId/memories/:memoryId — delete memory.
+  app.delete('/api/agents/:agentId/memories/:memoryId', async (req, res) => {
+    try {
+      const { agentId, memoryId } = req.params;
+      if (!agentId || !memoryId) {
+        return res.status(400).json({ success: false, error: 'agentId and memoryId are required' });
+      }
+      const svc = getMemoryService(logger);
+      const ok = await svc.deleteMemory(agentId, memoryId);
+      if (!ok) return res.status(404).json({ success: false, error: `Memory not found: ${memoryId}` });
+      res.json({ success: true });
+    } catch (err) {
+      logger.error('[agentContext] delete memory failed', { error: err?.message });
+      res.status(500).json({ success: false, error: err?.message || 'unknown' });
+    }
+  });
+  // ── Context snapshot ────────────────────────────────────────────────
+  // GET /api/agents/:agentId/context-snapshot — atomic read-only view of
+  // everything "live in the context window" for this agent right now:
+  //   - systemPrompt.original = user-authored prompt
+  //   - systemPrompt.full     = enhanced prompt with all tool injections
+  //   - messages              = exactly what getMessagesForAI returns
+  //                             (i.e. what would be sent on the next turn)
+  //   - pendingQueues         = msg queues not yet folded into the
+  //                             conversation history
+  //   - stats                 = sizes, counts, model id
+  app.get('/api/agents/:agentId/context-snapshot', async (req, res) => {
+    try {
+      const { agentId } = req.params;
+      if (!agentId) return res.status(400).json({ success: false, error: 'agentId is required' });
+      const agentPool = getAgentPool();
+      if (!agentPool || typeof agentPool.getAgent !== 'function') {
+        return res.status(503).json({ success: false, error: 'agent pool not available' });
+      }
+      const agent = await agentPool.getAgent(agentId);
+      if (!agent) return res.status(404).json({ success: false, error: `Agent not found: ${agentId}` });
+      // System prompt — both forms. `systemPrompt` is the enhanced one
+      // (with tool descriptions injected); `originalSystemPrompt` is the
+      // user-authored version. Showing both lets the user understand
+      // exactly what the model sees vs what they typed.
+      const original = agent.originalSystemPrompt || agent.systemPrompt || '';
+      const full     = agent.systemPrompt || original;
+      // Messages prepared for the next turn. getMessagesForAI is the
+      // exact function the scheduler calls right before sending; this
+      // is the source of truth for "what would the model see now?".
+      const modelId = agent.currentModel || agent.preferredModel;
+      let messages = [];
+      let messagesError = null;
+      if (modelId && typeof agentPool.getMessagesForAI === 'function') {
+        try {
+          messages = await agentPool.getMessagesForAI(agentId, modelId);
+        } catch (e) {
+          // Don't fail the whole snapshot — surface the error inline so
+          // the user can see "messages couldn't be assembled" without
+          // losing the system-prompt + queue views.
+          messagesError = e?.message || String(e);
+        }
+      }
+      // Per-message lightweight projection — strip enormous tool output
+      // bodies so the snapshot is bounded. Caller can re-query with a
+      // "give me message X in full" path if/when we add it.
+      const MAX_PREVIEW = 4000;
+      const projection = (Array.isArray(messages) ? messages : []).map((m, i) => {
+        const content = typeof m.content === 'string' ? m.content : safeStringify(m.content);
+        const truncated = content.length > MAX_PREVIEW;
+        return {
+          index: i,
+          role: m.role,
+          name: m.name || null,
+          contentPreview: truncated ? content.slice(0, MAX_PREVIEW) : content,
+          contentLength: content.length,
+          truncated,
+          timestamp: m.timestamp || null,
+          hasToolCalls: !!(m.toolCalls || m.tool_calls),
+          toolCallId: m.toolCallId || m.tool_call_id || null,
+        };
+      });
+      // Pending queues — what's waiting to be folded in but isn't yet.
+      const queues = agent.messageQueues || {};
+      const queueProjection = (arr, kind) => (Array.isArray(arr) ? arr : []).map((m, i) => ({
+        index: i,
+        kind,
+        contentPreview: safePreview(m?.content ?? m?.message ?? m?.text ?? '', 200),
+        timestamp: m?.timestamp || null,
+      }));
+      const totalSystemPromptLen = full.length;
+      const totalMessageLen = projection.reduce((acc, m) => acc + (m.contentLength || 0), 0);
+      // Rough token estimate (≈ 4 chars / token). Cheap and good enough
+      // for the UI bar; the model-side accounting still uses real tokenizers.
+      const estimatedTokens = Math.ceil((totalSystemPromptLen + totalMessageLen) / 4);
+      res.json({
+        success: true,
+        agent: {
+          id: agent.id,
+          name: agent.name,
+          mode: agent.mode,
+          status: agent.status,
+          currentModel: agent.currentModel || null,
+          preferredModel: agent.preferredModel || null,
+        },
+        systemPrompt: {
+          original,
+          full,
+          enhancementBytes: Math.max(0, full.length - original.length),
+          originalLength: original.length,
+          fullLength: full.length,
+        },
+        messages: projection,
+        messagesError,
+        pendingQueues: {
+          userMessages:       queueProjection(queues.userMessages,       'user'),
+          interAgentMessages: queueProjection(queues.interAgentMessages, 'inter-agent'),
+          toolResults:        queueProjection(queues.toolResults,        'tool-result'),
+        },
+        stats: {
+          messageCount: projection.length,
+          totalMessageBytes: totalMessageLen,
+          estimatedTokens,
+          generatedAt: new Date().toISOString(),
+        },
+      });
+    } catch (err) {
+      logger.error('[agentContext] snapshot failed', { error: err?.message });
+      res.status(500).json({ success: false, error: err?.message || 'unknown' });
+    }
+  });
+}
+function safeStringify(v) {
+  if (v == null) return '';
+  try { return typeof v === 'string' ? v : JSON.stringify(v); }
+  catch { return String(v); }
+}
+function safePreview(v, max) {
+  const s = safeStringify(v);
+  return s.length > max ? s.slice(0, max) : s;
+}
+export default { registerAgentContextRoutes };

package/src/interfaces/schedulerRoutes.js ADDED Viewed

@@ -0,0 +1,50 @@
+/**
+ * Scheduler visualizer routes — extracted from webServer.js so they're
+ * testable against the real production wiring (the lesson from the widget
+ * routes 503 incident: tests that don't match production shape don't catch
+ * production bugs).
+ *
+ * Two routes:
+ *   GET /api/scheduler/state   — JSON snapshot from scheduler.getState()
+ *   GET /scheduler             — self-contained HTML viewer page
+ *
+ * Registration:
+ *   registerSchedulerRoutes(app, {
+ *     getScheduler: () => orchestrator?.agentPool?.scheduler,
+ *     logger,
+ *     html: SCHEDULER_VIEWER_HTML,
+ *   });
+ *
+ * `getScheduler` is a thunk (not the scheduler itself) so the routes resolve
+ * the scheduler at request-time — handles the case where the scheduler is
+ * attached after the routes are registered (orchestrator startup ordering).
+ */
+export function registerSchedulerRoutes(app, deps = {}) {
+  if (!app) return;
+  const getScheduler = typeof deps.getScheduler === 'function' ? deps.getScheduler : () => null;
+  const logger = deps.logger || { error: () => {} };
+  const html = typeof deps.html === 'string' ? deps.html : '<!doctype html><title>scheduler</title>';
+  // JSON snapshot of scheduler + all agents — polled by /scheduler at 1 Hz.
+  app.get('/api/scheduler/state', async (req, res) => {
+    try {
+      const sched = getScheduler();
+      if (!sched || typeof sched.getState !== 'function') {
+        return res.status(503).json({ error: 'scheduler is not attached' });
+      }
+      const state = await sched.getState();
+      res.json(state);
+    } catch (err) {
+      try { logger.error('Failed to build scheduler state', { error: err?.message }); } catch (_) {}
+      res.status(500).json({ error: err?.message || 'unknown' });
+    }
+  });
+  // Self-contained HTML viewer page (no external assets).
+  app.get('/scheduler', (req, res) => {
+    res.type('html').send(html);
+  });
+}
+export default { registerSchedulerRoutes };

package/src/interfaces/webServer.js CHANGED Viewed

@@ -44,6 +44,12 @@ import { initFileExplorerModule } from '../modules/fileExplorer/index.js';
 // Import FlowExecutor for flow pipeline execution
 import FlowExecutor from '../core/flowExecutor.js';
+// Scheduler visualizer routes (extracted for testability)
+import { registerSchedulerRoutes } from './schedulerRoutes.js';
+// Agent memory + context-snapshot routes — power the Memory tab in AgentEditModal.
+import { registerAgentContextRoutes } from './agentContextRoutes.js';
+import { getMemoryService } from '../services/memoryService.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -432,7 +438,7 @@ class WebServer {
   async initialize() {
     try {
       this.setupMiddleware();
-      this.setupRoutes();
+      await this.setupRoutes();
       this.setupWebSocket();
       await this.startServer();
@@ -661,7 +667,61 @@ class WebServer {
    * Setup API routes
    * @private
    */
-  setupRoutes() {
+  async setupRoutes() {
+    // widget-module: remove this block if the module is deleted.
+    // Mounts the widget runtime asset + audit routes under /api/widget/*.
+    // AWAITED BEFORE other routes: Express matches routes in registration
+    // order, and the SPA catch-all registered later in this file matches
+    // EVERY GET request — if widget routes aren't in place first, the
+    // fallback returns index.html for /api/widget/runtime.js and the
+    // iframe tries to parse HTML as JS ("Unexpected token '<'").
+    try {
+      const mod = await import('../modules/widget/index.js');
+      if (!mod.isDisabled()) {
+        // The orchestrator does NOT carry toolsRegistry in production —
+        // it lives on `this` (the WebServer). Other route handlers in
+        // this file work around it with a `this.toolsRegistry || ...
+        // orchestrator?.toolsRegistry` fallback. Pass both explicitly
+        // so the widget module's routes resolve the tool reliably.
+        mod.registerRoutes(this.app, this.orchestrator, {
+          toolsRegistry: this.toolsRegistry,
+        });
+        this.logger.info('Widget module routes registered');
+        // Bridge the WidgetTool's event bus to a `widget_changed` WebSocket
+        // push. The artifacts panel listens for these so its summary cache
+        // stays current — independent of whether the chat feed has the
+        // tool-result message mounted (the feed is lazily virtualized; old
+        // entries unload as the user scrolls and would otherwise be missed).
+        try {
+          const widgetTool =
+            this.toolsRegistry?.getTool?.('widget') ||
+            this.orchestrator?.toolsRegistry?.getTool?.('widget');
+          if (widgetTool?.events?.on) {
+            widgetTool.events.on('widget-changed', (evt) => {
+              try {
+                // sessionId=null → broadcastToSession falls back to all
+                // connections. The frontend filters on currentAgent.
+                this.broadcastToSession(null, {
+                  type: 'widget_changed',
+                  data: evt,
+                });
+              } catch (err) {
+                this.logger.warn('Failed to broadcast widget_changed', { error: err.message });
+              }
+            });
+            this.logger.info('Widget event bus bridged to WebSocket');
+          } else {
+            this.logger.warn('Widget tool has no events bus — push updates disabled');
+          }
+        } catch (err) {
+          this.logger.warn('Widget event bus subscribe failed', { error: err.message });
+        }
+      }
+    } catch (err) {
+      this.logger.warn('Widget module not available', { error: err.message });
+    }
     // Health check
     this.app.get('/api/health', async (req, res) => {
       try {
@@ -3428,24 +3488,21 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
     // Scheduler Visualizer — JSON state endpoint + HTML viewer
     // ============================================
-    // JSON snapshot of scheduler + all agents — polled by /scheduler at 1 Hz.
-    this.app.get('/api/scheduler/state', async (req, res) => {
-      try {
-        const sched = this.orchestrator?.agentPool?.scheduler;
-        if (!sched?.getState) {
-          return res.status(503).json({ error: 'scheduler is not attached' });
-        }
-        const state = await sched.getState();
-        res.json(state);
-      } catch (err) {
-        this.logger.error('Failed to build scheduler state', { error: err.message });
-        res.status(500).json({ error: err.message });
-      }
-    });
-    // Self-contained HTML viewer. See SCHEDULER_VIEWER_HTML below.
-    this.app.get('/scheduler', (req, res) => {
-      res.type('html').send(SCHEDULER_VIEWER_HTML);
+    // Mount scheduler visualizer routes via the extracted helper. The thunk
+    // form for getScheduler ensures we resolve the scheduler at request time
+    // (it may be attached after route registration during orchestrator boot).
+    registerSchedulerRoutes(this.app, {
+      getScheduler: () => this.orchestrator?.agentPool?.scheduler,
+      logger: this.logger,
+      html: SCHEDULER_VIEWER_HTML,
+    });
+    // Agent context + memory routes (Memory tab in AgentEditModal).
+    // Same thunk pattern: agentPool may be attached after route registration.
+    registerAgentContextRoutes(this.app, {
+      getAgentPool: () => this.orchestrator?.agentPool,
+      getMemoryService,
+      logger: this.logger,
     });
     // ============================================