onbuzz 4.4.0 → 4.5.0

package/package.json

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

package/src/core/agentPool.js

@@ -203,6 +203,10 @@ class AgentPool {
       createdAt: now,
       lastActivity: now,
       pausedUntil: null,
+      // Used by platformControlTool for ancestry checks. null = created
+      // via the UI / no parent agent. Set to <agentId> when an agent
+      // creates another via the platformcontrol tool.
+      createdBy: typeof config.createdBy === 'string' ? config.createdBy : null,
       metadata: config.metadata || {},
       
       // CRITICAL: Store sessionId for API key resolution

package/src/core/agentScheduler.js

@@ -1940,6 +1940,15 @@ class AgentScheduler {
         enhancedSystemPrompt = (enhancedSystemPrompt || '') + systemConstraints;
       }
 
+      // Inject current local time. Re-evaluated every turn so the agent
+      // always sees the wall-clock time the model is answering at — useful
+      // for time-sensitive reasoning (cron expressions, "schedule for
+      // tomorrow morning", "is it past business hours?", etc.).
+      const timeContext = this.contextInjectionService.buildCurrentTimeContext();
+      if (timeContext) {
+        enhancedSystemPrompt = (enhancedSystemPrompt || '') + timeContext;
+      }
+
       // Inject external-channel routing guidance ONLY when the agent has
       // at least one live bridge. Pulls the per-channel alias list from
       // each service so the agent can address specific channels/threads

package/src/core/stateManager.js

@@ -388,6 +388,11 @@ class StateManager {
       description: teamData.description || '',
       memberAgentIds: [],
       color: teamData.color || '#3B82F6', // Default blue
+      // Used by platformControlTool's `ownedByMe` team scope. null when
+      // the team was created via the UI / by no specific agent. When an
+      // agent creates a team via the platformcontrol tool, this carries
+      // the caller's id so ownership scope filtering works.
+      createdBy: typeof teamData.createdBy === 'string' ? teamData.createdBy : null,
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString()
     };

package/src/index.js

@@ -56,6 +56,7 @@ import VisionTool from './tools/visionTool.js';
 import UserPromptTool from './tools/userPromptTool.js';
 import CodeMapTool from './tools/codeMapTool.js';
 import WhatsAppTool from './tools/whatsappTool.js';
+import PlatformControlTool from './tools/platformControlTool.js';
 import ScheduleService from './services/scheduleService.js';
 import AsyncToolManager from './tools/asyncToolManager.js';
 import WebServer from './interfaces/webServer.js';
@@ -485,6 +486,10 @@ class LoxiaApplication {
     // Register WhatsApp Tool
     await this.toolsRegistry.registerTool(WhatsAppTool);
 
+    // Register Platform Control Tool — agent-facing platform control
+    // (currently: scheduled tasks; per-agent permission, default DISABLED).
+    await this.toolsRegistry.registerTool(PlatformControlTool);
+
     // widget-module: remove this block if the module is deleted.
     // Registers the WidgetTool for agent-facing custom-UI rendering.
     // Honors LOXIA_DISABLE_WIDGETS=1 env flag for a zero-source kill switch.
@@ -505,6 +510,27 @@ class LoxiaApplication {
     if (agentDelayTool && typeof agentDelayTool.setAgentPool === 'function') {
       agentDelayTool.setAgentPool(this.agentPool);
     }
+
+    // Wire ScheduleService into PlatformControlTool. Without this, the
+    // tool reports "ScheduleService is not available" for any feature
+    // action — useful as a defensive default but not what we want here.
+    const platformControlTool = this.toolsRegistry.getTool('platformcontrol');
+    if (platformControlTool) {
+      if (typeof platformControlTool.setScheduleService === 'function') {
+        platformControlTool.setScheduleService(this.scheduleService);
+      }
+      // Agent + team CRUD requires AgentPool, StateManager, MemoryService.
+      if (typeof platformControlTool.setAgentPool === 'function') {
+        platformControlTool.setAgentPool(this.agentPool);
+      }
+      if (typeof platformControlTool.setStateManager === 'function') {
+        platformControlTool.setStateManager(this.stateManager);
+      }
+      if (typeof platformControlTool.setMemoryService === 'function') {
+        const { getMemoryService } = await import('./services/memoryService.js');
+        platformControlTool.setMemoryService(getMemoryService(this.logger));
+      }
+    }
     
     // Set AgentPool dependency for JobDoneTool
     const jobDoneTool = this.toolsRegistry.getTool('jobdone');

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

@@ -0,0 +1,272 @@
+/**
+ * HTTP route tests for the agent memory + context-snapshot routes.
+ *
+ * Mounts a real express app + the production registerAgentContextRoutes
+ * helper with stubbed memory service / agent pool, hits each endpoint via
+ * fetch, asserts the JSON shape. Same approach as schedulerRoutes.test.js.
+ */
+import { jest, describe, it, expect, beforeAll, afterAll } from '@jest/globals';
+import express from 'express';
+import { createServer } from 'http';
+import { registerAgentContextRoutes } from '../agentContextRoutes.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 };
+}
+
+function makeMemoryService() {
+  const mems = new Map();   // agentId → memories[]
+  return {
+    loadMemories: jest.fn(async (agentId) => mems.get(agentId) || []),
+    addMemory:    jest.fn(async (agentId, data) => {
+      const mem = { id: 'm-' + Date.now() + '-' + Math.random().toString(36).slice(2, 6), ...data, createdAt: new Date().toISOString() };
+      const list = mems.get(agentId) || [];
+      list.push(mem);
+      mems.set(agentId, list);
+      return mem;
+    }),
+    updateMemory: jest.fn(async (agentId, memId, updates) => {
+      const list = mems.get(agentId) || [];
+      const i = list.findIndex(m => m.id === memId);
+      if (i === -1) return null;
+      list[i] = { ...list[i], ...updates, updatedAt: new Date().toISOString() };
+      return list[i];
+    }),
+    deleteMemory: jest.fn(async (agentId, memId) => {
+      const list = mems.get(agentId) || [];
+      const i = list.findIndex(m => m.id === memId);
+      if (i === -1) return false;
+      list.splice(i, 1);
+      return true;
+    }),
+    _store: mems,
+  };
+}
+
+function startApp({ memoryService, agentPool }) {
+  const app = express();
+  app.use(express.json());
+  registerAgentContextRoutes(app, {
+    getAgentPool: () => agentPool,
+    getMemoryService: () => memoryService,
+    logger: { error: jest.fn(), warn: jest.fn() },
+  });
+  const server = createServer(app);
+  return new Promise(resolve => {
+    server.listen(0, () => {
+      const port = server.address().port;
+      resolve({ server, baseUrl: `http://localhost:${port}` });
+    });
+  });
+}
+
+describe('memory CRUD', () => {
+  let server, baseUrl, mem;
+  beforeAll(async () => {
+    mem = makeMemoryService();
+    ({ server, baseUrl } = await startApp({ memoryService: mem, agentPool: null }));
+  });
+  afterAll(() => server?.close());
+
+  it('GET memories returns empty list initially', async () => {
+    const r = await http(`${baseUrl}/api/agents/agent-x/memories`);
+    expect(r.status).toBe(200);
+    expect(r.body).toEqual({ success: true, count: 0, memories: [] });
+  });
+
+  it('POST adds a memory and returns it', async () => {
+    const r = await http(`${baseUrl}/api/agents/agent-x/memories`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: 'A note', content: 'remember this' }),
+    });
+    expect(r.status).toBe(200);
+    expect(r.body.memory).toMatchObject({ title: 'A note', content: 'remember this' });
+    expect(r.body.memory.id).toMatch(/^m-/);
+  });
+
+  it('POST trims title/description; rejects empty title', async () => {
+    const r1 = await http(`${baseUrl}/api/agents/agent-x/memories`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: '   ', content: 'x' }),
+    });
+    expect(r1.status).toBe(400);
+    const r2 = await http(`${baseUrl}/api/agents/agent-x/memories`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: '  Trimmed  ', description: '  desc  ', content: 'c' }),
+    });
+    expect(r2.status).toBe(200);
+    expect(r2.body.memory.title).toBe('Trimmed');
+    expect(r2.body.memory.description).toBe('desc');
+  });
+
+  it('POST rejects when content is missing', async () => {
+    const r = await http(`${baseUrl}/api/agents/agent-x/memories`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: 'no content' }),
+    });
+    expect(r.status).toBe(400);
+    expect(r.body.error).toMatch(/content/);
+  });
+
+  it('PUT updates an existing memory', async () => {
+    const created = await http(`${baseUrl}/api/agents/agent-x/memories`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: 'orig', content: 'c' }),
+    });
+    const id = created.body.memory.id;
+    const r = await http(`${baseUrl}/api/agents/agent-x/memories/${id}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: 'updated' }),
+    });
+    expect(r.status).toBe(200);
+    expect(r.body.memory.title).toBe('updated');
+  });
+
+  it('PUT 404s on unknown memoryId', async () => {
+    const r = await http(`${baseUrl}/api/agents/agent-x/memories/nope`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: 'x' }),
+    });
+    expect(r.status).toBe(404);
+  });
+
+  it('DELETE removes a memory', async () => {
+    const created = await http(`${baseUrl}/api/agents/agent-x/memories`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: 'goner', content: 'bye' }),
+    });
+    const id = created.body.memory.id;
+    const r = await http(`${baseUrl}/api/agents/agent-x/memories/${id}`, { method: 'DELETE' });
+    expect(r.status).toBe(200);
+    expect(r.body.success).toBe(true);
+    // PUT after delete → 404
+    const after = await http(`${baseUrl}/api/agents/agent-x/memories/${id}`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: 'x' }),
+    });
+    expect(after.status).toBe(404);
+  });
+
+  it('DELETE 404s on unknown memoryId', async () => {
+    const r = await http(`${baseUrl}/api/agents/agent-x/memories/nope`, { method: 'DELETE' });
+    expect(r.status).toBe(404);
+  });
+});
+
+describe('context snapshot', () => {
+  let server, baseUrl;
+  const messages = [
+    { role: 'system', content: 'system…' },
+    { role: 'user', content: 'hello' },
+    { role: 'assistant', content: 'hi there' },
+  ];
+  const agent = {
+    id: 'agent-x', name: 'Test', mode: 'AGENT', status: 'ACTIVE',
+    currentModel: 'gpt-x',
+    preferredModel: 'gpt-x',
+    originalSystemPrompt: 'You are helpful.',
+    systemPrompt: 'You are helpful.\n\n[Tools: ...]',
+    messageQueues: {
+      userMessages: [{ content: 'pending user msg', timestamp: '2026-04-26T00:00:00Z' }],
+      interAgentMessages: [],
+      toolResults: [{ content: 'tool result body' }],
+    },
+  };
+  const agentPool = {
+    getAgent: jest.fn(async (id) => id === 'agent-x' ? agent : null),
+    getMessagesForAI: jest.fn(async () => messages),
+  };
+
+  beforeAll(async () => {
+    ({ server, baseUrl } = await startApp({
+      memoryService: makeMemoryService(),
+      agentPool,
+    }));
+  });
+  afterAll(() => server?.close());
+
+  it('returns the full snapshot shape', async () => {
+    const r = await http(`${baseUrl}/api/agents/agent-x/context-snapshot`);
+    expect(r.status).toBe(200);
+    expect(r.body).toMatchObject({
+      success: true,
+      agent: { id: 'agent-x', name: 'Test', currentModel: 'gpt-x' },
+      systemPrompt: {
+        original: 'You are helpful.',
+        full: 'You are helpful.\n\n[Tools: ...]',
+        originalLength: 16,
+        fullLength: 30,
+        enhancementBytes: 14,
+      },
+      pendingQueues: {
+        userMessages: [expect.objectContaining({ contentPreview: 'pending user msg' })],
+        interAgentMessages: [],
+        toolResults: [expect.objectContaining({ contentPreview: 'tool result body' })],
+      },
+    });
+    expect(r.body.messages).toHaveLength(3);
+    expect(r.body.messages[0]).toMatchObject({ index: 0, role: 'system' });
+    expect(r.body.stats.messageCount).toBe(3);
+    expect(r.body.stats.estimatedTokens).toBeGreaterThan(0);
+  });
+
+  it('truncates very long message content (with `truncated:true`)', async () => {
+    const huge = 'x'.repeat(10_000);
+    agentPool.getMessagesForAI.mockResolvedValueOnce([{ role: 'user', content: huge }]);
+    const r = await http(`${baseUrl}/api/agents/agent-x/context-snapshot`);
+    expect(r.body.messages[0].truncated).toBe(true);
+    expect(r.body.messages[0].contentPreview.length).toBeLessThan(huge.length);
+    expect(r.body.messages[0].contentLength).toBe(huge.length);
+  });
+
+  it('returns 404 for unknown agent', async () => {
+    const r = await http(`${baseUrl}/api/agents/missing/context-snapshot`);
+    expect(r.status).toBe(404);
+  });
+
+  it('surfaces messagesError when getMessagesForAI throws (rather than 500ing)', async () => {
+    agentPool.getMessagesForAI.mockRejectedValueOnce(new Error('boom'));
+    const r = await http(`${baseUrl}/api/agents/agent-x/context-snapshot`);
+    expect(r.status).toBe(200);          // snapshot still returns
+    expect(r.body.messages).toEqual([]);
+    expect(r.body.messagesError).toMatch(/boom/);
+    // System prompt + queues still surface for UI use
+    expect(r.body.systemPrompt.full).toBeTruthy();
+  });
+});
+
+describe('defensive', () => {
+  it('agentPool unavailable → 503 on context-snapshot, but memory routes still work', async () => {
+    const mem = makeMemoryService();
+    const { server, baseUrl } = await startApp({ memoryService: mem, agentPool: null });
+    try {
+      const ctx = await http(`${baseUrl}/api/agents/agent-x/context-snapshot`);
+      expect(ctx.status).toBe(503);
+      const list = await http(`${baseUrl}/api/agents/agent-x/memories`);
+      expect(list.status).toBe(200);
+    } finally { server.close(); }
+  });
+
+  it('registerAgentContextRoutes(null) is a no-op', () => {
+    expect(() => registerAgentContextRoutes(null, {})).not.toThrow();
+  });
+
+  it('registerAgentContextRoutes without getMemoryService skips registration', () => {
+    const app = express();
+    expect(() => registerAgentContextRoutes(app, { getAgentPool: () => null })).not.toThrow();
+    // No routes added — sanity check by hitting one (will 404 since unmounted).
+    // We don't need a server; the express stack just won't have these handlers.
+  });
+});

package/src/interfaces/agentContextRoutes.js

@@ -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/webServer.js

@@ -46,6 +46,9 @@ 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);
@@ -3494,6 +3497,14 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       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,
+    });
+
     // ============================================
     // Artifacts API Endpoint
     // ============================================