@axiom-lattice/gateway 4.1.6 → 4.2.0

package/dist/index.mjs

@@ -1,6 +1,10 @@
+import {
+  getContentTypeFromFilename,
+  getFilenameFromPath
+} from "./chunk-LHQY46YB.mjs";
 import {
   registerMcpServerConfigRoutes
-} from "./chunk-K4XELOSO.mjs";
+} from "./chunk-QKPZWWHH.mjs";
 import {
   Logger,
   getQrCode,
@@ -16,10 +20,6 @@ import {
   resolvePathWithinRoot,
   saveProjectFile
 } from "./chunk-J4BK77PA.mjs";
-import {
-  getContentTypeFromFilename,
-  getFilenameFromPath
-} from "./chunk-LHQY46YB.mjs";
 
 // src/index.ts
 import "dotenv/config";
@@ -29,7 +29,7 @@ import multipart from "@fastify/multipart";
 import sensible from "@fastify/sensible";
 import websocket from "@fastify/websocket";
 import staticPlugin from "@fastify/static";
-import path3 from "path";
+import path4 from "path";
 
 // src/routes/index.ts
 import { randomUUID as randomUUID19 } from "crypto";
@@ -4121,9 +4121,9 @@ var ExportImportService = class {
     if (!files || files.size === 0) return void 0;
     const prefix = `files/${entityType}/${entityId}/`;
     const result = /* @__PURE__ */ new Map();
-    for (const [path4, content] of files.entries()) {
-      if (path4.startsWith(prefix)) {
-        result.set(path4.slice(prefix.length), content);
+    for (const [path5, content] of files.entries()) {
+      if (path5.startsWith(prefix)) {
+        result.set(path5.slice(prefix.length), content);
       }
     }
     return result.size > 0 ? result : void 0;
@@ -6224,21 +6224,21 @@ var WorkspaceController = class {
   async listPath(request) {
     const tenantId = this.getTenantId(request);
     const { workspaceId, projectId } = request.params;
-    const path4 = request.query.path || "/";
+    const path5 = request.query.path || "/";
     const assistantId = request.query.assistantId;
-    console.log(`[listPath] tenantId=${tenantId} workspaceId=${workspaceId} projectId=${projectId} path=${path4} assistantId=${assistantId}`);
-    const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path4);
-    console.log(`[listPath] backend type=${backend.constructor.name} calling lsInfo(${path4})`);
-    const files = await backend.lsInfo(path4);
+    console.log(`[listPath] tenantId=${tenantId} workspaceId=${workspaceId} projectId=${projectId} path=${path5} assistantId=${assistantId}`);
+    const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path5);
+    console.log(`[listPath] backend type=${backend.constructor.name} calling lsInfo(${path5})`);
+    const files = await backend.lsInfo(path5);
     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: path4, offset = 0, limit = 1e3, assistantId } = request.query;
-    const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path4);
-    const content = await backend.read(path4, Number(offset), Number(limit));
+    const { path: path5, offset = 0, limit = 1e3, assistantId } = request.query;
+    const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path5);
+    const content = await backend.read(path5, Number(offset), Number(limit));
     return { success: true, data: { content, offset, limit } };
   }
   /**
@@ -6424,14 +6424,202 @@ function registerWorkspaceRoutes(app2, projectCollaboration) {
     "/api/filesystem/browse",
     controller.browseFilesystem.bind(controller)
   );
+  return controller;
+}
+
+// src/services/collaboration/ProjectAccessService.ts
+import { randomUUID as randomUUID6 } from "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 ?? randomUUID6;
+  }
+  /** 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/controllers/database-configs.ts
 import {
   getStoreLattice as getStoreLattice7,
   sqlDatabaseManager
 } from "@axiom-lattice/core";
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 function getTenantId9(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
@@ -6509,7 +6697,7 @@ async function createDatabaseConfig(request, reply) {
         message: "Database configuration with this key already exists"
       };
     }
-    const id3 = body.id || randomUUID6();
+    const id3 = body.id || randomUUID7();
     const config = await store.createConfig(tenantId, id3, body);
     try {
       sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
@@ -6714,7 +6902,7 @@ import {
   metricsServerManager as metricsServerManager2,
   SemanticMetricsClient as SemanticMetricsClient2
 } from "@axiom-lattice/core";
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 function getTenantId10(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
@@ -6795,7 +6983,7 @@ async function createMetricsServerConfig(request, reply) {
         message: "selectedDataSources is required for semantic metrics servers"
       };
     }
-    const id3 = body.id || randomUUID7();
+    const id3 = body.id || randomUUID8();
     const configData = {
       key: body.key,
       name: body.name,
@@ -8911,13 +9099,13 @@ function isStaleConsoleSessionCredential(authHeader) {
   }
 }
 function bypassesConsoleAuth(request) {
-  const path4 = request.url.split("?")[0];
+  const path5 = request.url.split("?")[0];
   const method = request.method;
-  if (method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/bootstrap$/.test(path4) || (method === "GET" || method === "POST") && /^\/api\/web-apps\/[^/]+\/runtime\/threads$/.test(path4) || (method === "PATCH" || method === "DELETE") && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+$/.test(path4) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/messages$/.test(path4) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/(messages\/stream|abort|attachments)$/.test(path4) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/interrupts\/[^/]+\/resume$/.test(path4)) return true;
-  if (request.method === "GET" && /^\/api\/a2a\/agents\/[^/]+\/\.well-known\/agent-card\.json$/.test(path4)) {
+  if (method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/bootstrap$/.test(path5) || (method === "GET" || method === "POST") && /^\/api\/web-apps\/[^/]+\/runtime\/threads$/.test(path5) || (method === "PATCH" || method === "DELETE") && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+$/.test(path5) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/messages$/.test(path5) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/files\/(viewfile|downloadfile)$/.test(path5) || method === "GET" && /^\/api\/web-apps\/[^/]+\/runtime\/api\/assistants\/[^/]+\/threads\/[^/]+\/sandbox\/(viewfile|downloadfile)$/.test(path5) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/(messages\/stream|abort|attachments)$/.test(path5) || method === "POST" && /^\/api\/web-apps\/[^/]+\/runtime\/threads\/[^/]+\/interrupts\/[^/]+\/resume$/.test(path5) || method === "GET" && /^\/api\/web-apps\/[^/]+\/chat$/.test(path5) || method === "GET" && /^\/embed\/[^/]+$/.test(path5) || (method === "POST" || method === "DELETE") && path5 === "/open/mcp") return true;
+  if (request.method === "GET" && /^\/api\/a2a\/agents\/[^/]+\/\.well-known\/agent-card\.json$/.test(path5)) {
     return true;
   }
-  return request.method === "POST" && /^\/api\/a2a\/agents\/[^/]+\/jsonrpc$/.test(path4);
+  return request.method === "POST" && /^\/api\/a2a\/agents\/[^/]+\/jsonrpc$/.test(path5);
 }
 function registerConsoleAuthHook(app2, options) {
   app2.addHook("preHandler", async (request, reply) => {
@@ -8940,8 +9128,8 @@ function registerConsoleAuthHook(app2, options) {
     }
     if (PUBLIC_ROUTES.some((route) => request.url === route)) return;
     if (request.url.startsWith("/s/")) return;
-    const path4 = request.url.split("?")[0];
-    if (request.method === "GET" && /^\/api\/workspaces\/[^/]+\/projects\/[^/]+\/viewfile$/.test(path4) || request.method === "GET" && /^\/api\/workspaces\/[^/]+\/projects\/[^/]+\/downloadfile$/.test(path4) || request.method === "POST" && /^\/api\/workspaces\/[^/]+\/projects\/[^/]+\/uploadfile$/.test(path4) || path4.startsWith("/f/") || path4 === "/f") {
+    const path5 = request.url.split("?")[0];
+    if (request.method === "GET" && /^\/api\/workspaces\/[^/]+\/projects\/[^/]+\/viewfile$/.test(path5) || request.method === "GET" && /^\/api\/workspaces\/[^/]+\/projects\/[^/]+\/downloadfile$/.test(path5) || request.method === "POST" && /^\/api\/workspaces\/[^/]+\/projects\/[^/]+\/uploadfile$/.test(path5) || path5.startsWith("/f/") || path5 === "/f") {
       return;
     }
     await reply.status(401).send({
@@ -9302,7 +9490,7 @@ function registerChannelRoutes(app2, dependencies) {
 }
 
 // src/controllers/channel-installations.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import {
   descriptorDataValue
 } from "@axiom-lattice/protocols";
@@ -9506,7 +9694,7 @@ async function createChannelInstallation(request, reply) {
       };
     }
     const store = await getInstallationStore();
-    const installationId = randomUUID8();
+    const installationId = randomUUID9();
     const createInput = {
       channel: body.channel,
       name: body.name,
@@ -10069,8 +10257,8 @@ var log = {
 };
 var connections = /* @__PURE__ */ new Map();
 var pending = /* @__PURE__ */ new Map();
-function getAgentIdFromPath(path4) {
-  const match = path4.match(/^\/api\/a2a\/bridge\/proxy\/([^/]+)/);
+function getAgentIdFromPath(path5) {
+  const match = path5.match(/^\/api\/a2a\/bridge\/proxy\/([^/]+)/);
   return match ? match[1] : null;
 }
 function handleBridgeConnection(socket, _request) {
@@ -10466,7 +10654,7 @@ async function getLocalA2ATemplates(_request, reply) {
 }
 
 // src/routes/a2a-test-connection.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 function describeTestConnectionError(error, agentCardUrl) {
   if (!(error instanceof Error)) {
     return `Failed to fetch agent card from ${agentCardUrl}: ${String(error)}`;
@@ -10506,7 +10694,7 @@ async function ensureLocalRuntimeForConnectionTest(localRuntime, agentCardUrl) {
     return { error: portValidation.error };
   }
   const state = await localA2AService.startProvider(
-    `test-${randomUUID9()}`,
+    `test-${randomUUID10()}`,
     testRuntime
   );
   if (state.status === "running") return { runtimeId: state.runtimeId };
@@ -10595,193 +10783,6 @@ import {
 import { snapshotExactRecord as snapshotExactRecord3 } from "@axiom-lattice/protocols";
 import { ProjectTaskOwnerPolicyError, projectTaskAdmissionNotifier } from "@axiom-lattice/core";
 
-// src/services/collaboration/ProjectAccessService.ts
-import { randomUUID as randomUUID10 } from "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 ?? randomUUID10;
-  }
-  /** 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
 import { isProjectLifecycleTask } from "@axiom-lattice/core";
 import {
@@ -11320,9 +11321,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) {
@@ -11763,7 +11761,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);
@@ -11772,7 +11771,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);
   }
@@ -11885,13 +11885,28 @@ var agentWebAppFeaturesSchema = z4.object({
   threadManagement: z4.boolean(),
   attachments: z4.boolean(),
   hitl: z4.boolean(),
-  genUI: z4.boolean()
+  genUI: z4.boolean(),
+  files: z4.boolean().optional()
 }).strict();
 var agentWebAppAppearanceSchema = z4.object({
   title: z4.string().max(120).optional(),
   welcomeMessage: z4.string().max(1e3).optional(),
   primaryColor: z4.string().regex(/^#[0-9A-Fa-f]{6}$/).optional()
 }).strict();
+var agentWebAppIssuerSchema = z4.object({
+  iss: z4.string().min(1).max(255),
+  aud: z4.string().min(1).max(255),
+  alg: z4.enum(["HS256", "RS256"]),
+  secret: z4.string().min(1).max(512).optional(),
+  jwksUrl: z4.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 = z4.object({
+  policy: z4.enum(["unverified", "verified", "both"]),
+  issuers: z4.array(agentWebAppIssuerSchema).min(1).max(10)
+}).strict();
 var createAgentWebAppSchema = z4.object({
   assistantId: externalId,
   name: z4.string().min(1).max(120),
@@ -11899,14 +11914,16 @@ var createAgentWebAppSchema = z4.object({
   integration: z4.object({ type: z4.literal("react_sdk") }).strict(),
   scope: agentWebAppScopeSchema,
   features: agentWebAppFeaturesSchema,
-  appearance: agentWebAppAppearanceSchema
+  appearance: agentWebAppAppearanceSchema,
+  identity: agentWebAppIdentitySchema.optional()
 }).strict();
 var updateAgentWebAppSchema = z4.object({
   name: z4.string().min(1).max(120).optional(),
   description: z4.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 = z4.object({
   assistantId: externalId.optional()
@@ -11993,6 +12010,7 @@ function invalidRequest(reply, statusCode) {
 }
 
 // src/routes/agent-web-app-runtime.ts
+import { createHmac as createHmac3 } from "crypto";
 import { z as z5, ZodError as ZodError2 } from "zod";
 
 // src/services/agent-web-app/AgentWebAppRuntimeService.ts
@@ -12013,7 +12031,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,
@@ -12046,7 +12073,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
@@ -12067,6 +12094,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);
@@ -12101,6 +12136,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 ?? []);
@@ -12345,96 +12434,102 @@ function toRuntimeThread(thread) {
   };
 }
 
-// src/services/agent-web-app/AgentWebAppStreamProjector.ts
-import {
-  MessageChunkTypes as MessageChunkTypes4,
-  parseAgentWebAppGenUIBlock as parseAgentWebAppGenUIBlock2
-} from "@axiom-lattice/protocols";
-function createAgentWebAppStreamProjectionContext(options = {}) {
-  return { startedToolIds: /* @__PURE__ */ new Set(), allowInterrupts: options.allowInterrupts ?? true, allowGenUI: options.allowGenUI ?? false };
-}
-function projectAgentWebAppChunk(chunk, context) {
-  if (chunk.type === MessageChunkTypes4.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 = parseAgentWebAppGenUIBlock2(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 });
-      }
-    }
-    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 });
-      }
-    }
-    return events;
-  }
-  if (chunk.type === MessageChunkTypes4.TOOL && chunk.data.tool_call_id) {
-    return [{ type: "tool.completed", id: chunk.data.tool_call_id }];
-  }
-  if (chunk.type === MessageChunkTypes4.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 === MessageChunkTypes4.MESSAGE_COMPLETED) {
-    return [
-      { type: "message.completed", messageId: chunk.data.id },
-      { type: "stream.completed" }
-    ];
-  }
-  if (chunk.type === MessageChunkTypes4.MESSAGE_FAILED) {
-    return [
-      { type: "error", error: { code: "STREAM_FAILED", message: "Stream failed", retryable: true } },
-      { type: "stream.completed" }
-    ];
+// src/services/agent-web-app/AgentWebAppTokenVerifier.ts
+import { createHmac as createHmac2, createPublicKey, timingSafeEqual as timingSafeEqual2, verify as cryptoVerify } from "crypto";
+var WebAppTokenError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebAppTokenError";
   }
-  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;
+};
+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 {
-    const parsed = JSON.parse(content);
-    return isRecord3(parsed) ? parsed : { prompt: content };
+    value = JSON.parse(json);
   } catch {
-    return { prompt: content };
+    throw new WebAppTokenError("Malformed token segment");
   }
+  if (typeof value !== "object" || value === null) throw new WebAppTokenError("Malformed token segment");
+  return value;
 }
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+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 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 = createHmac2("sha256", issuer.secret).update(data).digest();
+    if (signature.length !== expected.length || !timingSafeEqual2(signature, expected)) {
+      throw new WebAppTokenError("Token signature invalid");
+    }
+  } 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 = cryptoVerify("RSA-SHA256", data, key, signature);
+    } catch {
+      valid = false;
+    }
+    if (!valid) throw new WebAppTokenError("Token signature invalid");
+  }
+  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");
+  }
+  return sub;
 }
 
 // src/routes/agent-web-app-runtime.ts
+import { createAgentWebAppStreamProjectionContext, projectAgentWebAppChunk } from "@axiom-lattice/protocols";
 var idSchema = z5.string().min(1).max(128);
 var paramsSchema = z5.object({ webAppId: idSchema }).strict();
 var threadParamsSchema = z5.object({ webAppId: idSchema, threadId: idSchema }).strict();
 var interruptParamsSchema = z5.object({ webAppId: idSchema, threadId: idSchema, interruptId: idSchema }).strict();
+var pendingMessageParamsSchema = z5.object({ webAppId: idSchema, threadId: idSchema, messageId: idSchema }).strict();
 var bootstrapQuerySchema = z5.object({ projectId: idSchema.optional(), modelKey: idSchema.optional() }).strict();
 var projectQuerySchema = z5.object({ projectId: idSchema.optional() }).strict();
+var projectQueryLenientSchema = projectQuerySchema.passthrough();
 var threadBodySchema = z5.object({ projectId: idSchema.optional(), label: z5.string().max(128).optional() }).strict();
 var streamBodySchema = z5.object({
   content: z5.string().trim().min(1).max(32768),
@@ -12453,8 +12548,27 @@ var resumeBodySchema = z5.object({
   ])
 }).strict();
 var MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+var stateQuerySchema = z5.object({
+  threadId: idSchema,
+  projectId: idSchema.optional(),
+  modelKey: idSchema.optional()
+}).strict();
+var resumeSchema = z5.object({
+  messageId: idSchema,
+  projectId: idSchema.optional(),
+  modelKey: idSchema.optional()
+}).strict();
+var devTokenSchema = z5.object({
+  iss: z5.string().min(1).max(255).optional(),
+  sub: z5.string().regex(/^[A-Za-z0-9._:@-]+$/).max(128).optional(),
+  hours: z5.number().gt(0).max(720).optional()
+}).strict();
+var fileQuerySchema = z5.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");
@@ -12463,47 +12577,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);
@@ -12512,15 +12688,27 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
         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);
-      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 () => {
+    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 = await resolveRuntimeIdentity(request, webAppId, identities);
       if (!request.isMultipart()) throw new ZodError2([]);
       const part = await request.file({ limits: { files: 1, fileSize: MAX_ATTACHMENT_BYTES } });
       if (!part || !part.filename || part.filename.length > 255) throw new ZodError2([]);
@@ -12536,7 +12724,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);
@@ -12545,13 +12733,264 @@ 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}.${createHmac3("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 = z5.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 = z5.object({ webAppId: idSchema, assistantId: idSchema, threadId: idSchema }).strict();
+    const mirrorBody = z5.object({ metadata: z5.object({ label: z5.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 = z5.object({ webAppId: idSchema, assistantId: idSchema }).strict();
+    const mirrorPendingParams = z5.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 ZodError2([]);
+        const part = await request.file({ limits: { files: 1, fileSize: MAX_ATTACHMENT_BYTES } });
+        if (!part || !part.filename || part.filename.length > 255) throw new ZodError2([]);
+        const bytes = await part.toBuffer();
+        if (bytes.length === 0 || part.file.truncated) throw new ZodError2([]);
+        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 = z5.object({
+        thread_id: idSchema.optional(),
+        assistant_id: idSchema.optional(),
+        messages: z5.array(z5.object({ content: z5.string().min(1).max(32768) }).passthrough()).min(1).max(20),
+        background: z5.boolean().optional(),
+        streaming: z5.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 = z5.object({
+        assistant_id: idSchema.optional(),
+        thread_id: idSchema,
+        message_id: idSchema,
+        known_content: z5.string().optional(),
+        poll_interval: z5.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 } : {} };
@@ -12566,13 +13005,22 @@ async function pipeAgentWebAppStream(raw, stream, options = {}) {
     ]
   });
 }
+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) {
@@ -12593,6 +13041,105 @@ 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
+import { existsSync as existsSync2 } from "fs";
+import { readFile, readdir as readdir2 } from "fs/promises";
+import path3 from "path";
+import { z as z6 } from "zod";
+var idSchema2 = z6.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 readdir2(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 = path3.resolve(__dirname, "embed");
+    if (existsSync2(path3.join(compiled, BUNDLED_MARKER))) return compiled;
+  }
+  let dir = path3.dirname(path3.resolve(process.argv[1] ?? process.cwd()));
+  for (let depth = 0; depth < 8; depth += 1) {
+    const candidate = path3.join(dir, "packages", "gateway", "dist", "embed");
+    if (existsSync2(path3.join(candidate, BUNDLED_MARKER))) return candidate;
+    const parent = path3.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 ?? path3.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 readFile(path3.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
 import { createCipheriv, createDecipheriv, createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
 var TTL_MS = 15 * 6e4;
@@ -12675,10 +13222,10 @@ function isAttachmentPayload(value) {
 }
 
 // src/controllers/capability-bundles.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/services/capability/CapabilityBundleService.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 import { CapabilityBundleMergeError, CapabilityBundleValidationError, mergeCapabilityBundles, validateCapabilityBundleInput } from "@axiom-lattice/core";
 var CapabilityBundleServiceError = class extends Error {
   constructor(code, message, statusCode) {
@@ -12688,7 +13235,7 @@ var CapabilityBundleServiceError = class extends Error {
     this.name = "CapabilityBundleServiceError";
   }
 };
-var uuid = z6.string().uuid();
+var uuid = z7.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);
@@ -12890,12 +13437,12 @@ var CapabilityBundleService = class {
 
 // src/controllers/capability-bundles.ts
 var logger3 = new Logger({ serviceName: "lattice/gateway/capability-bundles" });
-var capability = z7.unknown();
-var createSchema = z7.object({ name: z7.string(), description: z7.string().optional(), capabilities: z7.array(capability) }).strict();
-var updateSchema = createSchema.partial().extend({ expectedUpdatedAt: z7.string().optional() });
-var bundleIdSchema = z7.string().uuid();
-var bundleParamsSchema = z7.object({ bundleId: bundleIdSchema });
-var projectSchema = z7.object({ bundleIds: z7.array(bundleIdSchema), expectedRevisions: z7.record(z7.string()).optional() }).strict();
+var capability = z8.unknown();
+var createSchema = z8.object({ name: z8.string(), description: z8.string().optional(), capabilities: z8.array(capability) }).strict();
+var updateSchema = createSchema.partial().extend({ expectedUpdatedAt: z8.string().optional() });
+var bundleIdSchema = z8.string().uuid();
+var bundleParamsSchema = z8.object({ bundleId: bundleIdSchema });
+var projectSchema = z8.object({ bundleIds: z8.array(bundleIdSchema), expectedRevisions: z8.record(z8.string()).optional() }).strict();
 function tenant(request, authRequired2) {
   const authenticated = request.user?.tenantId;
   const header2 = request.headers["x-tenant-id"];
@@ -13163,6 +13710,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);
     });
@@ -13767,45 +14322,46 @@ function matchesNormalizedPayload(message, input) {
 
 // src/routes/project-rooms.ts
 import { ZodError as ZodError3 } from "zod";
+import { toProjectRoomPublicMessage } from "@axiom-lattice/protocols";
 
 // src/schemas/project-room.ts
-import { z as z8 } from "zod";
-var id2 = z8.string().trim().min(1).max(128);
-var isoDate = z8.string().datetime({ offset: true }).transform((value) => new Date(value));
-var expectedUpdatedAt = z8.object({ expectedUpdatedAt: isoDate }).strict();
-var projectRoomParamsSchema = z8.object({ projectId: id2 }).strict();
-var membershipParamsSchema = z8.object({ projectId: id2, membershipId: id2 }).strict();
-var roomMessagesQuerySchema = z8.object({
-  beforeCreatedAt: z8.string().datetime({ offset: true }).transform((value) => new Date(value)).optional(),
+import { z as z9 } from "zod";
+var id2 = z9.string().trim().min(1).max(128);
+var isoDate = z9.string().datetime({ offset: true }).transform((value) => new Date(value));
+var expectedUpdatedAt = z9.object({ expectedUpdatedAt: isoDate }).strict();
+var projectRoomParamsSchema = z9.object({ projectId: id2 }).strict();
+var membershipParamsSchema = z9.object({ projectId: id2, membershipId: id2 }).strict();
+var roomMessagesQuerySchema = z9.object({
+  beforeCreatedAt: z9.string().datetime({ offset: true }).transform((value) => new Date(value)).optional(),
   beforeId: id2.optional(),
-  limit: z8.coerce.number().int().min(1).max(100).optional()
+  limit: z9.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 = z8.object({
-  text: z8.string(),
-  mentions: z8.array(z8.union([
-    z8.object({ type: z8.literal("team") }).strict(),
-    z8.object({ type: z8.literal("bot"), membershipId: id2 }).strict()
+var createRoomMessageSchema = z9.object({
+  text: z9.string(),
+  mentions: z9.array(z9.union([
+    z9.object({ type: z9.literal("team") }).strict(),
+    z9.object({ type: z9.literal("bot"), membershipId: id2 }).strict()
   ])).optional(),
   replyToMessageId: id2.optional()
 }).strict();
-var addProjectMemberSchema = z8.object({ userId: id2, role: z8.enum(["owner", "admin", "member", "viewer"]) }).strict();
-var updateProjectMemberSchema = z8.object({ role: z8.enum(["owner", "admin", "member", "viewer"]), expectedUpdatedAt: isoDate }).strict();
+var addProjectMemberSchema = z9.object({ userId: id2, role: z9.enum(["owner", "admin", "member", "viewer"]) }).strict();
+var updateProjectMemberSchema = z9.object({ role: z9.enum(["owner", "admin", "member", "viewer"]), expectedUpdatedAt: isoDate }).strict();
 var mutationExpectedUpdatedAtSchema = expectedUpdatedAt;
-var roomMessageRetryParamsSchema = z8.object({ projectId: id2, messageId: id2 }).strict();
-var emptyObjectSchema = z8.object({}).strict();
-var idempotencyKeySchema = z8.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 = z8.object({
+var roomMessageRetryParamsSchema = z9.object({ projectId: id2, messageId: id2 }).strict();
+var emptyObjectSchema = z9.object({}).strict();
+var idempotencyKeySchema = z9.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 = z9.object({
   assistantId: id2,
-  role: z8.enum(["coordinator", "specialist"]),
-  title: z8.string(),
-  responsibility: z8.string().optional(),
-  mentionName: z8.string()
+  role: z9.enum(["coordinator", "specialist"]),
+  title: z9.string(),
+  responsibility: z9.string().optional(),
+  mentionName: z9.string()
 }).strict();
-var updateProjectBotSchema = z8.object({
-  role: z8.enum(["coordinator", "specialist"]).optional(),
-  title: z8.string().optional(),
-  responsibility: z8.string().optional(),
-  mentionName: z8.string().optional(),
+var updateProjectBotSchema = z9.object({
+  role: z9.enum(["coordinator", "specialist"]).optional(),
+  title: z9.string().optional(),
+  responsibility: z9.string().optional(),
+  mentionName: z9.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" });
 
@@ -13823,7 +14379,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);
@@ -13834,7 +14391,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);
@@ -13843,6 +14400,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);
@@ -13865,6 +14428,11 @@ function actor(request, projectId) {
   projectRoomParamsSchema.parse({ projectId });
   return { tenantId: user.tenantId, userId: user.id, projectId };
 }
+function toProjectRoomMessage(message) {
+  const publicMessage = 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();
@@ -13930,6 +14498,7 @@ import {
   generateDirectHumanProjectId,
   generateDirectBotProjectId
 } from "@axiom-lattice/core";
+import { toProjectRoomPublicMessage as toProjectRoomPublicMessage2 } from "@axiom-lattice/protocols";
 var CoSpaceAuthError = class extends Error {
   constructor() {
     super(...arguments);
@@ -13944,6 +14513,18 @@ 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 ?? (() => randomUUID16());
   app2.get(
@@ -13994,6 +14575,7 @@ function registerCoSpaceRoutes(app2, deps) {
               limit: 1
             });
             const lastMessage = messages[0];
+            const publicLastMessage = lastMessage === void 0 ? void 0 : toProjectRoomPublicMessage2(lastMessage);
             const memberships = await deps.membershipStore.list(
               actor2.tenantId,
               project.id
@@ -14009,19 +14591,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);
@@ -14031,6 +14620,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
@@ -14046,10 +14636,17 @@ function registerCoSpaceRoutes(app2, deps) {
           rooms.unshift({
             project: publicRoom.project,
             room: publicRoom.room,
-            lastMessage: publicMessages[0],
+            lastMessage: publicLastMessage === void 0 ? void 0 : toProjectRoomPublicMessage2(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 } };
@@ -16604,7 +17201,7 @@ function snapshotProjectableWorkItem(value) {
   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 || !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,
@@ -16751,7 +17348,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);
 }
 
@@ -17108,6 +17705,7 @@ function snapshotJson(value, ancestors = /* @__PURE__ */ new Set()) {
 // src/services/collaboration/ProjectRoomRealtimePublisher.ts
 import { createHash as createHash7 } from "crypto";
 import {
+  projectRoomUserEventScope,
   snapshotExactRecord as snapshotExactRecord10,
   snapshotProjectRoomBotMembershipRealtime,
   snapshotProjectRoomMembershipRealtime,
@@ -17182,6 +17780,46 @@ var BrokerProjectRoomRealtimePublisher = class {
       };
     });
   }
+  /** Publishes a membership notice onto the affected user's channel scope. */
+  membershipAffected(input) {
+    this.publish("membership.affected", () => {
+      const value = snapshotExactRecord10(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 = 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 = snapshotExactRecord10(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 = 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 {
@@ -17240,88 +17878,296 @@ function safeErrorCode(error) {
   return error instanceof Error && error.name === "Error" ? "Error" : "UnknownError";
 }
 
-// src/services/collaboration/ProjectRoomRealtimeService.ts
-import { ProjectRoomCursorError as ProjectRoomCursorError2 } from "@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;
+// src/services/collaboration/ProjectRoomTaskEventSubscriber.ts
+import { isProjectLifecycleTask as isProjectLifecycleTask6 } from "@axiom-lattice/core";
+import { snapshotExactRecord as snapshotExactRecord11 } from "@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.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);
+    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");
   }
-  /** Enqueues one public business event. */
-  enqueueBusiness(event) {
-    this.enqueue(serializeBusiness(event));
+  /** Admits one notification without awaiting any store operation. */
+  handle(value) {
+    const event = this.parse(value);
+    if (!event) {
+      this.warn("Project task realtime notification rejected", { code: "INVALID_TASK_REALTIME_EVENT" });
+      return Promise.resolve();
+    }
+    if (!this.accepting || this.closed) return Promise.resolve();
+    const scopeKey3 = JSON.stringify([event.tenantId, event.workspaceId, event.projectId, event.taskId]);
+    const eventKey = event.eventKey;
+    let queue = this.queues.get(scopeKey3);
+    if (!queue) {
+      if (this.pendingCount >= this.maxPending) return this.overflow(event.taskId);
+      queue = { events: [], keys: /* @__PURE__ */ new Set(), tail: Promise.resolve() };
+      this.queues.set(scopeKey3, queue);
+    }
+    if (queue.keys.has(eventKey)) return queue.tail;
+    if (this.pendingCount >= this.maxPending) return this.overflow(event.taskId);
+    queue.keys.add(eventKey);
+    queue.events.push(event);
+    this.pendingCount += 1;
+    const previousTail = queue.tail;
+    queue.tail = previousTail.then(() => this.processQueue(scopeKey3, queue)).catch((error) => {
+      this.warn("project-room:task-realtime-failed", { code: "TASK_REALTIME_NOTIFICATION_FAILED", error: error instanceof Error ? error.name : "UnknownError" });
+    });
+    const accepted = queue.tail;
+    this.accepted.add(accepted);
+    void accepted.finally(() => this.accepted.delete(accepted));
+    return accepted;
   }
-  /** Enqueues one connection control event. */
-  enqueueControl(event) {
-    this.enqueue(serializeControl(event));
+  /** Closes admission without interrupting accepted work. */
+  closeAdmission() {
+    this.accepting = false;
   }
-  /** Writes a heartbeat comment when the socket is not currently blocked. */
-  heartbeat() {
-    if (!this.closed && !this.writing) this.writeFrame(": heartbeat\n\n");
+  /** Drains accepted work, closing permanently if the bound expires. */
+  async drain(timeoutMs = 5e3) {
+    const work = Promise.allSettled([...this.accepted]).then(() => void 0);
+    let timer;
+    const timeout = new Promise((resolve3) => {
+      timer = setTimeout(() => resolve3("timeout"), timeoutMs);
+      timer.unref?.();
+    });
+    const outcome = await Promise.race([work.then(() => "drained"), timeout]);
+    if (timer) clearTimeout(timer);
+    this.closed = true;
+    if (outcome === "timeout") this.queues.clear();
   }
-  /** Closes the writer and removes every socket listener exactly once. */
-  close() {
-    if (this.closed) return;
+  /** Closes admission and drains accepted work. */
+  async dispose() {
+    this.closeAdmission();
+    await this.drain();
     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();
+  }
+  async processQueue(scopeKey3, queue) {
+    while (queue.events.length > 0) {
+      const event = queue.events.shift();
+      try {
+        if (!this.closed) await this.publish(event);
+      } finally {
+        queue.keys.delete(event.eventKey);
+        this.pendingCount -= 1;
+      }
     }
-    this.onClose?.();
+    if (queue.events.length === 0 && this.queues.get(scopeKey3) === queue) this.queues.delete(scopeKey3);
   }
-  /** 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((resolve3) => {
-      this.terminalResolve = resolve3;
+  async publish(event) {
+    try {
+      const taskValue = await this.deps.tasks.getById(event.tenantId, event.taskId);
+      const task = taskValue === null ? void 0 : snapshotTaskItem(taskValue);
+      if (this.closed) return;
+      if (!task || !isProjectLifecycleTask6(task) || task.tenantId !== event.tenantId || task.workspaceId !== event.workspaceId || task.projectId !== event.projectId || task.status !== event.status || task.updatedAt.toISOString() !== event.updatedAt || event.threadId !== void 0 && task.context?.thread_id !== event.threadId) {
+        this.warn("project-room:task-event-stale", { taskId: safeId3(event.taskId), eventKey: safeId3(event.eventKey) });
+        return;
+      }
+      const roomValue = await this.deps.rooms.getMainRoom(event.tenantId, event.projectId);
+      const room = snapshotProjectRoom(roomValue);
+      if (this.closed) return;
+      if (!room || room.tenantId !== event.tenantId || room.workspaceId !== event.workspaceId || room.projectId !== event.projectId) return;
+      const membershipValue = await this.deps.memberships.findByAssistant(event.tenantId, event.projectId, task.ownerId);
+      const membership = snapshotProjectBotMembership(membershipValue);
+      if (this.closed) return;
+      if (!membership || membership.tenantId !== event.tenantId || membership.workspaceId !== event.workspaceId || membership.projectId !== event.projectId || membership.roomId !== room.id || membership.assistantId !== task.ownerId) return;
+      this.deps.realtime.taskChanged({
+        tenantId: event.tenantId,
+        roomId: room.id,
+        projectId: event.projectId,
+        taskId: task.id,
+        status: task.status,
+        ownerMembershipId: membership.id,
+        updatedAt: task.updatedAt.toISOString(),
+        sourceKey: `task:${task.id}:${event.eventKey}`
+      });
+    } catch (error) {
+      this.warn("project-room:task-realtime-failed", { code: "TASK_REALTIME_NOTIFICATION_FAILED", taskId: safeId3(event.taskId), error: error instanceof Error ? error.name : "UnknownError" });
+    }
+  }
+  parse(value) {
+    const row = snapshotExactRecord11(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) {
+    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) => 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((resolve3) => {
+    timer = setTimeout(() => resolve3(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
+import { PROJECT_ROOM_USER_CHANNEL_PROJECT, projectRoomUserEventScope as projectRoomUserEventScope2 } from "@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((resolve3) => {
+      this.terminalResolve = resolve3;
     });
     this.terminal = true;
     this.frames.length = 0;
@@ -17388,449 +18234,265 @@ var ProjectRoomSseWriter = class {
       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 ProjectRoomCursorError2) 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
-import { isProjectLifecycleTask as isProjectLifecycleTask6 } from "@axiom-lattice/core";
-import { snapshotExactRecord as snapshotExactRecord11 } from "@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;
-    if (!Number.isSafeInteger(this.maxPending) || this.maxPending < 1) throw new RangeError("maxPending must be a positive safe integer");
-  }
-  /** Admits one notification without awaiting any store operation. */
-  handle(value) {
-    const event = this.parse(value);
-    if (!event) {
-      this.warn("Project task realtime notification rejected", { code: "INVALID_TASK_REALTIME_EVENT" });
-      return Promise.resolve();
-    }
-    if (!this.accepting || this.closed) return Promise.resolve();
-    const scopeKey3 = JSON.stringify([event.tenantId, event.workspaceId, event.projectId, event.taskId]);
-    const eventKey = event.eventKey;
-    let queue = this.queues.get(scopeKey3);
-    if (!queue) {
-      if (this.pendingCount >= this.maxPending) return this.overflow(event.taskId);
-      queue = { events: [], keys: /* @__PURE__ */ new Set(), tail: Promise.resolve() };
-      this.queues.set(scopeKey3, queue);
-    }
-    if (queue.keys.has(eventKey)) return queue.tail;
-    if (this.pendingCount >= this.maxPending) return this.overflow(event.taskId);
-    queue.keys.add(eventKey);
-    queue.events.push(event);
-    this.pendingCount += 1;
-    const previousTail = queue.tail;
-    queue.tail = previousTail.then(() => this.processQueue(scopeKey3, queue)).catch((error) => {
-      this.warn("project-room:task-realtime-failed", { code: "TASK_REALTIME_NOTIFICATION_FAILED", error: error instanceof Error ? error.name : "UnknownError" });
-    });
-    const accepted = queue.tail;
-    this.accepted.add(accepted);
-    void accepted.finally(() => this.accepted.delete(accepted));
-    return accepted;
-  }
-  /** Closes admission without interrupting accepted work. */
-  closeAdmission() {
-    this.accepting = false;
-  }
-  /** Drains accepted work, closing permanently if the bound expires. */
-  async drain(timeoutMs = 5e3) {
-    const work = Promise.allSettled([...this.accepted]).then(() => void 0);
-    let timer;
-    const timeout = new Promise((resolve3) => {
-      timer = setTimeout(() => resolve3("timeout"), timeoutMs);
-      timer.unref?.();
-    });
-    const outcome = await Promise.race([work.then(() => "drained"), timeout]);
-    if (timer) clearTimeout(timer);
-    this.closed = true;
-    if (outcome === "timeout") this.queues.clear();
-  }
-  /** Closes admission and drains accepted work. */
-  async dispose() {
-    this.closeAdmission();
-    await this.drain();
-    this.closed = true;
-  }
-  async processQueue(scopeKey3, queue) {
-    while (queue.events.length > 0) {
-      const event = queue.events.shift();
-      try {
-        if (!this.closed) await this.publish(event);
-      } finally {
-        queue.keys.delete(event.eventKey);
-        this.pendingCount -= 1;
-      }
-    }
-    if (queue.events.length === 0 && this.queues.get(scopeKey3) === queue) this.queues.delete(scopeKey3);
-  }
-  async publish(event) {
-    try {
-      const taskValue = await this.deps.tasks.getById(event.tenantId, event.taskId);
-      const task = taskValue === null ? void 0 : snapshotTaskItem(taskValue);
-      if (this.closed) return;
-      if (!task || !isProjectLifecycleTask6(task) || task.tenantId !== event.tenantId || task.workspaceId !== event.workspaceId || task.projectId !== event.projectId || task.status !== event.status || task.updatedAt.toISOString() !== event.updatedAt || event.threadId !== void 0 && task.context?.thread_id !== event.threadId) {
-        this.warn("project-room:task-event-stale", { taskId: safeId3(event.taskId), eventKey: safeId3(event.eventKey) });
-        return;
-      }
-      const roomValue = await this.deps.rooms.getMainRoom(event.tenantId, event.projectId);
-      const room = snapshotProjectRoom(roomValue);
-      if (this.closed) return;
-      if (!room || room.tenantId !== event.tenantId || room.workspaceId !== event.workspaceId || room.projectId !== event.projectId) return;
-      const membershipValue = await this.deps.memberships.findByAssistant(event.tenantId, event.projectId, task.ownerId);
-      const membership = snapshotProjectBotMembership(membershipValue);
-      if (this.closed) return;
-      if (!membership || membership.tenantId !== event.tenantId || membership.workspaceId !== event.workspaceId || membership.projectId !== event.projectId || membership.roomId !== room.id || membership.assistantId !== task.ownerId) return;
-      this.deps.realtime.taskChanged({
-        tenantId: event.tenantId,
-        roomId: room.id,
-        projectId: event.projectId,
-        taskId: task.id,
-        status: task.status,
-        ownerMembershipId: membership.id,
-        updatedAt: task.updatedAt.toISOString(),
-        sourceKey: `task:${task.id}:${event.eventKey}`
-      });
-    } catch (error) {
-      this.warn("project-room:task-realtime-failed", { code: "TASK_REALTIME_NOTIFICATION_FAILED", taskId: safeId3(event.taskId), error: error instanceof Error ? error.name : "UnknownError" });
-    }
-  }
-  parse(value) {
-    const row = snapshotExactRecord11(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;
+  armTerminalDeadline(deadlineMs, finish) {
+    this.terminalTimer = setTimeout(finish, deadlineMs);
+    this.terminalTimer.unref?.();
   }
-  warn(message, context) {
+  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 = projectRoomUserEventScope2(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 !== 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) => 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((resolve3) => {
-    timer = setTimeout(() => resolve3(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
-import { isProjectRoomEventId, snapshotExactRecord as snapshotExactRecord12 } from "@axiom-lattice/protocols";
-function registerProjectRoomEventRoutes(app2, deps) {
-  app2.get("/api/projects/:projectId/room/events", async (request, reply) => {
+// src/routes/workspace-room-events.ts
+import { snapshotExactRecord as snapshotExactRecord12 } from "@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",
@@ -17839,53 +18501,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 = snapshotExactRecord12(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 || !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 = snapshotExactRecord12(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) {
@@ -17896,7 +18540,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 } });
 }
 
@@ -18035,6 +18678,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
   const projectRoomStore = getStoreLattice16("default", "projectRoom").store;
   const projectBotMembershipStore = getStoreLattice16("default", "projectBotMembership").store;
   const projectRoomMessageStore = getStoreLattice16("default", "projectRoomMessage").store;
+  const projectRoomReadStateStore = getStoreLattice16("default", "projectRoomReadState").store;
   const threadStore = getStoreLattice16("default", "thread").store;
   const taskStore = getStoreLattice16("default", "task").store;
   const taskWorkItemStore = getStoreLattice16("default", "taskWorkItem").store;
@@ -18046,23 +18690,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")
     });
   }
@@ -18144,7 +18795,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: {
@@ -18166,7 +18834,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)
@@ -18209,6 +18881,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: projectMutationMutex2,
+      executionMutex: projectTaskComposition?.mutex ?? {
+        runExclusive: (_scope, operation) => operation()
+      }
+    }),
     service: new AgentWebAppRuntimeService({
       webAppStore,
       threadStore: getStoreLattice16("default", "thread").store,
@@ -18216,7 +18928,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 agentLatticeManager4.initializeStoredAssistantsForTenant(tenantId);
           const config = agentLatticeManager4.getAgentConfigWithTenant(tenantId, assistantId);
           return config ? { id: assistantId, name: config.name, description: config.description } : null;
@@ -18259,6 +18971,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       }
     })
   });
+  registerAgentWebAppEmbedRoutes(app2, {});
   registerA2ABridgeRoutes(app2);
   registerSTTRoutes(app2);
   app2.get("/api/local-a2a", getLocalA2AStatus);
@@ -20980,9 +21693,9 @@ var MessageRouter = class {
 };
 
 // src/channels/room/RoomChannelAdapter.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 import { snapshotExactRecord as snapshotExactRecord15 } from "@axiom-lattice/protocols";
-var roomConfigSchema = z9.object({}).strict();
+var roomConfigSchema = z10.object({}).strict();
 function createRoomChannelAdapter(writer) {
   return {
     channel: "room",
@@ -21162,7 +21875,7 @@ app.register(multipart, {
 });
 app.register(websocket);
 app.register(staticPlugin, {
-  root: typeof __dirname === "string" ? path3.join(__dirname, "../public") : path3.resolve(process.cwd(), "public"),
+  root: typeof __dirname === "string" ? path4.join(__dirname, "../public") : path4.resolve(process.cwd(), "public"),
   prefix: "/"
 });
 app.setErrorHandler((error, request, reply) => {
@@ -21213,7 +21926,7 @@ async function restoreMcpConnections() {
     const connectedConfigs = configs.filter((c2) => c2.status === "connected");
     if (connectedConfigs.length === 0) return;
     logger5.info(`Restoring ${connectedConfigs.length} MCP server connections...`);
-    const { convertToConnection } = await import("./mcp-configs-SHRMQHIL.mjs");
+    const { convertToConnection } = await import("./mcp-configs-IIKQM5GM.mjs");
     for (const config of connectedConfigs) {
       try {
         const connection = convertToConnection(config.config);
@@ -21252,26 +21965,11 @@ var start = async (config) => {
     const projectRoomRealtimeMode = resolveProjectRoomRealtimeMode();
     let projectRoomRealtimeRuntime;
     if (projectRoomRealtimeMode === "single-gateway") {
-      const projectStore = getStoreLattice27("default", "project").store;
-      const membershipStore = getStoreLattice27("default", "projectMembership").store;
-      const access = new ProjectAccessService({
-        projectStore,
-        membershipStore,
-        userTenantLinkStore: getStoreLattice27("default", "userTenantLink").store
-      });
       projectRoomRealtimeRuntime = createProjectRoomRealtimeRuntime({
         tasks: getStoreLattice27("default", "task").store,
         rooms: getStoreLattice27("default", "projectRoom").store,
         memberships: getStoreLattice27("default", "projectBotMembership").store,
-        log: { warn: (message, context) => logger5.warn(message, context) },
-        requireReadAccess: async (actor2) => {
-          await access.requireExistingProjectAccess({
-            tenantId: actor2.tenantId,
-            userId: actor2.userId,
-            projectId: actor2.projectId,
-            capability: "read"
-          });
-        }
+        log: { warn: (message, context) => logger5.warn(message, context) }
       });
     }
     let channelDeps;
@@ -21329,7 +22027,7 @@ var start = async (config) => {
     });
     try {
       const { A2AAuthService, parseEnvKeys } = await import("./A2AAuthService-DK5X6VIL.mjs");
-      const { registerA2AStandardRoutes } = await import("./a2a-standard-G3J5ZHQ7.mjs");
+      const { registerA2AStandardRoutes } = await import("./a2a-standard-WC2BSOFV.mjs");
       const a2a = await import("./a2a-7N3WDAOP.mjs");
       const a2aKeyStore = getStoreLattice27("default", "a2aApiKey").store;
       const assistantStore = getStoreLattice27("default", "assistant").store;
@@ -21358,6 +22056,15 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
+    try {
+      const { registerOpenRoutes } = await import("./open-DCAOL5CG.mjs");
+      registerOpenRoutes(app);
+      logger5.info("Open MCP spike routes registered");
+    } catch (err) {
+      logger5.warn("Open MCP spike routes unavailable", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
     if (!sandboxLatticeManager2.hasLattice("default")) {
       sandboxLatticeManager2.registerLattice("default", getConfiguredSandboxProvider());
       logger5.info("Registered sandbox manager from env configuration");