fix(local-mcp): don't drop relay requests fired before session assignment

broadcastEvent silently returned when this.session was still null, but the
MCP relay server starts listening (and the client subprocess can hit it with
its initialize handshake) before newSession() resolves and assigns
this.session. The earliest relay request for every configured server -
almost always the only initialize attempt an MCP client makes - was lost at
the source instead of reaching the desktop.

Author: richardsolomou

packages/agent/src/server/agent-server.test.ts

@@ -1240,6 +1240,56 @@ describe("AgentServer HTTP Mode", () => {
     });
   });
 
+  describe("broadcastEvent", () => {
+    function exposeBroadcastEvent(testServer: AgentServer) {
+      return testServer as unknown as {
+        eventStreamSender: {
+          enqueue: ReturnType<typeof vi.fn>;
+          stop: ReturnType<typeof vi.fn>;
+        } | null;
+        pendingEvents: Record<string, unknown>[];
+        session: unknown;
+        broadcastEvent(event: Record<string, unknown>): void;
+      };
+    }
+
+    it("enqueues and buffers events raised before a session is assigned", () => {
+      // Regression: an MCP relay request can fire the instant the client
+      // subprocess starts, ahead of session assignment. broadcastEvent must
+      // not silently drop it.
+      const testServer = exposeBroadcastEvent(createServer());
+      testServer.eventStreamSender = {
+        enqueue: vi.fn(),
+        stop: vi.fn(async () => {}),
+      };
+      testServer.session = null;
+
+      const event = {
+        type: "mcp_request",
+        requestId: "req-1",
+        server: "slack",
+      };
+      testServer.broadcastEvent(event);
+
+      expect(testServer.eventStreamSender.enqueue).toHaveBeenCalledWith(event);
+      expect(testServer.pendingEvents).toEqual([event]);
+    });
+
+    it("buffers events with no event stream sender configured and no session", () => {
+      const testServer = exposeBroadcastEvent(createServer());
+      testServer.session = null;
+
+      const event = {
+        type: "mcp_request",
+        requestId: "req-1",
+        server: "slack",
+      };
+      expect(() => testServer.broadcastEvent(event)).not.toThrow();
+
+      expect(testServer.pendingEvents).toEqual([event]);
+    });
+  });
+
   describe("GET /events", () => {
     it("returns 401 without authorization header", async () => {
       await createServer().start();

packages/agent/src/server/agent-server.ts

@@ -4263,14 +4263,14 @@ ${signedCommitInstructions}${prLinkInstructions}${shellEfficiencyInstructions}
   }
 
   private broadcastEvent(event: Record<string, unknown>): void {
-    if (!this.session) return;
-
     this.eventStreamSender?.enqueue(event);
 
     if (this.session?.sseController) {
       this.sendSseEvent(this.session.sseController, event);
     } else {
-      // Buffer events during initialization (sseController not yet attached)
+      // Buffers events raised before a session exists yet (e.g. an MCP relay
+      // request fired the instant the client subprocess starts, ahead of
+      // `this.session` assignment) or before its SSE controller attaches.
       this.pendingEvents.push(event);
     }
   }