fix(FN-3808): increase create-room member role typography

- Increase the member role text sizing in CreateRoomModal for better readability
- Update CreateRoomModal.css with the adjusted typography value
- Keep the change scoped to create-room role styling only

Fusion-Task-Id: FN-3808

packages/dashboard/app/api/__tests__/chat-rooms-api.test.ts

@@ -0,0 +1,94 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  addChatRoomMember,
+  createChatRoom,
+  deleteChatRoom,
+  deleteChatRoomMessage,
+  fetchChatRoom,
+  fetchChatRoomMembers,
+  fetchChatRoomMessages,
+  fetchChatRooms,
+  postChatRoomMessage,
+  removeChatRoomMember,
+  updateChatRoom,
+} from "../legacy";
+
+function jsonResponse(payload: unknown): Response {
+  return new Response(JSON.stringify(payload), { status: 200, headers: { "content-type": "application/json" } });
+}
+
+describe("chat room legacy API client", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("builds request for fetchChatRooms", async () => {
+    const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async () => jsonResponse({ rooms: [] }));
+    await fetchChatRooms({ status: "active", agentId: "agent-1" }, "proj-1");
+
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toContain("/api/chat/rooms?");
+    expect(url).toContain("projectId=proj-1");
+    expect(url).toContain("status=active");
+    expect(url).toContain("agentId=agent-1");
+    expect(init.method).toBeUndefined();
+  });
+
+  it("builds CRUD room endpoints", async () => {
+    const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async () => jsonResponse({ success: true }));
+
+    await fetchChatRoom("room-1", "proj-1");
+    await createChatRoom({ name: "Engineering" }, "proj-1");
+    await updateChatRoom("room-1", { description: "desc" }, "proj-1");
+    await deleteChatRoom("room-1", "proj-1");
+
+    expect((fetchMock.mock.calls[0] as [string])[0]).toContain("/api/chat/rooms/room-1?projectId=proj-1");
+
+    const [, createInit] = fetchMock.mock.calls[1] as [string, RequestInit];
+    expect(createInit.method).toBe("POST");
+    expect(createInit.body).toBe(JSON.stringify({ name: "Engineering", projectId: "proj-1" }));
+
+    const [, updateInit] = fetchMock.mock.calls[2] as [string, RequestInit];
+    expect(updateInit.method).toBe("PATCH");
+    expect(updateInit.body).toBe(JSON.stringify({ description: "desc" }));
+
+    const [, deleteInit] = fetchMock.mock.calls[3] as [string, RequestInit];
+    expect(deleteInit.method).toBe("DELETE");
+  });
+
+  it("builds member endpoints", async () => {
+    const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async () => jsonResponse({ success: true }));
+
+    await fetchChatRoomMembers("room-1", "proj-2");
+    await addChatRoomMember("room-1", { agentId: "agent-2", role: "owner" }, "proj-2");
+    await removeChatRoomMember("room-1", "agent-2", "proj-2");
+
+    expect((fetchMock.mock.calls[0] as [string])[0]).toContain("/api/chat/rooms/room-1/members?projectId=proj-2");
+    const [, addInit] = fetchMock.mock.calls[1] as [string, RequestInit];
+    expect(addInit.method).toBe("POST");
+    expect(addInit.body).toBe(JSON.stringify({ agentId: "agent-2", role: "owner" }));
+    expect((fetchMock.mock.calls[2] as [string])[0]).toContain("/api/chat/rooms/room-1/members/agent-2?projectId=proj-2");
+  });
+
+  it("builds message endpoints", async () => {
+    const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async () => jsonResponse({ success: true }));
+
+    await fetchChatRoomMessages("room-1", { limit: 2, offset: 1, before: "2026-01-01" }, "proj-3");
+    await postChatRoomMessage("room-1", { content: "hello", mentions: ["agent-x"] }, "proj-3");
+    await deleteChatRoomMessage("room-1", "msg-1", "proj-3");
+
+    const [listUrl] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(listUrl).toContain("/api/chat/rooms/room-1/messages?");
+    expect(listUrl).toContain("projectId=proj-3");
+    expect(listUrl).toContain("limit=2");
+    expect(listUrl).toContain("offset=1");
+    expect(listUrl).toContain("before=2026-01-01");
+
+    const [, postInit] = fetchMock.mock.calls[1] as [string, RequestInit];
+    expect(postInit.method).toBe("POST");
+    expect(postInit.body).toBe(JSON.stringify({ content: "hello", mentions: ["agent-x"] }));
+
+    const [, delInit] = fetchMock.mock.calls[2] as [string, RequestInit];
+    expect(delInit.method).toBe("DELETE");
+  });
+});

packages/dashboard/app/api/legacy.ts

@@ -42,7 +42,11 @@ import type {
   AgentRating,
   AgentRatingSummary,
   AgentRatingInput,
+  ChatAttachment,
   ChatMessage,
+  ChatRoom,
+  ChatRoomMember,
+  ChatRoomMessage,
   EnrichedChatSession,
   TodoList,
   TodoItem,
@@ -8052,6 +8056,27 @@ export interface ChatMessageListResponse {
   messages: ChatMessage[];
 }
 
+export interface ChatRoomListResponse {
+  rooms: ChatRoom[];
+}
+
+export interface ChatRoomResponse {
+  room: ChatRoom;
+  members?: ChatRoomMember[];
+}
+
+export interface ChatRoomMembersResponse {
+  members: ChatRoomMember[];
+}
+
+export interface ChatRoomMessageListResponse {
+  messages: ChatRoomMessage[];
+}
+
+export interface ChatRoomMessageResponse {
+  message: ChatRoomMessage;
+}
+
 /** Fetch all chat sessions for a project */
 export function fetchChatSessions(projectId?: string, status?: string): Promise<ChatSessionListResponse> {
   const search = new URLSearchParams();
@@ -8165,6 +8190,114 @@ export function deleteChatMessage(
   );
 }
 
+export function fetchChatRooms(
+  options: { status?: string; agentId?: string } = {},
+  projectId?: string,
+): Promise<ChatRoomListResponse> {
+  const search = new URLSearchParams();
+  if (projectId) search.set("projectId", projectId);
+  if (options.status) search.set("status", options.status);
+  if (options.agentId) search.set("agentId", options.agentId);
+  const qs = search.toString();
+  return api<ChatRoomListResponse>(`/chat/rooms${qs ? `?${qs}` : ""}`);
+}
+
+export function fetchChatRoom(id: string, projectId?: string): Promise<ChatRoomResponse> {
+  return api<ChatRoomResponse>(withProjectId(`/chat/rooms/${encodeURIComponent(id)}`, projectId));
+}
+
+export function createChatRoom(
+  input: { name: string; description?: string | null; createdBy?: string | null; memberAgentIds?: string[] },
+  projectId?: string,
+): Promise<ChatRoomResponse> {
+  const body = { ...input, ...(projectId ? { projectId } : {}) };
+  return api<ChatRoomResponse>(withProjectId("/chat/rooms", projectId), {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+}
+
+export function updateChatRoom(
+  id: string,
+  updates: { name?: string; description?: string | null; status?: "active" | "archived" },
+  projectId?: string,
+): Promise<{ room: ChatRoom }> {
+  return api<{ room: ChatRoom }>(withProjectId(`/chat/rooms/${encodeURIComponent(id)}`, projectId), {
+    method: "PATCH",
+    body: JSON.stringify(updates),
+  });
+}
+
+export function deleteChatRoom(id: string, projectId?: string): Promise<{ success: boolean }> {
+  return api<{ success: boolean }>(withProjectId(`/chat/rooms/${encodeURIComponent(id)}`, projectId), {
+    method: "DELETE",
+  });
+}
+
+export function fetchChatRoomMembers(id: string, projectId?: string): Promise<ChatRoomMembersResponse> {
+  return api<ChatRoomMembersResponse>(withProjectId(`/chat/rooms/${encodeURIComponent(id)}/members`, projectId));
+}
+
+export function addChatRoomMember(
+  id: string,
+  input: { agentId: string; role?: "owner" | "member" },
+  projectId?: string,
+): Promise<{ member: ChatRoomMember }> {
+  return api<{ member: ChatRoomMember }>(withProjectId(`/chat/rooms/${encodeURIComponent(id)}/members`, projectId), {
+    method: "POST",
+    body: JSON.stringify(input),
+  });
+}
+
+export function removeChatRoomMember(id: string, agentId: string, projectId?: string): Promise<{ success: boolean }> {
+  return api<{ success: boolean }>(
+    withProjectId(`/chat/rooms/${encodeURIComponent(id)}/members/${encodeURIComponent(agentId)}`, projectId),
+    { method: "DELETE" },
+  );
+}
+
+export function fetchChatRoomMessages(
+  id: string,
+  opts?: { limit?: number; offset?: number; before?: string },
+  projectId?: string,
+): Promise<ChatRoomMessageListResponse> {
+  const search = new URLSearchParams();
+  if (opts?.limit !== undefined) search.set("limit", String(opts.limit));
+  if (opts?.offset !== undefined) search.set("offset", String(opts.offset));
+  if (opts?.before) search.set("before", opts.before);
+  const qs = search.toString();
+  return api<ChatRoomMessageListResponse>(
+    withProjectId(`/chat/rooms/${encodeURIComponent(id)}/messages${qs ? `?${qs}` : ""}`, projectId),
+  );
+}
+
+export function postChatRoomMessage(
+  id: string,
+  input: { content: string; senderAgentId?: null; mentions?: string[]; attachments?: File[] | ChatAttachment[] },
+  projectId?: string,
+): Promise<ChatRoomMessageResponse> {
+  return api<ChatRoomMessageResponse>(withProjectId(`/chat/rooms/${encodeURIComponent(id)}/messages`, projectId), {
+    method: "POST",
+    body: JSON.stringify(input),
+  });
+}
+
+export function deleteChatRoomMessage(
+  id: string,
+  messageId: string,
+  projectId?: string,
+): Promise<{ success: boolean }> {
+  return api<{ success: boolean }>(
+    withProjectId(`/chat/rooms/${encodeURIComponent(id)}/messages/${encodeURIComponent(messageId)}`, projectId),
+    { method: "DELETE" },
+  );
+}
+
+/**
+ * Room POST /messages in FN-3808 is persist-only (201 JSON response).
+ * Do not add streamChatRoomResponse until FN-3810 introduces AI invocation/streaming.
+ */
+
 /** Cancel an in-flight chat generation. */
 export function cancelChatResponse(
   sessionId: string,

packages/dashboard/app/components/CreateRoomModal.css

@@ -45,6 +45,7 @@
 
 .create-room-modal-member-row {
   display: flex;
+  width: 100%;
   align-items: center;
   gap: var(--space-sm);
   text-align: left;
@@ -73,7 +74,7 @@
 .create-room-modal-member-role {
   margin-left: auto;
   color: var(--text-muted);
-  font-size: var(--space-sm);
+  font-size: var(--space-md);
 }
 
 .create-room-modal-empty {

packages/dashboard/src/__tests__/chat-room-routes.test.ts

@@ -0,0 +1,236 @@
+import { mkdtempSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { ChatStore, Database } from "@fusion/core";
+import { request } from "../test-request.js";
+
+class MockStore {
+  constructor(private readonly rootDir: string, private readonly db: Database) {}
+
+  getRootDir(): string { return this.rootDir; }
+  getFusionDir(): string { return join(this.rootDir, ".fusion"); }
+  getKbDir(): string { return join(this.rootDir, ".fusion"); }
+  getDatabase(): Database { return this.db; }
+}
+
+describe("Chat Room API Routes", () => {
+  let tempRoot: string;
+  let db: Database;
+  let store: MockStore;
+  let chatStore: ChatStore;
+  let app: ReturnType<typeof import("../server.js").createServer>;
+
+  beforeEach(async () => {
+    tempRoot = mkdtempSync(join(tmpdir(), "fusion-chat-room-routes-"));
+    const fusionDir = join(tempRoot, ".fusion");
+    db = new Database(fusionDir, { inMemory: true });
+    db.init();
+    store = new MockStore(tempRoot, db);
+    chatStore = new ChatStore(fusionDir, db);
+    const { createServer } = await import("../server.js");
+    app = createServer(store as any, { chatStore });
+  });
+
+  afterEach(async () => {
+    db.close();
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+
+  it("create + fetch + update + delete room", async () => {
+    const createRes = await request(app, "POST", "/api/chat/rooms", JSON.stringify({ name: "Engineering" }), {
+      "content-type": "application/json",
+    });
+    expect(createRes.status).toBe(201);
+
+    const roomId = (createRes.body as any).room.id as string;
+
+    const getRes = await request(app, "GET", `/api/chat/rooms/${roomId}`);
+    expect(getRes.status).toBe(200);
+
+    const patchRes = await request(
+      app,
+      "PATCH",
+      `/api/chat/rooms/${roomId}`,
+      JSON.stringify({ description: "Core team" }),
+      { "content-type": "application/json" },
+    );
+    expect(patchRes.status).toBe(200);
+    expect((patchRes.body as any).room.description).toBe("Core team");
+
+    const delRes = await request(app, "DELETE", `/api/chat/rooms/${roomId}`);
+    expect(delRes.status).toBe(200);
+    expect((delRes.body as any).success).toBe(true);
+  });
+
+  it("validates create and slug collision", async () => {
+    const missingName = await request(app, "POST", "/api/chat/rooms", JSON.stringify({}), {
+      "content-type": "application/json",
+    });
+    expect(missingName.status).toBe(400);
+
+    const first = await request(app, "POST", "/api/chat/rooms", JSON.stringify({ name: "Platform Team", projectId: "p1" }), {
+      "content-type": "application/json",
+    });
+    expect(first.status).toBe(201);
+
+    const duplicate = await request(app, "POST", "/api/chat/rooms", JSON.stringify({ name: "platform-team", projectId: "p1" }), {
+      "content-type": "application/json",
+    });
+    expect(duplicate.status).toBe(409);
+  });
+
+  it("returns 404 for unknown room", async () => {
+    const res = await request(app, "GET", "/api/chat/rooms/room-missing");
+    expect(res.status).toBe(404);
+  });
+
+  it("handles room members add/delete", async () => {
+    const createRes = await request(app, "POST", "/api/chat/rooms", JSON.stringify({ name: "Ops" }), {
+      "content-type": "application/json",
+    });
+    const roomId = (createRes.body as any).room.id as string;
+
+    const addRes = await request(
+      app,
+      "POST",
+      `/api/chat/rooms/${roomId}/members`,
+      JSON.stringify({ agentId: "agent-1", role: "member" }),
+      { "content-type": "application/json" },
+    );
+    expect(addRes.status).toBe(201);
+
+    const addRes2 = await request(
+      app,
+      "POST",
+      `/api/chat/rooms/${roomId}/members`,
+      JSON.stringify({ agentId: "agent-1", role: "member" }),
+      { "content-type": "application/json" },
+    );
+    expect(addRes2.status).toBe(201);
+
+    const deleteRes = await request(app, "DELETE", `/api/chat/rooms/${roomId}/members/agent-1`);
+    expect(deleteRes.status).toBe(200);
+
+    const deleteMissing = await request(app, "DELETE", `/api/chat/rooms/${roomId}/members/agent-1`);
+    expect(deleteMissing.status).toBe(404);
+  });
+
+  it("persists room message and validates sender/content", async () => {
+    const createRoomRes = await request(app, "POST", "/api/chat/rooms", JSON.stringify({ name: "Product" }), {
+      "content-type": "application/json",
+    });
+    const roomId = (createRoomRes.body as any).room.id as string;
+
+    const beforeCount = chatStore.getRoomMessages(roomId).length;
+
+    const postRes = await request(
+      app,
+      "POST",
+      `/api/chat/rooms/${roomId}/messages`,
+      JSON.stringify({ content: "  hello world  " }),
+      { "content-type": "application/json" },
+    );
+    expect(postRes.status).toBe(201);
+
+    const messageId = (postRes.body as any).message.id as string;
+    const persisted = chatStore.getRoomMessage(messageId);
+    expect(persisted?.content).toBe("hello world");
+
+    const afterCount = chatStore.getRoomMessages(roomId).length;
+    expect(afterCount).toBe(beforeCount + 1);
+
+    const invalidSender = await request(
+      app,
+      "POST",
+      `/api/chat/rooms/${roomId}/messages`,
+      JSON.stringify({ content: "x", senderAgentId: "agent-1" }),
+      { "content-type": "application/json" },
+    );
+    expect(invalidSender.status).toBe(400);
+
+    const emptyContent = await request(
+      app,
+      "POST",
+      `/api/chat/rooms/${roomId}/messages`,
+      JSON.stringify({ content: "   " }),
+      { "content-type": "application/json" },
+    );
+    expect(emptyContent.status).toBe(400);
+  });
+
+  it("deletes messages and supports pagination", async () => {
+    const room = chatStore.createRoom({ name: "QA" });
+    const m1 = chatStore.addRoomMessage(room.id, { role: "user", content: "one" });
+    const m2 = chatStore.addRoomMessage(room.id, { role: "user", content: "two" });
+    const m3 = chatStore.addRoomMessage(room.id, { role: "user", content: "three" });
+
+    const page = await request(app, "GET", `/api/chat/rooms/${room.id}/messages?limit=2&offset=1`);
+    expect(page.status).toBe(200);
+    expect((page.body as any).messages.map((m: any) => m.id)).toEqual([m2.id, m3.id]);
+
+    const del1 = await request(app, "DELETE", `/api/chat/rooms/${room.id}/messages/${m1.id}`);
+    expect(del1.status).toBe(200);
+
+    const del2 = await request(app, "DELETE", `/api/chat/rooms/${room.id}/messages/${m1.id}`);
+    expect(del2.status).toBe(404);
+  });
+
+  it("handles message attachments route", async () => {
+    const room = chatStore.createRoom({ name: "Files" });
+    const message = chatStore.addRoomMessage(room.id, { role: "user", content: "hello" });
+
+    const badPayload = await request(
+      app,
+      "POST",
+      `/api/chat/rooms/${room.id}/messages/${message.id}/attachments`,
+      JSON.stringify("invalid"),
+      { "content-type": "application/json" },
+    );
+    expect(badPayload.status).toBe(400);
+
+    const addAttachment = await request(
+      app,
+      "POST",
+      `/api/chat/rooms/${room.id}/messages/${message.id}/attachments`,
+      JSON.stringify({
+        id: "att-1",
+        filename: "a.txt",
+        originalName: "a.txt",
+        mimeType: "text/plain",
+        size: 1,
+        createdAt: new Date().toISOString(),
+      }),
+      { "content-type": "application/json" },
+    );
+    expect(addAttachment.status).toBe(200);
+    expect((addAttachment.body as any).message.attachments).toHaveLength(1);
+
+    const missingMessage = await request(
+      app,
+      "POST",
+      `/api/chat/rooms/${room.id}/messages/missing/attachments`,
+      JSON.stringify({
+        id: "att-2",
+        filename: "b.txt",
+        originalName: "b.txt",
+        mimeType: "text/plain",
+        size: 1,
+        createdAt: new Date().toISOString(),
+      }),
+      { "content-type": "application/json" },
+    );
+    expect(missingMessage.status).toBe(404);
+  });
+
+  it("rate-limits GET /chat/rooms", async () => {
+    let status = 200;
+    for (let i = 0; i < 1020; i++) {
+      const res = await request(app, "GET", "/api/chat/rooms");
+      status = res.status;
+      if (status === 429) break;
+    }
+    expect(status).toBe(429);
+  });
+});

packages/dashboard/src/__tests__/sse-chat-rooms.test.ts

@@ -0,0 +1,136 @@
+import { EventEmitter } from "node:events";
+import { mkdtempSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { Request, Response } from "express";
+import { ChatStore, Database } from "@fusion/core";
+import type { TaskStore } from "@fusion/core";
+import { createSSE } from "../sse.js";
+
+class MockSocket extends EventEmitter {
+  destroyed = false;
+  setKeepAlive = vi.fn();
+  destroy = vi.fn(() => {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.emit("close");
+  });
+}
+
+class MockResponse extends EventEmitter {
+  headers = new Map<string, string>();
+  writableEnded = false;
+  destroyed = false;
+  write = vi.fn();
+  flushHeaders = vi.fn();
+  end = vi.fn(() => {
+    if (this.writableEnded) return;
+    this.writableEnded = true;
+    this.emit("close");
+  });
+
+  constructor(readonly socket: MockSocket) {
+    super();
+  }
+
+  setHeader(name: string, value: string): void {
+    this.headers.set(name, value);
+  }
+}
+
+function createMockStore(): TaskStore {
+  const researchStore = {
+    on: vi.fn(),
+    off: vi.fn(),
+  };
+  return {
+    on: vi.fn(),
+    off: vi.fn(),
+    getResearchStore: vi.fn(() => researchStore),
+  } as unknown as TaskStore;
+}
+
+function openSseConnection(chatStore: ChatStore) {
+  const store = createMockStore();
+  const socket = new MockSocket();
+  const req = new EventEmitter() as Request & { query: Record<string, string>; socket: MockSocket };
+  req.query = { clientId: "chat-room-events" };
+  req.socket = socket;
+  const res = new MockResponse(socket);
+
+  createSSE(store, undefined, undefined, undefined, undefined, undefined, undefined, chatStore)(
+    req,
+    res as unknown as Response,
+  );
+
+  return { req, res };
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe("chat room SSE events", () => {
+  it("relays room lifecycle/member/message events and cleans up listeners", async () => {
+    const tempRoot = mkdtempSync(join(tmpdir(), "fusion-sse-chat-room-"));
+    const fusionDir = join(tempRoot, ".fusion");
+    const db = new Database(fusionDir, { inMemory: true });
+    db.init();
+    const chatStore = new ChatStore(fusionDir, db);
+    const { req, res } = openSseConnection(chatStore);
+
+    const room = chatStore.createRoom({
+      name: "engineering",
+      projectId: "proj-1",
+      createdBy: "agent-owner",
+      memberAgentIds: ["agent-owner"],
+    });
+    const member = chatStore.addRoomMember(room.id, "agent-2", "member");
+    const message = chatStore.addRoomMessage(room.id, {
+      role: "user",
+      content: "hello room",
+      senderAgentId: null,
+      mentions: [],
+    });
+    const updatedRoom = chatStore.updateRoom(room.id, { description: "updated" });
+    expect(updatedRoom).toBeDefined();
+    chatStore.removeRoomMember(room.id, "agent-2");
+    const attachmentUpdatedMessage = chatStore.addRoomMessageAttachment(room.id, message.id, {
+      id: "att-1",
+      filename: "doc.txt",
+      originalName: "doc.txt",
+      mimeType: "text/plain",
+      size: 3,
+      createdAt: new Date().toISOString(),
+    });
+    chatStore.deleteRoomMessage(message.id);
+    chatStore.deleteRoom(room.id);
+
+    expect(res.write).toHaveBeenCalledWith(`event: chat:room:created\ndata: ${JSON.stringify(room)}\n\n`);
+    expect(res.write).toHaveBeenCalledWith(`event: chat:room:member:added\ndata: ${JSON.stringify(member)}\n\n`);
+    expect(res.write).toHaveBeenCalledWith(`event: chat:room:message:added\ndata: ${JSON.stringify(message)}\n\n`);
+    expect(res.write).toHaveBeenCalledWith(`event: chat:room:updated\ndata: ${JSON.stringify(updatedRoom)}\n\n`);
+    expect(res.write).toHaveBeenCalledWith(
+      `event: chat:room:member:removed\ndata: ${JSON.stringify({ roomId: room.id, agentId: "agent-2" })}\n\n`,
+    );
+    expect(res.write).toHaveBeenCalledWith(`event: chat:room:message:updated\ndata: ${JSON.stringify(attachmentUpdatedMessage)}\n\n`);
+    expect(res.write).toHaveBeenCalledWith(`event: chat:room:message:deleted\ndata: ${JSON.stringify({ id: message.id })}\n\n`);
+    expect(res.write).toHaveBeenCalledWith(`event: chat:room:deleted\ndata: ${JSON.stringify({ id: room.id })}\n\n`);
+
+    req.emit("close");
+
+    expect(EventEmitter.listenerCount(chatStore, "chat:room:created")).toBe(0);
+    expect(EventEmitter.listenerCount(chatStore, "chat:room:updated")).toBe(0);
+    expect(EventEmitter.listenerCount(chatStore, "chat:room:deleted")).toBe(0);
+    expect(EventEmitter.listenerCount(chatStore, "chat:room:member:added")).toBe(0);
+    expect(EventEmitter.listenerCount(chatStore, "chat:room:member:removed")).toBe(0);
+    expect(EventEmitter.listenerCount(chatStore, "chat:room:message:added")).toBe(0);
+    expect(EventEmitter.listenerCount(chatStore, "chat:room:message:updated")).toBe(0);
+    expect(EventEmitter.listenerCount(chatStore, "chat:room:message:deleted")).toBe(0);
+
+    db.close();
+    await rm(tempRoot, { recursive: true, force: true });
+  });
+});

packages/dashboard/src/routes.ts

@@ -91,6 +91,7 @@ import { createApiRoutesContext } from "./routes/context.js";
 import { registerTaskWorkflowRoutes } from "./routes/register-task-workflow-routes.js";
 import { registerPlanningSubtaskRoutes } from "./routes/register-planning-subtask-routes.js";
 import { registerChatRoutes } from "./routes/register-chat-routes.js";
+import { registerChatRoomRoutes } from "./routes/register-chat-room-routes.js";
 import { registerSettingsMemoryRoutes } from "./routes/register-settings-memory-routes.js";
 import { registerMessagingScriptRoutes } from "./routes/register-messaging-scripts.js";
 import { registerGitGitHubRoutes } from "./routes/register-git-github.js";
@@ -978,6 +979,7 @@ export function createApiRoutes(store: TaskStore, options?: ServerOptions): Rout
     validateOptionalModelField,
     upload,
   });
+  registerChatRoomRoutes(routeContext);
   registerMessagingScriptRoutes(routeContext);
   registerGitGitHubRoutes(routeContext);
   registerFilesTerminalWorkspaceRoutes(routeContext);

packages/dashboard/src/routes/register-chat-room-routes.ts

@@ -0,0 +1,343 @@
+import type { ChatAttachment, ChatRoomCreateInput, ChatRoomStatus, ChatRoomUpdateInput } from "@fusion/core";
+import { ApiError, badRequest, internalError, notFound } from "../api-error.js";
+import { rateLimit, RATE_LIMITS } from "../rate-limit.js";
+import type { ApiRoutesContext } from "./types.js";
+
+function isSlugCollisionError(err: unknown): boolean {
+  const message = err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
+  return message.includes("slug") || message.includes("exists");
+}
+
+export function registerChatRoomRoutes(ctx: ApiRoutesContext): void {
+  const { router, options, chatLogger, rethrowAsApiError } = ctx;
+
+  router.get("/chat/rooms", rateLimit(RATE_LIMITS.api), async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) throw internalError("Chat store not available");
+
+      const { projectId, status, agentId } = req.query as {
+        projectId?: string;
+        status?: string;
+        agentId?: string;
+      };
+
+      const statusFilter = status as ChatRoomStatus | undefined;
+      const rooms = agentId
+        ? chatStore.listRoomsForAgent(agentId, { projectId, status: statusFilter })
+        : chatStore.listRooms({ projectId, status: statusFilter });
+
+      res.json({ rooms });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err, "Failed to list chat rooms");
+    }
+  });
+
+  router.post("/chat/rooms", rateLimit(RATE_LIMITS.mutation), async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) throw internalError("Chat store not available");
+
+      const { name, description, projectId, createdBy, memberAgentIds } = req.body as {
+        name?: string;
+        description?: string | null;
+        projectId?: string | null;
+        createdBy?: string | null;
+        memberAgentIds?: string[];
+      };
+
+      if (!name || typeof name !== "string" || !name.trim()) {
+        throw badRequest("name is required and must be a non-empty string");
+      }
+
+      const roomInput: ChatRoomCreateInput & { memberAgentIds?: string[] } = {
+        name: name.trim(),
+        ...(description !== undefined ? { description } : {}),
+        ...(projectId !== undefined ? { projectId } : {}),
+        ...(createdBy !== undefined ? { createdBy } : {}),
+        ...(Array.isArray(memberAgentIds) ? { memberAgentIds } : {}),
+      };
+
+      let room;
+      try {
+        room = chatStore.createRoom(roomInput);
+      } catch (err) {
+        if (isSlugCollisionError(err)) {
+          throw new ApiError(409, err instanceof Error ? err.message : "Room slug already exists");
+        }
+        throw err;
+      }
+
+      const members = chatStore.listRoomMembers(room.id);
+      res.status(201).json({ room, members });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err, "Failed to create chat room");
+    }
+  });
+
+  router.get("/chat/rooms/:id", rateLimit(RATE_LIMITS.api), async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) throw internalError("Chat store not available");
+
+      const roomId = String(req.params.id);
+      const room = chatStore.getRoom(roomId);
+      if (!room) throw notFound(`Chat room ${roomId} not found`);
+
+      const members = chatStore.listRoomMembers(roomId);
+      res.json({ room, members });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err, "Failed to get chat room");
+    }
+  });
+
+  router.patch("/chat/rooms/:id", rateLimit(RATE_LIMITS.mutation), async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) throw internalError("Chat store not available");
+
+      const roomId = String(req.params.id);
+      const { name, description, status } = req.body as { name?: string; description?: string | null; status?: ChatRoomStatus };
+
+      if (name === undefined && description === undefined && status === undefined) {
+        throw badRequest("at least one of name, description, or status is required");
+      }
+
+      const input: ChatRoomUpdateInput = {
+        ...(name !== undefined ? { name: name.trim() } : {}),
+        ...(description !== undefined ? { description } : {}),
+        ...(status !== undefined ? { status } : {}),
+      };
+
+      let room;
+      try {
+        room = chatStore.updateRoom(roomId, input);
+      } catch (err) {
+        if (isSlugCollisionError(err)) {
+          throw new ApiError(409, err instanceof Error ? err.message : "Room slug already exists");
+        }
+        throw err;
+      }
+
+      if (!room) throw notFound(`Chat room ${roomId} not found`);
+      res.json({ room });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err, "Failed to update chat room");
+    }
+  });
+
+  router.delete("/chat/rooms/:id", rateLimit(RATE_LIMITS.mutation), async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) throw internalError("Chat store not available");
+
+      const roomId = String(req.params.id);
+      const room = chatStore.getRoom(roomId);
+      if (!room) throw notFound(`Chat room ${roomId} not found`);
+
+      chatStore.deleteRoom(roomId);
+      res.json({ success: true });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err, "Failed to delete chat room");
+    }
+  });
+
+  router.get("/chat/rooms/:id/members", rateLimit(RATE_LIMITS.api), async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) throw internalError("Chat store not available");
+
+      const roomId = String(req.params.id);
+      const room = chatStore.getRoom(roomId);
+      if (!room) throw notFound(`Chat room ${roomId} not found`);
+
+      const members = chatStore.listRoomMembers(roomId);
+      res.json({ members });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err, "Failed to list chat room members");
+    }
+  });
+
+  router.post("/chat/rooms/:id/members", rateLimit(RATE_LIMITS.mutation), async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) throw internalError("Chat store not available");
+
+      const roomId = String(req.params.id);
+      const room = chatStore.getRoom(roomId);
+      if (!room) throw notFound(`Chat room ${roomId} not found`);
+
+      const { agentId, role } = req.body as { agentId?: string; role?: "owner" | "member" };
+      if (!agentId || typeof agentId !== "string" || !agentId.trim()) {
+        throw badRequest("agentId is required and must be a non-empty string");
+      }
+      if (role !== undefined && role !== "owner" && role !== "member") {
+        throw badRequest("role must be 'owner' or 'member'");
+      }
+
+      const member = chatStore.addRoomMember(roomId, agentId.trim(), role ?? "member");
+      res.status(201).json({ member });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err, "Failed to add chat room member");
+    }
+  });
+
+  router.delete("/chat/rooms/:id/members/:agentId", rateLimit(RATE_LIMITS.mutation), async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) throw internalError("Chat store not available");
+
+      const roomId = String(req.params.id);
+      const agentId = String(req.params.agentId);
+      const removed = chatStore.removeRoomMember(roomId, agentId);
+      if (!removed) throw notFound(`Room member ${agentId} not found in room ${roomId}`);
+
+      res.json({ success: true });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err, "Failed to remove chat room member");
+    }
+  });
+
+  router.get("/chat/rooms/:id/messages", rateLimit(RATE_LIMITS.api), async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) throw internalError("Chat store not available");
+
+      const roomId = String(req.params.id);
+      const room = chatStore.getRoom(roomId);
+      if (!room) throw notFound(`Chat room ${roomId} not found`);
+
+      const { limit: limitStr, offset: offsetStr, before } = req.query as { limit?: string; offset?: string; before?: string };
+      const limit = limitStr !== undefined ? parseInt(String(limitStr), 10) : 50;
+      const offset = offsetStr !== undefined ? parseInt(String(offsetStr), 10) : 0;
+      if (!Number.isFinite(limit) || limit < 1) throw badRequest("limit must be a positive integer");
+      if (!Number.isFinite(offset) || offset < 0) throw badRequest("offset must be a non-negative integer");
+
+      const messages = chatStore.getRoomMessages(roomId, {
+        limit,
+        offset,
+        ...(before ? { before } : {}),
+      });
+
+      res.json({ messages });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err, "Failed to list chat room messages");
+    }
+  });
+
+  router.post("/chat/rooms/:id/messages", rateLimit(RATE_LIMITS.mutation), async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) throw internalError("Chat store not available");
+
+      const roomId = String(req.params.id);
+      const room = chatStore.getRoom(roomId);
+      if (!room) throw notFound(`Chat room ${roomId} not found`);
+
+      const { content, senderAgentId, attachments } = req.body as {
+        content?: string;
+        senderAgentId?: string | null;
+        mentions?: string[];
+        attachments?: ChatAttachment[];
+      };
+
+      if (!content || typeof content !== "string" || !content.trim()) {
+        throw badRequest("content is required and must be a non-empty string");
+      }
+      if (senderAgentId !== undefined && senderAgentId !== null) {
+        throw badRequest("senderAgentId is reserved for FN-3810; must be null or omitted");
+      }
+
+      const message = chatStore.addRoomMessage(roomId, {
+        role: "user",
+        content: content.trim(),
+        senderAgentId: null,
+        mentions: [],
+        ...(Array.isArray(attachments) ? { attachments } : {}),
+      });
+
+      res.status(201).json({ message });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err, "Failed to create chat room message");
+    }
+  });
+
+  router.delete("/chat/rooms/:id/messages/:messageId", rateLimit(RATE_LIMITS.mutation), async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) throw internalError("Chat store not available");
+
+      const roomId = String(req.params.id);
+      const messageId = String(req.params.messageId);
+      const room = chatStore.getRoom(roomId);
+      if (!room) throw notFound(`Chat room ${roomId} not found`);
+
+      const message = chatStore.getRoomMessage(messageId);
+      if (!message || message.roomId !== roomId) {
+        throw notFound(`Message ${messageId} not found`);
+      }
+
+      chatStore.deleteRoomMessage(messageId);
+      res.json({ success: true });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err, "Failed to delete chat room message");
+    }
+  });
+
+  router.post("/chat/rooms/:id/messages/:messageId/attachments", rateLimit(RATE_LIMITS.mutation), async (req, res) => {
+    try {
+      const chatStore = options?.chatStore;
+      if (!chatStore) throw internalError("Chat store not available");
+
+      const roomId = String(req.params.id);
+      const messageId = String(req.params.messageId);
+      const room = chatStore.getRoom(roomId);
+      if (!room) throw notFound(`Chat room ${roomId} not found`);
+
+      const message = chatStore.getRoomMessage(messageId);
+      if (!message || message.roomId !== roomId) {
+        throw notFound(`Message ${messageId} not found`);
+      }
+
+      const attachment = req.body as ChatAttachment;
+      if (!attachment || typeof attachment !== "object") {
+        throw badRequest("attachment payload is required");
+      }
+
+      const updatedMessage = chatStore.addRoomMessageAttachment(roomId, messageId, attachment);
+      res.json({ message: updatedMessage });
+    } catch (err: unknown) {
+      if (err instanceof ApiError) throw err;
+      rethrowAsApiError(err, "Failed to add chat room message attachment");
+    }
+  });
+
+  if (process.env.FUSION_DEBUG_CHAT_ROUTES === "1") {
+    const chatRoomRoutes = [
+      "GET /chat/rooms",
+      "POST /chat/rooms",
+      "GET /chat/rooms/:id",
+      "PATCH /chat/rooms/:id",
+      "DELETE /chat/rooms/:id",
+      "GET /chat/rooms/:id/members",
+      "POST /chat/rooms/:id/members",
+      "DELETE /chat/rooms/:id/members/:agentId",
+      "GET /chat/rooms/:id/messages",
+      "POST /chat/rooms/:id/messages",
+      "DELETE /chat/rooms/:id/messages/:messageId",
+      "POST /chat/rooms/:id/messages/:messageId/attachments",
+    ];
+    chatLogger.info("room routes registered", { chatRoomRoutes });
+  }
+}

packages/dashboard/src/sse.ts

@@ -594,6 +594,38 @@ export function createSSE(
       send(`event: chat:message:deleted\ndata: ${JSON.stringify({ id: messageId })}\n\n`);
     };
 
+    const onChatRoomCreated = (room: unknown) => {
+      send(`event: chat:room:created\ndata: ${JSON.stringify(room)}\n\n`);
+    };
+
+    const onChatRoomUpdated = (room: unknown) => {
+      send(`event: chat:room:updated\ndata: ${JSON.stringify(room)}\n\n`);
+    };
+
+    const onChatRoomDeleted = (roomId: string) => {
+      send(`event: chat:room:deleted\ndata: ${JSON.stringify({ id: roomId })}\n\n`);
+    };
+
+    const onChatRoomMemberAdded = (member: unknown) => {
+      send(`event: chat:room:member:added\ndata: ${JSON.stringify(member)}\n\n`);
+    };
+
+    const onChatRoomMemberRemoved = (payload: unknown) => {
+      send(`event: chat:room:member:removed\ndata: ${JSON.stringify(payload)}\n\n`);
+    };
+
+    const onChatRoomMessageAdded = (message: unknown) => {
+      send(`event: chat:room:message:added\ndata: ${JSON.stringify(message)}\n\n`);
+    };
+
+    const onChatRoomMessageUpdated = (message: unknown) => {
+      send(`event: chat:room:message:updated\ndata: ${JSON.stringify(message)}\n\n`);
+    };
+
+    const onChatRoomMessageDeleted = (messageId: string) => {
+      send(`event: chat:room:message:deleted\ndata: ${JSON.stringify({ id: messageId })}\n\n`);
+    };
+
     // --- Automation store event handlers ---
     const onScheduleCreated = (schedule: unknown) => {
       send(`event: schedule:created\ndata: ${JSON.stringify(schedule)}\n\n`);
@@ -695,6 +727,14 @@ export function createSSE(
         chatStore.off("chat:session:deleted", onChatSessionDeleted);
         chatStore.off("chat:message:added", onChatMessageAdded);
         chatStore.off("chat:message:deleted", onChatMessageDeleted);
+        chatStore.off("chat:room:created", onChatRoomCreated);
+        chatStore.off("chat:room:updated", onChatRoomUpdated);
+        chatStore.off("chat:room:deleted", onChatRoomDeleted);
+        chatStore.off("chat:room:member:added", onChatRoomMemberAdded);
+        chatStore.off("chat:room:member:removed", onChatRoomMemberRemoved);
+        chatStore.off("chat:room:message:added", onChatRoomMessageAdded);
+        chatStore.off("chat:room:message:updated", onChatRoomMessageUpdated);
+        chatStore.off("chat:room:message:deleted", onChatRoomMessageDeleted);
       }
       if (automationStore) {
         automationStore.off("schedule:created", onScheduleCreated);
@@ -797,6 +837,14 @@ export function createSSE(
       chatStore.on("chat:session:deleted", onChatSessionDeleted);
       chatStore.on("chat:message:added", onChatMessageAdded);
       chatStore.on("chat:message:deleted", onChatMessageDeleted);
+      chatStore.on("chat:room:created", onChatRoomCreated);
+      chatStore.on("chat:room:updated", onChatRoomUpdated);
+      chatStore.on("chat:room:deleted", onChatRoomDeleted);
+      chatStore.on("chat:room:member:added", onChatRoomMemberAdded);
+      chatStore.on("chat:room:member:removed", onChatRoomMemberRemoved);
+      chatStore.on("chat:room:message:added", onChatRoomMessageAdded);
+      chatStore.on("chat:room:message:updated", onChatRoomMessageUpdated);
+      chatStore.on("chat:room:message:deleted", onChatRoomMessageDeleted);
     }
 
     if (automationStore) {