@axiom-lattice/gateway 4.1.6 → 4.2.0

package/dist/index.js

@@ -35,8 +35,8 @@ function getContentTypeFromFilename(filename) {
   const ext = filename.includes(".") ? filename.slice(filename.lastIndexOf(".")).toLowerCase() : "";
   return EXT_TO_MIME[ext] ?? "application/octet-stream";
 }
-function getFilenameFromPath(path6) {
-  const segments = path6.replace(/\/+$/, "").split("/");
+function getFilenameFromPath(path7) {
+  const segments = path7.replace(/\/+$/, "").split("/");
   return segments[segments.length - 1] || "download";
 }
 var EXT_TO_MIME;
@@ -647,7 +647,8 @@ function convertToConnection(config) {
     return {
       ...baseConfig,
       transport: config.transport === "streamable_http" ? "http" : config.transport,
-      url: config.url
+      url: config.url,
+      headers: config.headers
     };
   }
 }
@@ -869,17 +870,17 @@ function generateWechatUin() {
   buf.writeUInt32BE(Math.floor(Math.random() * 4294967295), 0);
   return buf.toString("base64url");
 }
-async function apiGet(path6, extraHeaders) {
-  const url = `${getBaseUrl()}${path6}`;
+async function apiGet(path7, extraHeaders) {
+  const url = `${getBaseUrl()}${path7}`;
   const headers = { ...extraHeaders };
   const res = await fetch(url, { headers });
   if (!res.ok) {
-    throw new Error(`iLink GET ${path6} failed: ${res.status} ${res.statusText}`);
+    throw new Error(`iLink GET ${path7} failed: ${res.status} ${res.statusText}`);
   }
   return res.json();
 }
-async function apiPost(path6, body, botToken, signal) {
-  const url = `${getBaseUrl()}${path6}`;
+async function apiPost(path7, body, botToken, signal) {
+  const url = `${getBaseUrl()}${path7}`;
   const headers = {
     "Content-Type": "application/json",
     "AuthorizationType": "ilink_bot_token",
@@ -893,7 +894,7 @@ async function apiPost(path6, body, botToken, signal) {
     signal
   });
   if (!res.ok) {
-    throw new Error(`iLink POST ${path6} failed: ${res.status} ${res.statusText}`);
+    throw new Error(`iLink POST ${path7} failed: ${res.status} ${res.statusText}`);
   }
   return res.json();
 }
@@ -1040,18 +1041,18 @@ function extractText(msg) {
   }
   return null;
 }
-var import_zod14, logger5, wechatConfigSchema, MAX_RECONNECT_DELAY_MS, BASE_RECONNECT_DELAY_MS, HEARTBEAT_INTERVAL_MS, MSG_TYPE_USER, MSG_ITEM_TEXT, activeConnections2, seenClientIds, wechatChannelAdapter;
+var import_zod15, logger5, wechatConfigSchema, MAX_RECONNECT_DELAY_MS, BASE_RECONNECT_DELAY_MS, HEARTBEAT_INTERVAL_MS, MSG_TYPE_USER, MSG_ITEM_TEXT, activeConnections2, seenClientIds, wechatChannelAdapter;
 var init_WechatChannelAdapter = __esm({
   "src/channels/wechat/WechatChannelAdapter.ts"() {
     "use strict";
-    import_zod14 = require("zod");
+    import_zod15 = require("zod");
     init_wechat_client();
     init_context_store();
     init_Logger();
     logger5 = new Logger({ serviceName: "lattice/gateway/wechat" });
-    wechatConfigSchema = import_zod14.z.object({
-      botToken: import_zod14.z.string(),
-      uin: import_zod14.z.string().optional()
+    wechatConfigSchema = import_zod15.z.object({
+      botToken: import_zod15.z.string(),
+      uin: import_zod15.z.string().optional()
     });
     MAX_RECONNECT_DELAY_MS = 3e4;
     BASE_RECONNECT_DELAY_MS = 1e3;
@@ -1512,7 +1513,7 @@ function extractFailureReason(task) {
   return extractText2(task.status.message.parts);
 }
 function observationEventKey(task, result, failureReason) {
-  const digest = (0, import_node_crypto19.createHash)("sha256").update(JSON.stringify({
+  const digest = (0, import_node_crypto21.createHash)("sha256").update(JSON.stringify({
     state: task.status.state,
     timestamp: task.status.timestamp,
     message: task.status.message,
@@ -1522,7 +1523,7 @@ function observationEventKey(task, result, failureReason) {
   return `a2a-status-observation:${task.id}:${digest}`;
 }
 function snapshotEventKey(task) {
-  const digest = (0, import_node_crypto19.createHash)("sha256").update(JSON.stringify(task)).digest("hex");
+  const digest = (0, import_node_crypto21.createHash)("sha256").update(JSON.stringify(task)).digest("hex");
   return `a2a-task-snapshot:${task.id}:${digest}`;
 }
 function isGovernedObservation(state) {
@@ -1534,11 +1535,11 @@ function isA2ATaskSnapshot(value) {
 function snapshotSequence(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
 }
-var import_node_crypto19, import_node_util, TASK_STATUS_TO_A2A_STATE, TITLE_MAX_LENGTH, A2ATaskScopeConflictError, A2ATaskStoreAdapter;
+var import_node_crypto21, import_node_util, TASK_STATUS_TO_A2A_STATE, TITLE_MAX_LENGTH, A2ATaskScopeConflictError, A2ATaskStoreAdapter;
 var init_A2ATaskStoreAdapter = __esm({
   "src/services/a2a/A2ATaskStoreAdapter.ts"() {
     "use strict";
-    import_node_crypto19 = require("crypto");
+    import_node_crypto21 = require("crypto");
     import_node_util = require("util");
     TASK_STATUS_TO_A2A_STATE = {
       pending: "submitted",
@@ -1641,11 +1642,11 @@ var init_A2ATaskStoreAdapter = __esm({
       async recordSnapshot(task, item) {
         const incomingSequence = snapshotSequence(task.metadata?.snapshotSequence) ?? 0;
         const currentSequence = this.snapshotSequences.get(task.id) ?? 0;
-        const sequence2 = Math.max(incomingSequence, currentSequence) + 1;
-        this.snapshotSequences.set(task.id, sequence2);
+        const sequence = Math.max(incomingSequence, currentSequence) + 1;
+        this.snapshotSequences.set(task.id, sequence);
         const sequencedTask = {
           ...task,
-          metadata: { ...task.metadata ?? {}, snapshotSequence: sequence2 }
+          metadata: { ...task.metadata ?? {}, snapshotSequence: sequence }
         };
         const eventKey = snapshotEventKey(sequencedTask);
         await this.workItemStore.createIfAbsentByEventKey({
@@ -1655,7 +1656,7 @@ var init_A2ATaskStoreAdapter = __esm({
           action: "activity",
           actor: `a2a:${this.scope.assistantId}`,
           summary: "A2A task snapshot",
-          detail: { type: "a2a_task_snapshot", snapshotSequence: sequence2, eventKey, task: sequencedTask },
+          detail: { type: "a2a_task_snapshot", snapshotSequence: sequence, eventKey, task: sequencedTask },
           eventKey,
           ...asString(task.metadata?.threadId) ? { threadId: asString(task.metadata?.threadId) } : {},
           ...item.workspaceId ? { workspaceId: item.workspaceId } : {}
@@ -1762,10 +1763,10 @@ var init_A2ATaskStoreAdapter = __esm({
           });
           for (const activity of activities) {
             if (activity.detail?.type !== "a2a_task_snapshot" || !isA2ATaskSnapshot(activity.detail.task)) continue;
-            const sequence2 = snapshotSequence(activity.detail.snapshotSequence) ?? snapshotSequence(activity.detail.task.metadata?.snapshotSequence);
+            const sequence = snapshotSequence(activity.detail.snapshotSequence) ?? snapshotSequence(activity.detail.task.metadata?.snapshotSequence);
             const candidate = {
               task: activity.detail.task,
-              sequence: sequence2,
+              sequence,
               eventKey: asString(activity.detail.eventKey) ?? activity.eventKey ?? snapshotEventKey(activity.detail.task),
               statusTimestamp: Date.parse(activity.detail.task.status.timestamp ?? ""),
               createdAt: activity.createdAt,
@@ -1895,13 +1896,13 @@ function agentMessage(text) {
     parts: [{ kind: "text", text }]
   };
 }
-var import_uuid11, import_core66, import_protocols27, _AxiomAgentExecutor, AxiomAgentExecutor;
+var import_uuid11, import_core66, import_protocols29, _AxiomAgentExecutor, AxiomAgentExecutor;
 var init_AxiomAgentExecutor = __esm({
   "src/services/a2a/AxiomAgentExecutor.ts"() {
     "use strict";
     import_uuid11 = require("uuid");
     import_core66 = require("@axiom-lattice/core");
-    import_protocols27 = require("@axiom-lattice/protocols");
+    import_protocols29 = require("@axiom-lattice/protocols");
     init_a2aFileRefs();
     init_task_file_refs();
     _AxiomAgentExecutor = class _AxiomAgentExecutor {
@@ -1999,7 +2000,7 @@ ${formatFileRefsSection(inputFiles)}` : text;
             const messageText = [
               `A2A governed task instruction: get and update the existing TaskItem ${ctx.taskId}; do not create a replacement task.`,
               "Before doing the requested work, initialize its canonical description through manage_task with ## Objective, ## Acceptance Criteria, and ## Belief State sections.",
-              "Keep lifecycle status truthful. Complete only through manage_task update with a nonblank result and structured beliefImpact; use interrupted, failed, or cancelled when appropriate.",
+              "Keep lifecycle status truthful. Change status only through manage_task set_status; complete with a nonblank result and structured beliefImpact, and use interrupted, failed, or cancelled when appropriate. Use manage_task update for content fields only.",
               "",
               requestText
             ].join("\n");
@@ -2010,16 +2011,16 @@ ${formatFileRefsSection(inputFiles)}` : text;
               custom_run_config: { taskId: ctx.taskId }
             });
             const stream = agent.chunkStream(messageId, [
-              import_protocols27.MessageChunkTypes.MESSAGE_COMPLETED
+              import_protocols29.MessageChunkTypes.MESSAGE_COMPLETED
             ]);
             for await (const chunk of stream) {
               if (execution.canceled) return;
               const chunkType = chunk.type;
               const chunkText = chunk.data?.content ?? "";
-              if (chunkType === import_protocols27.MessageChunkTypes.INTERRUPT) {
+              if (chunkType === import_protocols29.MessageChunkTypes.INTERRUPT) {
                 break;
               }
-              if (chunkType === import_protocols27.MessageChunkTypes.AI || chunkType === import_protocols27.MessageChunkTypes.TOOL) {
+              if (chunkType === import_protocols29.MessageChunkTypes.AI || chunkType === import_protocols29.MessageChunkTypes.TOOL) {
                 if (chunkText) {
                   bus.publish({
                     kind: "status-update",
@@ -2936,6 +2937,236 @@ var init_a2a = __esm({
   }
 });
 
+// src/services/open/openCredentials.ts
+function resolveSpikeCredential(token) {
+  if (!token) return null;
+  return SPIKE_CREDENTIALS.get(token) ?? null;
+}
+var SPIKE_CREDENTIALS;
+var init_openCredentials = __esm({
+  "src/services/open/openCredentials.ts"() {
+    "use strict";
+    SPIKE_CREDENTIALS = /* @__PURE__ */ new Map([
+      [
+        "spike_all",
+        {
+          credentialId: "spike_all",
+          kind: "api_key",
+          tenantId: "spike-tenant",
+          projectId: "spike-project",
+          grants: [{ domain: "kb" }, { domain: "sandbox" }]
+        }
+      ],
+      [
+        "spike_kb",
+        {
+          credentialId: "spike_kb",
+          kind: "api_key",
+          tenantId: "spike-tenant",
+          projectId: "spike-project",
+          grants: [{ domain: "kb" }]
+        }
+      ]
+    ]);
+  }
+});
+
+// src/services/open/mcpTransportRegistry.ts
+var mcpTransportRegistry_exports = {};
+__export(mcpTransportRegistry_exports, {
+  clearSessions: () => clearSessions,
+  deleteSession: () => deleteSession,
+  getSession: () => getSession,
+  registerSession: () => registerSession
+});
+async function registerSession(sessionId, credential, parts) {
+  sessions.set(sessionId, { ...parts, credential });
+}
+async function getSession(sessionId) {
+  return sessions.get(sessionId) ?? null;
+}
+async function deleteSession(sessionId) {
+  const entry = sessions.get(sessionId);
+  if (!entry) return;
+  sessions.delete(sessionId);
+  await entry.transport.close().catch(() => void 0);
+  await entry.server.close().catch(() => void 0);
+}
+async function clearSessions() {
+  for (const sessionId of [...sessions.keys()]) {
+    await deleteSession(sessionId);
+  }
+}
+var sessions;
+var init_mcpTransportRegistry = __esm({
+  "src/services/open/mcpTransportRegistry.ts"() {
+    "use strict";
+    sessions = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/services/open/mcpCatalog.ts
+function textResult(text) {
+  return [{ type: "text", text }];
+}
+function filterCatalogByGrants(credential) {
+  const domains = new Set(credential.grants.map((g) => g.domain));
+  return SPIKE_TOOL_CATALOG.filter((tool) => domains.has(tool.domain));
+}
+var import_zod16, SPIKE_TOOL_CATALOG;
+var init_mcpCatalog = __esm({
+  "src/services/open/mcpCatalog.ts"() {
+    "use strict";
+    import_zod16 = require("zod");
+    SPIKE_TOOL_CATALOG = [
+      {
+        toolName: "kb_search",
+        domain: "kb",
+        description: "Spike: pretend knowledge-base search.",
+        schema: {
+          query: import_zod16.z.string(),
+          limit: import_zod16.z.number().int().optional()
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false },
+        execute: async (args) => {
+          const { query } = args;
+          return textResult(`kb_search spike result for: ${query}`);
+        }
+      },
+      {
+        toolName: "echo",
+        domain: "sandbox",
+        description: "Spike: echoes the message back.",
+        schema: { message: import_zod16.z.string() },
+        annotations: { readOnlyHint: true, destructiveHint: false },
+        execute: async (args) => {
+          const { message } = args;
+          return textResult(`echo: ${message}`);
+        }
+      }
+    ];
+  }
+});
+
+// src/services/open/openMcpServer.ts
+function registerTools(server, tools) {
+  for (const tool of tools) {
+    server.registerTool(
+      tool.toolName,
+      {
+        description: tool.description,
+        inputSchema: tool.schema,
+        annotations: {
+          readOnlyHint: tool.annotations.readOnlyHint,
+          destructiveHint: tool.annotations.destructiveHint
+        }
+      },
+      async (args) => ({ content: await tool.execute(args) })
+    );
+  }
+}
+async function buildSessionServer(credential) {
+  const tools = filterCatalogByGrants(credential);
+  const server = new import_mcp.McpServer(OPEN_MCP_SERVER_INFO);
+  registerTools(server, tools);
+  const transport = new import_streamableHttp.StreamableHTTPServerTransport({
+    sessionIdGenerator: () => {
+      const sessionId = (0, import_crypto12.randomUUID)();
+      void registerSession(
+        sessionId,
+        { credentialId: credential.credentialId, kind: credential.kind },
+        { server, transport }
+      );
+      return sessionId;
+    },
+    enableJsonResponse: true,
+    onsessionclosed: (closedId) => {
+      void Promise.resolve().then(() => (init_mcpTransportRegistry(), mcpTransportRegistry_exports)).then(
+        ({ deleteSession: deleteSession2 }) => deleteSession2(closedId)
+      );
+    }
+  });
+  await server.connect(transport);
+  return { server, transport, tools };
+}
+var import_mcp, import_streamableHttp, import_crypto12, OPEN_MCP_SERVER_INFO;
+var init_openMcpServer = __esm({
+  "src/services/open/openMcpServer.ts"() {
+    "use strict";
+    import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+    import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    import_crypto12 = require("crypto");
+    init_mcpTransportRegistry();
+    init_mcpCatalog();
+    OPEN_MCP_SERVER_INFO = {
+      name: "axiom-open",
+      version: "0.1.0"
+    };
+  }
+});
+
+// src/routes/open.ts
+var open_exports = {};
+__export(open_exports, {
+  registerOpenRoutes: () => registerOpenRoutes
+});
+function extractBearer(request) {
+  const header2 = request.headers.authorization;
+  if (!header2?.startsWith("Bearer ")) return void 0;
+  return header2.slice("Bearer ".length).trim() || void 0;
+}
+function readSessionId(request) {
+  const raw = request.headers["mcp-session-id"];
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function registerOpenRoutes(app2) {
+  app2.post("/open/mcp", async (request, reply) => {
+    const credential = resolveSpikeCredential(extractBearer(request));
+    if (!credential) {
+      return reply.status(401).send({ error: "AUTH_FAILED" });
+    }
+    const body = request.body;
+    const sessionId = readSessionId(request);
+    if (sessionId) {
+      const session = await getSession(sessionId);
+      if (!session || session.credential.credentialId !== credential.credentialId) {
+        return reply.status(404).send({ error: "SESSION_NOT_FOUND" });
+      }
+      reply.hijack();
+      await session.transport.handleRequest(request.raw, reply.raw, body);
+      return;
+    }
+    if (!(0, import_types.isInitializeRequest)(body)) {
+      return reply.status(400).send({ error: "SESSION_REQUIRED" });
+    }
+    const built = await buildSessionServer(credential);
+    reply.hijack();
+    await built.transport.handleRequest(request.raw, reply.raw, body);
+  });
+  app2.delete(
+    "/open/mcp",
+    async (request, reply) => {
+      const sessionId = readSessionId(request);
+      if (!sessionId) {
+        return reply.status(400).send({ error: "SESSION_REQUIRED" });
+      }
+      await deleteSession(sessionId);
+      return reply.status(204).send();
+    }
+  );
+}
+var import_types;
+var init_open = __esm({
+  "src/routes/open.ts"() {
+    "use strict";
+    import_types = require("@modelcontextprotocol/sdk/types.js");
+    init_openCredentials();
+    init_openMcpServer();
+    init_mcpTransportRegistry();
+  }
+});
+
 // src/controllers/resources.ts
 var resources_exports = {};
 __export(resources_exports, {
@@ -3171,8 +3402,8 @@ var init_resources = __esm({
         return cookie.includes(`share_unlock_${token}=1`);
       }
       /** Returns true if the path has a file extension indicating it's a file, not a directory */
-      _isFilePath(path6) {
-        return /\.[a-zA-Z0-9]+$/.test(path6);
+      _isFilePath(path7) {
+        return /\.[a-zA-Z0-9]+$/.test(path7);
       }
       /**
        * Shared file resolution: directory → index.html, volume FS → sandbox, base tag, response.
@@ -3313,8 +3544,8 @@ var import_static = __toESM(require("@fastify/static"));
 var import_path = __toESM(require("path"));
 
 // src/routes/index.ts
-var import_node_crypto18 = require("crypto");
-var import_protocols24 = require("@axiom-lattice/protocols");
+var import_node_crypto20 = require("crypto");
+var import_protocols26 = require("@axiom-lattice/protocols");
 
 // src/controllers/assistant.ts
 var import_core = require("@axiom-lattice/core");
@@ -7381,9 +7612,9 @@ var ExportImportService = class {
     if (!files || files.size === 0) return void 0;
     const prefix = `files/${entityType}/${entityId}/`;
     const result = /* @__PURE__ */ new Map();
-    for (const [path6, content] of files.entries()) {
-      if (path6.startsWith(prefix)) {
-        result.set(path6.slice(prefix.length), content);
+    for (const [path7, content] of files.entries()) {
+      if (path7.startsWith(prefix)) {
+        result.set(path7.slice(prefix.length), content);
       }
     }
     return result.size > 0 ? result : void 0;
@@ -9488,21 +9719,21 @@ var WorkspaceController = class {
   async listPath(request) {
     const tenantId = this.getTenantId(request);
     const { workspaceId, projectId } = request.params;
-    const path6 = request.query.path || "/";
+    const path7 = request.query.path || "/";
     const assistantId = request.query.assistantId;
-    console.log(`[listPath] tenantId=${tenantId} workspaceId=${workspaceId} projectId=${projectId} path=${path6} assistantId=${assistantId}`);
-    const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path6);
-    console.log(`[listPath] backend type=${backend.constructor.name} calling lsInfo(${path6})`);
-    const files = await backend.lsInfo(path6);
+    console.log(`[listPath] tenantId=${tenantId} workspaceId=${workspaceId} projectId=${projectId} path=${path7} assistantId=${assistantId}`);
+    const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path7);
+    console.log(`[listPath] backend type=${backend.constructor.name} calling lsInfo(${path7})`);
+    const files = await backend.lsInfo(path7);
     console.log(`[listPath] result count=${files.length}`);
     return { success: true, data: files };
   }
   async readFile(request) {
     const tenantId = this.getTenantId(request);
     const { workspaceId, projectId } = request.params;
-    const { path: path6, offset = 0, limit = 1e3, assistantId } = request.query;
-    const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path6);
-    const content = await backend.read(path6, Number(offset), Number(limit));
+    const { path: path7, offset = 0, limit = 1e3, assistantId } = request.query;
+    const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path7);
+    const content = await backend.read(path7, Number(offset), Number(limit));
     return { success: true, data: { content, offset, limit } };
   }
   /**
@@ -9688,139 +9919,327 @@ function registerWorkspaceRoutes(app2, projectCollaboration) {
     "/api/filesystem/browse",
     controller.browseFilesystem.bind(controller)
   );
+  return controller;
 }
 
-// src/controllers/database-configs.ts
-var import_core27 = require("@axiom-lattice/core");
-var import_crypto5 = require("crypto");
-function getTenantId9(request) {
-  const userTenantId = request.user?.tenantId;
-  if (userTenantId) {
-    return userTenantId;
+// src/services/collaboration/ProjectAccessService.ts
+var import_node_crypto3 = require("crypto");
+var ProjectCollaborationError = class extends Error {
+  /** Creates a project collaboration error. */
+  constructor(code, statusCode, message) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "ProjectCollaborationError";
   }
-  return request.headers["x-tenant-id"] || "default";
+};
+var allowedRoles = {
+  read: /* @__PURE__ */ new Set(["owner", "admin", "member", "viewer"]),
+  send: /* @__PURE__ */ new Set(["owner", "admin", "member"]),
+  manage: /* @__PURE__ */ new Set(["owner", "admin"])
+};
+var membershipConflictNames = /* @__PURE__ */ new Set([
+  "DuplicateProjectMembershipError",
+  "ProjectMembershipIdConflictError"
+]);
+function isProjectMembershipConflict(error) {
+  return error instanceof Error && membershipConflictNames.has(error.name);
 }
-async function getDatabaseConfigList(request, reply) {
-  const tenantId = getTenantId9(request);
-  try {
-    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
-    const store2 = storeLattice.store;
-    const configs = await store2.getAllConfigs(tenantId);
-    console.log("Backend: getAllConfigs returned:", configs);
-    if (configs.length > 0) {
-      console.log("Backend: First config key:", configs[0].key);
-    }
-    return {
-      success: true,
-      message: "Database configurations retrieved successfully",
-      data: {
-        records: configs,
-        total: configs.length
-      }
-    };
-  } catch (error) {
-    console.error("Failed to get database configs:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve database configurations",
-      data: {
-        records: [],
-        total: 0
-      }
-    };
+var ProjectAccessService = class {
+  /** Creates a project access service from explicitly injected stores. */
+  constructor(deps) {
+    this.deps = deps;
+    this.idFactory = deps.idFactory ?? import_node_crypto3.randomUUID;
   }
-}
-async function getDatabaseConfig(request, reply) {
-  const tenantId = getTenantId9(request);
-  const { key } = request.params;
-  try {
-    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
-    const store2 = storeLattice.store;
-    const config = await store2.getConfigByKey(tenantId, key);
-    if (!config) {
-      return {
-        success: false,
-        message: "Database configuration not found"
-      };
+  /** Returns the project and active membership when the user has the requested capability. */
+  async requireProjectAccess(input) {
+    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
+    if (!project) {
+      throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
     }
-    return {
-      success: true,
-      message: "Database configuration retrieved successfully",
-      data: config
-    };
-  } catch (error) {
-    console.error("Failed to get database config:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve database configuration"
-    };
-  }
-}
-async function createDatabaseConfig(request, reply) {
-  const tenantId = getTenantId9(request);
-  const body = request.body;
-  try {
-    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
-    const store2 = storeLattice.store;
-    const existing = await store2.getConfigByKey(tenantId, body.key);
-    if (existing) {
-      reply.code(409);
-      return {
-        success: false,
-        message: "Database configuration with this key already exists"
-      };
+    if (project.kind === "public") {
+      return this.requirePublicProjectAccess(project, input);
     }
-    const id3 = body.id || (0, import_crypto5.randomUUID)();
-    const config = await store2.createConfig(tenantId, id3, body);
+    const membership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (membership?.status === "active") {
+      this.requireCapability(membership, input.capability);
+      return { project, membership };
+    }
+    const memberships = await this.deps.membershipStore.list(input.tenantId, input.projectId);
+    if (memberships.length !== 0) this.accessDenied();
+    if (project.kind === "personal") this.accessDenied();
+    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
+    if (tenantLink?.role !== "owner" && tenantLink?.role !== "admin") this.accessDenied();
+    let claim;
     try {
-      import_core27.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
+      claim = await this.deps.membershipStore.createInitialOwner({
+        id: this.idFactory(),
+        tenantId: input.tenantId,
+        projectId: input.projectId,
+        userId: input.userId
+      });
     } catch (error) {
-      console.warn("Failed to auto-register database:", error);
-    }
-    reply.code(201);
-    return {
-      success: true,
-      message: "Database configuration created successfully",
-      data: config
-    };
-  } catch (error) {
-    console.error("Failed to create database config:", error);
-    return {
-      success: false,
-      message: "Failed to create database configuration"
-    };
-  }
-}
-async function updateDatabaseConfig(request, reply) {
-  const tenantId = getTenantId9(request);
-  const { key } = request.params;
-  const updates = request.body;
-  try {
-    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
-    const store2 = storeLattice.store;
-    const existing = await store2.getConfigByKey(tenantId, key);
-    if (!existing) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Database configuration not found"
-      };
-    }
-    const updated = await store2.updateConfig(tenantId, existing.id, updates);
-    if (!updated) {
-      return {
-        success: false,
-        message: "Failed to update database configuration"
-      };
-    }
-    if (updates.config) {
-      try {
-        import_core27.sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
-      } catch (error) {
-        console.warn("Failed to re-register database:", error);
+      if (isProjectMembershipConflict(error)) {
+        throw new ProjectCollaborationError(
+          "PROJECT_MEMBERSHIP_CONFLICT",
+          409,
+          "Project membership could not be initialized"
+        );
       }
+      throw error;
     }
-    return {
+    if (claim.kind === "created" || claim.kind === "existing") {
+      return { project, membership: claim.membership };
+    }
+    const racedMembership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (racedMembership?.status !== "active") this.accessDenied();
+    this.requireCapability(racedMembership, input.capability);
+    return { project, membership: racedMembership };
+  }
+  /** Authorizes an already-existing membership, or any tenant member for public rooms; never mutates persistence. */
+  async requireExistingProjectAccess(input) {
+    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
+    if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
+    if (project.kind === "public") {
+      return this.requireExistingPublicProjectAccess(project, input);
+    }
+    const membership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (!membership || membership.tenantId !== input.tenantId || membership.projectId !== input.projectId || membership.userId !== input.userId || membership.status !== "active") this.accessDenied();
+    this.requireCapability(membership, input.capability);
+    return { project, membership };
+  }
+  /** Authorizes roster visibility: read for public rooms, manage elsewhere. */
+  async requireRosterAccess(input) {
+    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
+    if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
+    return this.requireProjectAccess({
+      ...input,
+      capability: project.kind === "public" ? "read" : "manage"
+    });
+  }
+  async requirePublicProjectAccess(project, input) {
+    const membership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (membership?.status === "active") {
+      this.requireCapability(membership, input.capability);
+      return { project, membership };
+    }
+    const materialized = await this.materializePublicMembership(input);
+    this.requireCapability(materialized, input.capability);
+    return { project, membership: materialized };
+  }
+  async requireExistingPublicProjectAccess(project, input) {
+    const membership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (membership?.status === "active") {
+      this.requireCapability(membership, input.capability);
+      return { project, membership };
+    }
+    if (membership) this.accessDenied();
+    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
+    if (!tenantLink) this.accessDenied();
+    const role = tenantLink.role === "owner" || tenantLink.role === "admin" ? "admin" : "member";
+    const synthetic = {
+      id: `public:${input.userId}`,
+      tenantId: input.tenantId,
+      projectId: input.projectId,
+      userId: input.userId,
+      role,
+      status: "active",
+      joinedAt: project.createdAt,
+      updatedAt: project.updatedAt
+    };
+    this.requireCapability(synthetic, input.capability);
+    return { project, membership: synthetic };
+  }
+  async materializePublicMembership(input) {
+    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
+    if (!tenantLink) this.accessDenied();
+    const existing = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (existing) this.accessDenied();
+    const role = tenantLink.role === "owner" || tenantLink.role === "admin" ? "admin" : "member";
+    try {
+      return await this.deps.membershipStore.create({
+        id: this.idFactory(),
+        tenantId: input.tenantId,
+        projectId: input.projectId,
+        userId: input.userId,
+        role,
+        status: "active"
+      });
+    } catch (error) {
+      if (isProjectMembershipConflict(error)) {
+        const raced = await this.deps.membershipStore.findByUser(
+          input.tenantId,
+          input.projectId,
+          input.userId
+        );
+        if (raced?.status === "active") return raced;
+      }
+      throw error;
+    }
+  }
+  requireCapability(membership, capability2) {
+    if (!allowedRoles[capability2].has(membership.role)) this.accessDenied();
+  }
+  accessDenied() {
+    throw new ProjectCollaborationError("PROJECT_ACCESS_DENIED", 403, "Project access denied");
+  }
+};
+
+// src/controllers/database-configs.ts
+var import_core27 = require("@axiom-lattice/core");
+var import_crypto5 = require("crypto");
+function getTenantId9(request) {
+  const userTenantId = request.user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
+  return request.headers["x-tenant-id"] || "default";
+}
+async function getDatabaseConfigList(request, reply) {
+  const tenantId = getTenantId9(request);
+  try {
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
+    const store2 = storeLattice.store;
+    const configs = await store2.getAllConfigs(tenantId);
+    console.log("Backend: getAllConfigs returned:", configs);
+    if (configs.length > 0) {
+      console.log("Backend: First config key:", configs[0].key);
+    }
+    return {
+      success: true,
+      message: "Database configurations retrieved successfully",
+      data: {
+        records: configs,
+        total: configs.length
+      }
+    };
+  } catch (error) {
+    console.error("Failed to get database configs:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve database configurations",
+      data: {
+        records: [],
+        total: 0
+      }
+    };
+  }
+}
+async function getDatabaseConfig(request, reply) {
+  const tenantId = getTenantId9(request);
+  const { key } = request.params;
+  try {
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
+    const store2 = storeLattice.store;
+    const config = await store2.getConfigByKey(tenantId, key);
+    if (!config) {
+      return {
+        success: false,
+        message: "Database configuration not found"
+      };
+    }
+    return {
+      success: true,
+      message: "Database configuration retrieved successfully",
+      data: config
+    };
+  } catch (error) {
+    console.error("Failed to get database config:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve database configuration"
+    };
+  }
+}
+async function createDatabaseConfig(request, reply) {
+  const tenantId = getTenantId9(request);
+  const body = request.body;
+  try {
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
+    const store2 = storeLattice.store;
+    const existing = await store2.getConfigByKey(tenantId, body.key);
+    if (existing) {
+      reply.code(409);
+      return {
+        success: false,
+        message: "Database configuration with this key already exists"
+      };
+    }
+    const id3 = body.id || (0, import_crypto5.randomUUID)();
+    const config = await store2.createConfig(tenantId, id3, body);
+    try {
+      import_core27.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
+    } catch (error) {
+      console.warn("Failed to auto-register database:", error);
+    }
+    reply.code(201);
+    return {
+      success: true,
+      message: "Database configuration created successfully",
+      data: config
+    };
+  } catch (error) {
+    console.error("Failed to create database config:", error);
+    return {
+      success: false,
+      message: "Failed to create database configuration"
+    };
+  }
+}
+async function updateDatabaseConfig(request, reply) {
+  const tenantId = getTenantId9(request);
+  const { key } = request.params;
+  const updates = request.body;
+  try {
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
+    const store2 = storeLattice.store;
+    const existing = await store2.getConfigByKey(tenantId, key);
+    if (!existing) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Database configuration not found"
+      };
+    }
+    const updated = await store2.updateConfig(tenantId, existing.id, updates);
+    if (!updated) {
+      return {
+        success: false,
+        message: "Failed to update database configuration"
+      };
+    }
+    if (updates.config) {
+      try {
+        import_core27.sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
+      } catch (error) {
+        console.warn("Failed to re-register database:", error);
+      }
+    }
+    return {
       success: true,
       message: "Database configuration updated successfully",
       data: updated
@@ -11745,7 +12164,7 @@ function registerTenantRoutes(app2) {
 // src/controllers/auth.ts
 var import_core35 = require("@axiom-lattice/core");
 var import_uuid8 = require("uuid");
-var import_node_crypto3 = require("crypto");
+var import_node_crypto4 = require("crypto");
 var defaultAuthConfig = {
   autoApproveUsers: true,
   allowTenantRegistration: true,
@@ -12100,7 +12519,7 @@ var AuthController = class {
 function resolveConsoleTokenSecret(_authRequired) {
   const configured = process.env.AUTH_TOKEN_SECRET || process.env.JWT_SECRET;
   if (configured) return configured;
-  devSessionSecret ?? (devSessionSecret = (0, import_node_crypto3.randomBytes)(32).toString("hex"));
+  devSessionSecret ?? (devSessionSecret = (0, import_node_crypto4.randomBytes)(32).toString("hex"));
   console.warn(
     "[auth] AUTH_TOKEN_SECRET/JWT_SECRET is not set; using an in-process generated signing secret (sessions are invalidated on restart). Set AUTH_TOKEN_SECRET for production."
   );
@@ -12109,7 +12528,7 @@ function resolveConsoleTokenSecret(_authRequired) {
 var devSessionSecret;
 function createConsoleSessionToken(payload, secret) {
   const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
-  const signature = (0, import_node_crypto3.createHmac)("sha256", secret).update(encodedPayload).digest("base64url");
+  const signature = (0, import_node_crypto4.createHmac)("sha256", secret).update(encodedPayload).digest("base64url");
   return `${encodedPayload}.${signature}`;
 }
 function isConsoleSessionPayload(value) {
@@ -12136,8 +12555,8 @@ function verifySignedConsoleSession(authHeader, secret) {
   try {
     const actualSignature = Buffer.from(encodedSignature, "base64url");
     if (actualSignature.toString("base64url") !== encodedSignature) return void 0;
-    const expectedSignature = (0, import_node_crypto3.createHmac)("sha256", secret).update(encodedPayload).digest();
-    if (actualSignature.length !== expectedSignature.length || !(0, import_node_crypto3.timingSafeEqual)(actualSignature, expectedSignature)) {
+    const expectedSignature = (0, import_node_crypto4.createHmac)("sha256", secret).update(encodedPayload).digest();
+    if (actualSignature.length !== expectedSignature.length || !(0, import_node_crypto4.timingSafeEqual)(actualSignature, expectedSignature)) {
       return void 0;
     }
     const payload = JSON.parse(
@@ -12167,13 +12586,13 @@ function isStaleConsoleSessionCredential(authHeader) {
   }
 }
 function bypassesConsoleAuth(request) {
-  const path6 = request.url.split("?")[0];
+  const path7 = request.url.split("?")[0];
   const method = request.method;
-  if (method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/bootstrap$/.test(path6) || (method === "GET" || method === "POST") && /^\/api\/web-apps\/[^/]+\/runtime\/threads$/.test(path6) || (method === "PATCH" || method === "DELETE") && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+$/.test(path6) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/messages$/.test(path6) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/(messages\/stream|abort|attachments)$/.test(path6) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/interrupts\/[^/]+\/resume$/.test(path6)) return true;
-  if (request.method === "GET" && /^\/api\/a2a\/agents\/[^/]+\/\.well-known\/agent-card\.json$/.test(path6)) {
+  if (method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/bootstrap$/.test(path7) || (method === "GET" || method === "POST") && /^\/api\/web-apps\/[^/]+\/runtime\/threads$/.test(path7) || (method === "PATCH" || method === "DELETE") && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+$/.test(path7) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/messages$/.test(path7) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/files\/(viewfile|downloadfile)$/.test(path7) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/api\/assistants\/[^/]+\/threads\/[^/]+\/sandbox\/(viewfile|downloadfile)$/.test(path7) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/(messages\/stream|abort|attachments)$/.test(path7) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/interrupts\/[^/]+\/resume$/.test(path7) || method === "GET" && /^\/api\/web-apps\/[^/]+\/chat$/.test(path7) || method === "GET" && /^\/embed\/[^/]+$/.test(path7) || (method === "POST" || method === "DELETE") && path7 === "/open/mcp") return true;
+  if (request.method === "GET" && /^\/api\/a2a\/agents\/[^/]+\/\.well-known\/agent-card\.json$/.test(path7)) {
     return true;
   }
-  return request.method === "POST" && /^\/api\/a2a\/agents\/[^/]+\/jsonrpc$/.test(path6);
+  return request.method === "POST" && /^\/api\/a2a\/agents\/[^/]+\/jsonrpc$/.test(path7);
 }
 function registerConsoleAuthHook(app2, options) {
   app2.addHook("preHandler", async (request, reply) => {
@@ -12196,8 +12615,8 @@ function registerConsoleAuthHook(app2, options) {
     }
     if (PUBLIC_ROUTES.some((route) => request.url === route)) return;
     if (request.url.startsWith("/s/")) return;
-    const path6 = request.url.split("?")[0];
-    if (request.method === "GET" && /^\/api\/workspaces\/[^/]+\/projects\/[^/]+\/viewfile$/.test(path6) || request.method === "GET" && /^\/api\/workspaces\/[^/]+\/projects\/[^/]+\/downloadfile$/.test(path6) || request.method === "POST" && /^\/api\/workspaces\/[^/]+\/projects\/[^/]+\/uploadfile$/.test(path6) || path6.startsWith("/f/") || path6 === "/f") {
+    const path7 = request.url.split("?")[0];
+    if (request.method === "GET" && /^\/api\/workspaces\/[^/]+\/projects\/[^/]+\/viewfile$/.test(path7) || request.method === "GET" && /^\/api\/workspaces\/[^/]+\/projects\/[^/]+\/downloadfile$/.test(path7) || request.method === "POST" && /^\/api\/workspaces\/[^/]+\/projects\/[^/]+\/uploadfile$/.test(path7) || path7.startsWith("/f/") || path7 === "/f") {
       return;
     }
     await reply.status(401).send({
@@ -13323,8 +13742,8 @@ var log = {
 };
 var connections = /* @__PURE__ */ new Map();
 var pending = /* @__PURE__ */ new Map();
-function getAgentIdFromPath(path6) {
-  const match = path6.match(/^\/api\/a2a\/bridge\/proxy\/([^/]+)/);
+function getAgentIdFromPath(path7) {
+  const match = path7.match(/^\/api\/a2a\/bridge\/proxy\/([^/]+)/);
   return match ? match[1] : null;
 }
 function handleBridgeConnection(socket, _request) {
@@ -13718,7 +14137,7 @@ async function getLocalA2ATemplates(_request, reply) {
 }
 
 // src/routes/a2a-test-connection.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 function describeTestConnectionError(error, agentCardUrl) {
   if (!(error instanceof Error)) {
     return `Failed to fetch agent card from ${agentCardUrl}: ${String(error)}`;
@@ -13758,7 +14177,7 @@ async function ensureLocalRuntimeForConnectionTest(localRuntime, agentCardUrl) {
     return { error: portValidation.error };
   }
   const state = await localA2AService.startProvider(
-    `test-${(0, import_node_crypto4.randomUUID)()}`,
+    `test-${(0, import_node_crypto5.randomUUID)()}`,
     testRuntime
   );
   if (state.status === "running") return { runtimeId: state.runtimeId };
@@ -13835,193 +14254,6 @@ var import_core51 = require("@axiom-lattice/core");
 var import_protocols10 = require("@axiom-lattice/protocols");
 var import_core42 = require("@axiom-lattice/core");
 
-// src/services/collaboration/ProjectAccessService.ts
-var import_node_crypto5 = require("crypto");
-var ProjectCollaborationError = class extends Error {
-  /** Creates a project collaboration error. */
-  constructor(code, statusCode, message) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.name = "ProjectCollaborationError";
-  }
-};
-var allowedRoles = {
-  read: /* @__PURE__ */ new Set(["owner", "admin", "member", "viewer"]),
-  send: /* @__PURE__ */ new Set(["owner", "admin", "member"]),
-  manage: /* @__PURE__ */ new Set(["owner", "admin"])
-};
-var membershipConflictNames = /* @__PURE__ */ new Set([
-  "DuplicateProjectMembershipError",
-  "ProjectMembershipIdConflictError"
-]);
-function isProjectMembershipConflict(error) {
-  return error instanceof Error && membershipConflictNames.has(error.name);
-}
-var ProjectAccessService = class {
-  /** Creates a project access service from explicitly injected stores. */
-  constructor(deps) {
-    this.deps = deps;
-    this.idFactory = deps.idFactory ?? import_node_crypto5.randomUUID;
-  }
-  /** Returns the project and active membership when the user has the requested capability. */
-  async requireProjectAccess(input) {
-    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
-    if (!project) {
-      throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
-    }
-    if (project.kind === "public") {
-      return this.requirePublicProjectAccess(project, input);
-    }
-    const membership = await this.deps.membershipStore.findByUser(
-      input.tenantId,
-      input.projectId,
-      input.userId
-    );
-    if (membership?.status === "active") {
-      this.requireCapability(membership, input.capability);
-      return { project, membership };
-    }
-    const memberships = await this.deps.membershipStore.list(input.tenantId, input.projectId);
-    if (memberships.length !== 0) this.accessDenied();
-    if (project.kind === "personal") this.accessDenied();
-    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
-    if (tenantLink?.role !== "owner" && tenantLink?.role !== "admin") this.accessDenied();
-    let claim;
-    try {
-      claim = await this.deps.membershipStore.createInitialOwner({
-        id: this.idFactory(),
-        tenantId: input.tenantId,
-        projectId: input.projectId,
-        userId: input.userId
-      });
-    } catch (error) {
-      if (isProjectMembershipConflict(error)) {
-        throw new ProjectCollaborationError(
-          "PROJECT_MEMBERSHIP_CONFLICT",
-          409,
-          "Project membership could not be initialized"
-        );
-      }
-      throw error;
-    }
-    if (claim.kind === "created" || claim.kind === "existing") {
-      return { project, membership: claim.membership };
-    }
-    const racedMembership = await this.deps.membershipStore.findByUser(
-      input.tenantId,
-      input.projectId,
-      input.userId
-    );
-    if (racedMembership?.status !== "active") this.accessDenied();
-    this.requireCapability(racedMembership, input.capability);
-    return { project, membership: racedMembership };
-  }
-  /** Authorizes an already-existing membership, or any tenant member for public rooms; never mutates persistence. */
-  async requireExistingProjectAccess(input) {
-    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
-    if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
-    if (project.kind === "public") {
-      return this.requireExistingPublicProjectAccess(project, input);
-    }
-    const membership = await this.deps.membershipStore.findByUser(
-      input.tenantId,
-      input.projectId,
-      input.userId
-    );
-    if (!membership || membership.tenantId !== input.tenantId || membership.projectId !== input.projectId || membership.userId !== input.userId || membership.status !== "active") this.accessDenied();
-    this.requireCapability(membership, input.capability);
-    return { project, membership };
-  }
-  /** Authorizes roster visibility: read for public rooms, manage elsewhere. */
-  async requireRosterAccess(input) {
-    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
-    if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
-    return this.requireProjectAccess({
-      ...input,
-      capability: project.kind === "public" ? "read" : "manage"
-    });
-  }
-  async requirePublicProjectAccess(project, input) {
-    const membership = await this.deps.membershipStore.findByUser(
-      input.tenantId,
-      input.projectId,
-      input.userId
-    );
-    if (membership?.status === "active") {
-      this.requireCapability(membership, input.capability);
-      return { project, membership };
-    }
-    const materialized = await this.materializePublicMembership(input);
-    this.requireCapability(materialized, input.capability);
-    return { project, membership: materialized };
-  }
-  async requireExistingPublicProjectAccess(project, input) {
-    const membership = await this.deps.membershipStore.findByUser(
-      input.tenantId,
-      input.projectId,
-      input.userId
-    );
-    if (membership?.status === "active") {
-      this.requireCapability(membership, input.capability);
-      return { project, membership };
-    }
-    if (membership) this.accessDenied();
-    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
-    if (!tenantLink) this.accessDenied();
-    const role = tenantLink.role === "owner" || tenantLink.role === "admin" ? "admin" : "member";
-    const synthetic = {
-      id: `public:${input.userId}`,
-      tenantId: input.tenantId,
-      projectId: input.projectId,
-      userId: input.userId,
-      role,
-      status: "active",
-      joinedAt: project.createdAt,
-      updatedAt: project.updatedAt
-    };
-    this.requireCapability(synthetic, input.capability);
-    return { project, membership: synthetic };
-  }
-  async materializePublicMembership(input) {
-    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
-    if (!tenantLink) this.accessDenied();
-    const existing = await this.deps.membershipStore.findByUser(
-      input.tenantId,
-      input.projectId,
-      input.userId
-    );
-    if (existing) this.accessDenied();
-    const role = tenantLink.role === "owner" || tenantLink.role === "admin" ? "admin" : "member";
-    try {
-      return await this.deps.membershipStore.create({
-        id: this.idFactory(),
-        tenantId: input.tenantId,
-        projectId: input.projectId,
-        userId: input.userId,
-        role,
-        status: "active"
-      });
-    } catch (error) {
-      if (isProjectMembershipConflict(error)) {
-        const raced = await this.deps.membershipStore.findByUser(
-          input.tenantId,
-          input.projectId,
-          input.userId
-        );
-        if (raced?.status === "active") return raced;
-      }
-      throw error;
-    }
-  }
-  requireCapability(membership, capability2) {
-    if (!allowedRoles[capability2].has(membership.role)) this.accessDenied();
-  }
-  accessDenied() {
-    throw new ProjectCollaborationError("PROJECT_ACCESS_DENIED", 403, "Project access denied");
-  }
-};
-
 // src/services/collaboration/ProjectTaskThreadService.ts
 var import_core40 = require("@axiom-lattice/core");
 var import_protocols9 = require("@axiom-lattice/protocols");
@@ -14553,9 +14785,6 @@ function governedUpdate(task, body) {
   if (has("ownerType") && body.ownerType !== task.ownerType || has("ownerId") && body.ownerId !== task.ownerId) {
     return "TASK_OWNERSHIP_IMMUTABLE";
   }
-  if (task.ownerType !== "agent") return void 0;
-  if (has("parentId") && body.parentId !== task.parentId || has("dependencies") || has("requireReview") || has("result") || has("failureReason") || has("status")) return "TASK_LIFECYCLE_TRANSITION_REQUIRED";
-  if (has("context") || has("description")) return "COMPLETION_CONTEXT_MUTATION";
   return void 0;
 }
 function lifecycleStatus(code) {
@@ -14996,7 +15225,8 @@ var AgentWebAppService = class {
       integration: current.integration,
       scope: { ...current.scope, ...patch.scope },
       features: { ...current.features, ...patch.features },
-      appearance: { ...current.appearance, ...patch.appearance }
+      appearance: { ...current.appearance, ...patch.appearance },
+      identity: patch.identity ?? current.identity
     };
     await this.validateAssistant(context, current.assistantId);
     const validated = await this.validateConfig(context.tenantId, effective);
@@ -15005,7 +15235,8 @@ var AgentWebAppService = class {
       ...Object.prototype.hasOwnProperty.call(patch, "description") ? { description: validated.description } : {},
       ...patch.scope ? { scope: validated.scope } : {},
       ...patch.features ? { features: validated.features } : {},
-      ...patch.appearance ? { appearance: validated.appearance } : {}
+      ...patch.appearance ? { appearance: validated.appearance } : {},
+      ...patch.identity !== void 0 ? { identity: patch.identity } : {}
     };
     return this.writeSnapshot(context, current, update);
   }
@@ -15118,13 +15349,28 @@ var agentWebAppFeaturesSchema = import_zod4.z.object({
   threadManagement: import_zod4.z.boolean(),
   attachments: import_zod4.z.boolean(),
   hitl: import_zod4.z.boolean(),
-  genUI: import_zod4.z.boolean()
+  genUI: import_zod4.z.boolean(),
+  files: import_zod4.z.boolean().optional()
 }).strict();
 var agentWebAppAppearanceSchema = import_zod4.z.object({
   title: import_zod4.z.string().max(120).optional(),
   welcomeMessage: import_zod4.z.string().max(1e3).optional(),
   primaryColor: import_zod4.z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional()
 }).strict();
+var agentWebAppIssuerSchema = import_zod4.z.object({
+  iss: import_zod4.z.string().min(1).max(255),
+  aud: import_zod4.z.string().min(1).max(255),
+  alg: import_zod4.z.enum(["HS256", "RS256"]),
+  secret: import_zod4.z.string().min(1).max(512).optional(),
+  jwksUrl: import_zod4.z.string().url().max(2048).optional()
+}).strict().refine(
+  (value) => value.alg === "HS256" ? value.secret !== void 0 : value.jwksUrl !== void 0,
+  { message: "HS256 requires secret; RS256 requires jwksUrl" }
+);
+var agentWebAppIdentitySchema = import_zod4.z.object({
+  policy: import_zod4.z.enum(["unverified", "verified", "both"]),
+  issuers: import_zod4.z.array(agentWebAppIssuerSchema).min(1).max(10)
+}).strict();
 var createAgentWebAppSchema = import_zod4.z.object({
   assistantId: externalId,
   name: import_zod4.z.string().min(1).max(120),
@@ -15132,14 +15378,16 @@ var createAgentWebAppSchema = import_zod4.z.object({
   integration: import_zod4.z.object({ type: import_zod4.z.literal("react_sdk") }).strict(),
   scope: agentWebAppScopeSchema,
   features: agentWebAppFeaturesSchema,
-  appearance: agentWebAppAppearanceSchema
+  appearance: agentWebAppAppearanceSchema,
+  identity: agentWebAppIdentitySchema.optional()
 }).strict();
 var updateAgentWebAppSchema = import_zod4.z.object({
   name: import_zod4.z.string().min(1).max(120).optional(),
   description: import_zod4.z.string().max(1e3).optional(),
   scope: agentWebAppScopeSchema.partial().strict().optional(),
   features: agentWebAppFeaturesSchema.partial().strict().optional(),
-  appearance: agentWebAppAppearanceSchema.partial().strict().optional()
+  appearance: agentWebAppAppearanceSchema.partial().strict().optional(),
+  identity: agentWebAppIdentitySchema.optional()
 }).strict().refine((value) => Object.keys(value).length > 0, "Patch must not be empty");
 var listAgentWebAppsQuerySchema = import_zod4.z.object({
   assistantId: externalId.optional()
@@ -15226,6 +15474,7 @@ function invalidRequest(reply, statusCode) {
 }
 
 // src/routes/agent-web-app-runtime.ts
+var import_node_crypto8 = require("crypto");
 var import_zod6 = require("zod");
 
 // src/services/agent-web-app/AgentWebAppRuntimeService.ts
@@ -15247,7 +15496,16 @@ var AgentWebAppRuntimeService = class {
   constructor(deps) {
     this.deps = deps;
   }
-  async bootstrap(webAppId, userId, selection) {
+  /** Identity policy configuration for the web app, or null when the app is missing/unconfigured. */
+  async getIdentityConfig(webAppId) {
+    try {
+      const runtime = await this.resolveRuntime(webAppId, {});
+      return runtime.webApp.identity ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async bootstrap(webAppId, userId, selection, identity) {
     const runtime = await this.resolveRuntime(webAppId, selection);
     const assistant = await this.deps.assistantResolver.resolve(
       runtime.webApp.tenantId,
@@ -15280,7 +15538,7 @@ var AgentWebAppRuntimeService = class {
         defaultModelKey: runtime.webApp.scope.defaultModelKey,
         features: runtime.webApp.features,
         appearance: runtime.webApp.appearance,
-        identityAssurance: "unverified"
+        identityAssurance: identity?.assurance ?? "unverified"
       },
       projects,
       models
@@ -15301,6 +15559,14 @@ var AgentWebAppRuntimeService = class {
     this.requireFeature(runtime.webApp.features.threadManagement);
     return this.createOwnedThread(runtime, userId, input.label);
   }
+  /** Fetch one owned thread. */
+  async getThread(webAppId, userId, threadId, selection) {
+    const runtime = await this.resolveRuntime(webAppId, selection);
+    await this.requireOwnedThread(runtime, userId, threadId);
+    const thread = await this.deps.threadStore.getThreadById(runtime.webApp.tenantId, threadId);
+    if (!thread) this.threadNotFound();
+    return toRuntimeThread(thread);
+  }
   /** Update a thread label; omitted or blank labels preserve the existing label. */
   async updateThread(webAppId, userId, threadId, input) {
     const runtime = await this.resolveRuntime(webAppId, input);
@@ -15335,6 +15601,60 @@ var AgentWebAppRuntimeService = class {
       return [{ id: message.id, role: message.role, ...content && (typeof content === "string" || content.length > 0) ? { content } : {} }];
     });
   }
+  async getState(webAppId, userId, threadId, selection) {
+    const runtime = await this.resolveRuntime(webAppId, selection);
+    await this.requireOwnedThread(runtime, userId, threadId);
+    const agent = this.resolveAgent(runtime, threadId);
+    const state = await agent.getCurrentState();
+    const pendingMessages = await agent.getPendingMessages();
+    const normalized = pendingMessages.map((message) => ({
+      ...message,
+      content: typeof message.content === "object" && message.content !== null ? "message" in message.content ? message.content.message : JSON.stringify(message.content) : String(message.content ?? "")
+    }));
+    return { ...state && typeof state === "object" ? state : {}, pendingMessages: normalized };
+  }
+  /** Raw stored messages (Console memory contract, tool/interrupt preserved). */
+  async getConsoleMessages(webAppId, userId, threadId, selection) {
+    const runtime = await this.resolveRuntime(webAppId, selection);
+    await this.requireOwnedThread(runtime, userId, threadId);
+    return this.deps.messageReader.getCurrentMessages({
+      tenantId: runtime.webApp.tenantId,
+      assistantId: runtime.webApp.assistantId,
+      threadId,
+      workspaceId: runtime.project.workspaceId,
+      projectId: runtime.project.id
+    });
+  }
+  /** Background enqueue only (ADR-026): returns the message id; delivery happens over resume_stream. */
+  async enqueueMessage(webAppId, userId, threadId, content, selection) {
+    const runtime = await this.resolveOwnedRuntime(webAppId, userId, threadId, selection);
+    const agent = this.resolveAgent(runtime, threadId);
+    const execution = await this.execute(agent, runtime, { input: { message: content } });
+    return { messageId: execution.messageId };
+  }
+  async removePendingMessage(webAppId, userId, threadId, messageId, selection) {
+    const runtime = await this.resolveRuntime(webAppId, selection);
+    await this.requireOwnedThread(runtime, userId, threadId);
+    const agent = this.resolveAgent(runtime, threadId);
+    if (!await agent.removePendingMessage(messageId)) this.threadNotFound();
+  }
+  /** Thread-lifetime SSE resume from the last known client message id. */
+  async resumeStream(webAppId, userId, threadId, messageId, selection) {
+    const runtime = await this.resolveRuntime(webAppId, selection);
+    await this.requireOwnedThread(runtime, userId, threadId);
+    const agent = this.resolveAgent(runtime, threadId);
+    return { stream: agent.chunkStream(messageId, []) };
+  }
+  async resolveFileScope(webAppId, selection) {
+    const runtime = await this.resolveRuntime(webAppId, selection);
+    return {
+      tenantId: runtime.webApp.tenantId,
+      workspaceId: runtime.project.workspaceId,
+      projectId: runtime.project.id,
+      assistantId: runtime.webApp.assistantId,
+      enabled: runtime.webApp.features.files === true
+    };
+  }
   async streamMessage(webAppId, userId, threadId, input) {
     const runtime = await this.resolveOwnedRuntime(webAppId, userId, threadId, input);
     const refs = this.resolveAttachmentRefs(runtime, userId, threadId, input.attachmentRefs ?? []);
@@ -15579,93 +15899,102 @@ function toRuntimeThread(thread) {
   };
 }
 
-// src/services/agent-web-app/AgentWebAppStreamProjector.ts
-var import_protocols12 = require("@axiom-lattice/protocols");
-function createAgentWebAppStreamProjectionContext(options = {}) {
-  return { startedToolIds: /* @__PURE__ */ new Set(), allowInterrupts: options.allowInterrupts ?? true, allowGenUI: options.allowGenUI ?? false };
+// src/services/agent-web-app/AgentWebAppTokenVerifier.ts
+var import_node_crypto7 = require("crypto");
+var WebAppTokenError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebAppTokenError";
+  }
+};
+var MAX_TOKEN_BYTES = 8 * 1024;
+var CLOCK_SKEW_SECONDS = 60;
+var JWKS_TTL_MS = 10 * 60 * 1e3;
+var jwksCache = /* @__PURE__ */ new Map();
+function decodeSegment(segment) {
+  const json = Buffer.from(segment, "base64url").toString("utf8");
+  let value;
+  try {
+    value = JSON.parse(json);
+  } catch {
+    throw new WebAppTokenError("Malformed token segment");
+  }
+  if (typeof value !== "object" || value === null) throw new WebAppTokenError("Malformed token segment");
+  return value;
 }
-function projectAgentWebAppChunk(chunk, context) {
-  if (chunk.type === import_protocols12.MessageChunkTypes.AI) {
-    const events = [];
-    const startedToolIds = context?.startedToolIds ?? /* @__PURE__ */ new Set();
-    if (typeof chunk.data.content === "string" && chunk.data.content) events.push({ type: "message.delta", text: chunk.data.content });
-    if (context?.allowGenUI && Array.isArray(chunk.data.content)) {
-      for (const value of chunk.data.content) {
-        const block = (0, import_protocols12.parseAgentWebAppGenUIBlock)(value);
-        if (block) events.push({ type: "genui.render", block });
-      }
-    }
-    for (const call of chunk.data.tool_call_chunks ?? []) {
-      if (call.id && call.name && !startedToolIds.has(call.id)) {
-        startedToolIds.add(call.id);
-        events.push({ type: "tool.started", id: call.id, name: call.name });
-      }
+async function resolveKey(issuer, kid, fetchImpl) {
+  const cacheKey = issuer.jwksUrl ?? "";
+  const load = async () => {
+    const response = await fetchImpl(issuer.jwksUrl ?? "");
+    if (!response.ok) throw new WebAppTokenError("JWKS fetch failed");
+    const document = await response.json();
+    const keys2 = document.keys;
+    const entry2 = { keys: Array.isArray(keys2) ? keys2 : [], fetchedAt: Date.now() };
+    jwksCache.set(cacheKey, entry2);
+    return entry2;
+  };
+  const cached = jwksCache.get(cacheKey);
+  let entry = cached && Date.now() - cached.fetchedAt < JWKS_TTL_MS ? cached : await load();
+  let jwk = entry.keys.find((key) => kid === void 0 ? true : key.kid === kid);
+  if (!jwk && kid !== void 0) {
+    entry = await load();
+    jwk = entry.keys.find((key) => key.kid === kid);
+  }
+  if (!jwk) throw new WebAppTokenError("No matching JWKS key");
+  return (0, import_node_crypto7.createPublicKey)({ key: jwk, format: "jwk" });
+}
+async function verifyWebAppToken(token, issuer, options = {}) {
+  const nowMs = options.now ? options.now() : Date.now();
+  const now = Math.floor(nowMs / 1e3);
+  if (token.length === 0 || Buffer.byteLength(token) > MAX_TOKEN_BYTES) throw new WebAppTokenError("Token size invalid");
+  const parts = token.split(".");
+  if (parts.length !== 3) throw new WebAppTokenError("Token structure invalid");
+  const [rawHeader, rawPayload, rawSignature] = parts;
+  const header2 = decodeSegment(rawHeader);
+  const payload = decodeSegment(rawPayload);
+  if (header2.alg !== issuer.alg) throw new WebAppTokenError("Token algorithm mismatch");
+  if (payload.iss !== issuer.iss) throw new WebAppTokenError("Token issuer mismatch");
+  if (payload.aud !== issuer.aud) throw new WebAppTokenError("Token audience mismatch");
+  const exp = typeof payload.exp === "number" ? payload.exp : void 0;
+  if (exp === void 0 || exp + CLOCK_SKEW_SECONDS < now) throw new WebAppTokenError("Token expired");
+  const nbf = typeof payload.nbf === "number" ? payload.nbf : void 0;
+  if (nbf !== void 0 && nbf - CLOCK_SKEW_SECONDS > now) throw new WebAppTokenError("Token not yet valid");
+  const signature = Buffer.from(rawSignature, "base64url");
+  const data = Buffer.from(`${rawHeader}.${rawPayload}`);
+  if (issuer.alg === "HS256") {
+    if (typeof issuer.secret !== "string" || issuer.secret.length === 0) throw new WebAppTokenError("Issuer secret missing");
+    const expected = (0, import_node_crypto7.createHmac)("sha256", issuer.secret).update(data).digest();
+    if (signature.length !== expected.length || !(0, import_node_crypto7.timingSafeEqual)(signature, expected)) {
+      throw new WebAppTokenError("Token signature invalid");
     }
-    for (const call of chunk.data.tool_calls ?? []) {
-      if (!startedToolIds.has(call.id)) {
-        startedToolIds.add(call.id);
-        events.push({ type: "tool.started", id: call.id, name: call.name });
-      }
+  } else {
+    if (typeof issuer.jwksUrl !== "string") throw new WebAppTokenError("Issuer JWKS URL missing");
+    const key = await resolveKey(issuer, typeof header2.kid === "string" ? header2.kid : void 0, options.fetchImpl ?? fetch);
+    let valid = false;
+    try {
+      valid = (0, import_node_crypto7.verify)("RSA-SHA256", data, key, signature);
+    } catch {
+      valid = false;
     }
-    return events;
-  }
-  if (chunk.type === import_protocols12.MessageChunkTypes.TOOL && chunk.data.tool_call_id) {
-    return [{ type: "tool.completed", id: chunk.data.tool_call_id }];
+    if (!valid) throw new WebAppTokenError("Token signature invalid");
   }
-  if (chunk.type === import_protocols12.MessageChunkTypes.INTERRUPT) {
-    if (context && !context.allowInterrupts) return [{ type: "stream.completed" }];
-    const interrupt = publicInterrupt(chunk);
-    return interrupt ? [{ type: "interrupt.created", interrupt }, { type: "stream.completed" }] : [{ type: "stream.completed" }];
-  }
-  if (chunk.type === import_protocols12.MessageChunkTypes.MESSAGE_COMPLETED) {
-    return [
-      { type: "message.completed", messageId: chunk.data.id },
-      { type: "stream.completed" }
-    ];
+  const sub = payload.sub;
+  if (typeof sub !== "string" || sub.length === 0 || sub.length > 128 || !/^[A-Za-z0-9._:@-]+$/.test(sub)) {
+    throw new WebAppTokenError("Token subject invalid");
   }
-  if (chunk.type === import_protocols12.MessageChunkTypes.MESSAGE_FAILED) {
-    return [
-      { type: "error", error: { code: "STREAM_FAILED", message: "Stream failed", retryable: true } },
-      { type: "stream.completed" }
-    ];
-  }
-  return [];
-}
-function publicInterrupt(chunk) {
-  const value = parseInterruptContent(chunk.data.content);
-  if (!value) return void 0;
-  const topLevelId = chunk.id;
-  const id3 = typeof topLevelId === "string" ? topLevelId : chunk.data.id;
-  if (!id3) return void 0;
-  return {
-    id: id3,
-    type: typeof value.type === "string" ? value.type : "input",
-    prompt: typeof value.prompt === "string" ? value.prompt : typeof value.message === "string" ? value.message : "Input required",
-    ...isRecord3(value.data) ? { data: value.data } : {}
-  };
-}
-function parseInterruptContent(content) {
-  if (!content) return {};
-  if (isRecord3(content)) return content;
-  if (typeof content !== "string") return void 0;
-  try {
-    const parsed = JSON.parse(content);
-    return isRecord3(parsed) ? parsed : { prompt: content };
-  } catch {
-    return { prompt: content };
-  }
-}
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  return sub;
 }
 
 // src/routes/agent-web-app-runtime.ts
+var import_protocols12 = require("@axiom-lattice/protocols");
 var idSchema = import_zod6.z.string().min(1).max(128);
 var paramsSchema = import_zod6.z.object({ webAppId: idSchema }).strict();
 var threadParamsSchema = import_zod6.z.object({ webAppId: idSchema, threadId: idSchema }).strict();
 var interruptParamsSchema = import_zod6.z.object({ webAppId: idSchema, threadId: idSchema, interruptId: idSchema }).strict();
+var pendingMessageParamsSchema = import_zod6.z.object({ webAppId: idSchema, threadId: idSchema, messageId: idSchema }).strict();
 var bootstrapQuerySchema = import_zod6.z.object({ projectId: idSchema.optional(), modelKey: idSchema.optional() }).strict();
 var projectQuerySchema = import_zod6.z.object({ projectId: idSchema.optional() }).strict();
+var projectQueryLenientSchema = projectQuerySchema.passthrough();
 var threadBodySchema = import_zod6.z.object({ projectId: idSchema.optional(), label: import_zod6.z.string().max(128).optional() }).strict();
 var streamBodySchema = import_zod6.z.object({
   content: import_zod6.z.string().trim().min(1).max(32768),
@@ -15684,8 +16013,27 @@ var resumeBodySchema = import_zod6.z.object({
   ])
 }).strict();
 var MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+var stateQuerySchema = import_zod6.z.object({
+  threadId: idSchema,
+  projectId: idSchema.optional(),
+  modelKey: idSchema.optional()
+}).strict();
+var resumeSchema = import_zod6.z.object({
+  messageId: idSchema,
+  projectId: idSchema.optional(),
+  modelKey: idSchema.optional()
+}).strict();
+var devTokenSchema = import_zod6.z.object({
+  iss: import_zod6.z.string().min(1).max(255).optional(),
+  sub: import_zod6.z.string().regex(/^[A-Za-z0-9._:@-]+$/).max(128).optional(),
+  hours: import_zod6.z.number().gt(0).max(720).optional()
+}).strict();
+var fileQuerySchema = import_zod6.z.object({
+  projectId: idSchema.optional(),
+  modelKey: idSchema.optional()
+}).passthrough();
 function createExternalHeaderIdentityResolver() {
-  return { resolve(request) {
+  return { async resolve(request) {
     const raw = request.headers["x-axiom-external-user-id"];
     if (raw === void 0) throw new AgentWebAppRuntimeError("USER_ID_REQUIRED", 401, "External user id is required");
     if (Array.isArray(raw) || typeof raw !== "string") throw new AgentWebAppRuntimeError("INVALID_USER_ID", 400, "External user id is invalid");
@@ -15694,47 +16042,109 @@ function createExternalHeaderIdentityResolver() {
     return { userId, assurance: "unverified" };
   } };
 }
+function createWebAppIdentityResolver(deps) {
+  const headerResolver = createExternalHeaderIdentityResolver();
+  return {
+    async resolve(request, webAppId) {
+      let config;
+      try {
+        config = await deps.getIdentityConfig(webAppId);
+      } catch {
+        config = void 0;
+      }
+      const policy = config?.policy ?? "unverified";
+      const authHeader = request.headers.authorization;
+      const bearer = typeof authHeader === "string" && authHeader.startsWith("Bearer ") ? authHeader.slice(7).trim() : void 0;
+      if (policy !== "unverified" && bearer !== void 0) {
+        const issuers = config?.issuers ?? [];
+        if (issuers.length === 0) throw new AgentWebAppRuntimeError("INVALID_REQUEST", 401, "No trusted issuer configured");
+        let lastError = new AgentWebAppRuntimeError("INVALID_REQUEST", 401, "Invalid identity token");
+        for (const issuer of issuers) {
+          try {
+            const sub = await verifyWebAppToken(bearer, issuer);
+            return { userId: sub, assurance: "verified" };
+          } catch (error) {
+            if (error instanceof WebAppTokenError) {
+              lastError = error;
+              continue;
+            }
+            throw error;
+          }
+        }
+        const message = lastError instanceof WebAppTokenError ? `Invalid identity token: ${lastError.message}` : "Invalid identity token";
+        throw new AgentWebAppRuntimeError("INVALID_REQUEST", 401, message);
+      }
+      if (policy === "verified") throw new AgentWebAppRuntimeError("USER_ID_REQUIRED", 401, "A verified identity token is required");
+      return headerResolver.resolve(request, webAppId);
+    }
+  };
+}
 function registerAgentWebAppRuntimeRoutes(app2, deps) {
-  const identities = deps.identityResolver ?? createExternalHeaderIdentityResolver();
+  const identities = deps.identityResolver ?? createWebAppIdentityResolver({ getIdentityConfig: (webAppId) => deps.service.getIdentityConfig(webAppId) });
   app2.register(async (routes) => {
     routes.setErrorHandler((error, _request, reply) => normalizeError2(reply, error));
     routes.get("/api/web-apps/:webAppId/runtime/bootstrap", async (request, reply) => handle2(reply, async () => {
       const { webAppId } = paramsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
-      return { data: await deps.service.bootstrap(webAppId, identity.userId, withPreview(bootstrapQuerySchema.parse(request.query), identity.preview)) };
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+      return { data: await deps.service.bootstrap(webAppId, identity.userId, withPreview(bootstrapQuerySchema.parse(request.query), identity.preview), { assurance: identity.assurance ?? "unverified" }) };
     }));
     routes.get("/api/web-apps/:webAppId/runtime/threads", async (request, reply) => handle2(reply, async () => {
       const { webAppId } = paramsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       const records = await deps.service.listThreads(webAppId, identity.userId, withPreview(projectQuerySchema.parse(request.query), identity.preview));
       return { data: { records, total: records.length } };
     }));
     routes.post("/api/web-apps/:webAppId/runtime/threads", async (request, reply) => handle2(reply, async () => {
       const { webAppId } = paramsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       return { statusCode: 201, data: await deps.service.createThread(webAppId, identity.userId, withPreview(threadBodySchema.parse(request.body), identity.preview)) };
     }));
     routes.patch("/api/web-apps/:webAppId/runtime/threads/:threadId", async (request, reply) => handle2(reply, async () => {
       const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       return { data: await deps.service.updateThread(webAppId, identity.userId, threadId, withPreview(threadBodySchema.parse(request.body), identity.preview)) };
     }));
     routes.delete("/api/web-apps/:webAppId/runtime/threads/:threadId", async (request, reply) => handle2(reply, async () => {
       const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       await deps.service.deleteThread(webAppId, identity.userId, threadId, withPreview(projectQuerySchema.parse(request.query), identity.preview));
       return { data: { id: threadId } };
     }));
     routes.get("/api/web-apps/:webAppId/runtime/threads/:threadId/messages", async (request, reply) => handle2(reply, async () => {
       const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       const messages = await deps.service.getMessages(webAppId, identity.userId, threadId, withPreview(projectQuerySchema.parse(request.query), identity.preview));
       return { data: { messages } };
     }));
+    routes.get("/api/web-apps/:webAppId/runtime/state", async (request, reply) => handle2(reply, async () => {
+      const { webAppId } = paramsSchema.parse(request.params);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+      const { threadId, projectId, modelKey: modelKey2 } = stateQuerySchema.parse(request.query);
+      const state = await deps.service.getState(webAppId, identity.userId, threadId, withPreview({ projectId, modelKey: modelKey2 }, identity.preview));
+      return { data: state };
+    }));
+    routes.delete("/api/web-apps/:webAppId/runtime/threads/:threadId/pending-messages/:messageId", async (request, reply) => handle2(reply, async () => {
+      const { webAppId, threadId, messageId } = pendingMessageParamsSchema.parse(request.params);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+      await deps.service.removePendingMessage(webAppId, identity.userId, threadId, messageId, withPreview(projectQuerySchema.parse(request.query), identity.preview));
+      return { data: { removed: true } };
+    }));
     routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/messages/stream", async (request, reply) => {
       try {
         const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-        const identity = resolveRuntimeIdentity(request, webAppId, identities);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const input = streamBodySchema.parse(request.body);
+        const result = await deps.service.streamMessage(webAppId, identity.userId, threadId, withPreview(input, identity.preview));
+        beginSse(reply);
+        await pipeNativeWebAppStream(reply.raw, result.stream);
+      } catch (error) {
+        return normalizeError2(reply, error);
+      }
+    });
+    routes.post("/api/web-apps/:webAppId/runtime/v1/threads/:threadId/messages/stream", async (request, reply) => {
+      try {
+        const { webAppId, threadId } = threadParamsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
         const input = streamBodySchema.parse(request.body);
         const result = await deps.service.streamMessage(webAppId, identity.userId, threadId, withPreview(input, identity.preview));
         beginSse(reply);
@@ -15743,15 +16153,27 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
         return normalizeError2(reply, error);
       }
     });
+    routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/resume", async (request, reply) => {
+      try {
+        const { webAppId, threadId } = threadParamsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const { messageId, projectId, modelKey: modelKey2 } = resumeSchema.parse(request.body);
+        const result = await deps.service.resumeStream(webAppId, identity.userId, threadId, messageId, withPreview({ projectId, modelKey: modelKey2 }, identity.preview));
+        beginSse(reply);
+        await pipeNativeWebAppStream(reply.raw, result.stream);
+      } catch (error) {
+        return normalizeError2(reply, error);
+      }
+    });
     routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/abort", async (request, reply) => handle2(reply, async () => {
       const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       await deps.service.abort(webAppId, identity.userId, threadId, withPreview(projectQuerySchema.parse(request.query), identity.preview));
       return { data: { aborted: true } };
     }));
     routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/attachments", async (request, reply) => handle2(reply, async () => {
       const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       if (!request.isMultipart()) throw new import_zod6.ZodError([]);
       const part = await request.file({ limits: { files: 1, fileSize: MAX_ATTACHMENT_BYTES } });
       if (!part || !part.filename || part.filename.length > 255) throw new import_zod6.ZodError([]);
@@ -15767,7 +16189,7 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
     routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/interrupts/:interruptId/resume", async (request, reply) => {
       try {
         const { webAppId, threadId, interruptId } = interruptParamsSchema.parse(request.params);
-        const identity = resolveRuntimeIdentity(request, webAppId, identities);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
         const { projectId, modelKey: modelKey2, message, response } = resumeBodySchema.parse(request.body);
         const result = await deps.service.resumeInterrupt(webAppId, identity.userId, threadId, interruptId, withPreview({ projectId, modelKey: modelKey2 }, identity.preview), { message, response });
         beginSse(reply);
@@ -15776,34 +16198,294 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
         return normalizeError2(reply, error);
       }
     });
+    routes.post("/api/web-apps/:webAppId/dev/token", async (request, reply) => handle2(reply, async () => {
+      if (process.env.WEB_APP_DEV_TOKEN_ENABLED !== "true") {
+        throw new AgentWebAppRuntimeError("FEATURE_DISABLED", 403, "Dev token issuance is disabled (set WEB_APP_DEV_TOKEN_ENABLED=true)");
+      }
+      const { webAppId } = paramsSchema.parse(request.params);
+      const { iss, sub, hours } = devTokenSchema.parse(request.body ?? {});
+      const config = await deps.service.getIdentityConfig(webAppId);
+      const issuer = (config?.issuers ?? []).find((entry) => entry.alg === "HS256" && (iss === void 0 || entry.iss === iss));
+      if (!issuer || typeof issuer.secret !== "string") {
+        throw new AgentWebAppRuntimeError("INVALID_REQUEST", 400, "Web app has no HS256 issuer configured");
+      }
+      const now = Math.floor(Date.now() / 1e3);
+      const expiresIn = (hours ?? 24) * 3600;
+      const subject = sub ?? "dev-user";
+      const b64url = (input) => Buffer.from(input).toString("base64url");
+      const body = `${b64url(JSON.stringify({ alg: "HS256", typ: "JWT" }))}.${b64url(JSON.stringify({ sub: subject, iss: issuer.iss, aud: issuer.aud, iat: now, exp: now + expiresIn }))}`;
+      const token = `${body}.${(0, import_node_crypto8.createHmac)("sha256", issuer.secret).update(body).digest("base64url")}`;
+      return { data: { token, tokenType: "Bearer", expiresIn, subject } };
+    }));
+    if (deps.taskController) {
+      const tasks = deps.taskController;
+      const withSubject = (handler) => async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const proxy = Object.create(request);
+        proxy.headers = { ...request.headers, "x-user-id": identity.userId };
+        return handler(proxy, reply);
+      };
+      routes.get("/api/web-apps/:webAppId/runtime/tasks", withSubject((request, reply) => tasks.list(request, reply)));
+      routes.post("/api/web-apps/:webAppId/runtime/tasks", withSubject((request, reply) => tasks.create(request, reply)));
+      routes.get("/api/web-apps/:webAppId/runtime/tasks/:taskId", withSubject((request, reply) => tasks.get(request, reply)));
+      routes.put("/api/web-apps/:webAppId/runtime/tasks/:taskId", withSubject((request, reply) => tasks.update(request, reply)));
+      routes.patch("/api/web-apps/:webAppId/runtime/tasks/:taskId", withSubject((request, reply) => tasks.update(request, reply)));
+      routes.delete("/api/web-apps/:webAppId/runtime/tasks/:taskId", withSubject((request, reply) => tasks.remove(request, reply)));
+      routes.patch("/api/web-apps/:webAppId/runtime/tasks/:taskId/complete", withSubject((request, reply) => tasks.complete(request, reply)));
+      routes.get("/api/web-apps/:webAppId/runtime/tasks/:taskId/work-items", withSubject((request, reply) => tasks.workItems(request, reply)));
+    }
+    if (deps.workspaceController) {
+      const workspace = deps.workspaceController;
+      const fileScope = async (webAppId, selection) => {
+        const scope = await deps.service.resolveFileScope(webAppId, selection);
+        if (!scope.enabled) throw new AgentWebAppRuntimeError("FEATURE_DISABLED", 403, "Files are disabled for this web app");
+        return scope;
+      };
+      const scopedRequest = (request, scope, params, query) => {
+        const proxy = Object.create(request);
+        proxy.params = params;
+        proxy.query = query;
+        proxy.headers = { ...request.headers, "x-tenant-id": scope.tenantId };
+        return proxy;
+      };
+      const unwrap = (result) => ({ data: result.data });
+      routes.get("/api/web-apps/:webAppId/runtime/files/listpath", async (request) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        const result = await workspace.listPath(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query));
+        return unwrap(result);
+      });
+      routes.get("/api/web-apps/:webAppId/runtime/files/readfile", async (request) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        const result = await workspace.readFile(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query));
+        return unwrap(result);
+      });
+      routes.post("/api/web-apps/:webAppId/runtime/files/uploadfile", async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const scoped = scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, { assistantId: scope.assistantId });
+        await workspace.uploadFile(scoped, reply);
+        return reply;
+      });
+      routes.get("/api/web-apps/:webAppId/runtime/files/viewfile", async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        await workspace.viewFile(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query), reply);
+        return reply;
+      });
+      routes.get("/api/web-apps/:webAppId/runtime/files/downloadfile", async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        await workspace.downloadFile(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query), reply);
+        return reply;
+      });
+      routes.get("/api/web-apps/:webAppId/runtime/files/downloadfolder", async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        await workspace.downloadFolder(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query), reply);
+        return reply;
+      });
+      const genuiSandboxParams = import_zod6.z.object({ webAppId: idSchema, assistantId: idSchema, threadId: idSchema }).strict();
+      const delegateGenuiFile = (method) => async (request, reply) => {
+        const { webAppId } = genuiSandboxParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        await method(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query), reply);
+        return reply;
+      };
+      routes.get("/api/web-apps/:webAppId/runtime/assistants/:assistantId/threads/:threadId/sandbox/downloadfile", delegateGenuiFile(workspace.downloadFile.bind(workspace)));
+      routes.get("/api/web-apps/:webAppId/runtime/assistants/:assistantId/threads/:threadId/sandbox/viewfile", delegateGenuiFile(workspace.viewFile.bind(workspace)));
+      const delegateAnonGenuiFile = (method) => async (request, reply) => {
+        const { webAppId } = genuiSandboxParams.parse(request.params);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        await method(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query), reply);
+        return reply;
+      };
+      routes.get("/api/web-apps/:webAppId/runtime/api/assistants/:assistantId/threads/:threadId/sandbox/downloadfile", delegateAnonGenuiFile(workspace.downloadFile.bind(workspace)));
+      routes.get("/api/web-apps/:webAppId/runtime/api/assistants/:assistantId/threads/:threadId/sandbox/viewfile", delegateAnonGenuiFile(workspace.viewFile.bind(workspace)));
+    }
+    const mirrorThreadParams = import_zod6.z.object({ webAppId: idSchema, assistantId: idSchema, threadId: idSchema }).strict();
+    const mirrorBody = import_zod6.z.object({ metadata: import_zod6.z.object({ label: import_zod6.z.string().max(300).optional() }).strict().optional(), projectId: idSchema.optional(), modelKey: idSchema.optional() }).strict();
+    const toConsoleThread = (thread, assistantId) => ({
+      id: thread.id,
+      assistantId,
+      metadata: thread.label ? { label: thread.label } : {},
+      createdAt: thread.createdAt,
+      updatedAt: thread.updatedAt
+    });
+    const mirrorAssistantParams = import_zod6.z.object({ webAppId: idSchema, assistantId: idSchema }).strict();
+    const mirrorPendingParams = import_zod6.z.object({ webAppId: idSchema, assistantId: idSchema, threadId: idSchema, messageId: idSchema }).strict();
+    const registerMirror = (prefix) => {
+      routes.get(`${prefix}/assistants/:assistantId/threads`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, assistantId } = mirrorAssistantParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const threads = await deps.service.listThreads(webAppId, identity.userId, projectQueryLenientSchema.parse(request.query));
+        return { data: { records: threads.map((thread) => toConsoleThread(thread, assistantId)) } };
+      }));
+      routes.post(`${prefix}/assistants/:assistantId/threads`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, assistantId } = mirrorAssistantParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const body = mirrorBody.parse(request.body ?? {});
+        const created = await deps.service.createThread(webAppId, identity.userId, { label: body.metadata?.label, ...body.projectId ? { projectId: body.projectId } : {} });
+        return { statusCode: 201, data: { id: created.id } };
+      }));
+      routes.get(`${prefix}/assistants/:assistantId/threads/:threadId`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, assistantId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const thread = await deps.service.getThread(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+        return { data: toConsoleThread(thread, assistantId) };
+      }));
+      routes.put(`${prefix}/assistants/:assistantId/threads/:threadId`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, assistantId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const body = mirrorBody.parse(request.body ?? {});
+        const updated = await deps.service.updateThread(webAppId, identity.userId, threadId, { label: body.metadata?.label, ...body.projectId ? { projectId: body.projectId } : {} });
+        return { data: toConsoleThread(updated, assistantId) };
+      }));
+      routes.delete(`${prefix}/assistants/:assistantId/threads/:threadId`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        await deps.service.deleteThread(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+        return { data: { success: true, message: "Thread deleted" } };
+      }));
+      routes.post(`${prefix}/assistants/:assistantId/threads/:threadId/sandbox/uploadfile`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        if (!request.isMultipart()) throw new import_zod6.ZodError([]);
+        const part = await request.file({ limits: { files: 1, fileSize: MAX_ATTACHMENT_BYTES } });
+        if (!part || !part.filename || part.filename.length > 255) throw new import_zod6.ZodError([]);
+        const bytes = await part.toBuffer();
+        if (bytes.length === 0 || part.file.truncated) throw new import_zod6.ZodError([]);
+        const uploaded = await deps.service.uploadAttachment(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query), {
+          name: part.filename,
+          mimeType: part.mimetype || "application/octet-stream",
+          bytes
+        });
+        return { statusCode: 201, data: { id: uploaded.ref, path: uploaded.ref, name: uploaded.name, mimeType: uploaded.mimeType, size: uploaded.size } };
+      }));
+      routes.get(`${prefix}/assistants/:assistantId/:threadId/memory`, async (request) => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const messages = await deps.service.getConsoleMessages(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+        return messages;
+      });
+      routes.get(`${prefix}/assistants/:assistantId/:threadId/state`, async (request) => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        return deps.service.getState(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+      });
+      routes.delete(`${prefix}/assistants/:assistantId/threads/:threadId/pending-messages/:messageId`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, threadId, messageId } = mirrorPendingParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        await deps.service.removePendingMessage(webAppId, identity.userId, threadId, messageId, projectQueryLenientSchema.parse(request.query));
+        return { data: { removed: true } };
+      }));
+      routes.post(`${prefix}/assistants/:assistantId/threads/:threadId/abort`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        await deps.service.abort(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+        return { data: { aborted: true } };
+      }));
+      const runsBodySchema = import_zod6.z.object({
+        thread_id: idSchema.optional(),
+        assistant_id: idSchema.optional(),
+        messages: import_zod6.z.array(import_zod6.z.object({ content: import_zod6.z.string().min(1).max(32768) }).passthrough()).min(1).max(20),
+        background: import_zod6.z.boolean().optional(),
+        streaming: import_zod6.z.boolean().optional(),
+        projectId: idSchema.optional(),
+        modelKey: idSchema.optional()
+      }).passthrough();
+      routes.post(`${prefix}/runs`, async (request, reply) => {
+        try {
+          const { webAppId } = paramsSchema.parse(request.params);
+          const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+          const body = runsBodySchema.parse(request.body ?? {});
+          if (!body.background || body.streaming) {
+            throw new AgentWebAppRuntimeError("INVALID_REQUEST", 400, "Mirror runs supports only background enqueue (stream via resume_stream)");
+          }
+          const threadId = body.thread_id ?? "";
+          if (!threadId) throw new AgentWebAppRuntimeError("INVALID_REQUEST", 400, "thread_id is required");
+          const content = body.messages.map((message) => message.content).join("\n");
+          const { messageId } = await deps.service.enqueueMessage(webAppId, identity.userId, threadId, content, { projectId: body.projectId, modelKey: body.modelKey });
+          return reply.code(202).send({ success: true, messageId, queued: true });
+        } catch (error) {
+          return normalizeError2(reply, error);
+        }
+      });
+      const resumeStreamSchema2 = import_zod6.z.object({
+        assistant_id: idSchema.optional(),
+        thread_id: idSchema,
+        message_id: idSchema,
+        known_content: import_zod6.z.string().optional(),
+        poll_interval: import_zod6.z.number().optional(),
+        projectId: idSchema.optional(),
+        modelKey: idSchema.optional()
+      }).strict();
+      routes.post(`${prefix}/resume_stream`, async (request, reply) => {
+        try {
+          const { webAppId } = paramsSchema.parse(request.params);
+          const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+          const body = resumeStreamSchema2.parse(request.body ?? {});
+          const result = await deps.service.resumeStream(webAppId, identity.userId, body.thread_id, body.message_id, { projectId: body.projectId, modelKey: body.modelKey });
+          beginSse(reply);
+          await pipeNativeWebAppStream(reply.raw, result.stream);
+        } catch (error) {
+          return normalizeError2(reply, error);
+        }
+      });
+    };
+    registerMirror("/api/web-apps/:webAppId/runtime");
+    registerMirror("/api/web-apps/:webAppId/runtime/api");
   });
 }
-function resolveRuntimeIdentity(request, webAppId, identities) {
-  if (request.headers["x-axiom-web-app-preview"] !== "true") return identities.resolve(request);
+async function resolveRuntimeIdentity(request, webAppId, identities) {
+  if (request.headers["x-axiom-web-app-preview"] !== "true") return identities.resolve(request, webAppId);
   const user = request.user;
   if (!user?.id || !user.tenantId) throw new AgentWebAppRuntimeError("USER_ID_REQUIRED", 401, "Authenticated Console preview is required");
-  return { userId: `console-preview:${user.id}:${webAppId}`, preview: { tenantId: user.tenantId, userId: user.id } };
+  return { userId: `console-preview:${user.id}:${webAppId}`, assurance: "unverified", preview: { tenantId: user.tenantId, userId: user.id } };
 }
 function withPreview(selection, preview) {
   return { ...selection, ...preview ? { preview } : {} };
 }
 async function pipeAgentWebAppStream(raw, stream, options = {}) {
-  const projection = createAgentWebAppStreamProjectionContext(options);
+  const projection = (0, import_protocols12.createAgentWebAppStreamProjectionContext)(options);
   await pipeAsyncIterableToSse(raw, stream, {
-    project: (chunk) => projectAgentWebAppChunk(chunk, projection),
+    project: (chunk) => (0, import_protocols12.projectAgentWebAppChunk)(chunk, projection),
     onError: () => [
       { type: "error", error: { code: "STREAM_FAILED", message: "Stream failed", retryable: true } },
       { type: "stream.completed" }
     ]
   });
 }
+async function pipeNativeWebAppStream(raw, stream) {
+  await pipeAsyncIterableToSse(raw, stream, {
+    onError: () => [{
+      type: "error",
+      data: { id: "", content: "Stream failed" }
+    }]
+  });
+}
 function beginSse(reply) {
   reply.hijack();
   reply.raw.writeHead(200, {
     "Content-Type": "text/event-stream; charset=utf-8",
     "Cache-Control": "no-cache, no-transform",
     Connection: "keep-alive",
-    "X-Accel-Buffering": "no"
+    "X-Accel-Buffering": "no",
+    "Access-Control-Allow-Origin": "*"
   });
 }
 async function handle2(reply, operation) {
@@ -15824,8 +16506,107 @@ function isMultipartRequestError(error) {
   return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && error.code.startsWith("FST_");
 }
 
+// src/routes/agent-web-app-embed.ts
+var import_node_fs2 = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"));
+var import_zod7 = require("zod");
+var idSchema2 = import_zod7.z.string().min(1).max(128).regex(/^[A-Za-z0-9._:@-]+$/);
+var JS_CONTENT_TYPE = "application/javascript; charset=utf-8";
+var CSS_CONTENT_TYPE = "text/css; charset=utf-8";
+var EXACT_ASSETS = {
+  "agent-chat-loader.js": { contentType: JS_CONTENT_TYPE },
+  "embed-page.js": { contentType: JS_CONTENT_TYPE },
+  "embed-page.css": { contentType: CSS_CONTENT_TYPE }
+};
+var HASHED_CHUNK_PATTERN = /^embed-page-[A-Za-z0-9._-]+\.(js|css)$/;
+var CHUNK_CSS_PATTERN = /^embed-page-[A-Za-z0-9._-]+\.css$/;
+function resolveAsset(asset) {
+  if (asset.includes("..")) return null;
+  const exact2 = EXACT_ASSETS[asset];
+  if (exact2 !== void 0) return { contentType: exact2.contentType, immutable: false };
+  const hashed = HASHED_CHUNK_PATTERN.exec(asset);
+  if (hashed) {
+    return { contentType: hashed[1] === "css" ? CSS_CONTENT_TYPE : JS_CONTENT_TYPE, immutable: true };
+  }
+  return null;
+}
+async function listChunkCssFiles(assetsDir) {
+  try {
+    return (await (0, import_promises2.readdir)(assetsDir)).filter((name) => CHUNK_CSS_PATTERN.test(name) && !name.includes("..")).sort();
+  } catch {
+    return [];
+  }
+}
+var BUNDLED_MARKER = "agent-chat-loader.js";
+function resolveBundledEmbedDir() {
+  if (typeof __dirname === "string") {
+    const compiled = import_node_path2.default.resolve(__dirname, "embed");
+    if ((0, import_node_fs2.existsSync)(import_node_path2.default.join(compiled, BUNDLED_MARKER))) return compiled;
+  }
+  let dir = import_node_path2.default.dirname(import_node_path2.default.resolve(process.argv[1] ?? process.cwd()));
+  for (let depth = 0; depth < 8; depth += 1) {
+    const candidate = import_node_path2.default.join(dir, "packages", "gateway", "dist", "embed");
+    if ((0, import_node_fs2.existsSync)(import_node_path2.default.join(candidate, BUNDLED_MARKER))) return candidate;
+    const parent = import_node_path2.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function renderChatShell(chunkCssFiles) {
+  const chunkCssLinks = chunkCssFiles.map(
+    (name) => `    <link rel="stylesheet" href="/embed/${name}" />`
+  );
+  return [
+    "<!doctype html>",
+    '<html lang="en">',
+    "  <head>",
+    '    <meta charset="utf-8" />',
+    '    <meta name="viewport" content="width=device-width, initial-scale=1" />',
+    "    <title>Agent chat</title>",
+    '    <link rel="stylesheet" href="/embed/embed-page.css" />',
+    ...chunkCssLinks,
+    "  </head>",
+    "  <body>",
+    '    <div id="axiom-embed-root">',
+    "      <noscript>This chat requires JavaScript.</noscript>",
+    '      <p class="axiom-embed-loading">Loading chat\u2026</p>',
+    "    </div>",
+    '    <script type="module" src="/embed/embed-page.js"></script>',
+    "  </body>",
+    "</html>"
+  ].join("\n");
+}
+function registerAgentWebAppEmbedRoutes(app2, deps = {}) {
+  const bundledDir = resolveBundledEmbedDir();
+  const assetsDir = deps.assetsDir ?? process.env.AXIOM_EMBED_ASSETS_DIR ?? bundledDir ?? import_node_path2.default.resolve(process.cwd(), "assets/embed");
+  let chunkCssFiles = null;
+  app2.get("/api/web-apps/:webAppId/chat", async (request, reply) => {
+    const parsed = idSchema2.safeParse(request.params.webAppId);
+    if (!parsed.success) {
+      return reply.code(400).send({ success: false, error: { code: "INVALID_REQUEST", message: "Invalid web app id", retryable: false } });
+    }
+    chunkCssFiles ?? (chunkCssFiles = await listChunkCssFiles(assetsDir));
+    return reply.header("content-type", "text/html; charset=utf-8").header("cache-control", "no-store").send(renderChatShell(chunkCssFiles));
+  });
+  app2.get("/embed/:asset", async (request, reply) => {
+    const asset = request.params.asset ?? "";
+    const resolved = resolveAsset(asset);
+    if (resolved === null) {
+      return reply.code(404).send({ success: false, error: { code: "INVALID_REQUEST", message: "Unknown embed asset", retryable: false } });
+    }
+    try {
+      const body = await (0, import_promises2.readFile)(import_node_path2.default.join(assetsDir, asset));
+      return reply.header("content-type", resolved.contentType).header("cache-control", resolved.immutable ? "public, max-age=31536000, immutable" : "public, max-age=300").send(body);
+    } catch {
+      return reply.code(404).send({ success: false, error: { code: "INVALID_REQUEST", message: "Embed asset not built", retryable: false } });
+    }
+  });
+}
+
 // src/services/agent-web-app/AgentWebAppAttachmentRef.ts
-var import_node_crypto7 = require("crypto");
+var import_node_crypto9 = require("crypto");
 var TTL_MS = 15 * 6e4;
 function resolveAgentWebAppAttachmentSecret(consoleSecret) {
   return process.env.WEB_APP_ATTACHMENT_SECRET || process.env.AUTH_TOKEN_SECRET || process.env.JWT_SECRET || consoleSecret;
@@ -15834,7 +16615,7 @@ var AgentWebAppAttachmentRefService = class {
   constructor(secret, now = Date.now) {
     this.now = now;
     if (!secret) throw new Error("Attachment signing secret is required");
-    this.key = (0, import_node_crypto7.createHash)("sha256").update(secret, "utf8").digest();
+    this.key = (0, import_node_crypto9.createHash)("sha256").update(secret, "utf8").digest();
   }
   sign(input) {
     const payload = {
@@ -15849,8 +16630,8 @@ var AgentWebAppAttachmentRefService = class {
       contentDigest: input.contentDigest,
       exp: this.now() + TTL_MS
     };
-    const iv = (0, import_node_crypto7.randomBytes)(12);
-    const cipher = (0, import_node_crypto7.createCipheriv)("aes-256-gcm", this.key, iv);
+    const iv = (0, import_node_crypto9.randomBytes)(12);
+    const cipher = (0, import_node_crypto9.createCipheriv)("aes-256-gcm", this.key, iv);
     const ciphertext = Buffer.concat([
       cipher.update(JSON.stringify(payload), "utf8"),
       cipher.final()
@@ -15865,7 +16646,7 @@ var AgentWebAppAttachmentRefService = class {
       const iv = decodeCanonical(encodedIv, 12);
       const ciphertext = decodeCanonical(encodedCiphertext);
       const tag = decodeCanonical(encodedTag, 16);
-      const decipher = (0, import_node_crypto7.createDecipheriv)("aes-256-gcm", this.key, iv);
+      const decipher = (0, import_node_crypto9.createDecipheriv)("aes-256-gcm", this.key, iv);
       decipher.setAuthTag(tag);
       const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
       const value = JSON.parse(plaintext.toString("utf8"));
@@ -15896,7 +16677,7 @@ function decodeCanonical(value, expectedBytes) {
   return decoded;
 }
 function digestUser(userId) {
-  return (0, import_node_crypto7.createHash)("sha256").update(userId, "utf8").digest("hex");
+  return (0, import_node_crypto9.createHash)("sha256").update(userId, "utf8").digest("hex");
 }
 function isAttachmentPayload(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
@@ -15909,10 +16690,10 @@ function isAttachmentPayload(value) {
 init_workspace_file_service();
 
 // src/controllers/capability-bundles.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
 // src/services/capability/CapabilityBundleService.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var import_core43 = require("@axiom-lattice/core");
 var CapabilityBundleServiceError = class extends Error {
   constructor(code, message, statusCode) {
@@ -15922,7 +16703,7 @@ var CapabilityBundleServiceError = class extends Error {
     this.name = "CapabilityBundleServiceError";
   }
 };
-var uuid = import_zod7.z.string().uuid();
+var uuid = import_zod8.z.string().uuid();
 function ownRecord(value) {
   if (value === void 0 || value === null) return {};
   if (typeof value !== "object" || Array.isArray(value)) throw new CapabilityBundleServiceError("INVALID_BUNDLE_CONFIG", "Project config must be an object", 409);
@@ -16125,12 +16906,12 @@ var CapabilityBundleService = class {
 // src/controllers/capability-bundles.ts
 init_Logger();
 var logger3 = new Logger({ serviceName: "lattice/gateway/capability-bundles" });
-var capability = import_zod8.z.unknown();
-var createSchema = import_zod8.z.object({ name: import_zod8.z.string(), description: import_zod8.z.string().optional(), capabilities: import_zod8.z.array(capability) }).strict();
-var updateSchema = createSchema.partial().extend({ expectedUpdatedAt: import_zod8.z.string().optional() });
-var bundleIdSchema = import_zod8.z.string().uuid();
-var bundleParamsSchema = import_zod8.z.object({ bundleId: bundleIdSchema });
-var projectSchema = import_zod8.z.object({ bundleIds: import_zod8.z.array(bundleIdSchema), expectedRevisions: import_zod8.z.record(import_zod8.z.string()).optional() }).strict();
+var capability = import_zod9.z.unknown();
+var createSchema = import_zod9.z.object({ name: import_zod9.z.string(), description: import_zod9.z.string().optional(), capabilities: import_zod9.z.array(capability) }).strict();
+var updateSchema = createSchema.partial().extend({ expectedUpdatedAt: import_zod9.z.string().optional() });
+var bundleIdSchema = import_zod9.z.string().uuid();
+var bundleParamsSchema = import_zod9.z.object({ bundleId: bundleIdSchema });
+var projectSchema = import_zod9.z.object({ bundleIds: import_zod9.z.array(bundleIdSchema), expectedRevisions: import_zod9.z.record(import_zod9.z.string()).optional() }).strict();
 function tenant(request, authRequired2) {
   const authenticated = request.user?.tenantId;
   const header2 = request.headers["x-tenant-id"];
@@ -16260,12 +17041,12 @@ function registerCapabilityBundleRoutes(app2, controller) {
 }
 
 // src/services/collaboration/ProjectRoomService.ts
-var import_node_crypto8 = require("crypto");
+var import_node_crypto10 = require("crypto");
 var ProjectRoomService = class {
   /** Creates a project room service from explicitly injected collaborators. */
   constructor(deps) {
     this.deps = deps;
-    this.idFactory = deps.idFactory ?? import_node_crypto8.randomUUID;
+    this.idFactory = deps.idFactory ?? import_node_crypto10.randomUUID;
   }
   /** Authorizes read access and atomically ensures the project's main room. */
   async ensureMainRoom(input) {
@@ -16284,7 +17065,7 @@ var ProjectRoomService = class {
 };
 
 // src/services/collaboration/ProjectMembershipService.ts
-var import_node_crypto9 = require("crypto");
+var import_node_crypto11 = require("crypto");
 var ProjectMembershipServiceError = class extends Error {
   constructor(code, statusCode, message) {
     super(message);
@@ -16300,7 +17081,7 @@ function isMembershipConflict(error) {
 var ProjectMembershipService = class {
   constructor(deps) {
     this.deps = deps;
-    this.idFactory = deps.idFactory ?? import_node_crypto9.randomUUID;
+    this.idFactory = deps.idFactory ?? import_node_crypto11.randomUUID;
     this.mutationMutex = deps.projectMutationMutex ?? import_core41.projectMutationMutex;
   }
   async list(actor2) {
@@ -16398,6 +17179,14 @@ var ProjectMembershipService = class {
       const room = await this.deps.roomStore.getMainRoom(membership.tenantId, membership.projectId);
       if (!room) throw new Error("Project main room not found");
       this.deps.realtime.membershipChanged({ tenantId: membership.tenantId, roomId: room.id, membership, change, sourceKey });
+      this.deps.realtime.membershipAffected({
+        tenantId: membership.tenantId,
+        userId: membership.userId,
+        change,
+        projectId: membership.projectId,
+        roomId: room.id,
+        sourceKey: `membership-affected:${sourceKey}`
+      });
     }).catch((error) => {
       this.reportRealtimeFailure(membership.id);
     });
@@ -16426,7 +17215,7 @@ var ProjectMembershipService = class {
 };
 
 // src/services/collaboration/ProjectRosterService.ts
-var import_node_crypto10 = require("crypto");
+var import_node_crypto12 = require("crypto");
 var ProjectRosterServiceError = class extends Error {
   /** Creates a stable roster service error. */
   constructor(code, statusCode, message) {
@@ -16443,7 +17232,7 @@ var ProjectRosterService = class {
   /** Creates a roster service from explicitly injected collaborators. */
   constructor(deps) {
     this.deps = deps;
-    this.idFactory = deps.idFactory ?? import_node_crypto10.randomUUID;
+    this.idFactory = deps.idFactory ?? import_node_crypto12.randomUUID;
     this.mutationMutex = deps.projectMutationMutex ?? import_core41.projectMutationMutex;
   }
   /** Lists all bot memberships visible to a project reader. */
@@ -16663,7 +17452,7 @@ var ProjectRosterService = class {
 };
 
 // src/services/collaboration/RoomMessageService.ts
-var import_node_crypto11 = require("crypto");
+var import_node_crypto13 = require("crypto");
 
 // src/services/collaboration/ProjectBotMembershipSnapshot.ts
 var import_protocols13 = require("@axiom-lattice/protocols");
@@ -16752,7 +17541,7 @@ var RoomMessageService = class {
   constructor(deps, options = {}) {
     this.deps = deps;
     this.idempotentOutcomes = /* @__PURE__ */ new Map();
-    this.idFactory = deps.idFactory ?? import_node_crypto11.randomUUID;
+    this.idFactory = deps.idFactory ?? import_node_crypto13.randomUUID;
     const limit = options.idempotentOutcomeLimit ?? 1e3;
     if (!Number.isSafeInteger(limit) || limit < 1) throw new RangeError("idempotentOutcomeLimit must be a positive safe integer");
     this.idempotentOutcomeLimit = limit;
@@ -16933,7 +17722,7 @@ var RoomMessageService = class {
     let idempotencyKey;
     if (value.requestIdempotencyKey !== void 0) {
       if (typeof value.requestIdempotencyKey !== "string" || !/^[\x21-\x7e]{1,200}$/.test(value.requestIdempotencyKey.trim())) throw new RoomMessageServiceError("INVALID_MESSAGE", 400, "Invalid idempotency key");
-      idempotencyKey = `room-human:${actor2.userId}:${(0, import_node_crypto11.createHash)("sha256").update(value.requestIdempotencyKey.trim(), "utf8").digest("hex")}`;
+      idempotencyKey = `room-human:${actor2.userId}:${(0, import_node_crypto13.createHash)("sha256").update(value.requestIdempotencyKey.trim(), "utf8").digest("hex")}`;
     }
     return { text, mentions, botIds, ...value.replyToMessageId === void 0 ? {} : { replyToMessageId: value.replyToMessageId }, ...idempotencyKey === void 0 ? {} : { idempotencyKey } };
   }
@@ -16990,7 +17779,7 @@ function cloneRoomMessage(message) {
   };
 }
 function fingerprintRequest(input) {
-  return (0, import_node_crypto11.createHash)("sha256").update(JSON.stringify({
+  return (0, import_node_crypto13.createHash)("sha256").update(JSON.stringify({
     text: input.text,
     mentions: input.mentions,
     replyToMessageId: input.replyToMessageId ?? null
@@ -17001,46 +17790,47 @@ function matchesNormalizedPayload(message, input) {
 }
 
 // src/routes/project-rooms.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
+var import_protocols14 = require("@axiom-lattice/protocols");
 
 // src/schemas/project-room.ts
-var import_zod9 = require("zod");
-var id2 = import_zod9.z.string().trim().min(1).max(128);
-var isoDate = import_zod9.z.string().datetime({ offset: true }).transform((value) => new Date(value));
-var expectedUpdatedAt = import_zod9.z.object({ expectedUpdatedAt: isoDate }).strict();
-var projectRoomParamsSchema = import_zod9.z.object({ projectId: id2 }).strict();
-var membershipParamsSchema = import_zod9.z.object({ projectId: id2, membershipId: id2 }).strict();
-var roomMessagesQuerySchema = import_zod9.z.object({
-  beforeCreatedAt: import_zod9.z.string().datetime({ offset: true }).transform((value) => new Date(value)).optional(),
+var import_zod10 = require("zod");
+var id2 = import_zod10.z.string().trim().min(1).max(128);
+var isoDate = import_zod10.z.string().datetime({ offset: true }).transform((value) => new Date(value));
+var expectedUpdatedAt = import_zod10.z.object({ expectedUpdatedAt: isoDate }).strict();
+var projectRoomParamsSchema = import_zod10.z.object({ projectId: id2 }).strict();
+var membershipParamsSchema = import_zod10.z.object({ projectId: id2, membershipId: id2 }).strict();
+var roomMessagesQuerySchema = import_zod10.z.object({
+  beforeCreatedAt: import_zod10.z.string().datetime({ offset: true }).transform((value) => new Date(value)).optional(),
   beforeId: id2.optional(),
-  limit: import_zod9.z.coerce.number().int().min(1).max(100).optional()
+  limit: import_zod10.z.coerce.number().int().min(1).max(100).optional()
 }).strict().refine((value) => value.beforeCreatedAt === void 0 === (value.beforeId === void 0), { message: "Both cursor fields are required" });
-var createRoomMessageSchema = import_zod9.z.object({
-  text: import_zod9.z.string(),
-  mentions: import_zod9.z.array(import_zod9.z.union([
-    import_zod9.z.object({ type: import_zod9.z.literal("team") }).strict(),
-    import_zod9.z.object({ type: import_zod9.z.literal("bot"), membershipId: id2 }).strict()
+var createRoomMessageSchema = import_zod10.z.object({
+  text: import_zod10.z.string(),
+  mentions: import_zod10.z.array(import_zod10.z.union([
+    import_zod10.z.object({ type: import_zod10.z.literal("team") }).strict(),
+    import_zod10.z.object({ type: import_zod10.z.literal("bot"), membershipId: id2 }).strict()
   ])).optional(),
   replyToMessageId: id2.optional()
 }).strict();
-var addProjectMemberSchema = import_zod9.z.object({ userId: id2, role: import_zod9.z.enum(["owner", "admin", "member", "viewer"]) }).strict();
-var updateProjectMemberSchema = import_zod9.z.object({ role: import_zod9.z.enum(["owner", "admin", "member", "viewer"]), expectedUpdatedAt: isoDate }).strict();
+var addProjectMemberSchema = import_zod10.z.object({ userId: id2, role: import_zod10.z.enum(["owner", "admin", "member", "viewer"]) }).strict();
+var updateProjectMemberSchema = import_zod10.z.object({ role: import_zod10.z.enum(["owner", "admin", "member", "viewer"]), expectedUpdatedAt: isoDate }).strict();
 var mutationExpectedUpdatedAtSchema = expectedUpdatedAt;
-var roomMessageRetryParamsSchema = import_zod9.z.object({ projectId: id2, messageId: id2 }).strict();
-var emptyObjectSchema = import_zod9.z.object({}).strict();
-var idempotencyKeySchema = import_zod9.z.string().refine((value) => value.trim().length >= 1 && value.trim().length <= 200 && /^[\x20-\x7e]+$/.test(value.trim()), "Invalid idempotency key").transform((value) => value.trim());
-var addProjectBotSchema = import_zod9.z.object({
+var roomMessageRetryParamsSchema = import_zod10.z.object({ projectId: id2, messageId: id2 }).strict();
+var emptyObjectSchema = import_zod10.z.object({}).strict();
+var idempotencyKeySchema = import_zod10.z.string().refine((value) => value.trim().length >= 1 && value.trim().length <= 200 && /^[\x20-\x7e]+$/.test(value.trim()), "Invalid idempotency key").transform((value) => value.trim());
+var addProjectBotSchema = import_zod10.z.object({
   assistantId: id2,
-  role: import_zod9.z.enum(["coordinator", "specialist"]),
-  title: import_zod9.z.string(),
-  responsibility: import_zod9.z.string().optional(),
-  mentionName: import_zod9.z.string()
+  role: import_zod10.z.enum(["coordinator", "specialist"]),
+  title: import_zod10.z.string(),
+  responsibility: import_zod10.z.string().optional(),
+  mentionName: import_zod10.z.string()
 }).strict();
-var updateProjectBotSchema = import_zod9.z.object({
-  role: import_zod9.z.enum(["coordinator", "specialist"]).optional(),
-  title: import_zod9.z.string().optional(),
-  responsibility: import_zod9.z.string().optional(),
-  mentionName: import_zod9.z.string().optional(),
+var updateProjectBotSchema = import_zod10.z.object({
+  role: import_zod10.z.enum(["coordinator", "specialist"]).optional(),
+  title: import_zod10.z.string().optional(),
+  responsibility: import_zod10.z.string().optional(),
+  mentionName: import_zod10.z.string().optional(),
   expectedUpdatedAt: isoDate
 }).strict().refine((value) => value.role !== void 0 || value.title !== void 0 || value.responsibility !== void 0 || value.mentionName !== void 0, { message: "At least one mutable field is required" });
 
@@ -17058,7 +17848,8 @@ function registerProjectRoomRoutes(app2, deps) {
     const params = projectRoomParamsSchema.parse(request.params);
     const query = roomMessagesQuerySchema.parse(request.query);
     const before = query.beforeCreatedAt === void 0 && query.beforeId === void 0 ? void 0 : { createdAt: query.beforeCreatedAt, id: query.beforeId };
-    return { data: await deps.messageService.list(actor(request, params.projectId), { ...before ? { before } : {}, ...query.limit === void 0 ? {} : { limit: query.limit } }) };
+    const messages = await deps.messageService.list(actor(request, params.projectId), { ...before ? { before } : {}, ...query.limit === void 0 ? {} : { limit: query.limit } });
+    return { data: messages.map(toProjectRoomMessage) };
   }));
   app2.post("/api/projects/:projectId/room/messages", async (request, reply) => run(reply, async () => {
     const params = projectRoomParamsSchema.parse(request.params);
@@ -17069,7 +17860,7 @@ function registerProjectRoomRoutes(app2, deps) {
     const idempotencyKey = rawIdempotencyKey === void 0 ? void 0 : idempotencyKeySchema.parse(rawIdempotencyKey);
     const result = await deps.messageService.createAndDispatch(requestActor, { ...input, ...idempotencyKey === void 0 ? {} : { requestIdempotencyKey: idempotencyKey } });
     const allSucceeded = result.dispatch.length > 0 && result.dispatch.every((entry) => entry.success);
-    return { statusCode: allSucceeded ? result.replayed ? 200 : 201 : 202, data: result };
+    return { statusCode: allSucceeded ? result.replayed ? 200 : 201 : 202, data: { message: toProjectRoomMessage(result.message), dispatch: result.dispatch, replayed: result.replayed } };
   }));
   app2.post("/api/projects/:projectId/room/messages/:messageId/retry", async (request, reply) => run(reply, async () => {
     const params = roomMessageRetryParamsSchema.parse(request.params);
@@ -17078,6 +17869,12 @@ function registerProjectRoomRoutes(app2, deps) {
     const dispatch = await deps.messageService.retry(actor(request, params.projectId), params.messageId);
     return { statusCode: dispatch.length > 0 && dispatch.every((entry) => entry.success) ? 200 : 202, data: dispatch };
   }));
+  app2.post("/api/projects/:projectId/room/read-state", async (request, reply) => run(reply, async () => {
+    const params = projectRoomParamsSchema.parse(request.params);
+    emptyObjectSchema.parse(request.body ?? {});
+    await deps.readStateService.mark(actor(request, params.projectId));
+    return { data: { marked: true } };
+  }));
   app2.get("/api/projects/:projectId/members", async (request, reply) => run(reply, async () => ({ data: await deps.membershipService.list(actor(request, projectRoomParamsSchema.parse(request.params).projectId)) })));
   app2.post("/api/projects/:projectId/members", async (request, reply) => run(reply, async () => {
     const p = projectRoomParamsSchema.parse(request.params);
@@ -17100,19 +17897,24 @@ function actor(request, projectId) {
   projectRoomParamsSchema.parse({ projectId });
   return { tenantId: user.tenantId, userId: user.id, projectId };
 }
+function toProjectRoomMessage(message) {
+  const publicMessage = (0, import_protocols14.toProjectRoomPublicMessage)(message);
+  if (publicMessage === void 0) throw new Error("Room message could not be mapped to its public DTO");
+  return publicMessage;
+}
 async function run(reply, operation) {
   try {
     const result = await operation();
     return reply.code(result.statusCode ?? 200).send({ success: true, data: result.data });
   } catch (error) {
-    if (error instanceof import_zod10.ZodError) return reply.code(400).send({ success: false, error: { code: "INVALID_REQUEST", message: "Invalid request", retryable: false } });
+    if (error instanceof import_zod11.ZodError) return reply.code(400).send({ success: false, error: { code: "INVALID_REQUEST", message: "Invalid request", retryable: false } });
     if (error instanceof ProjectRoomAuthError || error instanceof ProjectCollaborationError || error instanceof ProjectMembershipServiceError || error instanceof ProjectRosterServiceError || error instanceof RoomMessageServiceError) return reply.code(error.statusCode).send({ success: false, error: { code: error.code, message: error.message, retryable: error instanceof RoomMessageServiceError && error.retryable } });
     return reply.code(500).send({ success: false, error: { code: "INTERNAL_ERROR", message: "Internal server error", retryable: false } });
   }
 }
 
 // src/routes/project-roster.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var ProjectRosterAuthError = class extends Error {
   constructor() {
     super(...arguments);
@@ -17152,16 +17954,17 @@ async function execute(reply, operation) {
     const result = await operation();
     return reply.code(result.statusCode ?? 200).send({ success: true, data: result.data });
   } catch (error) {
-    if (error instanceof import_zod11.ZodError) return reply.code(400).send({ success: false, error: { code: "INVALID_REQUEST", message: "Invalid request", retryable: false } });
+    if (error instanceof import_zod12.ZodError) return reply.code(400).send({ success: false, error: { code: "INVALID_REQUEST", message: "Invalid request", retryable: false } });
     if (error instanceof ProjectRosterAuthError || error instanceof ProjectCollaborationError || error instanceof ProjectRosterServiceError) return reply.code(error.statusCode).send({ success: false, error: { code: error.code, message: error.message, retryable: false } });
     return reply.code(500).send({ success: false, error: { code: "INTERNAL_ERROR", message: "Internal server error", retryable: false } });
   }
 }
 
 // src/routes/cospace.ts
-var import_node_crypto12 = require("crypto");
-var import_zod12 = require("zod");
+var import_node_crypto14 = require("crypto");
+var import_zod13 = require("zod");
 var import_core44 = require("@axiom-lattice/core");
+var import_protocols15 = require("@axiom-lattice/protocols");
 var CoSpaceAuthError = class extends Error {
   constructor() {
     super(...arguments);
@@ -17176,8 +17979,20 @@ function getActor2(request) {
   }
   return { tenantId: user.tenantId, userId: user.id };
 }
+async function computeUnread(deps, tenantId, userId, roomId, lastMessage) {
+  if (!lastMessage) return 0;
+  const readState = await deps.readStateStore.get(tenantId, roomId, userId);
+  const horizon = readState?.lastReadAt;
+  if (horizon && lastMessage.createdAt.getTime() <= horizon.getTime()) return 0;
+  return deps.messageStore.countAfter({
+    tenantId,
+    roomId,
+    after: horizon ?? /* @__PURE__ */ new Date(0),
+    excludeAuthorUserId: userId
+  });
+}
 function registerCoSpaceRoutes(app2, deps) {
-  const idFactory = deps.idFactory ?? (() => (0, import_node_crypto12.randomUUID)());
+  const idFactory = deps.idFactory ?? (() => (0, import_node_crypto14.randomUUID)());
   app2.get(
     "/api/workspaces/:workspaceId/rooms",
     async (request, reply) => {
@@ -17226,6 +18041,7 @@ function registerCoSpaceRoutes(app2, deps) {
               limit: 1
             });
             const lastMessage = messages[0];
+            const publicLastMessage = lastMessage === void 0 ? void 0 : (0, import_protocols15.toProjectRoomPublicMessage)(lastMessage);
             const memberships = await deps.membershipStore.list(
               actor2.tenantId,
               project.id
@@ -17241,19 +18057,26 @@ function registerCoSpaceRoutes(app2, deps) {
             rooms.push({
               project,
               room,
-              lastMessage,
+              lastMessage: publicLastMessage,
               participantCount: memberships.filter(
                 (m) => m.status === "active"
               ).length,
-              participantNames
+              participantNames,
+              unreadCount: await computeUnread(
+                deps,
+                actor2.tenantId,
+                actor2.userId,
+                room.id,
+                lastMessage
+              )
             });
           } catch (e) {
             console.error("[CoSpace] Failed to process room for project:", project.id, e);
           }
         }
         rooms.sort((a, b) => {
-          const aTime = a.lastMessage?.createdAt?.getTime() ?? 0;
-          const bTime = b.lastMessage?.createdAt?.getTime() ?? 0;
+          const aTime = a.lastMessage ? Date.parse(a.lastMessage.createdAt) : 0;
+          const bTime = b.lastMessage ? Date.parse(b.lastMessage.createdAt) : 0;
           return bTime - aTime;
         });
         const publicRoom = await deps.publicRoom.ensure(actor2.tenantId, params.workspaceId);
@@ -17263,6 +18086,7 @@ function registerCoSpaceRoutes(app2, deps) {
             roomId: publicRoom.room.id,
             limit: 1
           });
+          const publicLastMessage = publicMessages[0];
           const publicMemberships = await deps.membershipStore.list(
             actor2.tenantId,
             publicRoom.project.id
@@ -17278,10 +18102,17 @@ function registerCoSpaceRoutes(app2, deps) {
           rooms.unshift({
             project: publicRoom.project,
             room: publicRoom.room,
-            lastMessage: publicMessages[0],
+            lastMessage: publicLastMessage === void 0 ? void 0 : (0, import_protocols15.toProjectRoomPublicMessage)(publicLastMessage),
             participantCount: publicMemberships.filter((m) => m.status === "active").length,
             participantNames: publicParticipantNames,
-            isPublic: true
+            isPublic: true,
+            unreadCount: await computeUnread(
+              deps,
+              actor2.tenantId,
+              actor2.userId,
+              publicRoom.room.id,
+              publicLastMessage
+            )
           });
         }
         return { data: { rooms } };
@@ -17646,7 +18477,7 @@ function registerCoSpaceRoutes(app2, deps) {
         data: result.data
       });
     } catch (error) {
-      if (error instanceof import_zod12.ZodError) {
+      if (error instanceof import_zod13.ZodError) {
         return reply.code(400).send({
           success: false,
           error: {
@@ -17917,7 +18748,7 @@ var RoomTargetResolver = class {
 };
 
 // src/services/collaboration/RoomDispatchService.ts
-var import_protocols14 = require("@axiom-lattice/protocols");
+var import_protocols16 = require("@axiom-lattice/protocols");
 
 // src/router/InternalRoomDispatch.ts
 var INTERNAL_ROOM_DISPATCH = Symbol("internal-room-dispatch");
@@ -18015,7 +18846,7 @@ function snapshotDispatchSource(value) {
   };
 }
 function snapshotMentions(value) {
-  const rows = (0, import_protocols14.snapshotExactArray)(value);
+  const rows = (0, import_protocols16.snapshotExactArray)(value);
   if (!rows) return void 0;
   const result = [];
   for (const row of rows) {
@@ -18033,16 +18864,16 @@ function snapshotMentions(value) {
 function exactValues(value, required, optional = []) {
   try {
     if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-    return (0, import_protocols14.snapshotExactRecord)(value, required, optional);
+    return (0, import_protocols16.snapshotExactRecord)(value, required, optional);
   } catch {
     return void 0;
   }
 }
 
 // src/services/collaboration/CoordinatorWakeNotifier.ts
-var import_node_crypto13 = require("crypto");
+var import_node_crypto15 = require("crypto");
 var import_core45 = require("@axiom-lattice/core");
-var import_protocols15 = require("@axiom-lattice/protocols");
+var import_protocols17 = require("@axiom-lattice/protocols");
 var SYNTHETIC_WAKE_AUTHOR = "coordinator-wake";
 var CoordinatorWakeNotifier = class {
   /** Creates a bounded Project Task lifecycle observer that wakes the Room Coordinator. */
@@ -18055,7 +18886,7 @@ var CoordinatorWakeNotifier = class {
     this.accepted = /* @__PURE__ */ new Set();
     this.maxPending = deps.maxPending ?? 1024;
     if (!Number.isSafeInteger(this.maxPending) || this.maxPending < 1) throw new RangeError("maxPending must be a positive safe integer");
-    this.idFactory = deps.idFactory ?? import_node_crypto13.randomUUID;
+    this.idFactory = deps.idFactory ?? import_node_crypto15.randomUUID;
   }
   /** Admits one notification without awaiting any store or dispatch operation. */
   handle(value) {
@@ -18196,7 +19027,7 @@ var CoordinatorWakeNotifier = class {
     }
   }
   parse(value) {
-    const row = (0, import_protocols15.snapshotExactRecord)(value, ["tenantId", "workspaceId", "projectId", "taskId", "status", "action", "eventKey", "updatedAt"], ["threadId"]);
+    const row = (0, import_protocols17.snapshotExactRecord)(value, ["tenantId", "workspaceId", "projectId", "taskId", "status", "action", "eventKey", "updatedAt"], ["threadId"]);
     const actions = ["in_progress", "interrupted", "failed", "completed", "cancelled", "reassigned"];
     const statuses = ["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"];
     if (!row || !actions.includes(String(row.action)) || !statuses.includes(String(row.status)) || !["tenantId", "workspaceId", "projectId", "taskId", "eventKey", "updatedAt"].every((key) => typeof row[key] === "string" && row[key].length > 0) || !Number.isFinite(Date.parse(row.updatedAt)) || row.threadId !== void 0 && typeof row.threadId !== "string") return void 0;
@@ -18234,9 +19065,9 @@ function safeId(value) {
 }
 
 // src/services/collaboration/ProjectTaskExecutionMutex.ts
-var import_protocols16 = require("@axiom-lattice/protocols");
+var import_protocols18 = require("@axiom-lattice/protocols");
 function machineKey(scope) {
-  const snapshot = (0, import_protocols16.snapshotExactRecord)(scope, ["tenantId", "assistantId", "projectId"]);
+  const snapshot = (0, import_protocols18.snapshotExactRecord)(scope, ["tenantId", "assistantId", "projectId"]);
   if (!snapshot) throw new Error("Invalid Project task machine scope");
   const values = [snapshot.tenantId, snapshot.assistantId, snapshot.projectId];
   for (const value of values) {
@@ -18313,7 +19144,7 @@ var ProjectTaskExecutionMutex = class {
 
 // src/services/collaboration/ProjectTaskExecutionService.ts
 var import_core46 = require("@axiom-lattice/core");
-var import_protocols17 = require("@axiom-lattice/protocols");
+var import_protocols19 = require("@axiom-lattice/protocols");
 var SYSTEM_ACTOR = "system";
 var QUEUE_CLASSIFICATION_ATTEMPTS = 3;
 var ProjectTaskExecutionError = class extends Error {
@@ -18868,7 +19699,7 @@ function buildTrustedTaskContext(task, thread, inputMessageId) {
   };
 }
 function taskThreadMetadata(thread) {
-  const row = (0, import_protocols17.snapshotExactRecord)(thread.metadata, [
+  const row = (0, import_protocols19.snapshotExactRecord)(thread.metadata, [
     "source",
     "kind",
     "workspaceId",
@@ -18909,7 +19740,7 @@ function classifyRecoveryRows(task, thread, pending2, processingBefore, processi
 }
 function validRecoveryRow(row, task, thread) {
   try {
-    const trusted = (0, import_protocols17.parseTrustedRunContext)(row.trusted_run_context).projectTask;
+    const trusted = (0, import_protocols19.parseTrustedRunContext)(row.trusted_run_context).projectTask;
     const metadata = taskThreadMetadata(thread);
     return row.execution_mode === "followup" && !!trusted && trusted.tenantId === task.tenantId && trusted.workspaceId === task.workspaceId && trusted.projectId === task.projectId && trusted.assistantId === task.ownerId && trusted.taskId === task.id && trusted.threadId === thread.id && trusted.inputMessageId === row.id && !!metadata && trusted.roomId === metadata.roomId && trusted.membershipId === metadata.membershipId && metadata.assistantId === task.ownerId && metadata.taskId === task.id;
   } catch {
@@ -18918,7 +19749,7 @@ function validRecoveryRow(row, task, thread) {
 }
 
 // src/services/collaboration/ProjectTaskObserver.ts
-var import_node_crypto14 = require("crypto");
+var import_node_crypto16 = require("crypto");
 var import_core47 = require("@axiom-lattice/core");
 var SYSTEM_ACTOR2 = "system";
 var TERMINAL_ACTIONS = ["completed", "failed", "interrupted", "cancelled"];
@@ -19455,7 +20286,7 @@ var ProjectTaskObserver = class {
       action: "activity",
       summary: "Project task recovery warning",
       detail: { type: "project_task_recovery_warning", phase, message },
-      eventKey: `project-task-recovery-warning:${task.id}:${phase}:${(0, import_node_crypto14.createHash)("sha256").update(message).digest("hex")}`
+      eventKey: `project-task-recovery-warning:${task.id}:${phase}:${(0, import_node_crypto16.createHash)("sha256").update(message).digest("hex")}`
     });
   }
   async safeWarning(task, phase, error) {
@@ -19522,7 +20353,7 @@ var ProjectTaskObserver = class {
     }
   }
   async persistOverflowWarning(event) {
-    const scopeDigest = (0, import_node_crypto14.createHash)("sha256").update(JSON.stringify([event.tenantId, event.workspaceId, event.projectId])).digest("hex");
+    const scopeDigest = (0, import_node_crypto16.createHash)("sha256").update(JSON.stringify([event.tenantId, event.workspaceId, event.projectId])).digest("hex");
     try {
       await this.deps.workItems.createIfAbsentByEventKey({
         tenantId: event.tenantId,
@@ -19623,9 +20454,9 @@ function combineSignals(left, right) {
 }
 
 // src/services/collaboration/RoomProjectionService.ts
-var import_node_crypto15 = require("crypto");
+var import_node_crypto17 = require("crypto");
 var import_core48 = require("@axiom-lattice/core");
-var import_protocols18 = require("@axiom-lattice/protocols");
+var import_protocols20 = require("@axiom-lattice/protocols");
 var RoomProjectionService = class {
   /** @param deps Message, lifecycle-event, Task, warning, logging, and ID dependencies. */
   constructor(deps) {
@@ -19685,7 +20516,7 @@ var RoomProjectionService = class {
         tenantId: input.tenantId,
         workspaceId: input.workspaceId,
         projectId: input.projectId,
-        actions: [...import_protocols18.PROJECT_TASK_LIFECYCLE_ACTIONS],
+        actions: [...import_protocols20.PROJECT_TASK_LIFECYCLE_ACTIONS],
         before,
         limit: input.pageSize
       });
@@ -19792,7 +20623,7 @@ function safeRepairIdentity(value, scope) {
   return taskId && eventKey && tenantId === scope.tenantId && workspaceId === scope.workspaceId && projectId === scope.projectId ? { taskId, eventKey } : void 0;
 }
 function tupleKey(prefix, values) {
-  const digest = (0, import_node_crypto15.createHash)("sha256").update(JSON.stringify(values)).digest("hex");
+  const digest = (0, import_node_crypto17.createHash)("sha256").update(JSON.stringify(values)).digest("hex");
   return `${prefix}:${digest}`;
 }
 function parseProjectionInput(taskValue, itemValue) {
@@ -19807,7 +20638,7 @@ function parseProjectionInput(taskValue, itemValue) {
   }
 }
 function snapshotProjectableWorkItem(value) {
-  const row = (0, import_protocols18.snapshotExactRecord)(value, ["id", "taskId", "tenantId", "action", "actor", "createdAt"], [
+  const row = (0, import_protocols20.snapshotExactRecord)(value, ["id", "taskId", "tenantId", "action", "actor", "createdAt"], [
     "workspaceId",
     "projectId",
     "threadId",
@@ -19817,10 +20648,10 @@ function snapshotProjectableWorkItem(value) {
     "eventKey"
   ]);
   const createdAt = cloneExactDate(row?.createdAt);
-  if (!row || !createdAt || typeof row.id !== "string" || !row.id || typeof row.taskId !== "string" || !row.taskId || typeof row.tenantId !== "string" || !row.tenantId || typeof row.workspaceId !== "string" || !row.workspaceId || typeof row.projectId !== "string" || !row.projectId || typeof row.actor !== "string" || !row.actor || typeof row.eventKey !== "string" || !row.eventKey || !import_protocols18.PROJECT_TASK_LIFECYCLE_ACTIONS.includes(row.action) || row.threadId !== void 0 && typeof row.threadId !== "string" || row.summary !== void 0 && typeof row.summary !== "string" || row.attempt !== void 0 && (typeof row.attempt !== "number" || !Number.isFinite(row.attempt))) return void 0;
+  if (!row || !createdAt || typeof row.id !== "string" || !row.id || typeof row.taskId !== "string" || !row.taskId || typeof row.tenantId !== "string" || !row.tenantId || typeof row.workspaceId !== "string" || !row.workspaceId || typeof row.projectId !== "string" || !row.projectId || typeof row.actor !== "string" || !row.actor || typeof row.eventKey !== "string" || !row.eventKey || !import_protocols20.PROJECT_TASK_LIFECYCLE_ACTIONS.includes(row.action) || row.threadId !== void 0 && typeof row.threadId !== "string" || row.summary !== void 0 && typeof row.summary !== "string" || row.attempt !== void 0 && (typeof row.attempt !== "number" || !Number.isFinite(row.attempt))) return void 0;
   try {
     const detail = row.detail === void 0 ? void 0 : snapshotJsonValue(row.detail);
-    if (detail !== void 0 && !isRecord4(detail)) return void 0;
+    if (detail !== void 0 && !isRecord3(detail)) return void 0;
     return {
       id: row.id,
       taskId: row.taskId,
@@ -19844,12 +20675,12 @@ function parseIso(value) {
   return typeof value === "string" && value.length > 0 && Number.isFinite(Date.parse(value));
 }
 function parseInterruption(value) {
-  const common = (0, import_protocols18.snapshotExactRecord)(value, ["type", "summary", "requestedAt"]);
+  const common = (0, import_protocols20.snapshotExactRecord)(value, ["type", "summary", "requestedAt"]);
   if (common && (common.type === "missing_input" || common.type === "user_decision") && typeof common.summary === "string" && common.summary.length > 0 && parseIso(common.requestedAt)) {
     return { type: common.type, summary: common.summary, requestedAt: common.requestedAt };
   }
-  const external = (0, import_protocols18.snapshotExactRecord)(value, ["type", "summary", "requestedAt", "dependencyTaskIds"]);
-  const ids = (0, import_protocols18.snapshotExactArray)(external?.dependencyTaskIds);
+  const external = (0, import_protocols20.snapshotExactRecord)(value, ["type", "summary", "requestedAt", "dependencyTaskIds"]);
+  const ids = (0, import_protocols20.snapshotExactArray)(external?.dependencyTaskIds);
   if (external?.type === "external_dependency" && typeof external.summary === "string" && external.summary.length > 0 && parseIso(external.requestedAt) && ids && ids.length > 0 && ids.every((id3) => typeof id3 === "string" && id3.length > 0) && new Set(ids).size === ids.length) {
     return {
       type: "external_dependency",
@@ -19858,58 +20689,58 @@ function parseInterruption(value) {
       dependencyTaskIds: [...ids]
     };
   }
-  const review = (0, import_protocols18.snapshotExactRecord)(value, ["type", "evidenceId"]);
+  const review = (0, import_protocols20.snapshotExactRecord)(value, ["type", "evidenceId"]);
   return review?.type === "review_required" && typeof review.evidenceId === "string" && review.evidenceId.length > 0 ? { type: "review_required", evidenceId: review.evidenceId } : void 0;
 }
 function parseBeliefImpact(value) {
-  const rows = (0, import_protocols18.snapshotExactArray)(value);
+  const rows = (0, import_protocols20.snapshotExactArray)(value);
   if (!rows) return void 0;
   const impacts = [];
   for (const row of rows) {
-    const entry = (0, import_protocols18.snapshotExactRecord)(row, ["key", "after", "basis"]);
+    const entry = (0, import_protocols20.snapshotExactRecord)(row, ["key", "after", "basis"]);
     if (!entry || typeof entry.key !== "string" || !entry.key || typeof entry.after !== "number" || !Number.isFinite(entry.after) || typeof entry.basis !== "string" || !entry.basis) return void 0;
     impacts.push({ key: entry.key, after: entry.after, basis: entry.basis });
   }
   return impacts;
 }
 function parseCompletion(item) {
-  const row = (0, import_protocols18.snapshotExactRecord)(item.detail, ["evidenceId", "eventKey", "result", "beliefImpact"]);
+  const row = (0, import_protocols20.snapshotExactRecord)(item.detail, ["evidenceId", "eventKey", "result", "beliefImpact"]);
   const beliefImpact = parseBeliefImpact(row?.beliefImpact);
   if (!row || typeof row.evidenceId !== "string" || !row.evidenceId || typeof row.eventKey !== "string" || !row.eventKey || item.eventKey !== `${row.eventKey}:completed` || typeof row.result !== "string" || !beliefImpact) return void 0;
   return { evidenceId: row.evidenceId, eventKey: row.eventKey, result: row.result, beliefImpact };
 }
 function parseProjection(item) {
   if (item.action === "in_progress") {
-    const started = (0, import_protocols18.snapshotExactRecord)(item.detail, ["previousStatus"]);
+    const started = (0, import_protocols20.snapshotExactRecord)(item.detail, ["previousStatus"]);
     if (started?.previousStatus === "pending") return { kind: "started", text: "Task started" };
-    const resumed = (0, import_protocols18.snapshotExactRecord)(item.detail, ["type", "previousInterruption"]);
+    const resumed = (0, import_protocols20.snapshotExactRecord)(item.detail, ["type", "previousInterruption"]);
     if (resumed?.type === "interruption_resume" && parseInterruption(resumed.previousInterruption)) {
       return { kind: "resumed", text: "Task resumed" };
     }
-    const rejected = (0, import_protocols18.snapshotExactRecord)(item.detail, ["type", "evidenceId", "note"]);
+    const rejected = (0, import_protocols20.snapshotExactRecord)(item.detail, ["type", "evidenceId", "note"]);
     if (rejected?.type === "review_rejected" && typeof rejected.evidenceId === "string" && rejected.evidenceId && typeof rejected.note === "string" && rejected.note) {
       return { kind: "resumed", text: "Task resumed after review rejection" };
     }
-    const stale = (0, import_protocols18.snapshotExactRecord)(item.detail, ["type", "evidenceId"]);
+    const stale = (0, import_protocols20.snapshotExactRecord)(item.detail, ["type", "evidenceId"]);
     return stale?.type === "review_stale" && typeof stale.evidenceId === "string" && stale.evidenceId ? { kind: "resumed", text: "Task resumed after stale review" } : void 0;
   }
   if (item.action === "interrupted") {
     return parseInterruption(item.detail) ? { kind: "interrupted", text: "Task interrupted" } : void 0;
   }
   if (item.action === "failed") {
-    const row = (0, import_protocols18.snapshotExactRecord)(item.detail, ["failureReason"]);
+    const row = (0, import_protocols20.snapshotExactRecord)(item.detail, ["failureReason"]);
     return typeof row?.failureReason === "string" && row.failureReason ? { kind: "failed", text: "Task failed" } : void 0;
   }
   if (item.action === "completed") {
     return parseCompletion(item) ? { kind: "completed", text: "Task completed" } : void 0;
   }
   if (item.action === "cancelled") {
-    const empty = (0, import_protocols18.snapshotExactRecord)(item.detail, []);
-    const summarized = (0, import_protocols18.snapshotExactRecord)(item.detail, ["summary"]);
+    const empty = (0, import_protocols20.snapshotExactRecord)(item.detail, []);
+    const summarized = (0, import_protocols20.snapshotExactRecord)(item.detail, ["summary"]);
     return empty || typeof summarized?.summary === "string" && summarized.summary ? { kind: "cancelled", text: "Task cancelled" } : void 0;
   }
   if (item.action === "reassigned") {
-    const row = (0, import_protocols18.snapshotExactRecord)(
+    const row = (0, import_protocols20.snapshotExactRecord)(
       item.detail,
       ["previousOwnerId", "previousThreadId", "ownerId", "membershipId", "threadId"]
     );
@@ -19918,7 +20749,7 @@ function parseProjection(item) {
   return void 0;
 }
 function assertCanonicalProjection(value, expected) {
-  const row = (0, import_protocols18.snapshotExactRecord)(value, [
+  const row = (0, import_protocols20.snapshotExactRecord)(value, [
     "id",
     "tenantId",
     "workspaceId",
@@ -19932,9 +20763,9 @@ function assertCanonicalProjection(value, expected) {
     "idempotencyKey",
     "createdAt"
   ]);
-  const author = (0, import_protocols18.snapshotExactRecord)(row?.author, ["type"]);
-  const content = (0, import_protocols18.snapshotExactRecord)(row?.content, ["type", "text"]);
-  const mentions = (0, import_protocols18.snapshotExactArray)(row?.mentions);
+  const author = (0, import_protocols20.snapshotExactRecord)(row?.author, ["type"]);
+  const content = (0, import_protocols20.snapshotExactRecord)(row?.content, ["type", "text"]);
+  const mentions = (0, import_protocols20.snapshotExactArray)(row?.mentions);
   const createdAt = cloneExactDate(row?.createdAt);
   if (!row || !createdAt || author?.type !== "system" || content?.type !== "text" || content.text !== expected.content.text || !mentions || mentions.length !== 0 || typeof row.id !== "string" || !row.id || row.tenantId !== expected.tenantId || row.workspaceId !== expected.workspaceId || row.projectId !== expected.projectId || row.roomId !== expected.roomId || row.source !== "task" || row.sourceId !== expected.sourceId || row.idempotencyKey !== expected.idempotencyKey) {
     throw new Error("Invalid canonical task projection");
@@ -19955,7 +20786,7 @@ function assertCanonicalProjection(value, expected) {
   };
 }
 function snapshotLifecycleCursor(value) {
-  const row = (0, import_protocols18.snapshotExactRecord)(value, ["id", "taskId", "tenantId", "action", "actor", "createdAt"], [
+  const row = (0, import_protocols20.snapshotExactRecord)(value, ["id", "taskId", "tenantId", "action", "actor", "createdAt"], [
     "workspaceId",
     "projectId",
     "threadId",
@@ -19967,7 +20798,7 @@ function snapshotLifecycleCursor(value) {
   const createdAt = cloneExactDate(row?.createdAt);
   return row && typeof row.id === "string" && row.id.length > 0 && createdAt ? { id: row.id, createdAt } : void 0;
 }
-function isRecord4(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -19975,8 +20806,8 @@ function isRecord4(value) {
 var import_core50 = require("@axiom-lattice/core");
 
 // src/services/collaboration/ProjectRoomEventBroker.ts
-var import_node_crypto16 = require("crypto");
-var import_protocols19 = require("@axiom-lattice/protocols");
+var import_node_crypto18 = require("crypto");
+var import_protocols21 = require("@axiom-lattice/protocols");
 var DEFAULT_MAX_EVENTS_PER_ROOM = 1e3;
 var DEFAULT_MAX_EVENT_AGE_MS = 10 * 60 * 1e3;
 var DEFAULT_MAX_ROOMS = 1e3;
@@ -20000,7 +20831,7 @@ var ProjectRoomEventBroker = class {
     this.subscriberCount = 0;
     this.usageClock = 0;
     this.closed = false;
-    this.epoch = options.epoch ?? (0, import_node_crypto16.randomUUID)();
+    this.epoch = options.epoch ?? (0, import_node_crypto18.randomUUID)();
     if (!UUID_PATTERN.test(this.epoch)) {
       throw new TypeError("Project Room event epoch must be a lowercase canonical UUID");
     }
@@ -20039,7 +20870,7 @@ var ProjectRoomEventBroker = class {
     const canonicalScope = snapshotScope(scope);
     const key = scopeKey2(canonicalScope);
     const now = this.currentTime();
-    if (this.sequence >= Number.MAX_SAFE_INTEGER) throw new import_protocols19.ProjectRoomBrokerCapacityError();
+    if (this.sequence >= Number.MAX_SAFE_INTEGER) throw new import_protocols21.ProjectRoomBrokerCapacityError();
     const nextSequence = this.sequence + 1;
     const event = snapshotJson({
       ...snapshotDraft(draft),
@@ -20222,11 +21053,11 @@ var ProjectRoomEventBroker = class {
   }
   resolveCursor(key, afterEventId, plan) {
     if (afterEventId === void 0) return void 0;
-    const cursor = (0, import_protocols19.parseProjectRoomEventId)(afterEventId);
-    if (!cursor) throw new import_protocols19.ProjectRoomCursorError("CURSOR_EXPIRED");
-    if (cursor.epoch !== this.epoch) throw new import_protocols19.ProjectRoomCursorError("SERVER_RESTART");
+    const cursor = (0, import_protocols21.parseProjectRoomEventId)(afterEventId);
+    if (!cursor) throw new import_protocols21.ProjectRoomCursorError("CURSOR_EXPIRED");
+    if (cursor.epoch !== this.epoch) throw new import_protocols21.ProjectRoomCursorError("SERVER_RESTART");
     if (plan.sequences.has(cursor.sequence) || this.sequenceScopes.get(cursor.sequence) !== key) {
-      throw new import_protocols19.ProjectRoomCursorError("CURSOR_EXPIRED");
+      throw new import_protocols21.ProjectRoomCursorError("CURSOR_EXPIRED");
     }
     return cursor.sequence;
   }
@@ -20318,8 +21149,8 @@ function snapshotJson(value, ancestors = /* @__PURE__ */ new Set()) {
 }
 
 // src/services/collaboration/ProjectRoomRealtimePublisher.ts
-var import_node_crypto17 = require("crypto");
-var import_protocols20 = require("@axiom-lattice/protocols");
+var import_node_crypto19 = require("crypto");
+var import_protocols22 = require("@axiom-lattice/protocols");
 var BrokerProjectRoomRealtimePublisher = class {
   /** Creates a publisher around a broker and structured warning logger. */
   constructor(deps) {
@@ -20333,7 +21164,7 @@ var BrokerProjectRoomRealtimePublisher = class {
   /** Publishes a canonical message after projecting it to its public shape. */
   messageCreated(message) {
     this.publish("message.created", () => {
-      const projection = (0, import_protocols20.snapshotProjectRoomMessageRealtime)(message);
+      const projection = (0, import_protocols22.snapshotProjectRoomMessageRealtime)(message);
       if (!projection) return void 0;
       return {
         sourceKey: `message:${projection.publicMessage.id}`,
@@ -20348,7 +21179,7 @@ var BrokerProjectRoomRealtimePublisher = class {
     this.publish("roster.changed", () => {
       const membership = snapshotInput(input, "roster");
       if (membership.membership.tenantId !== membership.tenantId || membership.membership.roomId !== membership.roomId || !safeId2(membership.membership.projectId)) throw new TypeError("Invalid roster scope");
-      const projection = (0, import_protocols20.snapshotProjectRoomBotMembershipRealtime)(membership.membership);
+      const projection = (0, import_protocols22.snapshotProjectRoomBotMembershipRealtime)(membership.membership);
       if (!projection) return void 0;
       return {
         sourceKey: membership.sourceKey,
@@ -20363,7 +21194,7 @@ var BrokerProjectRoomRealtimePublisher = class {
     this.publish("membership.changed", () => {
       const membership = snapshotInput(input, "membership");
       if (membership.membership.tenantId !== membership.tenantId || !safeId2(membership.membership.projectId)) throw new TypeError("Invalid membership scope");
-      const projection = (0, import_protocols20.snapshotProjectRoomMembershipRealtime)(membership.membership);
+      const projection = (0, import_protocols22.snapshotProjectRoomMembershipRealtime)(membership.membership);
       if (!projection) return void 0;
       return {
         sourceKey: membership.sourceKey,
@@ -20389,12 +21220,52 @@ var BrokerProjectRoomRealtimePublisher = class {
       };
     });
   }
+  /** Publishes a membership notice onto the affected user's channel scope. */
+  membershipAffected(input) {
+    this.publish("membership.affected", () => {
+      const value = (0, import_protocols22.snapshotExactRecord)(input, ["tenantId", "userId", "change", "projectId", "roomId", "sourceKey"]);
+      if (!value || !safeId2(value.tenantId) || !safeId2(value.userId) || !safeId2(value.projectId) || !safeId2(value.roomId) || !safeSourceKey(value.sourceKey) || !["added", "removed", "role_changed"].includes(value.change)) {
+        throw new TypeError("Invalid membership input");
+      }
+      const scope = (0, import_protocols22.projectRoomUserEventScope)(value.tenantId, value.userId);
+      return {
+        sourceKey: value.sourceKey,
+        id: value.sourceKey,
+        scope,
+        draft: {
+          type: "membership.affected",
+          occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { change: value.change, projectId: value.projectId, roomId: value.roomId }
+        }
+      };
+    });
+  }
+  /** Publishes a read-marker update onto the acting user's channel scope. */
+  readChanged(input) {
+    this.publish("read.changed", () => {
+      const value = (0, import_protocols22.snapshotExactRecord)(input, ["tenantId", "userId", "projectId", "roomId", "lastReadAt", "sourceKey"]);
+      if (!value || !safeId2(value.tenantId) || !safeId2(value.userId) || !safeId2(value.projectId) || !safeId2(value.roomId) || !safeSourceKey(value.sourceKey) || typeof value.lastReadAt !== "string" || !Number.isFinite(Date.parse(value.lastReadAt))) {
+        throw new TypeError("Invalid read input");
+      }
+      const scope = (0, import_protocols22.projectRoomUserEventScope)(value.tenantId, value.userId);
+      return {
+        sourceKey: value.sourceKey,
+        id: value.sourceKey,
+        scope,
+        draft: {
+          type: "read.changed",
+          occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          data: { projectId: value.projectId, roomId: value.roomId, lastReadAt: new Date(Date.parse(value.lastReadAt)).toISOString() }
+        }
+      };
+    });
+  }
   publish(type, build) {
     let event;
     try {
       event = build();
       if (!event) throw new Error("Invalid Project Room realtime projection");
-      const dedupeKey = (0, import_node_crypto17.createHash)("sha256").update(JSON.stringify([type, event.scope.tenantId, event.scope.projectId, event.scope.roomId, event.sourceKey])).digest("hex");
+      const dedupeKey = (0, import_node_crypto19.createHash)("sha256").update(JSON.stringify([type, event.scope.tenantId, event.scope.projectId, event.scope.roomId, event.sourceKey])).digest("hex");
       if (this.sourceKeys.has(dedupeKey)) return;
       this.deps.broker.publish(event.scope, event.draft);
       this.sourceKeys.set(dedupeKey, true);
@@ -20417,13 +21288,13 @@ var BrokerProjectRoomRealtimePublisher = class {
 };
 function snapshotInput(input, kind) {
   const keys2 = kind === "message" ? ["tenantId", "roomId", "message", "sourceKey"] : kind === "roster" ? ["tenantId", "roomId", "membership", "sourceKey"] : ["tenantId", "roomId", "membership", "sourceKey"];
-  const value = (0, import_protocols20.snapshotExactRecord)(input, [...keys2, "change"]);
+  const value = (0, import_protocols22.snapshotExactRecord)(input, [...keys2, "change"]);
   const validChange = kind === "roster" ? ["added", "updated", "paused", "resumed", "removed"].includes(value?.change) : ["added", "role_changed", "removed"].includes(value?.change);
   if (!value || !safeId2(value.tenantId) || !safeId2(value.roomId) || !safeSourceKey(value.sourceKey) || !validChange) throw new TypeError(`Invalid ${kind} input`);
   return value;
 }
 function snapshotTaskInput(input) {
-  const value = (0, import_protocols20.snapshotExactRecord)(input, ["tenantId", "roomId", "projectId", "taskId", "status", "ownerMembershipId", "updatedAt", "sourceKey"]);
+  const value = (0, import_protocols22.snapshotExactRecord)(input, ["tenantId", "roomId", "projectId", "taskId", "status", "ownerMembershipId", "updatedAt", "sourceKey"]);
   if (!value || !safeId2(value.tenantId) || !safeId2(value.roomId) || !safeSourceKey(value.sourceKey)) throw new TypeError("Invalid task input");
   if (!safeId2(value.projectId) || !safeId2(value.taskId) || !safeId2(value.ownerMembershipId) || !["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"].includes(value.status)) throw new TypeError("Invalid task input");
   if (typeof value.updatedAt !== "string") throw new TypeError("Invalid task timestamp");
@@ -20447,384 +21318,16 @@ function safeErrorCode(error) {
   return error instanceof Error && error.name === "Error" ? "Error" : "UnknownError";
 }
 
-// src/services/collaboration/ProjectRoomRealtimeService.ts
-var import_protocols21 = require("@axiom-lattice/protocols");
-
-// src/services/collaboration/ProjectRoomSseWriter.ts
-var DEFAULT_MAX_FRAMES = 256;
-var DEFAULT_MAX_BYTES = 1024 * 1024;
-var DEFAULT_DRAIN_TIMEOUT_MS = 1e4;
-function serializeBusiness(event) {
-  return `id: ${event.id}
-event: ${event.type}
-data: ${JSON.stringify(event)}
-
-`;
-}
-function serializeControl(event) {
-  return `event: ${event.type}
-data: ${JSON.stringify(event.data)}
-
-`;
-}
-var ProjectRoomSseWriter = class {
-  /** Creates a writer over a raw HTTP response/socket. */
-  constructor(raw, options = {}) {
-    this.raw = raw;
-    this.frames = [];
-    this.queuedBytes = 0;
-    this.blockedBytes = 0;
-    this.writing = false;
-    this.closed = false;
-    this.terminal = false;
-    this.slowConsumerAttempted = false;
-    this.closeListener = () => this.close();
-    this.errorListener = () => this.close();
-    this.drainListener = () => {
-      if (this.closed || !this.writing) return;
-      this.clearDrainTimer();
-      this.blockedBytes = 0;
-      this.writing = false;
-      this.flush();
-    };
-    this.maxFrames = positive(options.maxFrames ?? DEFAULT_MAX_FRAMES, "maxFrames");
-    this.maxBytes = positive(options.maxBytes ?? DEFAULT_MAX_BYTES, "maxBytes");
-    this.drainTimeoutMs = positive(options.drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS, "drainTimeoutMs");
-    this.onClose = options.onClose;
-    raw.on("close", this.closeListener).on("error", this.errorListener).on("drain", this.drainListener);
-  }
-  /** Enqueues one public business event. */
-  enqueueBusiness(event) {
-    this.enqueue(serializeBusiness(event));
-  }
-  /** Enqueues one connection control event. */
-  enqueueControl(event) {
-    this.enqueue(serializeControl(event));
-  }
-  /** Writes a heartbeat comment when the socket is not currently blocked. */
-  heartbeat() {
-    if (!this.closed && !this.writing) this.writeFrame(": heartbeat\n\n");
-  }
-  /** Closes the writer and removes every socket listener exactly once. */
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    this.clearDrainTimer();
-    if (this.terminalTimer !== void 0) clearTimeout(this.terminalTimer);
-    this.terminalResolve?.();
-    this.terminalResolve = void 0;
-    this.terminalFinish = void 0;
-    this.raw.off("close", this.closeListener).off("error", this.errorListener).off("drain", this.drainListener);
-    this.frames.length = 0;
-    this.queuedBytes = 0;
-    try {
-      this.raw.end();
-    } catch {
-      this.raw.destroy();
-    }
-    this.onClose?.();
-  }
-  /** Stops ordinary delivery and attempts one terminal control before ending. */
-  closeWithControl(control, deadlineMs = 250) {
-    if (this.closed) return Promise.resolve();
-    if (this.terminal) return new Promise((resolve4) => {
-      this.terminalResolve = resolve4;
-    });
-    this.terminal = true;
-    this.frames.length = 0;
-    this.queuedBytes = 0;
-    const frame = serializeControl(control);
-    const finish = () => {
-      if (this.closed) return;
-      if (this.terminalTimer !== void 0) clearTimeout(this.terminalTimer);
-      this.terminalTimer = void 0;
-      this.close();
-    };
-    this.terminalFinish = finish;
-    const promise = new Promise((resolve4) => {
-      this.terminalResolve = resolve4;
-    });
-    if (!this.writing) {
-      try {
-        if (this.raw.write(frame)) finish();
-        else this.armTerminalDeadline(deadlineMs, finish);
-      } catch {
-        finish();
-      }
-    } else {
-      this.frames.push(frame);
-      this.flushTerminal(finish);
-      this.armTerminalDeadline(deadlineMs, finish);
-    }
-    return promise;
-  }
-  enqueue(frame) {
-    if (this.closed || this.terminal) return;
-    const bytes = Buffer.byteLength(frame, "utf8");
-    const inFlightFrames = this.writing ? 1 : 0;
-    if (bytes > this.maxBytes || this.frames.length + inFlightFrames + 1 > this.maxFrames || this.queuedBytes + this.blockedBytes + bytes > this.maxBytes) return this.failSlowConsumer();
-    this.frames.push(frame);
-    this.queuedBytes += bytes;
-    this.flush();
-  }
-  flush() {
-    if (this.closed || this.writing || this.frames.length === 0) return;
-    const frame = this.frames.shift();
-    if (!frame) return;
-    this.queuedBytes -= Buffer.byteLength(frame, "utf8");
-    if (this.terminal) this.writeTerminalFrame(frame, this.terminalFinish ?? (() => this.close()));
-    else this.writeFrame(frame);
-  }
-  flushTerminal(finish) {
-    if (this.closed || this.writing || this.frames.length === 0) return;
-    const frame = this.frames.shift();
-    if (!frame) return;
-    this.writeTerminalFrame(frame, finish);
-  }
-  writeTerminalFrame(frame, finish) {
-    try {
-      if (!this.raw.write(frame)) {
-        this.writing = true;
-        this.blockedBytes = Buffer.byteLength(frame, "utf8");
-      } else {
-        this.writing = false;
-        this.blockedBytes = 0;
-        (finish ?? (() => this.close()))();
-      }
-    } catch {
-      this.close();
-    }
-  }
-  armTerminalDeadline(deadlineMs, finish) {
-    this.terminalTimer = setTimeout(finish, deadlineMs);
-    this.terminalTimer.unref?.();
-  }
-  writeFrame(frame) {
-    if (this.closed) return;
-    try {
-      if (!this.raw.write(frame)) {
-        this.writing = true;
-        this.blockedBytes = Buffer.byteLength(frame, "utf8");
-        this.drainTimer = setTimeout(() => {
-          this.drainTimer = void 0;
-          this.failSlowConsumer();
-        }, this.drainTimeoutMs);
-        this.drainTimer.unref?.();
-      } else {
-        this.writing = false;
-        this.blockedBytes = 0;
-        this.flush();
-      }
-    } catch {
-      this.close();
-    }
-  }
-  clearDrainTimer() {
-    if (this.drainTimer !== void 0) clearTimeout(this.drainTimer);
-    this.drainTimer = void 0;
-  }
-  failSlowConsumer() {
-    if (this.closed) return;
-    this.frames.length = 0;
-    this.queuedBytes = 0;
-    if (!this.slowConsumerAttempted) {
-      this.slowConsumerAttempted = true;
-      try {
-        this.raw.write(serializeControl({ type: "resync", data: { reason: "SLOW_CONSUMER" } }));
-      } catch {
-      }
-    }
-    this.close();
-  }
-};
-function positive(value, name) {
-  if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`${name} must be positive`);
-  return value;
-}
-
-// src/services/collaboration/ProjectRoomRealtimeService.ts
-var MAX_REPLAY_EVENTS = 1e4;
-var MAX_NODE_TIMER_DELAY = 2147e6;
-var ProjectRoomRealtimeService = class {
-  /** Creates a service using one process-local broker and read-only authorizer. */
-  constructor(deps) {
-    this.deps = deps;
-    this.connections = /* @__PURE__ */ new Set();
-    this.closed = false;
-    this.activeConnections = /* @__PURE__ */ new Map();
-    this.now = deps.now ?? Date.now;
-    this.authRecheckMs = deps.authRecheckMs ?? 15e3;
-    this.heartbeatMs = deps.heartbeatMs ?? 15e3;
-  }
-  /** Returns whether the actor's tenant/user/project stream quota has capacity. */
-  canConnect(actor2) {
-    if (this.closed) return false;
-    return (this.activeConnections.get(connectionKey(actor2)) ?? 0) < (this.deps.maxConnectionsPerUserProject ?? 5);
-  }
-  /** Starts a connection; authorization is assumed to have been performed by the route. */
-  connect(input) {
-    if (!this.canConnect(input.actor)) {
-      input.raw.end();
-      return;
-    }
-    const quotaKey = connectionKey(input.actor);
-    this.activeConnections.set(quotaKey, (this.activeConnections.get(quotaKey) ?? 0) + 1);
-    const writer = new ProjectRoomSseWriter(input.raw, { onClose: () => connection.close() });
-    let phase = "initializing";
-    let subscription;
-    let accessTimer;
-    let heartbeatTimer;
-    let expiryTimer;
-    const lifetimeAbort = new AbortController();
-    let accessAbort;
-    let closed = false;
-    const buffered = [];
-    const clearTimer = (timer) => {
-      if (timer !== void 0) clearTimeout(timer);
-    };
-    const cleanup = () => {
-      if (closed) return;
-      closed = true;
-      phase = "closed";
-      clearTimer(accessTimer);
-      clearTimer(heartbeatTimer);
-      clearTimer(expiryTimer);
-      lifetimeAbort.abort();
-      accessAbort?.abort();
-      subscription?.unsubscribe();
-      writer.close();
-      this.connections.delete(connection);
-      const remainingConnections = (this.activeConnections.get(quotaKey) ?? 1) - 1;
-      if (remainingConnections === 0) this.activeConnections.delete(quotaKey);
-      else this.activeConnections.set(quotaKey, remainingConnections);
-    };
-    const revoke = (reason) => {
-      if (closed) return;
-      void writer.closeWithControl({ type: "access.revoked", data: { reason } }).then(cleanup, cleanup);
-    };
-    const scheduleAccessCheck = () => {
-      if (closed) return;
-      accessTimer = setTimeout(() => {
-        accessTimer = void 0;
-        if (closed) return;
-        accessAbort = new AbortController();
-        const combined = combineSignals2(lifetimeAbort.signal, accessAbort.signal);
-        Promise.resolve().then(() => this.deps.requireReadAccess(input.actor, combined.signal)).then(() => {
-          combined.cleanup();
-          accessAbort = void 0;
-          scheduleAccessCheck();
-        }, (_error) => {
-          combined.cleanup();
-          accessAbort = void 0;
-          if (!closed) revoke("PROJECT_ACCESS_REVOKED");
-        });
-      }, this.authRecheckMs);
-      accessTimer.unref?.();
-    };
-    const connection = { close: cleanup };
-    this.connections.add(connection);
-    const scheduleHeartbeat = () => {
-      if (closed) return;
-      heartbeatTimer = setTimeout(() => {
-        heartbeatTimer = void 0;
-        if (closed) return;
-        writer.heartbeat();
-        scheduleHeartbeat();
-      }, this.heartbeatMs);
-      heartbeatTimer.unref?.();
-    };
-    scheduleHeartbeat();
-    const remaining = input.actor.tokenExpiresAt - this.now();
-    if (remaining <= 0) {
-      revoke("TOKEN_EXPIRED");
-      return;
-    }
-    const maxTimerDelay = this.deps.maxTimerDelay ?? MAX_NODE_TIMER_DELAY;
-    const scheduleExpiry = () => {
-      if (closed) return;
-      const delay2 = input.actor.tokenExpiresAt - this.now();
-      if (delay2 <= 0) {
-        revoke("TOKEN_EXPIRED");
-        return;
-      }
-      expiryTimer = setTimeout(() => {
-        expiryTimer = void 0;
-        scheduleExpiry();
-      }, Math.min(delay2, maxTimerDelay));
-      expiryTimer.unref?.();
-    };
-    scheduleExpiry();
-    try {
-      subscription = this.deps.broker.subscribe(
-        { tenantId: input.actor.tenantId, roomId: input.roomId, projectId: input.actor.projectId },
-        input.lastEventId,
-        (event) => {
-          if (phase === "initializing") buffered.push(event);
-          else if (phase === "direct") writer.enqueueBusiness(event);
-        }
-      );
-      if (subscription.replay.length > MAX_REPLAY_EVENTS) {
-        void writer.closeWithControl({ type: "resync", data: { reason: "CURSOR_EXPIRED" } }).then(cleanup, cleanup);
-        return;
-      }
-      let lastSequence = sequence(subscription.headEventId);
-      for (const event of subscription.replay) {
-        writer.enqueueBusiness(event);
-        lastSequence = sequence(event.id);
-      }
-      writer.enqueueControl({ type: "ready", data: { epoch: this.deps.broker.epoch, headEventId: subscription.headEventId } });
-      while (buffered.length > 0) {
-        for (const event of buffered.splice(0).sort((left, right) => sequence(left.id) - sequence(right.id))) {
-          if (sequence(event.id) > lastSequence) {
-            writer.enqueueBusiness(event);
-            lastSequence = sequence(event.id);
-          }
-        }
-      }
-      phase = "direct";
-      scheduleAccessCheck();
-    } catch (error) {
-      if (error instanceof import_protocols21.ProjectRoomCursorError) void writer.closeWithControl({ type: "resync", data: { reason: error.code } }).then(cleanup, cleanup);
-      else cleanup();
-    }
-  }
-  /** Closes every connection and prevents new connections. */
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    for (const connection of [...this.connections]) connection.close();
-  }
-};
-function sequence(id3) {
-  return id3 === null ? 0 : Number(id3.slice(id3.lastIndexOf(":") + 1));
-}
-function connectionKey(actor2) {
-  return JSON.stringify([actor2.tenantId, actor2.userId, actor2.projectId]);
-}
-function combineSignals2(first, second) {
-  const controller = new AbortController();
-  const abort = () => controller.abort();
-  if (first.aborted || second.aborted) abort();
-  else {
-    first.addEventListener("abort", abort, { once: true });
-    second.addEventListener("abort", abort, { once: true });
-  }
-  return { signal: controller.signal, cleanup: () => {
-    first.removeEventListener("abort", abort);
-    second.removeEventListener("abort", abort);
-  } };
-}
-
-// src/services/collaboration/ProjectRoomTaskEventSubscriber.ts
-var import_core49 = require("@axiom-lattice/core");
-var import_protocols22 = require("@axiom-lattice/protocols");
-var ProjectRoomTaskEventSubscriber = class {
-  /** Creates a bounded Project task lifecycle observer. */
-  constructor(deps) {
-    this.deps = deps;
-    this.queues = /* @__PURE__ */ new Map();
-    this.pendingCount = 0;
-    this.accepting = true;
+// src/services/collaboration/ProjectRoomTaskEventSubscriber.ts
+var import_core49 = require("@axiom-lattice/core");
+var import_protocols23 = require("@axiom-lattice/protocols");
+var ProjectRoomTaskEventSubscriber = class {
+  /** Creates a bounded Project task lifecycle observer. */
+  constructor(deps) {
+    this.deps = deps;
+    this.queues = /* @__PURE__ */ new Map();
+    this.pendingCount = 0;
+    this.accepting = true;
     this.closed = false;
     this.accepted = /* @__PURE__ */ new Set();
     this.maxPending = deps.maxPending ?? 1024;
@@ -20927,117 +21430,509 @@ var ProjectRoomTaskEventSubscriber = class {
     }
   }
   parse(value) {
-    const row = (0, import_protocols22.snapshotExactRecord)(value, ["tenantId", "workspaceId", "projectId", "taskId", "status", "action", "eventKey", "updatedAt"], ["threadId"]);
+    const row = (0, import_protocols23.snapshotExactRecord)(value, ["tenantId", "workspaceId", "projectId", "taskId", "status", "action", "eventKey", "updatedAt"], ["threadId"]);
     const actions = ["in_progress", "interrupted", "failed", "completed", "cancelled", "reassigned"];
     const statuses = ["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"];
     if (!row || !actions.includes(String(row.action)) || !statuses.includes(String(row.status)) || !["tenantId", "workspaceId", "projectId", "taskId", "eventKey", "updatedAt"].every((key) => typeof row[key] === "string" && row[key].length > 0) || !Number.isFinite(Date.parse(row.updatedAt)) || row.threadId !== void 0 && typeof row.threadId !== "string") return void 0;
     return row;
   }
-  warn(message, context) {
+  warn(message, context) {
+    try {
+      this.deps.log.warn(message, context);
+    } catch {
+    }
+  }
+  overflow(taskId) {
+    this.warn("project-room:task-realtime-overflow", { code: "TASK_REALTIME_QUEUE_FULL", taskId });
+    return Promise.resolve();
+  }
+};
+function safeId3(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// src/services/collaboration/ProjectRoomRealtimeRuntime.ts
+var ProjectRoomRealtimeRuntime = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.accepted = /* @__PURE__ */ new Set();
+    this.broker = deps.broker;
+    this.publisher = deps.publisher;
+    this.shutdownTimeoutMs = deps.shutdownTimeoutMs ?? 5e3;
+    this.unsubscribe = deps.subscribe(((event) => {
+      let work;
+      try {
+        work = Promise.resolve(deps.subscriber.handle(event));
+      } catch (error) {
+        work = Promise.reject(error);
+      }
+      const accepted = work.catch((error) => {
+        deps.log.warn("project-room:task-subscriber-failed", { error: error instanceof Error ? error.name : "UnknownError" });
+      });
+      this.accepted.add(accepted);
+      void accepted.finally(() => this.accepted.delete(accepted));
+    }));
+  }
+  /** Stops admission, drains accepted work, and closes transport resources exactly once. */
+  close() {
+    this.closing ?? (this.closing = this.dispose());
+    return this.closing;
+  }
+  async dispose() {
+    this.unsubscribe();
+    this.deps.subscriber.closeAdmission();
+    const accepted = [...this.accepted];
+    const drained = await boundedAllSettled(accepted, this.shutdownTimeoutMs);
+    if (!drained) this.deps.log.warn("project-room:runtime-drain-timeout", {
+      timeoutMs: this.shutdownTimeoutMs,
+      pending: accepted.length
+    });
+    await this.deps.subscriber.drain(drained ? this.shutdownTimeoutMs : 0);
+    this.broker.close();
+  }
+};
+function createProjectRoomRealtimeRuntime(deps) {
+  const broker = new ProjectRoomEventBroker({ log: deps.log });
+  const publisher = new BrokerProjectRoomRealtimePublisher({ broker, log: deps.log });
+  const subscriber = new ProjectRoomTaskEventSubscriber({
+    tasks: deps.tasks,
+    rooms: deps.rooms,
+    memberships: deps.memberships,
+    realtime: publisher,
+    log: deps.log
+  });
+  return new ProjectRoomRealtimeRuntime({
+    broker,
+    publisher,
+    subscriber,
+    subscribe: (listener) => import_core50.taskLifecycleNotifier.subscribe(listener),
+    log: deps.log,
+    shutdownTimeoutMs: deps.shutdownTimeoutMs
+  });
+}
+async function boundedAllSettled(promises, timeoutMs) {
+  if (promises.length === 0) return true;
+  let timer;
+  const timeout = new Promise((resolve4) => {
+    timer = setTimeout(() => resolve4(false), timeoutMs);
+    timer.unref?.();
+  });
+  const result = await Promise.race([Promise.allSettled(promises).then(() => true), timeout]);
+  if (timer) clearTimeout(timer);
+  return result;
+}
+
+// src/services/collaboration/WorkspaceRoomEventsService.ts
+var import_protocols24 = require("@axiom-lattice/protocols");
+
+// src/services/collaboration/ProjectRoomSseWriter.ts
+var DEFAULT_MAX_FRAMES = 256;
+var DEFAULT_MAX_BYTES = 1024 * 1024;
+var DEFAULT_DRAIN_TIMEOUT_MS = 1e4;
+function serializeBusiness(event) {
+  return `id: ${event.id}
+event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`;
+}
+function serializeControl(event) {
+  return `event: ${event.type}
+data: ${JSON.stringify(event.data)}
+
+`;
+}
+var ProjectRoomSseWriter = class {
+  /** Creates a writer over a raw HTTP response/socket. */
+  constructor(raw, options = {}) {
+    this.raw = raw;
+    this.frames = [];
+    this.queuedBytes = 0;
+    this.blockedBytes = 0;
+    this.writing = false;
+    this.closed = false;
+    this.terminal = false;
+    this.slowConsumerAttempted = false;
+    this.closeListener = () => this.close();
+    this.errorListener = () => this.close();
+    this.drainListener = () => {
+      if (this.closed || !this.writing) return;
+      this.clearDrainTimer();
+      this.blockedBytes = 0;
+      this.writing = false;
+      this.flush();
+    };
+    this.maxFrames = positive(options.maxFrames ?? DEFAULT_MAX_FRAMES, "maxFrames");
+    this.maxBytes = positive(options.maxBytes ?? DEFAULT_MAX_BYTES, "maxBytes");
+    this.drainTimeoutMs = positive(options.drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS, "drainTimeoutMs");
+    this.onClose = options.onClose;
+    raw.on("close", this.closeListener).on("error", this.errorListener).on("drain", this.drainListener);
+  }
+  /** Enqueues one public business event. */
+  enqueueBusiness(event) {
+    this.enqueue(serializeBusiness(event));
+  }
+  /** Enqueues one connection control event. */
+  enqueueControl(event) {
+    this.enqueue(serializeControl(event));
+  }
+  /** Enqueues a pre-serialized SSE frame (used by scoped multi-room streams). */
+  enqueueRaw(frame) {
+    this.enqueue(frame);
+  }
+  /** Writes a heartbeat comment when the socket is not currently blocked. */
+  heartbeat() {
+    if (!this.closed && !this.writing) this.writeFrame(": heartbeat\n\n");
+  }
+  /** Closes the writer and removes every socket listener exactly once. */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.clearDrainTimer();
+    if (this.terminalTimer !== void 0) clearTimeout(this.terminalTimer);
+    this.terminalResolve?.();
+    this.terminalResolve = void 0;
+    this.terminalFinish = void 0;
+    this.raw.off("close", this.closeListener).off("error", this.errorListener).off("drain", this.drainListener);
+    this.frames.length = 0;
+    this.queuedBytes = 0;
+    try {
+      this.raw.end();
+    } catch {
+      this.raw.destroy();
+    }
+    this.onClose?.();
+  }
+  /** Stops ordinary delivery and attempts one terminal control before ending. */
+  closeWithControl(control, deadlineMs = 250) {
+    if (this.closed) return Promise.resolve();
+    if (this.terminal) return new Promise((resolve4) => {
+      this.terminalResolve = resolve4;
+    });
+    this.terminal = true;
+    this.frames.length = 0;
+    this.queuedBytes = 0;
+    const frame = serializeControl(control);
+    const finish = () => {
+      if (this.closed) return;
+      if (this.terminalTimer !== void 0) clearTimeout(this.terminalTimer);
+      this.terminalTimer = void 0;
+      this.close();
+    };
+    this.terminalFinish = finish;
+    const promise = new Promise((resolve4) => {
+      this.terminalResolve = resolve4;
+    });
+    if (!this.writing) {
+      try {
+        if (this.raw.write(frame)) finish();
+        else this.armTerminalDeadline(deadlineMs, finish);
+      } catch {
+        finish();
+      }
+    } else {
+      this.frames.push(frame);
+      this.flushTerminal(finish);
+      this.armTerminalDeadline(deadlineMs, finish);
+    }
+    return promise;
+  }
+  enqueue(frame) {
+    if (this.closed || this.terminal) return;
+    const bytes = Buffer.byteLength(frame, "utf8");
+    const inFlightFrames = this.writing ? 1 : 0;
+    if (bytes > this.maxBytes || this.frames.length + inFlightFrames + 1 > this.maxFrames || this.queuedBytes + this.blockedBytes + bytes > this.maxBytes) return this.failSlowConsumer();
+    this.frames.push(frame);
+    this.queuedBytes += bytes;
+    this.flush();
+  }
+  flush() {
+    if (this.closed || this.writing || this.frames.length === 0) return;
+    const frame = this.frames.shift();
+    if (!frame) return;
+    this.queuedBytes -= Buffer.byteLength(frame, "utf8");
+    if (this.terminal) this.writeTerminalFrame(frame, this.terminalFinish ?? (() => this.close()));
+    else this.writeFrame(frame);
+  }
+  flushTerminal(finish) {
+    if (this.closed || this.writing || this.frames.length === 0) return;
+    const frame = this.frames.shift();
+    if (!frame) return;
+    this.writeTerminalFrame(frame, finish);
+  }
+  writeTerminalFrame(frame, finish) {
+    try {
+      if (!this.raw.write(frame)) {
+        this.writing = true;
+        this.blockedBytes = Buffer.byteLength(frame, "utf8");
+      } else {
+        this.writing = false;
+        this.blockedBytes = 0;
+        (finish ?? (() => this.close()))();
+      }
+    } catch {
+      this.close();
+    }
+  }
+  armTerminalDeadline(deadlineMs, finish) {
+    this.terminalTimer = setTimeout(finish, deadlineMs);
+    this.terminalTimer.unref?.();
+  }
+  writeFrame(frame) {
+    if (this.closed) return;
     try {
-      this.deps.log.warn(message, context);
+      if (!this.raw.write(frame)) {
+        this.writing = true;
+        this.blockedBytes = Buffer.byteLength(frame, "utf8");
+        this.drainTimer = setTimeout(() => {
+          this.drainTimer = void 0;
+          this.failSlowConsumer();
+        }, this.drainTimeoutMs);
+        this.drainTimer.unref?.();
+      } else {
+        this.writing = false;
+        this.blockedBytes = 0;
+        this.flush();
+      }
     } catch {
+      this.close();
     }
   }
-  overflow(taskId) {
-    this.warn("project-room:task-realtime-overflow", { code: "TASK_REALTIME_QUEUE_FULL", taskId });
-    return Promise.resolve();
+  clearDrainTimer() {
+    if (this.drainTimer !== void 0) clearTimeout(this.drainTimer);
+    this.drainTimer = void 0;
+  }
+  failSlowConsumer() {
+    if (this.closed) return;
+    this.frames.length = 0;
+    this.queuedBytes = 0;
+    if (!this.slowConsumerAttempted) {
+      this.slowConsumerAttempted = true;
+      try {
+        this.raw.write(serializeControl({ type: "resync", data: { reason: "SLOW_CONSUMER" } }));
+      } catch {
+      }
+    }
+    this.close();
   }
 };
-function safeId3(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
+function positive(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`${name} must be positive`);
+  return value;
 }
 
-// src/services/collaboration/ProjectRoomRealtimeRuntime.ts
-var ProjectRoomRealtimeRuntime = class {
+// src/services/collaboration/WorkspaceRoomEventsService.ts
+var MAX_NODE_TIMER_DELAY = 2147e6;
+var WorkspaceRoomEventsService = class {
+  /** Creates a service over the shared process-local broker. */
   constructor(deps) {
     this.deps = deps;
-    this.accepted = /* @__PURE__ */ new Set();
-    this.broker = deps.broker;
-    this.publisher = deps.publisher;
-    this.service = deps.service;
-    this.shutdownTimeoutMs = deps.shutdownTimeoutMs ?? 5e3;
-    this.unsubscribe = deps.subscribe(((event) => {
-      let work;
-      try {
-        work = Promise.resolve(deps.subscriber.handle(event));
-      } catch (error) {
-        work = Promise.reject(error);
-      }
-      const accepted = work.catch((error) => {
-        deps.log.warn("project-room:task-subscriber-failed", { error: error instanceof Error ? error.name : "UnknownError" });
-      });
-      this.accepted.add(accepted);
-      void accepted.finally(() => this.accepted.delete(accepted));
-    }));
+    this.connections = /* @__PURE__ */ new Map();
+    this.closed = false;
+    this.now = deps.now ?? Date.now;
+    this.heartbeatMs = deps.heartbeatMs ?? 15e3;
+    this.authRecheckMs = deps.authRecheckMs ?? 15e3;
+    this.maxConnectionsPerUser = deps.maxConnectionsPerUser ?? 2;
+    this.maxTimerDelay = deps.maxTimerDelay ?? MAX_NODE_TIMER_DELAY;
   }
-  /** Stops admission, drains accepted work, and closes transport resources exactly once. */
+  /** Starts a live-only connection; the route performs authentication beforehand. */
+  connect(input) {
+    if (this.closed) {
+      input.raw.end();
+      return;
+    }
+    const userKey = JSON.stringify([input.actor.tenantId, input.actor.userId]);
+    const active = this.connections.get(userKey) ?? /* @__PURE__ */ new Set();
+    if (active.size >= this.maxConnectionsPerUser) {
+      const oldest = [...active].sort((left, right) => left.startedAt - right.startedAt)[0];
+      oldest?.supersede();
+    }
+    const connection = this.buildConnection(input.actor, input.workspaceId, input.raw);
+    active.add(connection);
+    this.connections.set(userKey, active);
+  }
+  /** Closes every connection and stops admitting new ones. */
   close() {
-    this.closing ?? (this.closing = this.dispose());
-    return this.closing;
+    if (this.closed) return;
+    this.closed = true;
+    for (const active of [...this.connections.values()]) for (const connection of [...active]) connection.close();
+    this.connections.clear();
   }
-  async dispose() {
-    this.unsubscribe();
-    this.deps.subscriber.closeAdmission();
-    const accepted = [...this.accepted];
-    const drained = await boundedAllSettled(accepted, this.shutdownTimeoutMs);
-    if (!drained) this.deps.log.warn("project-room:runtime-drain-timeout", {
-      timeoutMs: this.shutdownTimeoutMs,
-      pending: accepted.length
+  buildConnection(actor2, workspaceId, raw) {
+    let phase = "initializing";
+    const subscriptions = /* @__PURE__ */ new Map();
+    let heartbeatTimer;
+    let accessTimer;
+    let expiryTimer;
+    let closed = false;
+    const recordRef = {};
+    let rebuildTail = Promise.resolve(true);
+    const lifetimeAbort = new AbortController();
+    const clear = (timer) => {
+      if (timer !== void 0) clearTimeout(timer);
+    };
+    const userScope = (0, import_protocols24.projectRoomUserEventScope)(actor2.tenantId, actor2.userId);
+    const userScopeKey = JSON.stringify([userScope.tenantId, userScope.roomId, userScope.projectId]);
+    const roomScopeKey = (scope) => JSON.stringify([scope.tenantId, scope.roomId, scope.projectId]);
+    const serializeScoped = (scope, event) => scope === null ? `id: ${event.id}
+event: ${event.type}
+data: ${JSON.stringify(event)}
+
+` : `id: ${event.id}
+event: ${event.type}
+data: ${JSON.stringify({ ...event, scope })}
+
+`;
+    const writer = new ProjectRoomSseWriter(raw, { onClose: () => cleanup() });
+    const cleanup = () => {
+      if (closed) return;
+      closed = true;
+      phase = "closed";
+      clear(heartbeatTimer);
+      clear(accessTimer);
+      clear(expiryTimer);
+      lifetimeAbort.abort();
+      for (const entry of subscriptions.values()) entry.unsubscribe();
+      subscriptions.clear();
+      writer.close();
+      const userKey = JSON.stringify([actor2.tenantId, actor2.userId]);
+      const active = this.connections.get(userKey);
+      if (active && recordRef.current !== void 0) {
+        active.delete(recordRef.current);
+        if (active.size === 0) this.connections.delete(userKey);
+      }
+    };
+    const revoke = (reason) => {
+      if (closed) return;
+      void writer.closeWithControl({ type: "access.revoked", data: { reason } }).then(cleanup, cleanup);
+    };
+    const record = {
+      startedAt: this.now(),
+      supersede: () => revoke("CONNECTION_SUPERSEDED"),
+      close: cleanup
+    };
+    recordRef.current = record;
+    const rebuildSubscriptions = async () => {
+      try {
+        const rooms = await this.deps.listMemberRooms({ tenantId: actor2.tenantId, userId: actor2.userId, workspaceId });
+        if (closed) return true;
+        const wanted = /* @__PURE__ */ new Map();
+        for (const room of rooms) {
+          const scope = { tenantId: actor2.tenantId, roomId: room.roomId, projectId: room.projectId };
+          wanted.set(roomScopeKey(scope), scope);
+        }
+        for (const [key, entry] of [...subscriptions]) {
+          if (key === userScopeKey || wanted.has(key)) continue;
+          entry.unsubscribe();
+          subscriptions.delete(key);
+        }
+        for (const [key, scope] of wanted) {
+          if (subscriptions.has(key)) continue;
+          const subscription = this.deps.broker.subscribe(scope, void 0, roomListener(scope));
+          subscriptions.set(key, { scope, unsubscribe: subscription.unsubscribe });
+        }
+        if (!subscriptions.has(userScopeKey)) {
+          const subscription = this.deps.broker.subscribe(userScope, void 0, userListener);
+          subscriptions.set(userScopeKey, { scope: userScope, unsubscribe: subscription.unsubscribe });
+        }
+        return true;
+      } catch (error) {
+        this.deps.log.warn("workspace-room-events:resubscribe-failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return false;
+      }
+    };
+    const enqueueRebuild = () => {
+      rebuildTail = rebuildTail.then(rebuildSubscriptions, rebuildSubscriptions);
+    };
+    const userListener = (event) => {
+      if (phase === "live") writer.enqueueRaw(serializeScoped(null, event));
+      if (event.type === "membership.affected") enqueueRebuild();
+    };
+    const roomListener = (scope) => (event) => {
+      if (phase === "live") writer.enqueueRaw(serializeScoped(scope, event));
+    };
+    const scheduleExpiry = () => {
+      if (closed) return;
+      const delay2 = actor2.tokenExpiresAt - this.now();
+      if (delay2 <= 0) {
+        revoke("TOKEN_EXPIRED");
+        return;
+      }
+      expiryTimer = setTimeout(() => {
+        expiryTimer = void 0;
+        scheduleExpiry();
+      }, Math.min(delay2, this.maxTimerDelay));
+      expiryTimer.unref?.();
+    };
+    const scheduleHeartbeat = () => {
+      if (closed) return;
+      heartbeatTimer = setTimeout(() => {
+        heartbeatTimer = void 0;
+        if (closed) return;
+        writer.heartbeat();
+        scheduleHeartbeat();
+      }, this.heartbeatMs);
+      heartbeatTimer.unref?.();
+    };
+    const scheduleAccessCheck = () => {
+      if (closed) return;
+      accessTimer = setTimeout(() => {
+        accessTimer = void 0;
+        if (closed) return;
+        const projectIds = [...subscriptions.values()].map((entry) => entry.scope.projectId).filter((projectId) => projectId !== import_protocols24.PROJECT_ROOM_USER_CHANNEL_PROJECT);
+        Promise.all(projectIds.map((projectId) => Promise.resolve().then(() => this.deps.requireReadAccess({ tenantId: actor2.tenantId, userId: actor2.userId, projectId })))).then(() => {
+          if (!closed) scheduleAccessCheck();
+        }, () => {
+          if (!closed) revoke("PROJECT_ACCESS_REVOKED");
+        });
+      }, this.authRecheckMs);
+      accessTimer.unref?.();
+    };
+    scheduleHeartbeat();
+    enqueueRebuild();
+    const initialRebuild = rebuildTail;
+    void initialRebuild.then((ok) => {
+      if (closed) return;
+      if (!ok) {
+        cleanup();
+        return;
+      }
+      writer.enqueueControl({ type: "ready", data: { epoch: this.deps.broker.epoch, headEventId: null } });
+      phase = "live";
+      scheduleExpiry();
+      scheduleAccessCheck();
     });
-    await this.deps.subscriber.drain(drained ? this.shutdownTimeoutMs : 0);
-    this.service.close();
-    this.broker.close();
+    return record;
   }
 };
-function createProjectRoomRealtimeRuntime(deps) {
-  const broker = new ProjectRoomEventBroker({ log: deps.log });
-  const publisher = new BrokerProjectRoomRealtimePublisher({ broker, log: deps.log });
-  const service2 = new ProjectRoomRealtimeService({ broker, log: deps.log, requireReadAccess: deps.requireReadAccess });
-  const subscriber = new ProjectRoomTaskEventSubscriber({
-    tasks: deps.tasks,
-    rooms: deps.rooms,
-    memberships: deps.memberships,
-    realtime: publisher,
-    log: deps.log
-  });
-  return new ProjectRoomRealtimeRuntime({
-    broker,
-    publisher,
-    service: service2,
-    subscriber,
-    subscribe: (listener) => import_core50.taskLifecycleNotifier.subscribe(listener),
-    log: deps.log,
-    shutdownTimeoutMs: deps.shutdownTimeoutMs
-  });
-}
-async function boundedAllSettled(promises, timeoutMs) {
-  if (promises.length === 0) return true;
-  let timer;
-  const timeout = new Promise((resolve4) => {
-    timer = setTimeout(() => resolve4(false), timeoutMs);
-    timer.unref?.();
-  });
-  const result = await Promise.race([Promise.allSettled(promises).then(() => true), timeout]);
-  if (timer) clearTimeout(timer);
-  return result;
+
+// src/services/collaboration/WorkspaceMemberRoomLister.ts
+function createWorkspaceMemberRoomLister(deps) {
+  return async (input) => {
+    const projects = await deps.projects.getProjectsByWorkspace(input.tenantId, input.workspaceId);
+    const memberRooms = [];
+    for (const project of projects) {
+      const membership = await deps.memberships.findByUser(input.tenantId, project.id, input.userId);
+      if (!membership || membership.status !== "active") continue;
+      const room = await deps.rooms.getMainRoom(input.tenantId, project.id);
+      if (room) memberRooms.push({ projectId: project.id, roomId: room.id });
+    }
+    return memberRooms;
+  };
 }
 
-// src/routes/project-room-events.ts
-var import_protocols23 = require("@axiom-lattice/protocols");
-function registerProjectRoomEventRoutes(app2, deps) {
-  app2.get("/api/projects/:projectId/room/events", async (request, reply) => {
+// src/routes/workspace-room-events.ts
+var import_protocols25 = require("@axiom-lattice/protocols");
+function registerWorkspaceRoomEventRoutes(app2, deps) {
+  app2.get("/api/workspaces/:workspaceId/room-events", async (request, reply) => {
     try {
-      const projectId = exactProjectId(request.params);
-      const headers = strictHeaders(request, true);
+      const params = exactParams(request.params);
+      const headers = strictHeaders(request);
       if (request.body !== void 0 || Object.keys(request.query).length !== 0) return invalid(reply);
       const session = verifyConsoleSessionAuthHeader(headers.authorization, deps.tokenSecret);
       if (!session?.tenantId) return unauthorized(reply);
-      await deps.access.requireExistingProjectAccess({ tenantId: session.tenantId, userId: session.id, projectId, capability: "read" });
-      const room = exactRoom(await deps.rooms.getMainRoom(session.tenantId, projectId), session.tenantId, projectId);
-      if (!room) return reply.code(404).send({ success: false, error: { code: "PROJECT_ROOM_NOT_FOUND", message: "Project room not found", retryable: false } });
-      const actor2 = { tenantId: session.tenantId, userId: session.id, projectId, tokenExpiresAt: session.expiresAt };
-      if (!deps.realtime.canConnect(actor2)) return reply.code(429).send({ success: false, error: { code: "PROJECT_ROOM_STREAM_LIMIT", message: "Project room stream limit reached", retryable: true } });
       reply.hijack();
       reply.raw.writeHead(200, {
         "Content-Type": "text/event-stream",
@@ -21046,53 +21941,35 @@ function registerProjectRoomEventRoutes(app2, deps) {
         "X-Accel-Buffering": "no",
         "Access-Control-Allow-Origin": "*"
       });
-      deps.realtime.connect({ actor: actor2, roomId: room.id, ...headers.lastEventId ? { lastEventId: headers.lastEventId } : {}, raw: reply.raw });
-    } catch (error) {
-      return routeError(reply, error);
-    }
-  });
-  app2.get("/api/projects/:projectId/room/realtime-mode", async (request, reply) => {
-    try {
-      const projectId = exactProjectId(request.params);
-      const headers = strictHeaders(request, false);
-      if (request.body !== void 0 || Object.keys(request.query).length !== 0) return invalid(reply);
-      const session = verifyConsoleSessionAuthHeader(headers.authorization, deps.tokenSecret);
-      if (!session?.tenantId) return unauthorized(reply);
-      await deps.access.requireExistingProjectAccess({ tenantId: session.tenantId, userId: session.id, projectId, capability: "read" });
-      return reply.send({ success: true, data: { mode: "single-gateway", supportedGatewayProcesses: 1, durableReplay: false, epoch: deps.broker.epoch } });
+      deps.service.connect({
+        actor: { tenantId: session.tenantId, userId: session.id, tokenExpiresAt: session.expiresAt },
+        workspaceId: params.workspaceId,
+        raw: reply.raw
+      });
     } catch (error) {
       return routeError(reply, error);
     }
   });
 }
-function strictHeaders(request, requireSse) {
+function exactParams(params) {
+  const value = (0, import_protocols25.snapshotExactRecord)(params, ["workspaceId"]);
+  if (!value || typeof value.workspaceId !== "string" || !value.workspaceId.trim()) throw new InvalidRealtimeRequestError();
+  return { workspaceId: value.workspaceId };
+}
+function strictHeaders(request) {
   const raw = request.raw.rawHeaders;
   const values = (name) => raw.flatMap((value, index) => index % 2 === 0 && value.toLowerCase() === name ? [raw[index + 1]] : []);
   const authorization = values("authorization");
   const accept = values("accept");
   const cursor = values("last-event-id");
-  if (authorization.length !== 1 || authorization[0].includes(",") || cursor.length > 1 || cursor.some((value) => value.includes(",")) || requireSse && (accept.length !== 1 || !isSseAccept(accept[0]))) {
-    throw new InvalidRealtimeRequestError();
-  }
-  const lastEventId = cursor[0]?.trim();
-  if (lastEventId !== void 0 && (!lastEventId || !(0, import_protocols23.isProjectRoomEventId)(lastEventId))) throw new InvalidRealtimeRequestError();
-  return { authorization: authorization[0], ...lastEventId ? { lastEventId } : {} };
+  if (authorization.length !== 1 || authorization[0].includes(",") || cursor.length > 0 || accept.length !== 1 || !isSseAccept(accept[0])) throw new InvalidRealtimeRequestError();
+  return { authorization: authorization[0] };
 }
 function isSseAccept(value) {
   if (value.includes(",")) return false;
   const [mediaType, ...parameters] = value.split(";");
   return mediaType.trim() === "text/event-stream" && parameters.every((parameter) => /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\s*=\s*(?:[!#$%&'*+.^_`|~0-9A-Za-z-]+|"[^"]*")$/.test(parameter.trim()));
 }
-function exactProjectId(params) {
-  const value = (0, import_protocols23.snapshotExactRecord)(params, ["projectId"]);
-  if (!value || typeof value.projectId !== "string" || !value.projectId.trim()) throw new InvalidRealtimeRequestError();
-  return value.projectId;
-}
-function exactRoom(value, tenantId, projectId) {
-  if (!value || typeof value !== "object") return void 0;
-  const room = value;
-  return typeof room.id === "string" && room.id && room.tenantId === tenantId && room.projectId === projectId ? { id: room.id } : void 0;
-}
 var InvalidRealtimeRequestError = class extends Error {
 };
 function invalid(reply) {
@@ -21103,7 +21980,6 @@ function unauthorized(reply) {
 }
 function routeError(reply, error) {
   if (error instanceof InvalidRealtimeRequestError) return invalid(reply);
-  if (error instanceof ProjectCollaborationError) return reply.code(error.statusCode).send({ success: false, error: { code: error.code, message: error.message, retryable: false } });
   return reply.code(500).send({ success: false, error: { code: "INTERNAL_ERROR", message: "Internal server error", retryable: false } });
 }
 
@@ -21204,7 +22080,7 @@ function snapshotDataRecord(value) {
     for (const key of Reflect.ownKeys(descriptors)) {
       if (typeof key !== "string") return void 0;
       const descriptor = descriptors[key];
-      const data = (0, import_protocols24.descriptorDataValue)(descriptor);
+      const data = (0, import_protocols26.descriptorDataValue)(descriptor);
       if (!data) return void 0;
       result[key] = data.value;
     }
@@ -21219,7 +22095,7 @@ function isPublicRoomAddress(message) {
 }
 async function validateReassignmentThread(threads, input) {
   const thread = snapshotThread(await threads.getThreadById(input.tenantId, input.newThreadId));
-  const metadata = (0, import_protocols24.snapshotExactRecord)(thread?.metadata, [
+  const metadata = (0, import_protocols26.snapshotExactRecord)(thread?.metadata, [
     "source",
     "kind",
     "workspaceId",
@@ -21242,6 +22118,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
   const projectRoomStore = (0, import_core51.getStoreLattice)("default", "projectRoom").store;
   const projectBotMembershipStore = (0, import_core51.getStoreLattice)("default", "projectBotMembership").store;
   const projectRoomMessageStore = (0, import_core51.getStoreLattice)("default", "projectRoomMessage").store;
+  const projectRoomReadStateStore = (0, import_core51.getStoreLattice)("default", "projectRoomReadState").store;
   const threadStore = (0, import_core51.getStoreLattice)("default", "thread").store;
   const taskStore = (0, import_core51.getStoreLattice)("default", "task").store;
   const taskWorkItemStore = (0, import_core51.getStoreLattice)("default", "taskWorkItem").store;
@@ -21253,23 +22130,30 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     tasks: taskStore,
     rooms: projectRoomStore,
     memberships: projectBotMembershipStore,
-    log: realtimeLog,
-    requireReadAccess: async (actor2) => {
-      await accessService.requireExistingProjectAccess({
-        tenantId: actor2.tenantId,
-        userId: actor2.userId,
-        projectId: actor2.projectId,
-        capability: "read"
-      });
-    }
+    log: realtimeLog
   }) : void 0;
   if (projectRoomRealtimeRuntime) {
     app2.addHook("onClose", async () => projectRoomRealtimeRuntime?.close());
-    registerProjectRoomEventRoutes(app2, {
-      access: accessService,
-      rooms: projectRoomStore,
-      realtime: projectRoomRealtimeRuntime.service,
+    const workspaceRoomEventsService = new WorkspaceRoomEventsService({
       broker: projectRoomRealtimeRuntime.broker,
+      listMemberRooms: createWorkspaceMemberRoomLister({
+        projects: projectStore,
+        memberships: projectMembershipStore,
+        rooms: projectRoomStore
+      }),
+      requireReadAccess: async (input) => {
+        await accessService.requireExistingProjectAccess({
+          tenantId: input.tenantId,
+          userId: input.userId,
+          projectId: input.projectId,
+          capability: "read"
+        });
+      },
+      log: realtimeLog
+    });
+    app2.addHook("onClose", async () => workspaceRoomEventsService.close());
+    registerWorkspaceRoomEventRoutes(app2, {
+      service: workspaceRoomEventsService,
       tokenSecret: resolveConsoleTokenSecret(process.env.AUTH_REQUIRED === "true")
     });
   }
@@ -21333,7 +22217,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     });
   }
   if (projectTaskComposition) app2.addHook("onClose", async () => projectTaskComposition.lease.release());
-  const taskThreadService = projectTaskComposition?.lease.runtime.threads ?? new ProjectTaskThreadService({ threads: threadStore, idFactory: import_node_crypto18.randomUUID });
+  const taskThreadService = projectTaskComposition?.lease.runtime.threads ?? new ProjectTaskThreadService({ threads: threadStore, idFactory: import_node_crypto20.randomUUID });
   const taskLifecycle = projectTaskComposition?.lease.runtime.lifecycle ?? (0, import_core51.createTaskLifecycleService)({ taskStore, workItemStore: taskWorkItemStore });
   const reassignmentAuthorizer = (0, import_core51.createProjectTaskReassignmentAuthorizer)(
     new import_core51.ProjectTaskOwnerPolicy(projectBotMembershipStore),
@@ -21351,7 +22235,24 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     saveBot: projectBotMembershipStore.save.bind(projectBotMembershipStore),
     ensureCoordinator: (tenantId) => coordinatorProvisioner.ensure(tenantId)
   });
-  registerProjectRoomRoutes(app2, { roomService, membershipService, messageService });
+  const readStateService = {
+    mark: async (actorRef) => {
+      await accessService.requireExistingProjectAccess({ ...actorRef, capability: "read" });
+      const room = await projectRoomStore.getMainRoom(actorRef.tenantId, actorRef.projectId);
+      if (!room) return;
+      const lastReadAt = /* @__PURE__ */ new Date();
+      await projectRoomReadStateStore.markRead({ tenantId: actorRef.tenantId, roomId: room.id, userId: actorRef.userId, lastReadAt });
+      projectRoomRealtimeRuntime?.publisher.readChanged({
+        tenantId: actorRef.tenantId,
+        userId: actorRef.userId,
+        projectId: actorRef.projectId,
+        roomId: room.id,
+        lastReadAt: lastReadAt.toISOString(),
+        sourceKey: `read:${actorRef.userId}:${room.id}:${lastReadAt.getTime()}`
+      });
+    }
+  };
+  registerProjectRoomRoutes(app2, { roomService, membershipService, messageService, readStateService });
   registerProjectRosterRoutes(app2, { service: rosterService });
   registerCoSpaceRoutes(app2, {
     projectStore: {
@@ -21373,7 +22274,11 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     },
     messageStore: {
       list: projectRoomMessageStore.list.bind(projectRoomMessageStore),
-      create: projectRoomMessageStore.create.bind(projectRoomMessageStore)
+      create: projectRoomMessageStore.create.bind(projectRoomMessageStore),
+      countAfter: projectRoomMessageStore.countAfter.bind(projectRoomMessageStore)
+    },
+    readStateStore: {
+      get: projectRoomReadStateStore.get.bind(projectRoomReadStateStore)
     },
     userTenantLinkStore: {
       getUsersByTenant: userTenantLinkStore.getUsersByTenant.bind(userTenantLinkStore)
@@ -21416,6 +22321,46 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     })
   });
   registerAgentWebAppRuntimeRoutes(app2, {
+    workspaceController: new WorkspaceController(createProjectCollaborationInitializer({
+      membershipStore: projectMembershipStore,
+      roomStore: projectRoomStore,
+      userTenantLinkStore
+    })),
+    taskController: createTaskController({
+      access: {
+        requireProjectAccess: async (input) => {
+          const apps = await webAppStore.list(input.tenantId);
+          const allowed = apps.some((app3) => app3.status === "active" && app3.scope.allowedProjectIds.includes(input.projectId));
+          if (!allowed) throw new ProjectCollaborationError("PROJECT_ACCESS_DENIED", 403, "Project is not exposed through this web app");
+          const project = await projectStore.getProjectById(input.tenantId, input.projectId);
+          if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
+          return {
+            project,
+            membership: {
+              id: `webapp_guest_${input.projectId}_${input.userId}`,
+              tenantId: input.tenantId,
+              projectId: input.projectId,
+              userId: input.userId,
+              role: "member",
+              status: "active",
+              joinedAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date()
+            }
+          };
+        }
+      },
+      tasks: taskStore,
+      workItems: taskWorkItemStore,
+      bots: projectBotMembershipStore,
+      rooms: projectRoomStore,
+      threadService: taskThreadService,
+      reassignmentAuthorizer,
+      lifecycle: taskLifecycle,
+      projectMutationMutex: import_core51.projectMutationMutex,
+      executionMutex: projectTaskComposition?.mutex ?? {
+        runExclusive: (_scope, operation) => operation()
+      }
+    }),
     service: new AgentWebAppRuntimeService({
       webAppStore,
       threadStore: (0, import_core51.getStoreLattice)("default", "thread").store,
@@ -21423,7 +22368,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       assistantResolver: {
         resolve: async (tenantId, assistantId) => {
           const stored = await assistantStore.getAssistantById(tenantId, assistantId);
-          if (stored) return stored;
+          if (stored) return { id: stored.id, name: stored.name, description: stored.description };
           await import_core51.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId);
           const config = import_core51.agentLatticeManager.getAgentConfigWithTenant(tenantId, assistantId);
           return config ? { id: assistantId, name: config.name, description: config.description } : null;
@@ -21466,6 +22411,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       }
     })
   });
+  registerAgentWebAppEmbedRoutes(app2, {});
   registerA2ABridgeRoutes(app2);
   registerSTTRoutes(app2);
   app2.get("/api/local-a2a", getLocalA2AStatus);
@@ -21790,9 +22736,9 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
 function tryCreateProjectTaskRuntime(input) {
   let projectWorkItems;
   try {
-    projectWorkItems = (0, import_protocols24.requireProjectTaskWorkItemStore)(input.taskWorkItemStore);
+    projectWorkItems = (0, import_protocols26.requireProjectTaskWorkItemStore)(input.taskWorkItemStore);
   } catch (error) {
-    if (error instanceof import_protocols24.ProjectTaskStoreUnsupportedError) {
+    if (error instanceof import_protocols26.ProjectTaskStoreUnsupportedError) {
       input.log?.warn("project-task:runtime-unavailable", {
         code: error.code,
         missingMethods: error.missingMethods
@@ -21837,7 +22783,7 @@ function tryCreateProjectTaskRuntime(input) {
 function createRuntime(input, stores, log2) {
   const controller = new AbortController();
   const mutex = new ProjectTaskExecutionMutex();
-  const threads = new ProjectTaskThreadService({ threads: input.threadStore, idFactory: import_node_crypto18.randomUUID });
+  const threads = new ProjectTaskThreadService({ threads: input.threadStore, idFactory: import_node_crypto20.randomUUID });
   const lifecycle = (0, import_core51.createTaskLifecycleService)({ taskStore: input.taskStore, workItemStore: input.taskWorkItemStore });
   const projection = new RoomProjectionService({
     messages: input.projectRoomMessageStore,
@@ -21846,7 +22792,7 @@ function createRuntime(input, stores, log2) {
     warnings: input.taskWorkItemStore,
     log: log2,
     realtime: input.realtime,
-    idFactory: import_node_crypto18.randomUUID
+    idFactory: import_node_crypto20.randomUUID
   });
   const agentFor = (task, thread) => import_core51.agentInstanceManager.getAgent({
     tenant_id: task.tenantId,
@@ -23701,7 +24647,7 @@ var import_core65 = require("@axiom-lattice/core");
 
 // src/router/MessageRouter.ts
 var import_core64 = require("@axiom-lattice/core");
-var import_protocols25 = require("@axiom-lattice/protocols");
+var import_protocols27 = require("@axiom-lattice/protocols");
 var import_crypto11 = require("crypto");
 var BindingNotFoundError = class extends Error {
   constructor(message) {
@@ -23731,10 +24677,10 @@ var CORRELATED_REPLY_REQUIRED_KEYS = [
   "state"
 ];
 function exactDataValues(value, required, optional = []) {
-  return (0, import_protocols25.snapshotExactRecord)(value, required, optional);
+  return (0, import_protocols27.snapshotExactRecord)(value, required, optional);
 }
 function uniqueNonemptyStrings(value) {
-  const snapshot = (0, import_protocols25.snapshotExactArray)(value);
+  const snapshot = (0, import_protocols27.snapshotExactArray)(value);
   if (!snapshot || snapshot.length === 0 || snapshot.some((entry) => typeof entry !== "string" || entry.length === 0)) return void 0;
   const values = snapshot;
   return new Set(values).size === values.length ? values : void 0;
@@ -24171,9 +25117,9 @@ var MessageRouter = class {
 };
 
 // src/channels/room/RoomChannelAdapter.ts
-var import_zod13 = require("zod");
-var import_protocols26 = require("@axiom-lattice/protocols");
-var roomConfigSchema = import_zod13.z.object({}).strict();
+var import_zod14 = require("zod");
+var import_protocols28 = require("@axiom-lattice/protocols");
+var roomConfigSchema = import_zod14.z.object({}).strict();
 function createRoomChannelAdapter(writer) {
   return {
     channel: "room",
@@ -24216,7 +25162,7 @@ function exactStrings(value, keys2) {
 function exactValues2(value, required, optional = []) {
   try {
     if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-    return (0, import_protocols26.snapshotExactRecord)(value, required, optional);
+    return (0, import_protocols28.snapshotExactRecord)(value, required, optional);
   } catch {
     return void 0;
   }
@@ -24261,14 +25207,14 @@ async function prepareProjectTaskRuntime(runtime, log2) {
 }
 
 // src/index.ts
-var import_protocols28 = require("@axiom-lattice/protocols");
+var import_protocols30 = require("@axiom-lattice/protocols");
 process.on("unhandledRejection", (reason, promise) => {
   console.error("\u672A\u5904\u7406\u7684Promise\u62D2\u7EDD:", reason);
 });
 var DEFAULT_LOGGER_CONFIG = {
   name: "default",
   description: "Default logger for lattice-gateway service",
-  type: import_protocols28.LoggerType.PINO,
+  type: import_protocols30.LoggerType.PINO,
   serviceName: "lattice/gateway",
   loggerName: "lattice/gateway"
 };
@@ -24441,26 +25387,11 @@ var start = async (config) => {
     const projectRoomRealtimeMode = resolveProjectRoomRealtimeMode();
     let projectRoomRealtimeRuntime;
     if (projectRoomRealtimeMode === "single-gateway") {
-      const projectStore = (0, import_core70.getStoreLattice)("default", "project").store;
-      const membershipStore = (0, import_core70.getStoreLattice)("default", "projectMembership").store;
-      const access = new ProjectAccessService({
-        projectStore,
-        membershipStore,
-        userTenantLinkStore: (0, import_core70.getStoreLattice)("default", "userTenantLink").store
-      });
       projectRoomRealtimeRuntime = createProjectRoomRealtimeRuntime({
         tasks: (0, import_core70.getStoreLattice)("default", "task").store,
         rooms: (0, import_core70.getStoreLattice)("default", "projectRoom").store,
         memberships: (0, import_core70.getStoreLattice)("default", "projectBotMembership").store,
-        log: { warn: (message, context) => logger6.warn(message, context) },
-        requireReadAccess: async (actor2) => {
-          await access.requireExistingProjectAccess({
-            tenantId: actor2.tenantId,
-            userId: actor2.userId,
-            projectId: actor2.projectId,
-            capability: "read"
-          });
-        }
+        log: { warn: (message, context) => logger6.warn(message, context) }
       });
     }
     let channelDeps;
@@ -24547,6 +25478,15 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
+    try {
+      const { registerOpenRoutes: registerOpenRoutes2 } = await Promise.resolve().then(() => (init_open(), open_exports));
+      registerOpenRoutes2(app);
+      logger6.info("Open MCP spike routes registered");
+    } catch (err) {
+      logger6.warn("Open MCP spike routes unavailable", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
     if (!import_core70.sandboxLatticeManager.hasLattice("default")) {
       import_core70.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
       logger6.info("Registered sandbox manager from env configuration");