@axiom-lattice/gateway 4.1.5 → 4.1.7

package/dist/index.js

@@ -1512,7 +1512,7 @@ function extractFailureReason(task) {
   return extractText2(task.status.message.parts);
 }
 function observationEventKey(task, result, failureReason) {
-  const digest = (0, import_node_crypto17.createHash)("sha256").update(JSON.stringify({
+  const digest = (0, import_node_crypto21.createHash)("sha256").update(JSON.stringify({
     state: task.status.state,
     timestamp: task.status.timestamp,
     message: task.status.message,
@@ -1522,7 +1522,7 @@ function observationEventKey(task, result, failureReason) {
   return `a2a-status-observation:${task.id}:${digest}`;
 }
 function snapshotEventKey(task) {
-  const digest = (0, import_node_crypto17.createHash)("sha256").update(JSON.stringify(task)).digest("hex");
+  const digest = (0, import_node_crypto21.createHash)("sha256").update(JSON.stringify(task)).digest("hex");
   return `a2a-task-snapshot:${task.id}:${digest}`;
 }
 function isGovernedObservation(state) {
@@ -1534,11 +1534,11 @@ function isA2ATaskSnapshot(value) {
 function snapshotSequence(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
 }
-var import_node_crypto17, import_node_util, TASK_STATUS_TO_A2A_STATE, TITLE_MAX_LENGTH, A2ATaskScopeConflictError, A2ATaskStoreAdapter;
+var import_node_crypto21, import_node_util, TASK_STATUS_TO_A2A_STATE, TITLE_MAX_LENGTH, A2ATaskScopeConflictError, A2ATaskStoreAdapter;
 var init_A2ATaskStoreAdapter = __esm({
   "src/services/a2a/A2ATaskStoreAdapter.ts"() {
     "use strict";
-    import_node_crypto17 = require("crypto");
+    import_node_crypto21 = require("crypto");
     import_node_util = require("util");
     TASK_STATUS_TO_A2A_STATE = {
       pending: "submitted",
@@ -1999,7 +1999,7 @@ ${formatFileRefsSection(inputFiles)}` : text;
             const messageText = [
               `A2A governed task instruction: get and update the existing TaskItem ${ctx.taskId}; do not create a replacement task.`,
               "Before doing the requested work, initialize its canonical description through manage_task with ## Objective, ## Acceptance Criteria, and ## Belief State sections.",
-              "Keep lifecycle status truthful. Complete only through manage_task update with a nonblank result and structured beliefImpact; use interrupted, failed, or cancelled when appropriate.",
+              "Keep lifecycle status truthful. Change status only through manage_task set_status; complete with a nonblank result and structured beliefImpact, and use interrupted, failed, or cancelled when appropriate. Use manage_task update for content fields only.",
               "",
               requestText
             ].join("\n");
@@ -3313,7 +3313,7 @@ var import_static = __toESM(require("@fastify/static"));
 var import_path = __toESM(require("path"));
 
 // src/routes/index.ts
-var import_node_crypto16 = require("crypto");
+var import_node_crypto20 = require("crypto");
 var import_protocols24 = require("@axiom-lattice/protocols");
 
 // src/controllers/assistant.ts
@@ -8485,6 +8485,113 @@ var import_uuid3 = require("uuid");
 init_mime();
 init_workspace_file_service();
 init_path_containment();
+
+// src/services/collaboration/RoomCoordinatorProvisioner.ts
+var ROOM_COORDINATOR_KEY = "room-coordinator";
+var RoomCoordinatorProvisioner = class {
+  /** Creates a provisioner over the tenant-scoped assistant store operations. */
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /**
+   * Ensures the Room Coordinator assistant exists, reusing an existing record
+   * and reconciling concurrent create races by rereading the winner.
+   *
+   * @param tenantId Tenant to provision the coordinator for.
+   * @returns The persisted Room Coordinator assistant.
+   */
+  async ensure(tenantId) {
+    const existing = await this.deps.getAssistantById(tenantId, ROOM_COORDINATOR_KEY);
+    if (existing) return existing;
+    try {
+      return await this.deps.createAssistant(tenantId, ROOM_COORDINATOR_KEY, {
+        name: "Room Coordinator",
+        description: "Coordinates project room conversations and organizes room work.",
+        graphDefinition: {}
+      });
+    } catch (error) {
+      const winner = await this.deps.getAssistantById(tenantId, ROOM_COORDINATOR_KEY);
+      if (winner) return winner;
+      throw error;
+    }
+  }
+};
+
+// src/services/collaboration/WorkspacePublicRoomService.ts
+var import_node_crypto = require("crypto");
+var import_node_crypto2 = require("crypto");
+var WORKSPACE_PUBLIC_ROOM_PROJECT_PREFIX = "workspace_public_";
+var PUBLIC_ROOM_PROJECT_NAME = "General";
+var PUBLIC_ROOM_PROJECT_DESCRIPTION = "Public room for everyone in the workspace";
+function workspacePublicRoomProjectId(tenantId, workspaceId) {
+  const hash = (0, import_node_crypto.createHash)("sha256").update([tenantId, workspaceId].join(":")).digest("hex");
+  return `${WORKSPACE_PUBLIC_ROOM_PROJECT_PREFIX}${hash}`;
+}
+var WorkspacePublicRoomService = class {
+  /** Creates the service from explicitly injected stores and provisioners. */
+  constructor(deps) {
+    this.deps = deps;
+    this.idFactory = deps.idFactory ?? import_node_crypto2.randomUUID;
+  }
+  /**
+   * Returns the workspace's public room project and room, creating them on first call.
+   *
+   * @param tenantId Tenant owning the workspace.
+   * @param workspaceId Workspace hosting the public room.
+   * @returns The ensured project and room.
+   */
+  async ensure(tenantId, workspaceId) {
+    const projectId = workspacePublicRoomProjectId(tenantId, workspaceId);
+    const project = await this.ensureProject(tenantId, workspaceId, projectId);
+    const room = await this.deps.ensureMainRoom({
+      id: this.idFactory(),
+      tenantId,
+      workspaceId,
+      projectId,
+      name: project.name
+    });
+    await this.ensureCoordinatorBot(tenantId, workspaceId, projectId, room.id);
+    return { project, room };
+  }
+  async ensureProject(tenantId, workspaceId, projectId) {
+    const existing = await this.deps.getProjectById(tenantId, projectId);
+    if (existing && existing.kind === "public") return existing;
+    try {
+      return await this.deps.createProject(tenantId, workspaceId, projectId, {
+        name: PUBLIC_ROOM_PROJECT_NAME,
+        description: PUBLIC_ROOM_PROJECT_DESCRIPTION,
+        kind: "public"
+      });
+    } catch (error) {
+      const winner = await this.deps.getProjectById(tenantId, projectId);
+      if (winner && winner.kind === "public") return winner;
+      throw Object.assign(new Error("Workspace public room project could not be ensured"), { cause: error });
+    }
+  }
+  async ensureCoordinatorBot(tenantId, workspaceId, projectId, roomId) {
+    const coordinator = await this.deps.ensureCoordinator(tenantId);
+    const existing = await this.deps.findBotByAssistant(tenantId, projectId, coordinator.id);
+    if (existing && existing.status !== "removed") return;
+    const saved = await this.deps.saveBot({
+      id: this.idFactory(),
+      tenantId,
+      workspaceId,
+      projectId,
+      roomId,
+      assistantId: coordinator.id,
+      role: "coordinator",
+      title: coordinator.name,
+      mentionName: ROOM_COORDINATOR_KEY,
+      status: "active",
+      roomThreadId: this.idFactory()
+    });
+    if (saved.kind === "coordinator_conflict" || saved.kind === "mention_conflict") {
+      throw new Error(`Workspace public room coordinator bot could not be ensured: ${saved.kind}`);
+    }
+  }
+};
+
+// src/controllers/workspace.ts
 var MAX_ZIP_ENTRIES = 1e4;
 var MAX_ZIP_FILE_SIZE = 100 * 1024 * 1024;
 var MAX_ZIP_TOTAL_SIZE = 512 * 1024 * 1024;
@@ -8619,6 +8726,21 @@ var WorkspaceController = class {
     this.projectCollaboration = projectCollaboration;
     this.workspaceStore = (0, import_core24.getStoreLattice)("default", "workspace").store;
     this.projectStore = (0, import_core24.getStoreLattice)("default", "project").store;
+    const roomStore = (0, import_core24.getStoreLattice)("default", "projectRoom").store;
+    const botMembershipStore = (0, import_core24.getStoreLattice)("default", "projectBotMembership").store;
+    const assistantStore = (0, import_core24.getStoreLattice)("default", "assistant").store;
+    const coordinatorProvisioner = new RoomCoordinatorProvisioner({
+      getAssistantById: assistantStore.getAssistantById.bind(assistantStore),
+      createAssistant: assistantStore.createAssistant.bind(assistantStore)
+    });
+    this.publicRoom = new WorkspacePublicRoomService({
+      getProjectById: this.projectStore.getProjectById.bind(this.projectStore),
+      createProject: this.projectStore.createProject.bind(this.projectStore),
+      ensureMainRoom: roomStore.ensureMainRoom.bind(roomStore),
+      findBotByAssistant: botMembershipStore.findByAssistant.bind(botMembershipStore),
+      saveBot: botMembershipStore.save.bind(botMembershipStore),
+      ensureCoordinator: (tenantId) => coordinatorProvisioner.ensure(tenantId)
+    });
   }
   getTenantId(request) {
     const userTenantId = request.user?.tenantId;
@@ -8692,6 +8814,7 @@ var WorkspaceController = class {
     const { workspaceId } = request.params;
     const kindFilter = request.query.kind;
     await this.ensureTrainingProject(tenantId, workspaceId);
+    await this.publicRoom.ensure(tenantId, workspaceId);
     const projects = kindFilter ? await this.projectStore.getProjectsByWorkspace(tenantId, workspaceId, {
       kind: kindFilter
     }) : await this.projectStore.getProjectsByWorkspace(tenantId, workspaceId);
@@ -8735,6 +8858,12 @@ var WorkspaceController = class {
         message: CAPABILITY_BUNDLE_CONFIG_MESSAGE
       });
     }
+    if (data.kind === "public") {
+      return reply.status(409).send({
+        success: false,
+        error: "The public room project is managed automatically"
+      });
+    }
     if (user?.id && this.projectCollaboration) {
       try {
         const authorized = await this.projectCollaboration.authorizeCreator({ tenantId, userId: user.id });
@@ -8810,6 +8939,21 @@ var WorkspaceController = class {
         message: CAPABILITY_BUNDLE_CONFIG_MESSAGE
       });
     }
+    if (updates.kind !== void 0) {
+      const existingProject = await this.projectStore.getProjectById(tenantId, projectId);
+      if (existingProject && updates.kind === "public") {
+        return reply.status(409).send({
+          success: false,
+          error: "kind public is reserved for the workspace public room"
+        });
+      }
+      if (existingProject?.kind === "public") {
+        return reply.status(409).send({
+          success: false,
+          error: "The public room project classification cannot be changed"
+        });
+      }
+    }
     const project = await this.projectStore.updateProject(
       tenantId,
       projectId,
@@ -8840,6 +8984,12 @@ var WorkspaceController = class {
         });
       }
     }
+    if (project.kind === "public") {
+      return reply.status(409).send({
+        success: false,
+        error: "The public room project cannot be deleted"
+      });
+    }
     const deleted = await this.projectStore.deleteProject(tenantId, projectId);
     if (!deleted) {
       return reply.status(404).send({ success: false, error: "Project not found" });
@@ -9538,7 +9688,195 @@ function registerWorkspaceRoutes(app2, projectCollaboration) {
     "/api/filesystem/browse",
     controller.browseFilesystem.bind(controller)
   );
+  return controller;
+}
+
+// src/services/collaboration/ProjectAccessService.ts
+var import_node_crypto3 = require("crypto");
+var ProjectCollaborationError = class extends Error {
+  /** Creates a project collaboration error. */
+  constructor(code, statusCode, message) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "ProjectCollaborationError";
+  }
+};
+var allowedRoles = {
+  read: /* @__PURE__ */ new Set(["owner", "admin", "member", "viewer"]),
+  send: /* @__PURE__ */ new Set(["owner", "admin", "member"]),
+  manage: /* @__PURE__ */ new Set(["owner", "admin"])
+};
+var membershipConflictNames = /* @__PURE__ */ new Set([
+  "DuplicateProjectMembershipError",
+  "ProjectMembershipIdConflictError"
+]);
+function isProjectMembershipConflict(error) {
+  return error instanceof Error && membershipConflictNames.has(error.name);
 }
+var ProjectAccessService = class {
+  /** Creates a project access service from explicitly injected stores. */
+  constructor(deps) {
+    this.deps = deps;
+    this.idFactory = deps.idFactory ?? import_node_crypto3.randomUUID;
+  }
+  /** Returns the project and active membership when the user has the requested capability. */
+  async requireProjectAccess(input) {
+    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
+    if (!project) {
+      throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
+    }
+    if (project.kind === "public") {
+      return this.requirePublicProjectAccess(project, input);
+    }
+    const membership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (membership?.status === "active") {
+      this.requireCapability(membership, input.capability);
+      return { project, membership };
+    }
+    const memberships = await this.deps.membershipStore.list(input.tenantId, input.projectId);
+    if (memberships.length !== 0) this.accessDenied();
+    if (project.kind === "personal") this.accessDenied();
+    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
+    if (tenantLink?.role !== "owner" && tenantLink?.role !== "admin") this.accessDenied();
+    let claim;
+    try {
+      claim = await this.deps.membershipStore.createInitialOwner({
+        id: this.idFactory(),
+        tenantId: input.tenantId,
+        projectId: input.projectId,
+        userId: input.userId
+      });
+    } catch (error) {
+      if (isProjectMembershipConflict(error)) {
+        throw new ProjectCollaborationError(
+          "PROJECT_MEMBERSHIP_CONFLICT",
+          409,
+          "Project membership could not be initialized"
+        );
+      }
+      throw error;
+    }
+    if (claim.kind === "created" || claim.kind === "existing") {
+      return { project, membership: claim.membership };
+    }
+    const racedMembership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (racedMembership?.status !== "active") this.accessDenied();
+    this.requireCapability(racedMembership, input.capability);
+    return { project, membership: racedMembership };
+  }
+  /** Authorizes an already-existing membership, or any tenant member for public rooms; never mutates persistence. */
+  async requireExistingProjectAccess(input) {
+    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
+    if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
+    if (project.kind === "public") {
+      return this.requireExistingPublicProjectAccess(project, input);
+    }
+    const membership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (!membership || membership.tenantId !== input.tenantId || membership.projectId !== input.projectId || membership.userId !== input.userId || membership.status !== "active") this.accessDenied();
+    this.requireCapability(membership, input.capability);
+    return { project, membership };
+  }
+  /** Authorizes roster visibility: read for public rooms, manage elsewhere. */
+  async requireRosterAccess(input) {
+    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
+    if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
+    return this.requireProjectAccess({
+      ...input,
+      capability: project.kind === "public" ? "read" : "manage"
+    });
+  }
+  async requirePublicProjectAccess(project, input) {
+    const membership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (membership?.status === "active") {
+      this.requireCapability(membership, input.capability);
+      return { project, membership };
+    }
+    const materialized = await this.materializePublicMembership(input);
+    this.requireCapability(materialized, input.capability);
+    return { project, membership: materialized };
+  }
+  async requireExistingPublicProjectAccess(project, input) {
+    const membership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (membership?.status === "active") {
+      this.requireCapability(membership, input.capability);
+      return { project, membership };
+    }
+    if (membership) this.accessDenied();
+    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
+    if (!tenantLink) this.accessDenied();
+    const role = tenantLink.role === "owner" || tenantLink.role === "admin" ? "admin" : "member";
+    const synthetic = {
+      id: `public:${input.userId}`,
+      tenantId: input.tenantId,
+      projectId: input.projectId,
+      userId: input.userId,
+      role,
+      status: "active",
+      joinedAt: project.createdAt,
+      updatedAt: project.updatedAt
+    };
+    this.requireCapability(synthetic, input.capability);
+    return { project, membership: synthetic };
+  }
+  async materializePublicMembership(input) {
+    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
+    if (!tenantLink) this.accessDenied();
+    const existing = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (existing) this.accessDenied();
+    const role = tenantLink.role === "owner" || tenantLink.role === "admin" ? "admin" : "member";
+    try {
+      return await this.deps.membershipStore.create({
+        id: this.idFactory(),
+        tenantId: input.tenantId,
+        projectId: input.projectId,
+        userId: input.userId,
+        role,
+        status: "active"
+      });
+    } catch (error) {
+      if (isProjectMembershipConflict(error)) {
+        const raced = await this.deps.membershipStore.findByUser(
+          input.tenantId,
+          input.projectId,
+          input.userId
+        );
+        if (raced?.status === "active") return raced;
+      }
+      throw error;
+    }
+  }
+  requireCapability(membership, capability2) {
+    if (!allowedRoles[capability2].has(membership.role)) this.accessDenied();
+  }
+  accessDenied() {
+    throw new ProjectCollaborationError("PROJECT_ACCESS_DENIED", 403, "Project access denied");
+  }
+};
 
 // src/controllers/database-configs.ts
 var import_core27 = require("@axiom-lattice/core");
@@ -11595,7 +11933,7 @@ function registerTenantRoutes(app2) {
 // src/controllers/auth.ts
 var import_core35 = require("@axiom-lattice/core");
 var import_uuid8 = require("uuid");
-var import_node_crypto = require("crypto");
+var import_node_crypto4 = require("crypto");
 var defaultAuthConfig = {
   autoApproveUsers: true,
   allowTenantRegistration: true,
@@ -11950,7 +12288,7 @@ var AuthController = class {
 function resolveConsoleTokenSecret(_authRequired) {
   const configured = process.env.AUTH_TOKEN_SECRET || process.env.JWT_SECRET;
   if (configured) return configured;
-  devSessionSecret ?? (devSessionSecret = (0, import_node_crypto.randomBytes)(32).toString("hex"));
+  devSessionSecret ?? (devSessionSecret = (0, import_node_crypto4.randomBytes)(32).toString("hex"));
   console.warn(
     "[auth] AUTH_TOKEN_SECRET/JWT_SECRET is not set; using an in-process generated signing secret (sessions are invalidated on restart). Set AUTH_TOKEN_SECRET for production."
   );
@@ -11959,7 +12297,7 @@ function resolveConsoleTokenSecret(_authRequired) {
 var devSessionSecret;
 function createConsoleSessionToken(payload, secret) {
   const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
-  const signature = (0, import_node_crypto.createHmac)("sha256", secret).update(encodedPayload).digest("base64url");
+  const signature = (0, import_node_crypto4.createHmac)("sha256", secret).update(encodedPayload).digest("base64url");
   return `${encodedPayload}.${signature}`;
 }
 function isConsoleSessionPayload(value) {
@@ -11986,8 +12324,8 @@ function verifySignedConsoleSession(authHeader, secret) {
   try {
     const actualSignature = Buffer.from(encodedSignature, "base64url");
     if (actualSignature.toString("base64url") !== encodedSignature) return void 0;
-    const expectedSignature = (0, import_node_crypto.createHmac)("sha256", secret).update(encodedPayload).digest();
-    if (actualSignature.length !== expectedSignature.length || !(0, import_node_crypto.timingSafeEqual)(actualSignature, expectedSignature)) {
+    const expectedSignature = (0, import_node_crypto4.createHmac)("sha256", secret).update(encodedPayload).digest();
+    if (actualSignature.length !== expectedSignature.length || !(0, import_node_crypto4.timingSafeEqual)(actualSignature, expectedSignature)) {
       return void 0;
     }
     const payload = JSON.parse(
@@ -13568,7 +13906,7 @@ async function getLocalA2ATemplates(_request, reply) {
 }
 
 // src/routes/a2a-test-connection.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto5 = require("crypto");
 function describeTestConnectionError(error, agentCardUrl) {
   if (!(error instanceof Error)) {
     return `Failed to fetch agent card from ${agentCardUrl}: ${String(error)}`;
@@ -13608,7 +13946,7 @@ async function ensureLocalRuntimeForConnectionTest(localRuntime, agentCardUrl) {
     return { error: portValidation.error };
   }
   const state = await localA2AService.startProvider(
-    `test-${(0, import_node_crypto2.randomUUID)()}`,
+    `test-${(0, import_node_crypto5.randomUUID)()}`,
     testRuntime
   );
   if (state.status === "running") return { runtimeId: state.runtimeId };
@@ -13685,106 +14023,6 @@ var import_core51 = require("@axiom-lattice/core");
 var import_protocols10 = require("@axiom-lattice/protocols");
 var import_core42 = require("@axiom-lattice/core");
 
-// src/services/collaboration/ProjectAccessService.ts
-var import_node_crypto3 = require("crypto");
-var ProjectCollaborationError = class extends Error {
-  /** Creates a project collaboration error. */
-  constructor(code, statusCode, message) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.name = "ProjectCollaborationError";
-  }
-};
-var allowedRoles = {
-  read: /* @__PURE__ */ new Set(["owner", "admin", "member", "viewer"]),
-  send: /* @__PURE__ */ new Set(["owner", "admin", "member"]),
-  manage: /* @__PURE__ */ new Set(["owner", "admin"])
-};
-var membershipConflictNames = /* @__PURE__ */ new Set([
-  "DuplicateProjectMembershipError",
-  "ProjectMembershipIdConflictError"
-]);
-function isProjectMembershipConflict(error) {
-  return error instanceof Error && membershipConflictNames.has(error.name);
-}
-var ProjectAccessService = class {
-  /** Creates a project access service from explicitly injected stores. */
-  constructor(deps) {
-    this.deps = deps;
-    this.idFactory = deps.idFactory ?? import_node_crypto3.randomUUID;
-  }
-  /** Returns the project and active membership when the user has the requested capability. */
-  async requireProjectAccess(input) {
-    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
-    if (!project) {
-      throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
-    }
-    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 only an already-existing active membership and 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");
-    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 };
-  }
-  requireCapability(membership, capability2) {
-    if (!allowedRoles[capability2].has(membership.role)) this.accessDenied();
-  }
-  accessDenied() {
-    throw new ProjectCollaborationError("PROJECT_ACCESS_DENIED", 403, "Project access denied");
-  }
-};
-
 // src/services/collaboration/ProjectTaskThreadService.ts
 var import_core40 = require("@axiom-lattice/core");
 var import_protocols9 = require("@axiom-lattice/protocols");
@@ -14316,9 +14554,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) {
@@ -14759,7 +14994,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);
@@ -14768,7 +15004,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);
   }
@@ -14881,13 +15118,28 @@ var agentWebAppFeaturesSchema = import_zod4.z.object({
   threadManagement: import_zod4.z.boolean(),
   attachments: import_zod4.z.boolean(),
   hitl: import_zod4.z.boolean(),
-  genUI: import_zod4.z.boolean()
+  genUI: import_zod4.z.boolean(),
+  files: import_zod4.z.boolean().optional()
 }).strict();
 var agentWebAppAppearanceSchema = import_zod4.z.object({
   title: import_zod4.z.string().max(120).optional(),
   welcomeMessage: import_zod4.z.string().max(1e3).optional(),
   primaryColor: import_zod4.z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional()
 }).strict();
+var agentWebAppIssuerSchema = import_zod4.z.object({
+  iss: import_zod4.z.string().min(1).max(255),
+  aud: import_zod4.z.string().min(1).max(255),
+  alg: import_zod4.z.enum(["HS256", "RS256"]),
+  secret: import_zod4.z.string().min(1).max(512).optional(),
+  jwksUrl: import_zod4.z.string().url().max(2048).optional()
+}).strict().refine(
+  (value) => value.alg === "HS256" ? value.secret !== void 0 : value.jwksUrl !== void 0,
+  { message: "HS256 requires secret; RS256 requires jwksUrl" }
+);
+var agentWebAppIdentitySchema = import_zod4.z.object({
+  policy: import_zod4.z.enum(["unverified", "verified", "both"]),
+  issuers: import_zod4.z.array(agentWebAppIssuerSchema).min(1).max(10)
+}).strict();
 var createAgentWebAppSchema = import_zod4.z.object({
   assistantId: externalId,
   name: import_zod4.z.string().min(1).max(120),
@@ -14895,14 +15147,16 @@ var createAgentWebAppSchema = import_zod4.z.object({
   integration: import_zod4.z.object({ type: import_zod4.z.literal("react_sdk") }).strict(),
   scope: agentWebAppScopeSchema,
   features: agentWebAppFeaturesSchema,
-  appearance: agentWebAppAppearanceSchema
+  appearance: agentWebAppAppearanceSchema,
+  identity: agentWebAppIdentitySchema.optional()
 }).strict();
 var updateAgentWebAppSchema = import_zod4.z.object({
   name: import_zod4.z.string().min(1).max(120).optional(),
   description: import_zod4.z.string().max(1e3).optional(),
   scope: agentWebAppScopeSchema.partial().strict().optional(),
   features: agentWebAppFeaturesSchema.partial().strict().optional(),
-  appearance: agentWebAppAppearanceSchema.partial().strict().optional()
+  appearance: agentWebAppAppearanceSchema.partial().strict().optional(),
+  identity: agentWebAppIdentitySchema.optional()
 }).strict().refine((value) => Object.keys(value).length > 0, "Patch must not be empty");
 var listAgentWebAppsQuerySchema = import_zod4.z.object({
   assistantId: externalId.optional()
@@ -14989,10 +15243,11 @@ function invalidRequest(reply, statusCode) {
 }
 
 // src/routes/agent-web-app-runtime.ts
+var import_node_crypto8 = require("crypto");
 var import_zod6 = require("zod");
 
 // src/services/agent-web-app/AgentWebAppRuntimeService.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto6 = require("crypto");
 var import_protocols11 = require("@axiom-lattice/protocols");
 init_task_file_refs();
 function isRecord2(value) {
@@ -15010,7 +15265,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,
@@ -15043,7 +15307,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
@@ -15064,6 +15328,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);
@@ -15098,6 +15370,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 ?? []);
@@ -15116,10 +15442,10 @@ ${formatFileRefsSection(refs)}` : input.content;
     const runtime = await this.resolveOwnedRuntime(webAppId, userId, threadId, selection);
     this.requireNamedFeature(runtime.webApp.features.attachments, "Attachments are disabled");
     if (!this.deps.saveProjectFile || !this.deps.attachmentRefs) this.fail("INTERNAL_ERROR", 500, "Attachment service is unavailable");
-    const userDigest = (0, import_node_crypto4.createHash)("sha256").update(userId, "utf8").digest("hex");
-    const contentDigest = (0, import_node_crypto4.createHash)("sha256").update(file.bytes).digest("hex");
+    const userDigest = (0, import_node_crypto6.createHash)("sha256").update(userId, "utf8").digest("hex");
+    const contentDigest = (0, import_node_crypto6.createHash)("sha256").update(file.bytes).digest("hex");
     const displayName = file.name;
-    const physicalName = `${(0, import_node_crypto4.randomUUID)()}-${sanitizePhysicalFilename(file.name)}`;
+    const physicalName = `${(0, import_node_crypto6.randomUUID)()}-${sanitizePhysicalFilename(file.name)}`;
     const saved = await this.deps.saveProjectFile({
       tenantId: runtime.webApp.tenantId,
       workspaceId: runtime.project.workspaceId,
@@ -15271,7 +15597,7 @@ ${formatFileRefsSection(refs)}` : input.content;
     const thread = await this.deps.threadStore.createThread(
       runtime.webApp.tenantId,
       runtime.webApp.assistantId,
-      (0, import_node_crypto4.randomUUID)(),
+      (0, import_node_crypto6.randomUUID)(),
       { metadata: this.metadata(runtime, userId, normalizeLabel(rawLabel)) }
     );
     return toRuntimeThread(thread);
@@ -15323,7 +15649,7 @@ function implicitThreadId(runtime, userId) {
     userId,
     runtime.project.id
   ]);
-  const bytes = (0, import_node_crypto4.createHash)("sha256").update(canonicalTuple, "utf8").digest().subarray(0, 16);
+  const bytes = (0, import_node_crypto6.createHash)("sha256").update(canonicalTuple, "utf8").digest().subarray(0, 16);
   bytes[6] = bytes[6] & 15 | 128;
   bytes[8] = bytes[8] & 63 | 128;
   const hex = bytes.toString("hex");
@@ -15342,93 +15668,102 @@ function toRuntimeThread(thread) {
   };
 }
 
-// src/services/agent-web-app/AgentWebAppStreamProjector.ts
-var import_protocols12 = require("@axiom-lattice/protocols");
-function createAgentWebAppStreamProjectionContext(options = {}) {
-  return { startedToolIds: /* @__PURE__ */ new Set(), allowInterrupts: options.allowInterrupts ?? true, allowGenUI: options.allowGenUI ?? false };
-}
-function projectAgentWebAppChunk(chunk, context) {
-  if (chunk.type === import_protocols12.MessageChunkTypes.AI) {
-    const events = [];
-    const startedToolIds = context?.startedToolIds ?? /* @__PURE__ */ new Set();
-    if (typeof chunk.data.content === "string" && chunk.data.content) events.push({ type: "message.delta", text: chunk.data.content });
-    if (context?.allowGenUI && Array.isArray(chunk.data.content)) {
-      for (const value of chunk.data.content) {
-        const block = (0, import_protocols12.parseAgentWebAppGenUIBlock)(value);
-        if (block) events.push({ type: "genui.render", block });
-      }
-    }
-    for (const call of chunk.data.tool_call_chunks ?? []) {
-      if (call.id && call.name && !startedToolIds.has(call.id)) {
-        startedToolIds.add(call.id);
-        events.push({ type: "tool.started", id: call.id, name: call.name });
-      }
-    }
-    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 === import_protocols12.MessageChunkTypes.TOOL && chunk.data.tool_call_id) {
-    return [{ type: "tool.completed", id: chunk.data.tool_call_id }];
-  }
-  if (chunk.type === import_protocols12.MessageChunkTypes.INTERRUPT) {
-    if (context && !context.allowInterrupts) return [{ type: "stream.completed" }];
-    const interrupt = publicInterrupt(chunk);
-    return interrupt ? [{ type: "interrupt.created", interrupt }, { type: "stream.completed" }] : [{ type: "stream.completed" }];
-  }
-  if (chunk.type === import_protocols12.MessageChunkTypes.MESSAGE_COMPLETED) {
-    return [
-      { type: "message.completed", messageId: chunk.data.id },
-      { type: "stream.completed" }
-    ];
-  }
-  if (chunk.type === import_protocols12.MessageChunkTypes.MESSAGE_FAILED) {
-    return [
-      { type: "error", error: { code: "STREAM_FAILED", message: "Stream failed", retryable: true } },
-      { type: "stream.completed" }
-    ];
+// src/services/agent-web-app/AgentWebAppTokenVerifier.ts
+var import_node_crypto7 = require("crypto");
+var WebAppTokenError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebAppTokenError";
   }
-  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 (0, import_node_crypto7.createPublicKey)({ key: jwk, format: "jwk" });
+}
+async function verifyWebAppToken(token, issuer, options = {}) {
+  const nowMs = options.now ? options.now() : Date.now();
+  const now = Math.floor(nowMs / 1e3);
+  if (token.length === 0 || Buffer.byteLength(token) > MAX_TOKEN_BYTES) throw new WebAppTokenError("Token size invalid");
+  const parts = token.split(".");
+  if (parts.length !== 3) throw new WebAppTokenError("Token structure invalid");
+  const [rawHeader, rawPayload, rawSignature] = parts;
+  const header2 = decodeSegment(rawHeader);
+  const payload = decodeSegment(rawPayload);
+  if (header2.alg !== issuer.alg) throw new WebAppTokenError("Token algorithm mismatch");
+  if (payload.iss !== issuer.iss) throw new WebAppTokenError("Token issuer mismatch");
+  if (payload.aud !== issuer.aud) throw new WebAppTokenError("Token audience mismatch");
+  const exp = typeof payload.exp === "number" ? payload.exp : void 0;
+  if (exp === void 0 || exp + CLOCK_SKEW_SECONDS < now) throw new WebAppTokenError("Token expired");
+  const nbf = typeof payload.nbf === "number" ? payload.nbf : void 0;
+  if (nbf !== void 0 && nbf - CLOCK_SKEW_SECONDS > now) throw new WebAppTokenError("Token not yet valid");
+  const signature = Buffer.from(rawSignature, "base64url");
+  const data = Buffer.from(`${rawHeader}.${rawPayload}`);
+  if (issuer.alg === "HS256") {
+    if (typeof issuer.secret !== "string" || issuer.secret.length === 0) throw new WebAppTokenError("Issuer secret missing");
+    const expected = (0, import_node_crypto7.createHmac)("sha256", issuer.secret).update(data).digest();
+    if (signature.length !== expected.length || !(0, import_node_crypto7.timingSafeEqual)(signature, expected)) {
+      throw new WebAppTokenError("Token signature invalid");
+    }
+  } else {
+    if (typeof issuer.jwksUrl !== "string") throw new WebAppTokenError("Issuer JWKS URL missing");
+    const key = await resolveKey(issuer, typeof header2.kid === "string" ? header2.kid : void 0, options.fetchImpl ?? fetch);
+    let valid = false;
+    try {
+      valid = (0, import_node_crypto7.verify)("RSA-SHA256", data, key, signature);
+    } catch {
+      valid = false;
+    }
+    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
+var import_protocols12 = require("@axiom-lattice/protocols");
 var idSchema = import_zod6.z.string().min(1).max(128);
 var paramsSchema = import_zod6.z.object({ webAppId: idSchema }).strict();
 var threadParamsSchema = import_zod6.z.object({ webAppId: idSchema, threadId: idSchema }).strict();
 var interruptParamsSchema = import_zod6.z.object({ webAppId: idSchema, threadId: idSchema, interruptId: idSchema }).strict();
+var pendingMessageParamsSchema = import_zod6.z.object({ webAppId: idSchema, threadId: idSchema, messageId: idSchema }).strict();
 var bootstrapQuerySchema = import_zod6.z.object({ projectId: idSchema.optional(), modelKey: idSchema.optional() }).strict();
 var projectQuerySchema = import_zod6.z.object({ projectId: idSchema.optional() }).strict();
+var projectQueryLenientSchema = projectQuerySchema.passthrough();
 var threadBodySchema = import_zod6.z.object({ projectId: idSchema.optional(), label: import_zod6.z.string().max(128).optional() }).strict();
 var streamBodySchema = import_zod6.z.object({
   content: import_zod6.z.string().trim().min(1).max(32768),
@@ -15447,8 +15782,27 @@ var resumeBodySchema = import_zod6.z.object({
   ])
 }).strict();
 var MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+var stateQuerySchema = import_zod6.z.object({
+  threadId: idSchema,
+  projectId: idSchema.optional(),
+  modelKey: idSchema.optional()
+}).strict();
+var resumeSchema = import_zod6.z.object({
+  messageId: idSchema,
+  projectId: idSchema.optional(),
+  modelKey: idSchema.optional()
+}).strict();
+var devTokenSchema = import_zod6.z.object({
+  iss: import_zod6.z.string().min(1).max(255).optional(),
+  sub: import_zod6.z.string().regex(/^[A-Za-z0-9._:@-]+$/).max(128).optional(),
+  hours: import_zod6.z.number().gt(0).max(720).optional()
+}).strict();
+var fileQuerySchema = import_zod6.z.object({
+  projectId: idSchema.optional(),
+  modelKey: idSchema.optional()
+}).passthrough();
 function createExternalHeaderIdentityResolver() {
-  return { resolve(request) {
+  return { async resolve(request) {
     const raw = request.headers["x-axiom-external-user-id"];
     if (raw === void 0) throw new AgentWebAppRuntimeError("USER_ID_REQUIRED", 401, "External user id is required");
     if (Array.isArray(raw) || typeof raw !== "string") throw new AgentWebAppRuntimeError("INVALID_USER_ID", 400, "External user id is invalid");
@@ -15457,47 +15811,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);
@@ -15506,15 +15922,27 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
         return normalizeError2(reply, error);
       }
     });
+    routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/resume", async (request, reply) => {
+      try {
+        const { webAppId, threadId } = threadParamsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const { messageId, projectId, modelKey: modelKey2 } = resumeSchema.parse(request.body);
+        const result = await deps.service.resumeStream(webAppId, identity.userId, threadId, messageId, withPreview({ projectId, modelKey: modelKey2 }, identity.preview));
+        beginSse(reply);
+        await pipeNativeWebAppStream(reply.raw, result.stream);
+      } catch (error) {
+        return normalizeError2(reply, error);
+      }
+    });
     routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/abort", async (request, reply) => handle2(reply, async () => {
       const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       await deps.service.abort(webAppId, identity.userId, threadId, withPreview(projectQuerySchema.parse(request.query), identity.preview));
       return { data: { aborted: true } };
     }));
     routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/attachments", async (request, reply) => handle2(reply, async () => {
       const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       if (!request.isMultipart()) throw new import_zod6.ZodError([]);
       const part = await request.file({ limits: { files: 1, fileSize: MAX_ATTACHMENT_BYTES } });
       if (!part || !part.filename || part.filename.length > 255) throw new import_zod6.ZodError([]);
@@ -15530,7 +15958,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);
@@ -15539,34 +15967,287 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
         return normalizeError2(reply, error);
       }
     });
+    routes.post("/api/web-apps/:webAppId/dev/token", async (request, reply) => handle2(reply, async () => {
+      if (process.env.WEB_APP_DEV_TOKEN_ENABLED !== "true") {
+        throw new AgentWebAppRuntimeError("FEATURE_DISABLED", 403, "Dev token issuance is disabled (set WEB_APP_DEV_TOKEN_ENABLED=true)");
+      }
+      const { webAppId } = paramsSchema.parse(request.params);
+      const { iss, sub, hours } = devTokenSchema.parse(request.body ?? {});
+      const config = await deps.service.getIdentityConfig(webAppId);
+      const issuer = (config?.issuers ?? []).find((entry) => entry.alg === "HS256" && (iss === void 0 || entry.iss === iss));
+      if (!issuer || typeof issuer.secret !== "string") {
+        throw new AgentWebAppRuntimeError("INVALID_REQUEST", 400, "Web app has no HS256 issuer configured");
+      }
+      const now = Math.floor(Date.now() / 1e3);
+      const expiresIn = (hours ?? 24) * 3600;
+      const subject = sub ?? "dev-user";
+      const b64url = (input) => Buffer.from(input).toString("base64url");
+      const body = `${b64url(JSON.stringify({ alg: "HS256", typ: "JWT" }))}.${b64url(JSON.stringify({ sub: subject, iss: issuer.iss, aud: issuer.aud, iat: now, exp: now + expiresIn }))}`;
+      const token = `${body}.${(0, import_node_crypto8.createHmac)("sha256", issuer.secret).update(body).digest("base64url")}`;
+      return { data: { token, tokenType: "Bearer", expiresIn, subject } };
+    }));
+    if (deps.taskController) {
+      const tasks = deps.taskController;
+      const withSubject = (handler) => async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const proxy = Object.create(request);
+        proxy.headers = { ...request.headers, "x-user-id": identity.userId };
+        return handler(proxy, reply);
+      };
+      routes.get("/api/web-apps/:webAppId/runtime/tasks", withSubject((request, reply) => tasks.list(request, reply)));
+      routes.post("/api/web-apps/:webAppId/runtime/tasks", withSubject((request, reply) => tasks.create(request, reply)));
+      routes.get("/api/web-apps/:webAppId/runtime/tasks/:taskId", withSubject((request, reply) => tasks.get(request, reply)));
+      routes.put("/api/web-apps/:webAppId/runtime/tasks/:taskId", withSubject((request, reply) => tasks.update(request, reply)));
+      routes.patch("/api/web-apps/:webAppId/runtime/tasks/:taskId", withSubject((request, reply) => tasks.update(request, reply)));
+      routes.delete("/api/web-apps/:webAppId/runtime/tasks/:taskId", withSubject((request, reply) => tasks.remove(request, reply)));
+      routes.patch("/api/web-apps/:webAppId/runtime/tasks/:taskId/complete", withSubject((request, reply) => tasks.complete(request, reply)));
+      routes.get("/api/web-apps/:webAppId/runtime/tasks/:taskId/work-items", withSubject((request, reply) => tasks.workItems(request, reply)));
+    }
+    if (deps.workspaceController) {
+      const workspace = deps.workspaceController;
+      const fileScope = async (webAppId, selection) => {
+        const scope = await deps.service.resolveFileScope(webAppId, selection);
+        if (!scope.enabled) throw new AgentWebAppRuntimeError("FEATURE_DISABLED", 403, "Files are disabled for this web app");
+        return scope;
+      };
+      const scopedRequest = (request, scope, params, query) => {
+        const proxy = Object.create(request);
+        proxy.params = params;
+        proxy.query = query;
+        proxy.headers = { ...request.headers, "x-tenant-id": scope.tenantId };
+        return proxy;
+      };
+      const unwrap = (result) => ({ data: result.data });
+      routes.get("/api/web-apps/:webAppId/runtime/files/listpath", async (request) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        const result = await workspace.listPath(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query));
+        return unwrap(result);
+      });
+      routes.get("/api/web-apps/:webAppId/runtime/files/readfile", async (request) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        const result = await workspace.readFile(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query));
+        return unwrap(result);
+      });
+      routes.post("/api/web-apps/:webAppId/runtime/files/uploadfile", async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const scoped = scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, { assistantId: scope.assistantId });
+        await workspace.uploadFile(scoped, reply);
+        return reply;
+      });
+      routes.get("/api/web-apps/:webAppId/runtime/files/viewfile", async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        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 identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        await workspace.downloadFile(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query), reply);
+        return reply;
+      });
+      routes.get("/api/web-apps/:webAppId/runtime/files/downloadfolder", async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        await workspace.downloadFolder(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query), reply);
+        return reply;
+      });
+      const genuiSandboxParams = import_zod6.z.object({ webAppId: idSchema, assistantId: idSchema, threadId: idSchema }).strict();
+      const delegateGenuiFile = (method) => async (request, reply) => {
+        const { webAppId } = genuiSandboxParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        await method(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query), reply);
+        return reply;
+      };
+      routes.get("/api/web-apps/:webAppId/runtime/assistants/:assistantId/threads/:threadId/sandbox/downloadfile", delegateGenuiFile(workspace.downloadFile.bind(workspace)));
+      routes.get("/api/web-apps/:webAppId/runtime/assistants/:assistantId/threads/:threadId/sandbox/viewfile", delegateGenuiFile(workspace.viewFile.bind(workspace)));
+    }
+    const mirrorThreadParams = import_zod6.z.object({ webAppId: idSchema, assistantId: idSchema, threadId: idSchema }).strict();
+    const mirrorBody = import_zod6.z.object({ metadata: import_zod6.z.object({ label: import_zod6.z.string().max(300).optional() }).strict().optional(), projectId: idSchema.optional(), modelKey: idSchema.optional() }).strict();
+    const toConsoleThread = (thread, assistantId) => ({
+      id: thread.id,
+      assistantId,
+      metadata: thread.label ? { label: thread.label } : {},
+      createdAt: thread.createdAt,
+      updatedAt: thread.updatedAt
+    });
+    const mirrorAssistantParams = import_zod6.z.object({ webAppId: idSchema, assistantId: idSchema }).strict();
+    const mirrorPendingParams = import_zod6.z.object({ webAppId: idSchema, assistantId: idSchema, threadId: idSchema, messageId: idSchema }).strict();
+    const registerMirror = (prefix) => {
+      routes.get(`${prefix}/assistants/:assistantId/threads`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, assistantId } = mirrorAssistantParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const threads = await deps.service.listThreads(webAppId, identity.userId, projectQueryLenientSchema.parse(request.query));
+        return { data: { records: threads.map((thread) => toConsoleThread(thread, assistantId)) } };
+      }));
+      routes.post(`${prefix}/assistants/:assistantId/threads`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, assistantId } = mirrorAssistantParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const body = mirrorBody.parse(request.body ?? {});
+        const created = await deps.service.createThread(webAppId, identity.userId, { label: body.metadata?.label, ...body.projectId ? { projectId: body.projectId } : {} });
+        return { statusCode: 201, data: { id: created.id } };
+      }));
+      routes.get(`${prefix}/assistants/:assistantId/threads/:threadId`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, assistantId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const thread = await deps.service.getThread(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+        return { data: toConsoleThread(thread, assistantId) };
+      }));
+      routes.put(`${prefix}/assistants/:assistantId/threads/:threadId`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, assistantId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const body = mirrorBody.parse(request.body ?? {});
+        const updated = await deps.service.updateThread(webAppId, identity.userId, threadId, { label: body.metadata?.label, ...body.projectId ? { projectId: body.projectId } : {} });
+        return { data: toConsoleThread(updated, assistantId) };
+      }));
+      routes.delete(`${prefix}/assistants/:assistantId/threads/:threadId`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        await deps.service.deleteThread(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+        return { data: { success: true, message: "Thread deleted" } };
+      }));
+      routes.post(`${prefix}/assistants/:assistantId/threads/:threadId/sandbox/uploadfile`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        if (!request.isMultipart()) throw new import_zod6.ZodError([]);
+        const part = await request.file({ limits: { files: 1, fileSize: MAX_ATTACHMENT_BYTES } });
+        if (!part || !part.filename || part.filename.length > 255) throw new import_zod6.ZodError([]);
+        const bytes = await part.toBuffer();
+        if (bytes.length === 0 || part.file.truncated) throw new import_zod6.ZodError([]);
+        const uploaded = await deps.service.uploadAttachment(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query), {
+          name: part.filename,
+          mimeType: part.mimetype || "application/octet-stream",
+          bytes
+        });
+        return { statusCode: 201, data: { id: uploaded.ref, path: uploaded.ref, name: uploaded.name, mimeType: uploaded.mimeType, size: uploaded.size } };
+      }));
+      routes.get(`${prefix}/assistants/:assistantId/:threadId/memory`, async (request) => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const messages = await deps.service.getConsoleMessages(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+        return messages;
+      });
+      routes.get(`${prefix}/assistants/:assistantId/:threadId/state`, async (request) => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        return deps.service.getState(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+      });
+      routes.delete(`${prefix}/assistants/:assistantId/threads/:threadId/pending-messages/:messageId`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, threadId, messageId } = mirrorPendingParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        await deps.service.removePendingMessage(webAppId, identity.userId, threadId, messageId, projectQueryLenientSchema.parse(request.query));
+        return { data: { removed: true } };
+      }));
+      routes.post(`${prefix}/assistants/:assistantId/threads/:threadId/abort`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        await deps.service.abort(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+        return { data: { aborted: true } };
+      }));
+      const runsBodySchema = import_zod6.z.object({
+        thread_id: idSchema.optional(),
+        assistant_id: idSchema.optional(),
+        messages: import_zod6.z.array(import_zod6.z.object({ content: import_zod6.z.string().min(1).max(32768) }).passthrough()).min(1).max(20),
+        background: import_zod6.z.boolean().optional(),
+        streaming: import_zod6.z.boolean().optional(),
+        projectId: idSchema.optional(),
+        modelKey: idSchema.optional()
+      }).passthrough();
+      routes.post(`${prefix}/runs`, async (request, reply) => {
+        try {
+          const { webAppId } = paramsSchema.parse(request.params);
+          const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+          const body = runsBodySchema.parse(request.body ?? {});
+          if (!body.background || body.streaming) {
+            throw new AgentWebAppRuntimeError("INVALID_REQUEST", 400, "Mirror runs supports only background enqueue (stream via resume_stream)");
+          }
+          const threadId = body.thread_id ?? "";
+          if (!threadId) throw new AgentWebAppRuntimeError("INVALID_REQUEST", 400, "thread_id is required");
+          const content = body.messages.map((message) => message.content).join("\n");
+          const { messageId } = await deps.service.enqueueMessage(webAppId, identity.userId, threadId, content, { projectId: body.projectId, modelKey: body.modelKey });
+          return reply.code(202).send({ success: true, messageId, queued: true });
+        } catch (error) {
+          return normalizeError2(reply, error);
+        }
+      });
+      const resumeStreamSchema2 = import_zod6.z.object({
+        assistant_id: idSchema.optional(),
+        thread_id: idSchema,
+        message_id: idSchema,
+        known_content: import_zod6.z.string().optional(),
+        poll_interval: import_zod6.z.number().optional(),
+        projectId: idSchema.optional(),
+        modelKey: idSchema.optional()
+      }).strict();
+      routes.post(`${prefix}/resume_stream`, async (request, reply) => {
+        try {
+          const { webAppId } = paramsSchema.parse(request.params);
+          const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+          const body = resumeStreamSchema2.parse(request.body ?? {});
+          const result = await deps.service.resumeStream(webAppId, identity.userId, body.thread_id, body.message_id, { projectId: body.projectId, modelKey: body.modelKey });
+          beginSse(reply);
+          await pipeNativeWebAppStream(reply.raw, result.stream);
+        } catch (error) {
+          return normalizeError2(reply, error);
+        }
+      });
+    };
+    registerMirror("/api/web-apps/:webAppId/runtime");
+    registerMirror("/api/web-apps/:webAppId/runtime/api");
   });
 }
-function resolveRuntimeIdentity(request, webAppId, identities) {
-  if (request.headers["x-axiom-web-app-preview"] !== "true") return identities.resolve(request);
+async function resolveRuntimeIdentity(request, webAppId, identities) {
+  if (request.headers["x-axiom-web-app-preview"] !== "true") return identities.resolve(request, webAppId);
   const user = request.user;
   if (!user?.id || !user.tenantId) throw new AgentWebAppRuntimeError("USER_ID_REQUIRED", 401, "Authenticated Console preview is required");
-  return { userId: `console-preview:${user.id}:${webAppId}`, preview: { tenantId: user.tenantId, userId: user.id } };
+  return { userId: `console-preview:${user.id}:${webAppId}`, assurance: "unverified", preview: { tenantId: user.tenantId, userId: user.id } };
 }
 function withPreview(selection, preview) {
   return { ...selection, ...preview ? { preview } : {} };
 }
 async function pipeAgentWebAppStream(raw, stream, options = {}) {
-  const projection = createAgentWebAppStreamProjectionContext(options);
+  const projection = (0, import_protocols12.createAgentWebAppStreamProjectionContext)(options);
   await pipeAsyncIterableToSse(raw, stream, {
-    project: (chunk) => projectAgentWebAppChunk(chunk, projection),
+    project: (chunk) => (0, import_protocols12.projectAgentWebAppChunk)(chunk, projection),
     onError: () => [
       { type: "error", error: { code: "STREAM_FAILED", message: "Stream failed", retryable: true } },
       { type: "stream.completed" }
     ]
   });
 }
+async function pipeNativeWebAppStream(raw, stream) {
+  await pipeAsyncIterableToSse(raw, stream, {
+    onError: () => [{
+      type: "error",
+      data: { id: "", content: "Stream failed" }
+    }]
+  });
+}
 function beginSse(reply) {
   reply.hijack();
   reply.raw.writeHead(200, {
     "Content-Type": "text/event-stream; charset=utf-8",
     "Cache-Control": "no-cache, no-transform",
     Connection: "keep-alive",
-    "X-Accel-Buffering": "no"
+    "X-Accel-Buffering": "no",
+    "Access-Control-Allow-Origin": "*"
   });
 }
 async function handle2(reply, operation) {
@@ -15588,7 +16269,7 @@ function isMultipartRequestError(error) {
 }
 
 // src/services/agent-web-app/AgentWebAppAttachmentRef.ts
-var import_node_crypto5 = require("crypto");
+var import_node_crypto9 = require("crypto");
 var TTL_MS = 15 * 6e4;
 function resolveAgentWebAppAttachmentSecret(consoleSecret) {
   return process.env.WEB_APP_ATTACHMENT_SECRET || process.env.AUTH_TOKEN_SECRET || process.env.JWT_SECRET || consoleSecret;
@@ -15597,7 +16278,7 @@ var AgentWebAppAttachmentRefService = class {
   constructor(secret, now = Date.now) {
     this.now = now;
     if (!secret) throw new Error("Attachment signing secret is required");
-    this.key = (0, import_node_crypto5.createHash)("sha256").update(secret, "utf8").digest();
+    this.key = (0, import_node_crypto9.createHash)("sha256").update(secret, "utf8").digest();
   }
   sign(input) {
     const payload = {
@@ -15612,8 +16293,8 @@ var AgentWebAppAttachmentRefService = class {
       contentDigest: input.contentDigest,
       exp: this.now() + TTL_MS
     };
-    const iv = (0, import_node_crypto5.randomBytes)(12);
-    const cipher = (0, import_node_crypto5.createCipheriv)("aes-256-gcm", this.key, iv);
+    const iv = (0, import_node_crypto9.randomBytes)(12);
+    const cipher = (0, import_node_crypto9.createCipheriv)("aes-256-gcm", this.key, iv);
     const ciphertext = Buffer.concat([
       cipher.update(JSON.stringify(payload), "utf8"),
       cipher.final()
@@ -15628,7 +16309,7 @@ var AgentWebAppAttachmentRefService = class {
       const iv = decodeCanonical(encodedIv, 12);
       const ciphertext = decodeCanonical(encodedCiphertext);
       const tag = decodeCanonical(encodedTag, 16);
-      const decipher = (0, import_node_crypto5.createDecipheriv)("aes-256-gcm", this.key, iv);
+      const decipher = (0, import_node_crypto9.createDecipheriv)("aes-256-gcm", this.key, iv);
       decipher.setAuthTag(tag);
       const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
       const value = JSON.parse(plaintext.toString("utf8"));
@@ -15659,7 +16340,7 @@ function decodeCanonical(value, expectedBytes) {
   return decoded;
 }
 function digestUser(userId) {
-  return (0, import_node_crypto5.createHash)("sha256").update(userId, "utf8").digest("hex");
+  return (0, import_node_crypto9.createHash)("sha256").update(userId, "utf8").digest("hex");
 }
 function isAttachmentPayload(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
@@ -16023,12 +16704,12 @@ function registerCapabilityBundleRoutes(app2, controller) {
 }
 
 // src/services/collaboration/ProjectRoomService.ts
-var import_node_crypto6 = require("crypto");
+var import_node_crypto10 = require("crypto");
 var ProjectRoomService = class {
   /** Creates a project room service from explicitly injected collaborators. */
   constructor(deps) {
     this.deps = deps;
-    this.idFactory = deps.idFactory ?? import_node_crypto6.randomUUID;
+    this.idFactory = deps.idFactory ?? import_node_crypto10.randomUUID;
   }
   /** Authorizes read access and atomically ensures the project's main room. */
   async ensureMainRoom(input) {
@@ -16047,7 +16728,7 @@ var ProjectRoomService = class {
 };
 
 // src/services/collaboration/ProjectMembershipService.ts
-var import_node_crypto7 = require("crypto");
+var import_node_crypto11 = require("crypto");
 var ProjectMembershipServiceError = class extends Error {
   constructor(code, statusCode, message) {
     super(message);
@@ -16063,11 +16744,13 @@ function isMembershipConflict(error) {
 var ProjectMembershipService = class {
   constructor(deps) {
     this.deps = deps;
-    this.idFactory = deps.idFactory ?? import_node_crypto7.randomUUID;
+    this.idFactory = deps.idFactory ?? import_node_crypto11.randomUUID;
     this.mutationMutex = deps.projectMutationMutex ?? import_core41.projectMutationMutex;
   }
   async list(actor2) {
-    await this.authorize(actor2);
+    await this.deps.accessService.requireRosterAccess(actor2);
+    const membership = await this.deps.membershipStore.findByUser(actor2.tenantId, actor2.projectId, actor2.userId);
+    if (!membership || membership.status !== "active") this.accessDenied();
     return this.deps.membershipStore.list(actor2.tenantId, actor2.projectId);
   }
   async add(actor2, input) {
@@ -16187,7 +16870,7 @@ var ProjectMembershipService = class {
 };
 
 // src/services/collaboration/ProjectRosterService.ts
-var import_node_crypto8 = require("crypto");
+var import_node_crypto12 = require("crypto");
 var ProjectRosterServiceError = class extends Error {
   /** Creates a stable roster service error. */
   constructor(code, statusCode, message) {
@@ -16204,7 +16887,7 @@ var ProjectRosterService = class {
   /** Creates a roster service from explicitly injected collaborators. */
   constructor(deps) {
     this.deps = deps;
-    this.idFactory = deps.idFactory ?? import_node_crypto8.randomUUID;
+    this.idFactory = deps.idFactory ?? import_node_crypto12.randomUUID;
     this.mutationMutex = deps.projectMutationMutex ?? import_core41.projectMutationMutex;
   }
   /** Lists all bot memberships visible to a project reader. */
@@ -16424,7 +17107,7 @@ var ProjectRosterService = class {
 };
 
 // src/services/collaboration/RoomMessageService.ts
-var import_node_crypto9 = require("crypto");
+var import_node_crypto13 = require("crypto");
 
 // src/services/collaboration/ProjectBotMembershipSnapshot.ts
 var import_protocols13 = require("@axiom-lattice/protocols");
@@ -16513,7 +17196,7 @@ var RoomMessageService = class {
   constructor(deps, options = {}) {
     this.deps = deps;
     this.idempotentOutcomes = /* @__PURE__ */ new Map();
-    this.idFactory = deps.idFactory ?? import_node_crypto9.randomUUID;
+    this.idFactory = deps.idFactory ?? import_node_crypto13.randomUUID;
     const limit = options.idempotentOutcomeLimit ?? 1e3;
     if (!Number.isSafeInteger(limit) || limit < 1) throw new RangeError("idempotentOutcomeLimit must be a positive safe integer");
     this.idempotentOutcomeLimit = limit;
@@ -16694,7 +17377,7 @@ var RoomMessageService = class {
     let idempotencyKey;
     if (value.requestIdempotencyKey !== void 0) {
       if (typeof value.requestIdempotencyKey !== "string" || !/^[\x21-\x7e]{1,200}$/.test(value.requestIdempotencyKey.trim())) throw new RoomMessageServiceError("INVALID_MESSAGE", 400, "Invalid idempotency key");
-      idempotencyKey = `room-human:${actor2.userId}:${(0, import_node_crypto9.createHash)("sha256").update(value.requestIdempotencyKey.trim(), "utf8").digest("hex")}`;
+      idempotencyKey = `room-human:${actor2.userId}:${(0, import_node_crypto13.createHash)("sha256").update(value.requestIdempotencyKey.trim(), "utf8").digest("hex")}`;
     }
     return { text, mentions, botIds, ...value.replyToMessageId === void 0 ? {} : { replyToMessageId: value.replyToMessageId }, ...idempotencyKey === void 0 ? {} : { idempotencyKey } };
   }
@@ -16751,7 +17434,7 @@ function cloneRoomMessage(message) {
   };
 }
 function fingerprintRequest(input) {
-  return (0, import_node_crypto9.createHash)("sha256").update(JSON.stringify({
+  return (0, import_node_crypto13.createHash)("sha256").update(JSON.stringify({
     text: input.text,
     mentions: input.mentions,
     replyToMessageId: input.replyToMessageId ?? null
@@ -16920,42 +17603,9 @@ async function execute(reply, operation) {
 }
 
 // src/routes/cospace.ts
-var import_node_crypto10 = require("crypto");
+var import_node_crypto14 = require("crypto");
 var import_zod12 = require("zod");
 var import_core44 = require("@axiom-lattice/core");
-
-// src/services/collaboration/RoomCoordinatorProvisioner.ts
-var ROOM_COORDINATOR_KEY = "room-coordinator";
-var RoomCoordinatorProvisioner = class {
-  /** Creates a provisioner over the tenant-scoped assistant store operations. */
-  constructor(deps) {
-    this.deps = deps;
-  }
-  /**
-   * Ensures the Room Coordinator assistant exists, reusing an existing record
-   * and reconciling concurrent create races by rereading the winner.
-   *
-   * @param tenantId Tenant to provision the coordinator for.
-   * @returns The persisted Room Coordinator assistant.
-   */
-  async ensure(tenantId) {
-    const existing = await this.deps.getAssistantById(tenantId, ROOM_COORDINATOR_KEY);
-    if (existing) return existing;
-    try {
-      return await this.deps.createAssistant(tenantId, ROOM_COORDINATOR_KEY, {
-        name: "Room Coordinator",
-        description: "Coordinates project room conversations and organizes room work.",
-        graphDefinition: {}
-      });
-    } catch (error) {
-      const winner = await this.deps.getAssistantById(tenantId, ROOM_COORDINATOR_KEY);
-      if (winner) return winner;
-      throw error;
-    }
-  }
-};
-
-// src/routes/cospace.ts
 var CoSpaceAuthError = class extends Error {
   constructor() {
     super(...arguments);
@@ -16971,7 +17621,7 @@ function getActor2(request) {
   return { tenantId: user.tenantId, userId: user.id };
 }
 function registerCoSpaceRoutes(app2, deps) {
-  const idFactory = deps.idFactory ?? (() => (0, import_node_crypto10.randomUUID)());
+  const idFactory = deps.idFactory ?? (() => (0, import_node_crypto14.randomUUID)());
   app2.get(
     "/api/workspaces/:workspaceId/rooms",
     async (request, reply) => {
@@ -16996,6 +17646,7 @@ function registerCoSpaceRoutes(app2, deps) {
         );
         const accessibleProjects = [];
         for (const project of allProjects) {
+          if (project.kind === "public") continue;
           const membership = await deps.membershipStore.findByUser(
             actor2.tenantId,
             project.id,
@@ -17049,6 +17700,34 @@ function registerCoSpaceRoutes(app2, deps) {
           const bTime = b.lastMessage?.createdAt?.getTime() ?? 0;
           return bTime - aTime;
         });
+        const publicRoom = await deps.publicRoom.ensure(actor2.tenantId, params.workspaceId);
+        if (publicRoom) {
+          const publicMessages = await deps.messageStore.list({
+            tenantId: actor2.tenantId,
+            roomId: publicRoom.room.id,
+            limit: 1
+          });
+          const publicMemberships = await deps.membershipStore.list(
+            actor2.tenantId,
+            publicRoom.project.id
+          );
+          const publicParticipantNames = [];
+          for (const m of publicMemberships) {
+            if (m.status !== "active") continue;
+            const user = await deps.userStore.getUserById(m.userId);
+            if (user) {
+              publicParticipantNames.push(user.name);
+            }
+          }
+          rooms.unshift({
+            project: publicRoom.project,
+            room: publicRoom.room,
+            lastMessage: publicMessages[0],
+            participantCount: publicMemberships.filter((m) => m.status === "active").length,
+            participantNames: publicParticipantNames,
+            isPublic: true
+          });
+        }
         return { data: { rooms } };
       });
     }
@@ -17805,7 +18484,7 @@ function exactValues(value, required, optional = []) {
 }
 
 // src/services/collaboration/CoordinatorWakeNotifier.ts
-var import_node_crypto11 = require("crypto");
+var import_node_crypto15 = require("crypto");
 var import_core45 = require("@axiom-lattice/core");
 var import_protocols15 = require("@axiom-lattice/protocols");
 var SYNTHETIC_WAKE_AUTHOR = "coordinator-wake";
@@ -17820,7 +18499,7 @@ var CoordinatorWakeNotifier = class {
     this.accepted = /* @__PURE__ */ new Set();
     this.maxPending = deps.maxPending ?? 1024;
     if (!Number.isSafeInteger(this.maxPending) || this.maxPending < 1) throw new RangeError("maxPending must be a positive safe integer");
-    this.idFactory = deps.idFactory ?? import_node_crypto11.randomUUID;
+    this.idFactory = deps.idFactory ?? import_node_crypto15.randomUUID;
   }
   /** Admits one notification without awaiting any store or dispatch operation. */
   handle(value) {
@@ -18683,7 +19362,7 @@ function validRecoveryRow(row, task, thread) {
 }
 
 // src/services/collaboration/ProjectTaskObserver.ts
-var import_node_crypto12 = require("crypto");
+var import_node_crypto16 = require("crypto");
 var import_core47 = require("@axiom-lattice/core");
 var SYSTEM_ACTOR2 = "system";
 var TERMINAL_ACTIONS = ["completed", "failed", "interrupted", "cancelled"];
@@ -19220,7 +19899,7 @@ var ProjectTaskObserver = class {
       action: "activity",
       summary: "Project task recovery warning",
       detail: { type: "project_task_recovery_warning", phase, message },
-      eventKey: `project-task-recovery-warning:${task.id}:${phase}:${(0, import_node_crypto12.createHash)("sha256").update(message).digest("hex")}`
+      eventKey: `project-task-recovery-warning:${task.id}:${phase}:${(0, import_node_crypto16.createHash)("sha256").update(message).digest("hex")}`
     });
   }
   async safeWarning(task, phase, error) {
@@ -19287,7 +19966,7 @@ var ProjectTaskObserver = class {
     }
   }
   async persistOverflowWarning(event) {
-    const scopeDigest = (0, import_node_crypto12.createHash)("sha256").update(JSON.stringify([event.tenantId, event.workspaceId, event.projectId])).digest("hex");
+    const scopeDigest = (0, import_node_crypto16.createHash)("sha256").update(JSON.stringify([event.tenantId, event.workspaceId, event.projectId])).digest("hex");
     try {
       await this.deps.workItems.createIfAbsentByEventKey({
         tenantId: event.tenantId,
@@ -19388,7 +20067,7 @@ function combineSignals(left, right) {
 }
 
 // src/services/collaboration/RoomProjectionService.ts
-var import_node_crypto13 = require("crypto");
+var import_node_crypto17 = require("crypto");
 var import_core48 = require("@axiom-lattice/core");
 var import_protocols18 = require("@axiom-lattice/protocols");
 var RoomProjectionService = class {
@@ -19557,7 +20236,7 @@ function safeRepairIdentity(value, scope) {
   return taskId && eventKey && tenantId === scope.tenantId && workspaceId === scope.workspaceId && projectId === scope.projectId ? { taskId, eventKey } : void 0;
 }
 function tupleKey(prefix, values) {
-  const digest = (0, import_node_crypto13.createHash)("sha256").update(JSON.stringify(values)).digest("hex");
+  const digest = (0, import_node_crypto17.createHash)("sha256").update(JSON.stringify(values)).digest("hex");
   return `${prefix}:${digest}`;
 }
 function parseProjectionInput(taskValue, itemValue) {
@@ -19585,7 +20264,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 || !import_protocols18.PROJECT_TASK_LIFECYCLE_ACTIONS.includes(row.action) || row.threadId !== void 0 && typeof row.threadId !== "string" || row.summary !== void 0 && typeof row.summary !== "string" || row.attempt !== void 0 && (typeof row.attempt !== "number" || !Number.isFinite(row.attempt))) return void 0;
   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,
@@ -19732,7 +20411,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);
 }
 
@@ -19740,7 +20419,7 @@ function isRecord4(value) {
 var import_core50 = require("@axiom-lattice/core");
 
 // src/services/collaboration/ProjectRoomEventBroker.ts
-var import_node_crypto14 = require("crypto");
+var import_node_crypto18 = require("crypto");
 var import_protocols19 = require("@axiom-lattice/protocols");
 var DEFAULT_MAX_EVENTS_PER_ROOM = 1e3;
 var DEFAULT_MAX_EVENT_AGE_MS = 10 * 60 * 1e3;
@@ -19765,7 +20444,7 @@ var ProjectRoomEventBroker = class {
     this.subscriberCount = 0;
     this.usageClock = 0;
     this.closed = false;
-    this.epoch = options.epoch ?? (0, import_node_crypto14.randomUUID)();
+    this.epoch = options.epoch ?? (0, import_node_crypto18.randomUUID)();
     if (!UUID_PATTERN.test(this.epoch)) {
       throw new TypeError("Project Room event epoch must be a lowercase canonical UUID");
     }
@@ -20083,7 +20762,7 @@ function snapshotJson(value, ancestors = /* @__PURE__ */ new Set()) {
 }
 
 // src/services/collaboration/ProjectRoomRealtimePublisher.ts
-var import_node_crypto15 = require("crypto");
+var import_node_crypto19 = require("crypto");
 var import_protocols20 = require("@axiom-lattice/protocols");
 var BrokerProjectRoomRealtimePublisher = class {
   /** Creates a publisher around a broker and structured warning logger. */
@@ -20159,7 +20838,7 @@ var BrokerProjectRoomRealtimePublisher = class {
     try {
       event = build();
       if (!event) throw new Error("Invalid Project Room realtime projection");
-      const dedupeKey = (0, import_node_crypto15.createHash)("sha256").update(JSON.stringify([type, event.scope.tenantId, event.scope.projectId, event.scope.roomId, event.sourceKey])).digest("hex");
+      const dedupeKey = (0, import_node_crypto19.createHash)("sha256").update(JSON.stringify([type, event.scope.tenantId, event.scope.projectId, event.scope.roomId, event.sourceKey])).digest("hex");
       if (this.sourceKeys.has(dedupeKey)) return;
       this.deps.broker.publish(event.scope, event.draft);
       this.sourceKeys.set(dedupeKey, true);
@@ -21098,12 +21777,24 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     });
   }
   if (projectTaskComposition) app2.addHook("onClose", async () => projectTaskComposition.lease.release());
-  const taskThreadService = projectTaskComposition?.lease.runtime.threads ?? new ProjectTaskThreadService({ threads: threadStore, idFactory: import_node_crypto16.randomUUID });
+  const taskThreadService = projectTaskComposition?.lease.runtime.threads ?? new ProjectTaskThreadService({ threads: threadStore, idFactory: import_node_crypto20.randomUUID });
   const taskLifecycle = projectTaskComposition?.lease.runtime.lifecycle ?? (0, import_core51.createTaskLifecycleService)({ taskStore, workItemStore: taskWorkItemStore });
   const reassignmentAuthorizer = (0, import_core51.createProjectTaskReassignmentAuthorizer)(
     new import_core51.ProjectTaskOwnerPolicy(projectBotMembershipStore),
     (input) => validateReassignmentThread(threadStore, input)
   );
+  const coordinatorProvisioner = new RoomCoordinatorProvisioner({
+    getAssistantById: assistantStore.getAssistantById.bind(assistantStore),
+    createAssistant: assistantStore.createAssistant.bind(assistantStore)
+  });
+  const publicRoomService = new WorkspacePublicRoomService({
+    getProjectById: projectStore.getProjectById.bind(projectStore),
+    createProject: projectStore.createProject.bind(projectStore),
+    ensureMainRoom: projectRoomStore.ensureMainRoom.bind(projectRoomStore),
+    findBotByAssistant: projectBotMembershipStore.findByAssistant.bind(projectBotMembershipStore),
+    saveBot: projectBotMembershipStore.save.bind(projectBotMembershipStore),
+    ensureCoordinator: (tenantId) => coordinatorProvisioner.ensure(tenantId)
+  });
   registerProjectRoomRoutes(app2, { roomService, membershipService, messageService });
   registerProjectRosterRoutes(app2, { service: rosterService });
   registerCoSpaceRoutes(app2, {
@@ -21142,14 +21833,14 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       findByAssistant: projectBotMembershipStore.findByAssistant.bind(projectBotMembershipStore),
       save: projectBotMembershipStore.save.bind(projectBotMembershipStore)
     },
-    coordinatorProvisioner: new RoomCoordinatorProvisioner({
-      getAssistantById: assistantStore.getAssistantById.bind(assistantStore),
-      createAssistant: assistantStore.createAssistant.bind(assistantStore)
-    }),
+    coordinatorProvisioner,
     rosterService: {
       addBot: async (actor2, input) => {
         await rosterService.add(actor2, input);
       }
+    },
+    publicRoom: {
+      ensure: (tenantId, workspaceId) => publicRoomService.ensure(tenantId, workspaceId)
     }
   });
   registerCapabilityBundleRoutes(app2, new CapabilityBundleController({
@@ -21169,6 +21860,46 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     })
   });
   registerAgentWebAppRuntimeRoutes(app2, {
+    workspaceController: new WorkspaceController(createProjectCollaborationInitializer({
+      membershipStore: projectMembershipStore,
+      roomStore: projectRoomStore,
+      userTenantLinkStore
+    })),
+    taskController: createTaskController({
+      access: {
+        requireProjectAccess: async (input) => {
+          const apps = await webAppStore.list(input.tenantId);
+          const allowed = apps.some((app3) => app3.status === "active" && app3.scope.allowedProjectIds.includes(input.projectId));
+          if (!allowed) throw new ProjectCollaborationError("PROJECT_ACCESS_DENIED", 403, "Project is not exposed through this web app");
+          const project = await projectStore.getProjectById(input.tenantId, input.projectId);
+          if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
+          return {
+            project,
+            membership: {
+              id: `webapp_guest_${input.projectId}_${input.userId}`,
+              tenantId: input.tenantId,
+              projectId: input.projectId,
+              userId: input.userId,
+              role: "member",
+              status: "active",
+              joinedAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date()
+            }
+          };
+        }
+      },
+      tasks: taskStore,
+      workItems: taskWorkItemStore,
+      bots: projectBotMembershipStore,
+      rooms: projectRoomStore,
+      threadService: taskThreadService,
+      reassignmentAuthorizer,
+      lifecycle: taskLifecycle,
+      projectMutationMutex: import_core51.projectMutationMutex,
+      executionMutex: projectTaskComposition?.mutex ?? {
+        runExclusive: (_scope, operation) => operation()
+      }
+    }),
     service: new AgentWebAppRuntimeService({
       webAppStore,
       threadStore: (0, import_core51.getStoreLattice)("default", "thread").store,
@@ -21176,7 +21907,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       assistantResolver: {
         resolve: async (tenantId, assistantId) => {
           const stored = await assistantStore.getAssistantById(tenantId, assistantId);
-          if (stored) return stored;
+          if (stored) return { id: stored.id, name: stored.name, description: stored.description };
           await import_core51.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId);
           const config = import_core51.agentLatticeManager.getAgentConfigWithTenant(tenantId, assistantId);
           return config ? { id: assistantId, name: config.name, description: config.description } : null;
@@ -21590,7 +22321,7 @@ function tryCreateProjectTaskRuntime(input) {
 function createRuntime(input, stores, log2) {
   const controller = new AbortController();
   const mutex = new ProjectTaskExecutionMutex();
-  const threads = new ProjectTaskThreadService({ threads: input.threadStore, idFactory: import_node_crypto16.randomUUID });
+  const threads = new ProjectTaskThreadService({ threads: input.threadStore, idFactory: import_node_crypto20.randomUUID });
   const lifecycle = (0, import_core51.createTaskLifecycleService)({ taskStore: input.taskStore, workItemStore: input.taskWorkItemStore });
   const projection = new RoomProjectionService({
     messages: input.projectRoomMessageStore,
@@ -21599,7 +22330,7 @@ function createRuntime(input, stores, log2) {
     warnings: input.taskWorkItemStore,
     log: log2,
     realtime: input.realtime,
-    idFactory: import_node_crypto16.randomUUID
+    idFactory: import_node_crypto20.randomUUID
   });
   const agentFor = (task, thread) => import_core51.agentInstanceManager.getAgent({
     tenant_id: task.tenantId,