feat: add WebSocket event buffering + E2E tests

- Fix race condition: buffer events per run so late WS subscribers
  get replayed events (200 msg cap, 60s TTL auto-cleanup)
- Fix POST /api/agents/refresh to actually rescan discovery dirs
- Add server.setFactories() for refresh to use correct factories
- Add 20 E2E tests covering scenarios 1-9 from Phase 2 exit criteria:
  config creation, agent discovery from .agent.md, run execution,
  WebSocket streaming with replay, run lifecycle, refresh rescan,
  REST API contract validation, error cases
- Total: 122 tests (102 unit/integration + 20 E2E)

Author: vreshch

src/daemon-entry.ts

@@ -13,6 +13,7 @@ const main = async (): Promise<void> => {
 
   const server = createDaemonServer();
   const factories = [createMarkdownFactory(), createCodeFactory()];
+  server.setFactories(factories);
 
   // Initial agent discovery
   const agents = await scanAgents(config.discovery.dirs, factories);

src/daemon/routes.ts

@@ -7,13 +7,18 @@ const VERSION = '0.2.0';
 const startTime = Date.now();
 
 let agents: Agent[] = [];
+let refreshHandler: (() => Promise<Agent[]>) | null = null;
 
 export const setAgents = (newAgents: Agent[]): void => {
   agents = newAgents;
 };
 
 export const getAgents = (): Agent[] => agents;
 
+export const setRefreshHandler = (handler: () => Promise<Agent[]>): void => {
+  refreshHandler = handler;
+};
+
 export const createRoutes = (): Router => {
   const router = createRouter();
   router.use(json());
@@ -33,9 +38,16 @@ export const createRoutes = (): Router => {
     res.json(agents.map((a) => a.manifest));
   });
 
-  router.post('/api/agents/refresh', (_req, res) => {
-    // Scanner will be called by the server module
-    res.json(agents.map((a) => a.manifest));
+  router.post('/api/agents/refresh', async (_req, res) => {
+    try {
+      if (refreshHandler) {
+        agents = await refreshHandler();
+      }
+      res.json(agents.map((a) => a.manifest));
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      res.status(500).json({ error: message });
+    }
   });
 
   router.post('/api/agents/:name/run', async (req, res) => {

src/daemon/server.ts

@@ -1,28 +1,40 @@
 import { createServer, type Server } from 'node:http';
 import express from 'express';
-import { type Agent } from '@agentage/core';
+import { type Agent, type AgentFactory } from '@agentage/core';
 import { loadConfig } from './config.js';
 import { logInfo } from './logger.js';
-import { createRoutes, setAgents } from './routes.js';
+import { createRoutes, setAgents, setRefreshHandler } from './routes.js';
 import { setupWebSocket } from './websocket.js';
 import { cancelAllRuns } from './run-manager.js';
+import { scanAgents } from '../discovery/scanner.js';
 
 export interface DaemonServer {
   server: Server;
   start: () => Promise<void>;
   stop: () => Promise<void>;
   updateAgents: (agents: Agent[]) => void;
+  setFactories: (factories: AgentFactory[]) => void;
 }
 
 export const createDaemonServer = (): DaemonServer => {
   const app = express();
   const server = createServer(app);
+  let factories: AgentFactory[] = [];
 
   const routes = createRoutes();
   app.use(routes);
 
   setupWebSocket(server);
 
+  // Wire up refresh to actually rescan
+  setRefreshHandler(async () => {
+    const config = loadConfig();
+    const agents = await scanAgents(config.discovery.dirs, factories);
+    setAgents(agents);
+    logInfo(`Refresh: discovered ${agents.length} agent(s)`);
+    return agents;
+  });
+
   const start = async (): Promise<void> => {
     const config = loadConfig();
     const port = config.daemon.port;
@@ -57,5 +69,9 @@ export const createDaemonServer = (): DaemonServer => {
     setAgents(agents);
   };
 
-  return { server, start, stop, updateAgents };
+  const setFactoriesFn = (f: AgentFactory[]): void => {
+    factories = f;
+  };
+
+  return { server, start, stop, updateAgents, setFactories: setFactoriesFn };
 };

src/daemon/websocket.ts

@@ -16,7 +16,42 @@ interface UnsubscribeMessage {
 
 type ClientMessage = SubscribeMessage | UnsubscribeMessage;
 
+type BufferedMessage =
+  | { type: 'run_event'; runId: string; event: RunEvent }
+  | { type: 'run_state'; run: Run };
+
+const MAX_BUFFER_PER_RUN = 200;
+const BUFFER_TTL_MS = 60_000;
+
 const clientSubscriptions = new Map<WebSocket, Set<string>>();
+const runBuffers = new Map<string, BufferedMessage[]>();
+const bufferTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+const bufferMessage = (runId: string, msg: BufferedMessage): void => {
+  let buf = runBuffers.get(runId);
+  if (!buf) {
+    buf = [];
+    runBuffers.set(runId, buf);
+    // Auto-cleanup after TTL
+    const timer = setTimeout(() => {
+      runBuffers.delete(runId);
+      bufferTimers.delete(runId);
+    }, BUFFER_TTL_MS);
+    bufferTimers.set(runId, timer);
+  }
+  if (buf.length < MAX_BUFFER_PER_RUN) {
+    buf.push(msg);
+  }
+};
+
+const replayBuffer = (ws: WebSocket, runId: string): void => {
+  const buf = runBuffers.get(runId);
+  if (!buf) return;
+  logDebug(`Replaying ${buf.length} buffered messages for run ${runId}`);
+  for (const msg of buf) {
+    sendToClient(ws, msg);
+  }
+};
 
 const sendToClient = (ws: WebSocket, data: unknown): void => {
   if (ws.readyState === ws.OPEN) {
@@ -28,17 +63,23 @@ export const setupWebSocket = (server: Server): WebSocketServer => {
   const wss = new WebSocketServer({ server, path: '/ws' });
 
   onRunEvent((runId: string, event: RunEvent) => {
+    const msg: BufferedMessage = { type: 'run_event', runId, event };
+    bufferMessage(runId, msg);
+
     for (const [ws, subs] of clientSubscriptions) {
       if (subs.has(runId)) {
-        sendToClient(ws, { type: 'run_event', runId, event });
+        sendToClient(ws, msg);
       }
     }
   });
 
   onRunStateChange((run: Run) => {
+    const msg: BufferedMessage = { type: 'run_state', run };
+    bufferMessage(run.id, msg);
+
     for (const [ws, subs] of clientSubscriptions) {
       if (subs.has(run.id)) {
-        sendToClient(ws, { type: 'run_state', run });
+        sendToClient(ws, msg);
       }
     }
   });
@@ -54,6 +95,8 @@ export const setupWebSocket = (server: Server): WebSocketServer => {
         if (msg.type === 'subscribe') {
           clientSubscriptions.get(ws)?.add(msg.runId);
           logDebug(`Client subscribed to run ${msg.runId}`);
+          // Replay any buffered events the client missed
+          replayBuffer(ws, msg.runId);
         }
 
         if (msg.type === 'unsubscribe') {