@axiom-lattice/gateway 4.2.2 → 4.2.4

package/dist/index.mjs

@@ -1,7 +1,8 @@
 import {
   getContentTypeFromFilename,
-  getFilenameFromPath
-} from "./chunk-LHQY46YB.mjs";
+  getFilenameFromPath,
+  sendBufferWithRange
+} from "./chunk-EMYRCJOI.mjs";
 import {
   buildPreviewTokenScript
 } from "./chunk-2POW27EI.mjs";
@@ -26,7 +27,7 @@ import {
   isPathWithinRoot,
   resolvePathWithinRoot,
   saveProjectFile
-} from "./chunk-J4BK77PA.mjs";
+} from "./chunk-YKTXW6F6.mjs";
 import "./chunk-NFEGQTCC.mjs";
 
 // src/index.ts
@@ -40,10 +41,10 @@ import staticPlugin from "@fastify/static";
 import path4 from "path";
 
 // src/routes/index.ts
-import { randomUUID as randomUUID19 } from "crypto";
+import { randomUUID as randomUUID22 } from "crypto";
 import {
   descriptorDataValue as descriptorDataValue3,
-  snapshotExactRecord as snapshotExactRecord13,
+  snapshotExactRecord as snapshotExactRecord14,
   ProjectTaskStoreUnsupportedError,
   requireProjectTaskWorkItemStore
 } from "@axiom-lattice/protocols";
@@ -1006,7 +1007,8 @@ var createRun = async (request, reply) => {
             type: "error",
             data: {
               id: v4(),
-              content: error instanceof Error ? error.message : "Stream processing error"
+              content: error instanceof Error ? error.message : "Stream processing error",
+              code: error?.code ?? "stream_error"
             }
           }]
         });
@@ -1077,7 +1079,8 @@ var resumeStream = async (request, reply) => {
           type: "error",
           data: {
             id: v4(),
-            content: error instanceof Error ? error.message : "Resume stream processing error"
+            content: error instanceof Error ? error.message : "Resume stream processing error",
+            code: error?.code ?? "stream_error"
           }
         }]
       });
@@ -5103,8 +5106,9 @@ function registerSandboxProxyRoutes(app2) {
         try {
           const buf = await sandbox.file.downloadFile({ file: resolvedPath });
           const contentDisposition = `inline; filename="${filename.replace(/"/g, '\\"')}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
-          reply = reply.status(200).type(inferredContentType).header("Content-Disposition", contentDisposition).send(buf);
-          return reply;
+          return sendBufferWithRange(reply, buf, inferredContentType, request.headers.range, {
+            "Content-Disposition": contentDisposition
+          });
         } catch (err) {
           reply.status(500).send({ error: String(err) });
           return;
@@ -5128,7 +5132,19 @@ import { getSandBoxManager as getSandBoxManager3 } from "@axiom-lattice/core";
 import { v4 as uuidv4 } from "uuid";
 
 // src/services/collaboration/RoomCoordinatorProvisioner.ts
+import { roomCoordinatorConfig } from "@axiom-lattice/core";
 var ROOM_COORDINATOR_KEY = "room-coordinator";
+var ROOM_COORDINATOR_ASSISTANT_INPUT = {
+  name: "Room Coordinator",
+  description: "Coordinates project room conversations and organizes room work.",
+  graphDefinition: roomCoordinatorConfig
+};
+function needsConfigRepair(assistant) {
+  const graph = assistant.graphDefinition;
+  if (typeof graph !== "object" || graph === null || Array.isArray(graph)) return true;
+  const record = graph;
+  return typeof record.type !== "string" || !Array.isArray(record.middleware);
+}
 var RoomCoordinatorProvisioner = class {
   /** Creates a provisioner over the tenant-scoped assistant store operations. */
   constructor(deps) {
@@ -5143,13 +5159,17 @@ var RoomCoordinatorProvisioner = class {
    */
   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: {}
+    if (existing) {
+      if (!needsConfigRepair(existing)) return existing;
+      const repaired = await this.deps.updateAssistant(tenantId, ROOM_COORDINATOR_KEY, {
+        name: existing.name ?? ROOM_COORDINATOR_ASSISTANT_INPUT.name,
+        description: existing.description ?? ROOM_COORDINATOR_ASSISTANT_INPUT.description,
+        graphDefinition: ROOM_COORDINATOR_ASSISTANT_INPUT.graphDefinition
       });
+      return repaired ?? existing;
+    }
+    try {
+      return await this.deps.createAssistant(tenantId, ROOM_COORDINATOR_KEY, ROOM_COORDINATOR_ASSISTANT_INPUT);
     } catch (error) {
       const winner = await this.deps.getAssistantById(tenantId, ROOM_COORDINATOR_KEY);
       if (winner) return winner;
@@ -5158,9 +5178,134 @@ var RoomCoordinatorProvisioner = class {
   }
 };
 
+// src/services/collaboration/RoomCoordinatorEnsurer.ts
+import { randomUUID as randomUUID5 } from "crypto";
+
+// src/services/collaboration/ProjectMutationMutex.ts
+import {
+  ProjectMutationMutex,
+  projectMutationMutex
+} from "@axiom-lattice/core";
+
+// src/services/collaboration/RoomPresenceThread.ts
+var ROOM_PRESENCE_METADATA_KEYS = ["source", "kind", "workspaceId", "projectId", "roomId", "membershipId", "assistantId"];
+function roomPresenceMetadata(input) {
+  return {
+    source: "project_room",
+    kind: "room_presence",
+    workspaceId: input.workspaceId,
+    projectId: input.projectId,
+    roomId: input.roomId,
+    membershipId: input.membershipId,
+    assistantId: input.assistantId
+  };
+}
+function isRoomPresenceMetadata(metadata, expected) {
+  if (!metadata || Object.keys(metadata).length !== ROOM_PRESENCE_METADATA_KEYS.length) return false;
+  if (ROOM_PRESENCE_METADATA_KEYS.some((key) => !Object.prototype.hasOwnProperty.call(metadata, key))) return false;
+  return metadata.source === expected.source && metadata.kind === expected.kind && metadata.workspaceId === expected.workspaceId && metadata.projectId === expected.projectId && metadata.roomId === expected.roomId && metadata.membershipId === expected.membershipId && metadata.assistantId === expected.assistantId;
+}
+
+// src/services/collaboration/RoomCoordinatorEnsurer.ts
+var RoomCoordinatorEnsureError = class extends Error {
+  /** Creates a typed ensure failure with the underlying store outcome. */
+  constructor(outcome) {
+    super(`Room coordinator could not be ensured: ${outcome}`);
+    this.outcome = outcome;
+    this.name = "RoomCoordinatorEnsureError";
+  }
+};
+var RoomCoordinatorEnsurer = class {
+  /** Creates the ensurer from explicitly injected stores and provisioner. */
+  constructor(deps) {
+    this.deps = deps;
+    this.mutex = deps.mutationMutex ?? projectMutationMutex;
+    this.idFactory = deps.idFactory ?? randomUUID5;
+  }
+  /**
+   * Ensures the coordinator membership for one room.
+   *
+   * @param scope Exact tenant/workspace/project/room scope.
+   * @returns The existing or newly created coordinator membership.
+   */
+  async ensure(scope) {
+    return this.mutex.runExclusive({ tenantId: scope.tenantId, projectId: scope.projectId }, async () => {
+      const assistant = await this.deps.provisioner.ensure(scope.tenantId);
+      const existing = await this.deps.membershipStore.findByAssistant(scope.tenantId, scope.projectId, ROOM_COORDINATOR_KEY);
+      if (existing) return existing;
+      const membershipId = this.idFactory();
+      const threadId = this.idFactory();
+      const metadata = roomPresenceMetadata({
+        workspaceId: scope.workspaceId,
+        projectId: scope.projectId,
+        roomId: scope.roomId,
+        membershipId,
+        assistantId: assistant.id
+      });
+      await this.ensureThread(scope.tenantId, assistant.id, threadId, metadata);
+      const mentionName = await this.deps.resolveMentionName?.(scope.tenantId) ?? ROOM_COORDINATOR_KEY;
+      try {
+        const saved = await this.deps.membershipStore.save({
+          id: membershipId,
+          tenantId: scope.tenantId,
+          workspaceId: scope.workspaceId,
+          projectId: scope.projectId,
+          roomId: scope.roomId,
+          assistantId: assistant.id,
+          role: "coordinator",
+          title: assistant.name,
+          mentionName,
+          status: "active",
+          roomThreadId: threadId
+        });
+        if (saved.kind !== "created" && saved.kind !== "updated" && saved.kind !== "reactivated") {
+          const winner = await this.deps.membershipStore.findByAssistant(scope.tenantId, scope.projectId, ROOM_COORDINATOR_KEY);
+          if (winner) return winner;
+          throw new RoomCoordinatorEnsureError(saved.kind);
+        }
+        await this.deps.bindingLifecycle.ensure(saved.membership);
+        return saved.membership;
+      } catch (error) {
+        const winner = await this.deps.membershipStore.findByAssistant(scope.tenantId, scope.projectId, ROOM_COORDINATOR_KEY);
+        if (winner) return winner;
+        throw error;
+      }
+    });
+  }
+  async ensureThread(tenantId, assistantId, threadId, metadata) {
+    const existing = await this.deps.threadStore.getThreadById(tenantId, threadId);
+    if (existing) {
+      if (existing.id !== threadId || existing.tenantId !== tenantId || existing.assistantId !== assistantId || !isRoomPresenceMetadata(existing.metadata, metadata)) {
+        throw new RoomCoordinatorEnsureError("thread_conflict");
+      }
+      return;
+    }
+    const created = await this.deps.threadStore.createThread(tenantId, assistantId, threadId, { metadata });
+    if (!created || created.id !== threadId || created.tenantId !== tenantId || created.assistantId !== assistantId || !isRoomPresenceMetadata(created.metadata, metadata)) {
+      throw new RoomCoordinatorEnsureError("thread_conflict");
+    }
+  }
+};
+
+// src/services/collaboration/RoomBindingLifecycle.ts
+var NoopRoomBindingLifecycle = class {
+  /** Performs no binding work. */
+  async ensure(_membership) {
+  }
+  /** Performs no binding work. */
+  async pause(_membership) {
+  }
+  /** Performs no binding work. */
+  async resume(_membership) {
+  }
+  /** Performs no binding work. */
+  async remove(_membership) {
+  }
+};
+
 // src/services/collaboration/WorkspacePublicRoomService.ts
 import { createHash } from "crypto";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "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";
@@ -5172,7 +5317,7 @@ var WorkspacePublicRoomService = class {
   /** Creates the service from explicitly injected stores and provisioners. */
   constructor(deps) {
     this.deps = deps;
-    this.idFactory = deps.idFactory ?? randomUUID5;
+    this.idFactory = deps.idFactory ?? randomUUID6;
   }
   /**
    * Returns the workspace's public room project and room, creating them on first call.
@@ -5191,7 +5336,7 @@ var WorkspacePublicRoomService = class {
       projectId,
       name: project.name
     });
-    await this.ensureCoordinatorBot(tenantId, workspaceId, projectId, room.id);
+    await this.deps.ensureCoordinator({ tenantId, workspaceId, projectId, roomId: room.id });
     return { project, room };
   }
   async ensureProject(tenantId, workspaceId, projectId) {
@@ -5209,27 +5354,6 @@ var WorkspacePublicRoomService = class {
       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
@@ -5348,8 +5472,9 @@ function createProjectCollaborationInitializer(deps) {
       } catch {
         throw new ProjectCollaborationInitializationError("owner");
       }
+      let room;
       try {
-        await deps.roomStore.ensureMainRoom({
+        room = await deps.roomStore.ensureMainRoom({
           id: idFactory(),
           tenantId,
           workspaceId: project.workspaceId,
@@ -5359,6 +5484,22 @@ function createProjectCollaborationInitializer(deps) {
       } catch {
         throw new ProjectCollaborationInitializationError("room");
       }
+      if (project.kind === "business" && deps.ensureCoordinator) {
+        try {
+          await deps.ensureCoordinator({
+            tenantId,
+            workspaceId: project.workspaceId,
+            projectId: project.id,
+            roomId: room.id
+          });
+        } catch (error) {
+          deps.log?.warn("project:coordinator-initialization-failed", {
+            tenantId,
+            projectId: project.id,
+            errorName: error instanceof Error ? error.name : "UnknownError"
+          });
+        }
+      }
     }
   };
 }
@@ -5370,17 +5511,29 @@ var WorkspaceController = class {
     const roomStore = getStoreLattice6("default", "projectRoom").store;
     const botMembershipStore = getStoreLattice6("default", "projectBotMembership").store;
     const assistantStore = getStoreLattice6("default", "assistant").store;
+    const threadStore = getStoreLattice6("default", "thread").store;
+    const tenantStore = getStoreLattice6("default", "tenant").store;
     const coordinatorProvisioner = new RoomCoordinatorProvisioner({
       getAssistantById: assistantStore.getAssistantById.bind(assistantStore),
-      createAssistant: assistantStore.createAssistant.bind(assistantStore)
+      createAssistant: assistantStore.createAssistant.bind(assistantStore),
+      updateAssistant: assistantStore.updateAssistant.bind(assistantStore)
+    });
+    const coordinatorEnsurer = new RoomCoordinatorEnsurer({
+      provisioner: coordinatorProvisioner,
+      membershipStore: botMembershipStore,
+      threadStore,
+      bindingLifecycle: new NoopRoomBindingLifecycle(),
+      resolveMentionName: async (tenantId) => {
+        const tenant2 = await tenantStore.getTenantById(tenantId);
+        const value = tenant2?.metadata?.coordinatorMentionName;
+        return typeof value === "string" && value.length > 0 ? value : void 0;
+      }
     });
     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)
+      ensureCoordinator: (scope) => coordinatorEnsurer.ensure(scope)
     });
   }
   getTenantId(request) {
@@ -6089,15 +6242,19 @@ var WorkspaceController = class {
             }
             outputBuf = Buffer.from(content2, "utf-8");
           }
-          return reply.status(200).type(contentType).header("Content-Disposition", "inline").send(outputBuf);
+          return sendBufferWithRange(reply, outputBuf, contentType, request.headers.range);
         } catch (err) {
           return reply.status(502).send({ success: false, error: String(err) });
         }
       }
       const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, resolvedPath);
-      const content = await backend.read(resolvedPath, 0, Infinity);
       const filename = getFilenameFromPath(resolvedPath);
       const mimeType = getContentTypeFromFilename(filename);
+      if (isBinaryContentType(filename) && backend.readBinary) {
+        const buffer2 = await backend.readBinary(resolvedPath);
+        return sendBufferWithRange(reply, buffer2, mimeType, request.headers.range);
+      }
+      const content = await backend.read(resolvedPath, 0, Infinity);
       let finalContent = content;
       const isHtmlFs = mimeType?.toLowerCase().includes("text/html") || filename.toLowerCase().endsWith(".html") || filename.toLowerCase().endsWith(".htm");
       if (isHtmlFs) {
@@ -6120,7 +6277,7 @@ var WorkspaceController = class {
         }
       }
       const buffer = Buffer.from(finalContent, "utf-8");
-      return reply.status(200).type(mimeType).header("Content-Disposition", "inline").send(buffer);
+      return sendBufferWithRange(reply, buffer, mimeType, request.headers.range);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return reply.status(502).send({ success: false, error: `View proxy error: ${message}` });
@@ -6203,6 +6360,10 @@ var WorkspaceController = class {
       if (error instanceof ProjectFileValidationError) {
         return reply.status(400).send({ success: false, error: error.message });
       }
+      const code = error?.code;
+      if (code === "FST_REQ_FILE_TOO_LARGE" || error instanceof Error && /too large/i.test(error.message)) {
+        return reply.status(413).send({ success: false, error: "File is too large" });
+      }
       const message = error instanceof Error ? error.message : String(error);
       return reply.status(500).send({
         success: false,
@@ -6333,7 +6494,7 @@ function registerWorkspaceRoutes(app2, projectCollaboration) {
 }
 
 // src/services/collaboration/ProjectAccessService.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 var ProjectCollaborationError = class extends Error {
   /** Creates a project collaboration error. */
   constructor(code, statusCode, message) {
@@ -6359,7 +6520,7 @@ var ProjectAccessService = class {
   /** Creates a project access service from explicitly injected stores. */
   constructor(deps) {
     this.deps = deps;
-    this.idFactory = deps.idFactory ?? randomUUID6;
+    this.idFactory = deps.idFactory ?? randomUUID7;
   }
   /** Returns the project and active membership when the user has the requested capability. */
   async requireProjectAccess(input) {
@@ -6528,7 +6689,7 @@ import {
   getStoreLattice as getStoreLattice7,
   sqlDatabaseManager
 } from "@axiom-lattice/core";
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 function getTenantId8(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
@@ -6606,7 +6767,7 @@ async function createDatabaseConfig(request, reply) {
         message: "Database configuration with this key already exists"
       };
     }
-    const id3 = body.id || randomUUID7();
+    const id3 = body.id || randomUUID8();
     const config = await store.createConfig(tenantId, id3, body);
     try {
       sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
@@ -6811,7 +6972,7 @@ import {
   metricsServerManager as metricsServerManager2,
   SemanticMetricsClient as SemanticMetricsClient2
 } from "@axiom-lattice/core";
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 function getTenantId9(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
@@ -6892,7 +7053,7 @@ async function createMetricsServerConfig(request, reply) {
         message: "selectedDataSources is required for semantic metrics servers"
       };
     }
-    const id3 = body.id || randomUUID8();
+    const id3 = body.id || randomUUID9();
     const configData = {
       key: body.key,
       name: body.name,
@@ -9410,7 +9571,7 @@ function registerChannelRoutes(app2, dependencies) {
 }
 
 // src/controllers/channel-installations.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import {
   descriptorDataValue
 } from "@axiom-lattice/protocols";
@@ -9614,7 +9775,7 @@ async function createChannelInstallation(request, reply) {
       };
     }
     const store = await getInstallationStore();
-    const installationId = randomUUID9();
+    const installationId = randomUUID10();
     const createInput = {
       channel: body.channel,
       name: body.name,
@@ -10574,7 +10735,7 @@ async function getLocalA2ATemplates(_request, reply) {
 }
 
 // src/routes/a2a-test-connection.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 function describeTestConnectionError(error, agentCardUrl) {
   if (!(error instanceof Error)) {
     return `Failed to fetch agent card from ${agentCardUrl}: ${String(error)}`;
@@ -10614,7 +10775,7 @@ async function ensureLocalRuntimeForConnectionTest(localRuntime, agentCardUrl) {
     return { error: portValidation.error };
   }
   const state = await localA2AService.startProvider(
-    `test-${randomUUID10()}`,
+    `test-${randomUUID11()}`,
     testRuntime
   );
   if (state.status === "running") return { runtimeId: state.runtimeId };
@@ -11020,12 +11181,6 @@ function snapshotEnsureInput(input) {
   return { task, room, membership, mode: row.mode };
 }
 
-// src/services/collaboration/ProjectMutationMutex.ts
-import {
-  ProjectMutationMutex,
-  projectMutationMutex
-} from "@axiom-lattice/core";
-
 // src/controllers/tasks.ts
 var HttpTaskError = class extends Error {
   /** Creates a stable Task HTTP error. */
@@ -11934,7 +12089,7 @@ import { createHmac as createHmac3 } from "crypto";
 import { z as z5, ZodError as ZodError2 } from "zod";
 
 // src/services/agent-web-app/AgentWebAppRuntimeService.ts
-import { createHash as createHash2, randomUUID as randomUUID11 } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID12 } from "crypto";
 import { MessageChunkTypes as MessageChunkTypes3, parseAgentWebAppGenUIBlock } from "@axiom-lattice/protocols";
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -12131,7 +12286,7 @@ ${formatFileRefsSection(refs)}` : input.content;
     const userDigest = createHash2("sha256").update(userId, "utf8").digest("hex");
     const contentDigest = createHash2("sha256").update(file.bytes).digest("hex");
     const displayName = file.name;
-    const physicalName = `${randomUUID11()}-${sanitizePhysicalFilename(file.name)}`;
+    const physicalName = `${randomUUID12()}-${sanitizePhysicalFilename(file.name)}`;
     const saved = await this.deps.saveProjectFile({
       tenantId: runtime.webApp.tenantId,
       workspaceId: runtime.project.workspaceId,
@@ -12283,7 +12438,7 @@ ${formatFileRefsSection(refs)}` : input.content;
     const thread = await this.deps.threadStore.createThread(
       runtime.webApp.tenantId,
       runtime.webApp.assistantId,
-      randomUUID11(),
+      randomUUID12(),
       { metadata: this.metadata(runtime, userId, normalizeLabel(rawLabel)) }
     );
     return toRuntimeThread(thread);
@@ -12919,17 +13074,32 @@ async function pipeAgentWebAppStream(raw, stream, options = {}) {
   const projection = createAgentWebAppStreamProjectionContext(options);
   await pipeAsyncIterableToSse(raw, stream, {
     project: (chunk) => projectAgentWebAppChunk(chunk, projection),
-    onError: () => [
-      { type: "error", error: { code: "STREAM_FAILED", message: "Stream failed", retryable: true } },
-      { type: "stream.completed" }
-    ]
+    onError: (error) => {
+      const code = error?.code;
+      if (code === "aborted" || code === "superseded") return [{ type: "stream.completed" }];
+      return [
+        {
+          type: "error",
+          error: {
+            code: "STREAM_FAILED",
+            message: error instanceof Error && error.message ? error.message : "Stream failed",
+            retryable: false
+          }
+        },
+        { type: "stream.completed" }
+      ];
+    }
   });
 }
 async function pipeNativeWebAppStream(raw, stream) {
   await pipeAsyncIterableToSse(raw, stream, {
-    onError: () => [{
+    onError: (error) => [{
       type: "error",
-      data: { id: "", content: "Stream failed" }
+      data: {
+        id: "",
+        content: error instanceof Error && error.message ? error.message : "Stream failed",
+        code: error?.code ?? "stream_error"
+      }
     }]
   });
 }
@@ -13519,31 +13689,72 @@ function registerCapabilityBundleRoutes(app2, controller) {
 }
 
 // src/services/collaboration/ProjectRoomService.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 var ProjectRoomService = class {
   /** Creates a project room service from explicitly injected collaborators. */
   constructor(deps) {
     this.deps = deps;
-    this.idFactory = deps.idFactory ?? randomUUID12;
+    this.idFactory = deps.idFactory ?? randomUUID13;
   }
-  /** Authorizes read access and atomically ensures the project's main room. */
+  /**
+   * Authorizes read access and ensures the project's main room.
+   *
+   * @remarks
+   * This method is safe to call while holding the process-wide Project
+   * mutation mutex: it never re-enters it. Coordinator backfill is a separate
+   * entry point ({@link ensureMainRoomWithCoordinator}) because it acquires
+   * that mutex internally.
+   */
   async ensureMainRoom(input) {
+    const { room } = await this.authorizedRoom(input);
+    return room;
+  }
+  /**
+   * Authorizes read access, ensures the main room, and lazily backfills the
+   * built-in coordinator for business projects.
+   *
+   * @remarks
+   * Only call this outside the Project mutation mutex (room open / bootstrap
+   * paths); calling it under the mutex deadlocks on the coordinator ensurer.
+   */
+  async ensureMainRoomWithCoordinator(input) {
+    const { project, room } = await this.authorizedRoom(input);
+    if (project.kind === "business" && this.deps.ensureCoordinator) {
+      try {
+        await this.deps.ensureCoordinator({
+          tenantId: input.tenantId,
+          workspaceId: project.workspaceId,
+          projectId: project.id,
+          roomId: room.id
+        });
+      } catch (error) {
+        this.deps.log?.warn("project-room:coordinator-ensure-failed", {
+          tenantId: input.tenantId,
+          projectId: project.id,
+          errorName: error instanceof Error ? error.name : "UnknownError"
+        });
+      }
+    }
+    return room;
+  }
+  async authorizedRoom(input) {
     const { project } = await this.deps.accessService.requireProjectAccess({
       ...input,
       capability: "read"
     });
-    return this.deps.roomStore.ensureMainRoom({
+    const room = await this.deps.roomStore.ensureMainRoom({
       id: this.idFactory(),
       tenantId: input.tenantId,
       workspaceId: project.workspaceId,
       projectId: project.id,
       name: project.name
     });
+    return { project, room };
   }
 };
 
 // src/services/collaboration/ProjectMembershipService.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 var ProjectMembershipServiceError = class extends Error {
   constructor(code, statusCode, message) {
     super(message);
@@ -13559,30 +13770,30 @@ function isMembershipConflict(error) {
 var ProjectMembershipService = class {
   constructor(deps) {
     this.deps = deps;
-    this.idFactory = deps.idFactory ?? randomUUID13;
+    this.idFactory = deps.idFactory ?? randomUUID14;
     this.mutationMutex = deps.projectMutationMutex ?? projectMutationMutex;
   }
-  async list(actor2) {
-    await this.deps.accessService.requireRosterAccess(actor2);
-    const membership = await this.deps.membershipStore.findByUser(actor2.tenantId, actor2.projectId, actor2.userId);
+  async list(actor3) {
+    await this.deps.accessService.requireRosterAccess(actor3);
+    const membership = await this.deps.membershipStore.findByUser(actor3.tenantId, actor3.projectId, actor3.userId);
     if (!membership || membership.status !== "active") this.accessDenied();
-    return this.deps.membershipStore.list(actor2.tenantId, actor2.projectId);
+    return this.deps.membershipStore.list(actor3.tenantId, actor3.projectId);
   }
-  async add(actor2, input) {
-    return this.withProjectLock(actor2, async () => {
-      const access = await this.authorize(actor2);
+  async add(actor3, input) {
+    return this.withProjectLock(actor3, async () => {
+      const access = await this.authorize(actor3);
       if (input.role === "owner" && access.role !== "owner") this.accessDenied();
-      if (!await this.deps.userTenantLinkStore.getLink(input.userId, actor2.tenantId)) {
+      if (!await this.deps.userTenantLinkStore.getLink(input.userId, actor3.tenantId)) {
         throw new ProjectMembershipServiceError("TARGET_USER_NOT_IN_TENANT", 400, "Target user is not in the tenant");
       }
-      if (await this.deps.membershipStore.findByUser(actor2.tenantId, actor2.projectId, input.userId)) {
+      if (await this.deps.membershipStore.findByUser(actor3.tenantId, actor3.projectId, input.userId)) {
         throw new ProjectMembershipServiceError("MEMBERSHIP_EXISTS", 409, "Project membership already exists");
       }
       try {
         const created = await this.deps.membershipStore.create({
           id: this.idFactory(),
-          tenantId: actor2.tenantId,
-          projectId: actor2.projectId,
+          tenantId: actor3.tenantId,
+          projectId: actor3.projectId,
           userId: input.userId,
           role: input.role,
           status: "active"
@@ -13600,36 +13811,36 @@ var ProjectMembershipService = class {
       }
     });
   }
-  async updateRole(actor2, input) {
-    return this.withProjectLock(actor2, async () => {
-      const access = await this.authorize(actor2);
-      const target = await this.target(actor2, input.membershipId);
+  async updateRole(actor3, input) {
+    return this.withProjectLock(actor3, async () => {
+      const access = await this.authorize(actor3);
+      const target = await this.target(actor3, input.membershipId);
       this.requireActiveAndCurrent(target, input.expectedUpdatedAt);
       if ((target.role === "owner" || input.role === "owner") && access.role !== "owner") this.accessDenied();
-      const updated = await this.mapMutation(await this.deps.membershipStore.updateRole({ tenantId: actor2.tenantId, id: input.membershipId, role: input.role, expectedUpdatedAt: input.expectedUpdatedAt }));
+      const updated = await this.mapMutation(await this.deps.membershipStore.updateRole({ tenantId: actor3.tenantId, id: input.membershipId, role: input.role, expectedUpdatedAt: input.expectedUpdatedAt }));
       this.publish(updated, "role_changed", `membership:${updated.id}:role:${updated.role}:${input.expectedUpdatedAt.toISOString()}`);
       return updated;
     });
   }
-  async remove(actor2, input) {
-    return this.withProjectLock(actor2, async () => {
-      const access = await this.authorize(actor2);
-      const target = await this.target(actor2, input.membershipId);
+  async remove(actor3, input) {
+    return this.withProjectLock(actor3, async () => {
+      const access = await this.authorize(actor3);
+      const target = await this.target(actor3, input.membershipId);
       this.requireActiveAndCurrent(target, input.expectedUpdatedAt);
       if (target.role === "owner" && access.role !== "owner") this.accessDenied();
-      const removed = await this.mapMutation(await this.deps.membershipStore.remove({ tenantId: actor2.tenantId, id: input.membershipId, expectedUpdatedAt: input.expectedUpdatedAt }));
+      const removed = await this.mapMutation(await this.deps.membershipStore.remove({ tenantId: actor3.tenantId, id: input.membershipId, expectedUpdatedAt: input.expectedUpdatedAt }));
       this.publish(removed, "removed", `membership:${removed.id}:remove:${input.expectedUpdatedAt.toISOString()}`);
       return removed;
     });
   }
-  async authorize(actor2) {
-    await this.deps.accessService.requireProjectAccess({ ...actor2, capability: "manage" });
-    const membership = await this.deps.membershipStore.findByUser(actor2.tenantId, actor2.projectId, actor2.userId);
+  async authorize(actor3) {
+    await this.deps.accessService.requireProjectAccess({ ...actor3, capability: "manage" });
+    const membership = await this.deps.membershipStore.findByUser(actor3.tenantId, actor3.projectId, actor3.userId);
     if (!membership || membership.status !== "active") this.accessDenied();
     return membership;
   }
-  async target(actor2, id3) {
-    const target = (await this.deps.membershipStore.list(actor2.tenantId, actor2.projectId)).find((item) => item.id === id3);
+  async target(actor3, id3) {
+    const target = (await this.deps.membershipStore.list(actor3.tenantId, actor3.projectId)).find((item) => item.id === id3);
     if (!target) throw new ProjectMembershipServiceError("MEMBERSHIP_NOT_FOUND", 404, "Project membership not found");
     return target;
   }
@@ -13684,16 +13895,16 @@ var ProjectMembershipService = class {
   accessDenied() {
     throw new ProjectMembershipServiceError("PROJECT_ACCESS_DENIED", 403, "Project access denied");
   }
-  async withProjectLock(actor2, operation) {
+  async withProjectLock(actor3, operation) {
     return this.mutationMutex.runExclusive(
-      { tenantId: actor2.tenantId, projectId: actor2.projectId },
+      { tenantId: actor3.tenantId, projectId: actor3.projectId },
       operation
     );
   }
 };
 
 // src/services/collaboration/ProjectRosterService.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 var ProjectRosterServiceError = class extends Error {
   /** Creates a stable roster service error. */
   constructor(code, statusCode, message) {
@@ -13703,35 +13914,38 @@ var ProjectRosterServiceError = class extends Error {
     this.name = "ProjectRosterServiceError";
   }
 };
+function coordinatorProtected(message) {
+  return new ProjectRosterServiceError("ROOM_COORDINATOR_PROTECTED", 409, message);
+}
 var activeStatuses = ["active", "paused"];
 var activeTaskStatuses = ["pending", "in_progress", "interrupted"];
-var metadataKeys = ["source", "kind", "workspaceId", "projectId", "roomId", "membershipId", "assistantId"];
 var ProjectRosterService = class {
   /** Creates a roster service from explicitly injected collaborators. */
   constructor(deps) {
     this.deps = deps;
-    this.idFactory = deps.idFactory ?? randomUUID14;
+    this.idFactory = deps.idFactory ?? randomUUID15;
     this.mutationMutex = deps.projectMutationMutex ?? projectMutationMutex;
   }
   /** Lists all bot memberships visible to a project reader. */
-  async list(actor2) {
-    await this.authorize(actor2, "read");
-    return this.deps.membershipStore.list(actor2.tenantId, actor2.projectId);
+  async list(actor3) {
+    await this.authorize(actor3, "read");
+    return this.deps.membershipStore.list(actor3.tenantId, actor3.projectId);
   }
   /** Adds or reactivates a bot and ensures its room-presence thread exists. */
-  async add(actor2, input) {
-    return this.withLock(actor2, async () => {
-      await this.authorize(actor2, "manage");
-      const room = await this.deps.roomService.ensureMainRoom(actor2);
-      const assistant = await this.deps.assistantStore.getAssistantById(actor2.tenantId, input.assistantId);
-      if (!assistant || assistant.tenantId !== actor2.tenantId) throw new ProjectRosterServiceError("ASSISTANT_NOT_FOUND", 404, "Assistant not found");
+  async add(actor3, input) {
+    this.assertAssignableRole(input);
+    return this.withLock(actor3, async () => {
+      await this.authorize(actor3, "manage");
+      const room = await this.deps.roomService.ensureMainRoom(actor3);
+      const assistant = await this.deps.assistantStore.getAssistantById(actor3.tenantId, input.assistantId);
+      if (!assistant || assistant.tenantId !== actor3.tenantId) throw new ProjectRosterServiceError("ASSISTANT_NOT_FOUND", 404, "Assistant not found");
       const normalized = this.validateInput(input);
-      const existing = await this.deps.membershipStore.findByAssistant(actor2.tenantId, actor2.projectId, input.assistantId);
-      if (existing) this.validateMembership(existing, actor2, room, input.assistantId);
-      let ids = existing ? { membershipId: existing.id, threadId: existing.roomThreadId } : await this.findSafePresence(actor2, room, input.assistantId);
+      const existing = await this.deps.membershipStore.findByAssistant(actor3.tenantId, actor3.projectId, input.assistantId);
+      if (existing) this.validateMembership(existing, actor3, room, input.assistantId);
+      let ids = existing ? { membershipId: existing.id, threadId: existing.roomThreadId } : await this.findSafePresence(actor3, room, input.assistantId);
       for (let attempt = 0; attempt < 3; attempt += 1) {
         try {
-          await this.ensureThread(actor2, room, input.assistantId, ids.membershipId, ids.threadId);
+          await this.ensureThread(actor3, room, input.assistantId, ids.membershipId, ids.threadId);
           break;
         } catch (error) {
           if (!(error instanceof ProjectRosterServiceError) || error.code !== "THREAD_CONFLICT" || existing) throw error;
@@ -13739,65 +13953,67 @@ var ProjectRosterService = class {
           if (attempt === 2) throw error;
         }
       }
-      await this.authorize(actor2, "manage");
+      await this.authorize(actor3, "manage");
       let result;
       try {
-        result = await this.deps.membershipStore.save({ id: ids.membershipId, tenantId: actor2.tenantId, workspaceId: room.workspaceId, projectId: actor2.projectId, roomId: room.id, assistantId: input.assistantId, role: input.role, title: normalized.title, ...normalized.responsibility === void 0 ? {} : { responsibility: normalized.responsibility }, mentionName: normalized.mentionName, status: "active", roomThreadId: ids.threadId });
+        result = await this.deps.membershipStore.save({ id: ids.membershipId, tenantId: actor3.tenantId, workspaceId: room.workspaceId, projectId: actor3.projectId, roomId: room.id, assistantId: input.assistantId, role: input.role, title: normalized.title, ...normalized.responsibility === void 0 ? {} : { responsibility: normalized.responsibility }, mentionName: normalized.mentionName, status: "active", roomThreadId: ids.threadId });
       } catch (error) {
         if (error instanceof Error && ["ProjectBotMembershipIdConflictError", "DuplicateProjectBotMembershipError"].includes(error.name)) throw new ProjectRosterServiceError("ROSTER_CONFLICT", 409, "Roster membership conflict");
         throw error;
       }
       if (result.kind !== "created" && result.kind !== "updated" && result.kind !== "reactivated") throw new ProjectRosterServiceError("ROSTER_CONFLICT", 409, `Roster ${result.kind.replace("_", " ")}`);
-      this.validateMembership(result.membership, actor2, room, input.assistantId, ids.threadId);
+      this.validateMembership(result.membership, actor3, room, input.assistantId, ids.threadId);
       await this.deps.bindingLifecycle.ensure(result.membership);
       this.publish(result.membership, result.kind === "created" ? "added" : result.kind === "reactivated" ? "resumed" : "updated", `roster:${result.membership.id}:${result.membership.updatedAt.toISOString()}`);
       return result.membership;
     });
   }
   /** Updates mutable bot presentation fields using optimistic concurrency. */
-  async update(actor2, input) {
+  async update(actor3, input) {
     const patch = { ...input.role === void 0 ? {} : { role: input.role }, ...input.title === void 0 ? {} : { title: this.validateTitle(input.title) }, ...input.responsibility === void 0 ? {} : { responsibility: this.validateResponsibility(input.responsibility) }, ...input.mentionName === void 0 ? {} : { mentionName: this.validateMention(input.mentionName) } };
-    return this.mutate(actor2, input.membershipId, input.expectedUpdatedAt, patch);
+    return this.mutate(actor3, input.membershipId, input.expectedUpdatedAt, patch);
   }
   /** Pauses a bot without deleting its presence thread or history. */
-  async pause(actor2, input) {
-    return this.mutate(actor2, input.membershipId, input.expectedUpdatedAt, { status: "paused" }, "pause");
+  async pause(actor3, input) {
+    return this.mutate(actor3, input.membershipId, input.expectedUpdatedAt, { status: "paused" }, "pause");
   }
   /** Resumes a bot without replacing its presence thread or history. */
-  async resume(actor2, input) {
-    return this.mutate(actor2, input.membershipId, input.expectedUpdatedAt, { status: "active" }, "resume");
+  async resume(actor3, input) {
+    return this.mutate(actor3, input.membershipId, input.expectedUpdatedAt, { status: "active" }, "resume");
   }
   /** Removes a bot after checking every active task status independently. */
-  async remove(actor2, input) {
-    return this.withLock(actor2, async () => {
-      await this.authorize(actor2, "manage");
-      const target = await this.target(actor2, input.membershipId);
+  async remove(actor3, input) {
+    return this.withLock(actor3, async () => {
+      await this.authorize(actor3, "manage");
+      const target = await this.target(actor3, input.membershipId);
       this.requireCurrent(target, input.expectedUpdatedAt);
+      if (target.role === "coordinator") throw coordinatorProtected("The built-in room coordinator cannot be removed");
       for (const status of activeTaskStatuses) {
-        const tasks = await this.deps.taskStore.list({ tenantId: actor2.tenantId, projectId: actor2.projectId, ownerType: "agent", ownerId: target.assistantId, status, limit: 1 });
+        const tasks = await this.deps.taskStore.list({ tenantId: actor3.tenantId, projectId: actor3.projectId, ownerType: "agent", ownerId: target.assistantId, status, limit: 1 });
         if (tasks.length > 0) throw new ProjectRosterServiceError("BOT_HAS_ACTIVE_TASKS", 409, "Bot has active tasks");
       }
-      await this.authorize(actor2, "manage");
+      await this.authorize(actor3, "manage");
       await this.deps.bindingLifecycle.remove(target);
       try {
-        const removed = await this.applyUpdate(actor2, target, { status: "removed" }, input.expectedUpdatedAt);
+        const removed = await this.applyUpdate(actor3, target, { status: "removed" }, input.expectedUpdatedAt);
         this.publish(removed, "removed", `roster:${removed.id}:${removed.updatedAt.toISOString()}`);
         return removed;
       } catch (error) {
-        const current = await this.deps.membershipStore.findById(actor2.tenantId, target.id);
-        if (!current || current.tenantId !== actor2.tenantId || current.projectId !== actor2.projectId) throw error;
+        const current = await this.deps.membershipStore.findById(actor3.tenantId, target.id);
+        if (!current || current.tenantId !== actor3.tenantId || current.projectId !== actor3.projectId) throw error;
         await this.applyLifecycle(current);
         throw error;
       }
     });
   }
-  async mutate(actor2, id3, expected, patch, lifecycle) {
-    return this.withLock(actor2, async () => {
-      await this.authorize(actor2, "manage");
-      const target = await this.target(actor2, id3);
+  async mutate(actor3, id3, expected, patch, lifecycle) {
+    return this.withLock(actor3, async () => {
+      await this.authorize(actor3, "manage");
+      const target = await this.target(actor3, id3);
       this.requireCurrent(target, expected);
-      await this.authorize(actor2, "manage");
-      const updated = await this.applyUpdate(actor2, target, patch, expected);
+      this.assertCoordinatorPolicy(target, patch, lifecycle);
+      await this.authorize(actor3, "manage");
+      const updated = await this.applyUpdate(actor3, target, patch, expected);
       if (lifecycle === "pause") await this.deps.bindingLifecycle.pause(updated);
       else if (lifecycle === "resume") await this.deps.bindingLifecycle.resume(updated);
       else await this.applyLifecycle(updated);
@@ -13806,6 +14022,18 @@ var ProjectRosterService = class {
       return updated;
     });
   }
+  assertAssignableRole(input) {
+    if (input.role === "coordinator" && input.assistantId !== ROOM_COORDINATOR_KEY) throw coordinatorProtected("Only the built-in room coordinator can hold the coordinator role");
+    if (input.assistantId === ROOM_COORDINATOR_KEY && input.role !== "coordinator") throw coordinatorProtected("The built-in room coordinator cannot be added as a specialist");
+  }
+  assertCoordinatorPolicy(target, patch, lifecycle) {
+    if (target.role === "coordinator") {
+      if (lifecycle !== void 0) throw coordinatorProtected(`The built-in room coordinator cannot be ${lifecycle === "pause" ? "paused" : "resumed"}`);
+      if (patch.role !== void 0 && patch.role !== "coordinator") throw coordinatorProtected("The built-in room coordinator role cannot be changed");
+      return;
+    }
+    if (patch.role === "coordinator") throw coordinatorProtected("Only the built-in room coordinator can hold the coordinator role");
+  }
   publish(membership, change, sourceKey) {
     if (!this.deps.realtime) return;
     Promise.resolve().then(() => this.deps.realtime.rosterChanged({ tenantId: membership.tenantId, roomId: membership.roomId, membership, change, sourceKey })).catch(() => {
@@ -13826,36 +14054,36 @@ var ProjectRosterService = class {
     }
     await this.deps.bindingLifecycle.ensure(membership);
   }
-  async applyUpdate(actor2, target, patch, expectedUpdatedAt2) {
+  async applyUpdate(actor3, target, patch, expectedUpdatedAt2) {
     let result;
     try {
-      result = await this.deps.membershipStore.update({ tenantId: actor2.tenantId, id: target.id, patch, expectedUpdatedAt: expectedUpdatedAt2 });
+      result = await this.deps.membershipStore.update({ tenantId: actor3.tenantId, id: target.id, patch, expectedUpdatedAt: expectedUpdatedAt2 });
     } catch (error) {
       if (error instanceof Error && ["ProjectBotMembershipIdConflictError", "DuplicateProjectBotMembershipError"].includes(error.name)) throw new ProjectRosterServiceError("ROSTER_CONFLICT", 409, "Roster membership conflict");
       throw error;
     }
     if (result.kind === "updated") {
-      this.validateMembership(result.membership, actor2, { id: target.roomId, workspaceId: target.workspaceId }, target.assistantId, target.roomThreadId);
+      this.validateMembership(result.membership, actor3, { id: target.roomId, workspaceId: target.workspaceId }, target.assistantId, target.roomThreadId);
       return result.membership;
     }
     if (result.kind === "not_found") throw new ProjectRosterServiceError("ROSTER_MEMBER_NOT_FOUND", 404, "Roster member not found");
     if (result.kind === "conflict") throw new ProjectRosterServiceError("ROSTER_CONFLICT", 409, "Roster member changed; reload before saving");
     throw new ProjectRosterServiceError("ROSTER_CONFLICT", 409, `Roster ${result.kind.replace("_", " ")}`);
   }
-  async authorize(actor2, capability2) {
-    await this.deps.accessService.requireProjectAccess({ ...actor2, capability: capability2 });
+  async authorize(actor3, capability2) {
+    await this.deps.accessService.requireProjectAccess({ ...actor3, capability: capability2 });
   }
-  async target(actor2, id3) {
-    const target = await this.deps.membershipStore.findById(actor2.tenantId, id3);
-    if (!target || target.tenantId !== actor2.tenantId || target.projectId !== actor2.projectId) throw new ProjectRosterServiceError("ROSTER_MEMBER_NOT_FOUND", 404, "Roster member not found");
-    const room = await this.deps.roomService.ensureMainRoom(actor2);
-    const assistant = await this.deps.assistantStore.getAssistantById(actor2.tenantId, target.assistantId);
-    if (!assistant || assistant.tenantId !== actor2.tenantId) throw new ProjectRosterServiceError("ASSISTANT_NOT_FOUND", 404, "Assistant not found");
+  async target(actor3, id3) {
+    const target = await this.deps.membershipStore.findById(actor3.tenantId, id3);
+    if (!target || target.tenantId !== actor3.tenantId || target.projectId !== actor3.projectId) throw new ProjectRosterServiceError("ROSTER_MEMBER_NOT_FOUND", 404, "Roster member not found");
+    const room = await this.deps.roomService.ensureMainRoom(actor3);
+    const assistant = await this.deps.assistantStore.getAssistantById(actor3.tenantId, target.assistantId);
+    if (!assistant || assistant.tenantId !== actor3.tenantId) throw new ProjectRosterServiceError("ASSISTANT_NOT_FOUND", 404, "Assistant not found");
     if (!target.roomThreadId) throw new ProjectRosterServiceError("ROSTER_CONFLICT", 409, "Roster member immutable scope mismatch");
-    this.validateMembership(target, actor2, room, target.assistantId, target.roomThreadId);
-    const thread = await this.deps.threadStore.getThreadById(actor2.tenantId, target.roomThreadId);
+    this.validateMembership(target, actor3, room, target.assistantId, target.roomThreadId);
+    const thread = await this.deps.threadStore.getThreadById(actor3.tenantId, target.roomThreadId);
     if (!thread) throw new ProjectRosterServiceError("THREAD_CONFLICT", 409, "Presence thread not found");
-    this.validateThread(thread, actor2.tenantId, this.expectedMetadata(room, actor2, target.id, target.assistantId), target.roomThreadId);
+    this.validateThread(thread, actor3.tenantId, this.expectedMetadata(room, actor3, target.id, target.assistantId), target.roomThreadId);
     return target;
   }
   requireCurrent(target, expected) {
@@ -13881,56 +14109,55 @@ var ProjectRosterService = class {
     return normalized;
   }
   metadata(metadata, expected) {
-    if (!metadata || Object.keys(metadata).length !== metadataKeys.length || metadataKeys.some((key) => !Object.prototype.hasOwnProperty.call(metadata, key))) return false;
-    return metadata.source === expected.source && metadata.kind === expected.kind && metadata.workspaceId === expected.workspaceId && metadata.projectId === expected.projectId && metadata.roomId === expected.roomId && metadata.membershipId === expected.membershipId && metadata.assistantId === expected.assistantId;
+    return isRoomPresenceMetadata(metadata, expected);
   }
-  expectedMetadata(room, actor2, membershipId, assistantId) {
-    return { source: "project_room", kind: "room_presence", workspaceId: room.workspaceId, projectId: actor2.projectId, roomId: room.id, membershipId, assistantId };
+  expectedMetadata(room, actor3, membershipId, assistantId) {
+    return roomPresenceMetadata({ workspaceId: room.workspaceId, projectId: actor3.projectId, roomId: room.id, membershipId, assistantId });
   }
-  validateMembership(value, actor2, room, assistantId, threadId) {
-    if (value.tenantId !== actor2.tenantId || value.projectId !== actor2.projectId || value.workspaceId !== room.workspaceId || value.roomId !== room.id || value.assistantId !== assistantId || threadId !== void 0 && value.roomThreadId !== threadId) throw new ProjectRosterServiceError("ROSTER_CONFLICT", 409, "Roster membership immutable scope mismatch");
+  validateMembership(value, actor3, room, assistantId, threadId) {
+    if (value.tenantId !== actor3.tenantId || value.projectId !== actor3.projectId || value.workspaceId !== room.workspaceId || value.roomId !== room.id || value.assistantId !== assistantId || threadId !== void 0 && value.roomThreadId !== threadId) throw new ProjectRosterServiceError("ROSTER_CONFLICT", 409, "Roster membership immutable scope mismatch");
   }
-  async findSafePresence(actor2, room, assistantId) {
-    const threads = await this.deps.threadStore.getThreadsByAssistantId(actor2.tenantId, assistantId, { source: "project_room", kind: "room_presence", workspaceId: room.workspaceId, projectId: actor2.projectId, roomId: room.id, assistantId });
-    const memberships = await this.deps.membershipStore.list(actor2.tenantId, actor2.projectId);
+  async findSafePresence(actor3, room, assistantId) {
+    const threads = await this.deps.threadStore.getThreadsByAssistantId(actor3.tenantId, assistantId, { source: "project_room", kind: "room_presence", workspaceId: room.workspaceId, projectId: actor3.projectId, roomId: room.id, assistantId });
+    const memberships = await this.deps.membershipStore.list(actor3.tenantId, actor3.projectId);
     for (const thread of threads) {
       const metadata = thread.metadata;
-      if (thread.tenantId !== actor2.tenantId || thread.assistantId !== assistantId || typeof metadata?.membershipId !== "string" || !this.metadata(metadata, this.expectedMetadata(room, actor2, metadata.membershipId, assistantId))) continue;
+      if (thread.tenantId !== actor3.tenantId || thread.assistantId !== assistantId || typeof metadata?.membershipId !== "string" || !this.metadata(metadata, this.expectedMetadata(room, actor3, metadata.membershipId, assistantId))) continue;
       const membershipId = metadata.membershipId;
-      const owner = await this.deps.membershipStore.findById(actor2.tenantId, membershipId);
-      if (owner && (owner.tenantId !== actor2.tenantId || owner.workspaceId !== room.workspaceId || owner.projectId !== actor2.projectId || owner.roomId !== room.id || owner.roomThreadId !== thread.id || owner.assistantId !== assistantId || owner.id !== membershipId)) continue;
+      const owner = await this.deps.membershipStore.findById(actor3.tenantId, membershipId);
+      if (owner && (owner.tenantId !== actor3.tenantId || owner.workspaceId !== room.workspaceId || owner.projectId !== actor3.projectId || owner.roomId !== room.id || owner.roomThreadId !== thread.id || owner.assistantId !== assistantId || owner.id !== membershipId)) continue;
       if (memberships.some((item) => item.roomThreadId === thread.id)) continue;
       return { membershipId, threadId: thread.id };
     }
     return { membershipId: this.idFactory(), threadId: this.idFactory() };
   }
-  async ensureThread(actor2, room, assistantId, membershipId, threadId) {
-    const expected = this.expectedMetadata(room, actor2, membershipId, assistantId);
-    const existing = await this.deps.threadStore.getThreadById(actor2.tenantId, threadId);
+  async ensureThread(actor3, room, assistantId, membershipId, threadId) {
+    const expected = this.expectedMetadata(room, actor3, membershipId, assistantId);
+    const existing = await this.deps.threadStore.getThreadById(actor3.tenantId, threadId);
     if (existing) {
-      this.validateThread(existing, actor2.tenantId, expected, threadId);
+      this.validateThread(existing, actor3.tenantId, expected, threadId);
       return;
     }
-    const created = await this.deps.threadStore.createThread(actor2.tenantId, assistantId, threadId, { metadata: expected });
-    this.validateThread(created, actor2.tenantId, expected, threadId);
-    const reread = await this.deps.threadStore.getThreadById(actor2.tenantId, threadId);
+    const created = await this.deps.threadStore.createThread(actor3.tenantId, assistantId, threadId, { metadata: expected });
+    this.validateThread(created, actor3.tenantId, expected, threadId);
+    const reread = await this.deps.threadStore.getThreadById(actor3.tenantId, threadId);
     if (!reread) throw new ProjectRosterServiceError("THREAD_CONFLICT", 409, "Presence thread was not persisted");
-    this.validateThread(reread, actor2.tenantId, expected, threadId);
+    this.validateThread(reread, actor3.tenantId, expected, threadId);
   }
   validateThread(thread, tenantId, expected, threadId) {
     if (thread.id !== threadId || thread.tenantId !== tenantId || thread.assistantId !== expected.assistantId || !this.metadata(thread.metadata, expected)) throw new ProjectRosterServiceError("THREAD_CONFLICT", 409, "Presence thread identity mismatch");
   }
   /** Serializes roster writes with task ownership mutations in this process. */
-  withLock(actor2, operation) {
+  withLock(actor3, operation) {
     return this.mutationMutex.runExclusive(
-      { tenantId: actor2.tenantId, projectId: actor2.projectId },
+      { tenantId: actor3.tenantId, projectId: actor3.projectId },
       operation
     );
   }
 };
 
 // src/services/collaboration/RoomMessageService.ts
-import { createHash as createHash4, randomUUID as randomUUID15 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID16 } from "crypto";
 
 // src/services/collaboration/ProjectBotMembershipSnapshot.ts
 import { snapshotExactRecord as snapshotExactRecord4 } from "@axiom-lattice/protocols";
@@ -14019,54 +14246,54 @@ var RoomMessageService = class {
   constructor(deps, options = {}) {
     this.deps = deps;
     this.idempotentOutcomes = /* @__PURE__ */ new Map();
-    this.idFactory = deps.idFactory ?? randomUUID15;
+    this.idFactory = deps.idFactory ?? randomUUID16;
     const limit = options.idempotentOutcomeLimit ?? 1e3;
     if (!Number.isSafeInteger(limit) || limit < 1) throw new RangeError("idempotentOutcomeLimit must be a positive safe integer");
     this.idempotentOutcomeLimit = limit;
   }
   /** Lists newest-first messages strictly before an optional cursor. */
-  async list(actor2, input = {}) {
+  async list(actor3, input = {}) {
     const snapshot = this.snapshotList(input);
-    const access = await this.deps.accessService.requireProjectAccess({ ...actor2, capability: "read" });
-    const room = await this.room(actor2, access.project);
-    const messages = await this.deps.messageStore.list({ tenantId: actor2.tenantId, roomId: room.id, ...snapshot.before === void 0 ? {} : { before: snapshot.before }, limit: snapshot.limit });
-    return messages.map((message) => this.validateMessage(message, actor2, room));
+    const access = await this.deps.accessService.requireProjectAccess({ ...actor3, capability: "read" });
+    const room = await this.room(actor3, access.project);
+    const messages = await this.deps.messageStore.list({ tenantId: actor3.tenantId, roomId: room.id, ...snapshot.before === void 0 ? {} : { before: snapshot.before }, limit: snapshot.limit });
+    return messages.map((message) => this.validateMessage(message, actor3, room));
   }
   /**
    * Validates and persists a human-authored text message without dispatching it.
    * @deprecated This persistence primitive remains for the Phase 1 route boundary; the later
    * route task will switch POST handling to createAndDispatch.
    */
-  async createHumanMessage(actor2, input) {
-    return (await this.persistHumanMessage(actor2, input, false)).message;
+  async createHumanMessage(actor3, input) {
+    return (await this.persistHumanMessage(actor3, input, false)).message;
   }
-  async persistHumanMessage(actor2, input, allowIdempotencyKey) {
-    const snapshot = this.snapshotCreate(actor2, input, allowIdempotencyKey);
-    const access = await this.deps.accessService.requireProjectAccess({ ...actor2, capability: "send" });
-    const room = await this.room(actor2, access.project);
-    return this.persistNormalizedHumanMessage(actor2, snapshot, room);
+  async persistHumanMessage(actor3, input, allowIdempotencyKey) {
+    const snapshot = this.snapshotCreate(actor3, input, allowIdempotencyKey);
+    const access = await this.deps.accessService.requireProjectAccess({ ...actor3, capability: "send" });
+    const room = await this.room(actor3, access.project);
+    return this.persistNormalizedHumanMessage(actor3, snapshot, room);
   }
-  async persistNormalizedHumanMessage(actor2, snapshot, room) {
-    for (const membershipId of snapshot.botIds) await this.validateMentionIdentity(actor2, room, membershipId);
+  async persistNormalizedHumanMessage(actor3, snapshot, room) {
+    for (const membershipId of snapshot.botIds) await this.validateMentionIdentity(actor3, room, membershipId);
     let reply = null;
     if (snapshot.replyToMessageId !== void 0) {
-      reply = await this.deps.messageStore.findById(actor2.tenantId, snapshot.replyToMessageId);
-      if (!reply || reply.id !== snapshot.replyToMessageId || !this.isMessage(reply, actor2, room)) throw new RoomMessageServiceError("INVALID_REPLY_TARGET", 404, "Reply target not found");
+      reply = await this.deps.messageStore.findById(actor3.tenantId, snapshot.replyToMessageId);
+      if (!reply || reply.id !== snapshot.replyToMessageId || !this.isMessage(reply, actor3, room)) throw new RoomMessageServiceError("INVALID_REPLY_TARGET", 404, "Reply target not found");
     }
-    for (const membershipId of snapshot.botIds) await this.validateMentionIdentity(actor2, room, membershipId);
-    await this.deps.accessService.requireProjectAccess({ ...actor2, capability: "send" });
+    for (const membershipId of snapshot.botIds) await this.validateMentionIdentity(actor3, room, membershipId);
+    await this.deps.accessService.requireProjectAccess({ ...actor3, capability: "send" });
     const id3 = this.idFactory();
     let result;
-    const candidate = { id: id3, tenantId: actor2.tenantId, workspaceId: room.workspaceId, projectId: actor2.projectId, roomId: room.id, author: { type: "human", userId: actor2.userId }, content: { type: "text", text: snapshot.text }, mentions: snapshot.mentions, ...snapshot.replyToMessageId === void 0 ? {} : { replyToMessageId: snapshot.replyToMessageId }, source: "user", ...snapshot.idempotencyKey === void 0 ? {} : { idempotencyKey: snapshot.idempotencyKey } };
+    const candidate = { id: id3, tenantId: actor3.tenantId, workspaceId: room.workspaceId, projectId: actor3.projectId, roomId: room.id, author: { type: "human", userId: actor3.userId }, content: { type: "text", text: snapshot.text }, mentions: snapshot.mentions, ...snapshot.replyToMessageId === void 0 ? {} : { replyToMessageId: snapshot.replyToMessageId }, source: "user", ...snapshot.idempotencyKey === void 0 ? {} : { idempotencyKey: snapshot.idempotencyKey } };
     try {
       result = snapshot.idempotencyKey === void 0 ? await this.deps.messageStore.create(candidate) : await this.deps.messageStore.createIdempotent({ ...candidate, idempotencyKey: snapshot.idempotencyKey });
     } catch (error) {
       if (error instanceof Error && /Message.*Conflict|Conflict.*Message|DuplicateProjectRoomMessage/.test(error.name)) throw new RoomMessageServiceError("MESSAGE_CONFLICT", 409, "Message conflict");
       throw error;
     }
-    const validated = this.validateMessage(result, actor2, room, result.id === id3 ? id3 : void 0);
+    const validated = this.validateMessage(result, actor3, room, result.id === id3 ? id3 : void 0);
     const replayed = result.id !== id3;
-    if (validated.author.type !== "human" || validated.author.userId !== actor2.userId || validated.source !== "user" || validated.sourceId !== void 0 || snapshot.idempotencyKey === void 0 && validated.idempotencyKey !== void 0 || snapshot.idempotencyKey !== void 0 && validated.idempotencyKey !== snapshot.idempotencyKey) throw new RoomMessageServiceError("INVALID_STORED_MESSAGE", 500, "Invalid created message");
+    if (validated.author.type !== "human" || validated.author.userId !== actor3.userId || validated.source !== "user" || validated.sourceId !== void 0 || snapshot.idempotencyKey === void 0 && validated.idempotencyKey !== void 0 || snapshot.idempotencyKey !== void 0 && validated.idempotencyKey !== snapshot.idempotencyKey) throw new RoomMessageServiceError("INVALID_STORED_MESSAGE", 500, "Invalid created message");
     if (!matchesNormalizedPayload(validated, snapshot)) {
       if (replayed && snapshot.idempotencyKey !== void 0) throw new RoomMessageServiceError("IDEMPOTENCY_KEY_REUSED", 409, "Idempotency key reused with different message input");
       throw new RoomMessageServiceError("INVALID_STORED_MESSAGE", 500, "Invalid created message");
@@ -14078,11 +14305,11 @@ var RoomMessageService = class {
    * Idempotent outcomes are single-flight and retained only in this service process; a
    * store replay after restart reports `DISPATCH_STATUS_UNKNOWN` until explicitly retried.
    */
-  async createAndDispatch(actor2, input) {
-    const normalized = this.snapshotCreate(actor2, input, true);
-    const access = await this.deps.accessService.requireProjectAccess({ ...actor2, capability: "send" });
-    const room = await this.room(actor2, access.project);
-    const key = this.idempotencyMapKey(actor2, room, normalized);
+  async createAndDispatch(actor3, input) {
+    const normalized = this.snapshotCreate(actor3, input, true);
+    const access = await this.deps.accessService.requireProjectAccess({ ...actor3, capability: "send" });
+    const room = await this.room(actor3, access.project);
+    const key = this.idempotencyMapKey(actor3, room, normalized);
     const requestFingerprint = fingerprintRequest(normalized);
     if (key !== void 0) {
       const existing = this.idempotentOutcomes.get(key);
@@ -14092,7 +14319,7 @@ var RoomMessageService = class {
         return this.resultForCaller(await existing.promise, true);
       }
       this.admitIdempotentEntry();
-      const promise = this.createAndDispatchOutcome(actor2, normalized, room);
+      const promise = this.createAndDispatchOutcome(actor3, normalized, room);
       const entry = { requestFingerprint, promise, settled: false };
       this.idempotentOutcomes.set(key, entry);
       promise.then(() => this.settleIdempotentOutcome(key, entry), () => {
@@ -14101,16 +14328,16 @@ var RoomMessageService = class {
       const resolved = await promise;
       return this.resultForCaller(resolved, resolved.replayed);
     }
-    const outcome = await this.createAndDispatchOutcome(actor2, normalized, room);
+    const outcome = await this.createAndDispatchOutcome(actor3, normalized, room);
     return this.resultForCaller(outcome, outcome.replayed);
   }
-  async createAndDispatchOutcome(actor2, input, room) {
-    const persisted = await this.persistNormalizedHumanMessage(actor2, input, room);
+  async createAndDispatchOutcome(actor3, input, room) {
+    const persisted = await this.persistNormalizedHumanMessage(actor3, input, room);
     if (persisted.replayed) return { message: persisted.message, dispatch: [{ success: false, errorCode: "DISPATCH_STATUS_UNKNOWN" }], replayed: true };
     const message = persisted.message;
     this.notifyMessageCreated(message);
     try {
-      await this.deps.accessService.requireProjectAccess({ ...actor2, capability: "send" });
+      await this.deps.accessService.requireProjectAccess({ ...actor3, capability: "send" });
     } catch (error) {
       return { message, dispatch: [{ success: false, errorCode: error instanceof ProjectCollaborationError && error.code === "PROJECT_ACCESS_DENIED" ? "AUTHORIZATION_REVOKED" : "DISPATCH_FAILED" }], replayed: false };
     }
@@ -14129,8 +14356,8 @@ var RoomMessageService = class {
       });
     });
   }
-  idempotencyMapKey(actor2, room, input) {
-    return input.idempotencyKey === void 0 ? void 0 : `${actor2.tenantId}:${room.id}:${input.idempotencyKey}`;
+  idempotencyMapKey(actor3, room, input) {
+    return input.idempotencyKey === void 0 ? void 0 : `${actor3.tenantId}:${room.id}:${input.idempotencyKey}`;
   }
   settleIdempotentOutcome(key, entry) {
     if (this.idempotentOutcomes.get(key) !== entry) return;
@@ -14155,14 +14382,14 @@ var RoomMessageService = class {
     return { message: cloneRoomMessage(outcome.message), dispatch: outcome.dispatch.map((entry) => ({ ...entry })), replayed };
   }
   /** Retries an existing human message using the current roster without creating a copy. */
-  async retry(actor2, messageId) {
-    const access = await this.deps.accessService.requireProjectAccess({ ...actor2, capability: "send" });
-    const message = await this.deps.messageStore.findById(actor2.tenantId, messageId);
-    const room = await this.room(actor2, access.project);
-    if (!message || message.id !== messageId || !this.isMessage(message, actor2, room) || message.author.type !== "human" || message.source !== "user") {
+  async retry(actor3, messageId) {
+    const access = await this.deps.accessService.requireProjectAccess({ ...actor3, capability: "send" });
+    const message = await this.deps.messageStore.findById(actor3.tenantId, messageId);
+    const room = await this.room(actor3, access.project);
+    if (!message || message.id !== messageId || !this.isMessage(message, actor3, room) || message.author.type !== "human" || message.source !== "user") {
       throw new RoomMessageServiceError("INVALID_RETRY_SOURCE", 404, "Retry source not found");
     }
-    await this.deps.accessService.requireProjectAccess({ ...actor2, capability: "send" });
+    await this.deps.accessService.requireProjectAccess({ ...actor3, capability: "send" });
     return this.safeDispatch(message);
   }
   async safeDispatch(message) {
@@ -14180,7 +14407,7 @@ var RoomMessageService = class {
     if (typeof limit !== "number" || !Number.isFinite(limit) || !Number.isInteger(limit) || limit < 1) throw new RoomMessageServiceError("INVALID_MESSAGE", 400, "Invalid message limit");
     return { ...before === void 0 ? {} : { before }, limit: Math.min(100, limit) };
   }
-  snapshotCreate(actor2, input, allowIdempotencyKey = false) {
+  snapshotCreate(actor3, input, allowIdempotencyKey = false) {
     const allowed = allowIdempotencyKey ? ["text", "mentions", "replyToMessageId", "requestIdempotencyKey"] : ["text", "mentions", "replyToMessageId"];
     if (typeof input !== "object" || input === null || Array.isArray(input) || Object.keys(input).some((key) => !allowed.includes(key)) || !Object.prototype.hasOwnProperty.call(input, "text")) throw new RoomMessageServiceError("INVALID_MESSAGE", 400, "Invalid message input");
     const value = input;
@@ -14200,35 +14427,35 @@ 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}:${createHash4("sha256").update(value.requestIdempotencyKey.trim(), "utf8").digest("hex")}`;
+      idempotencyKey = `room-human:${actor3.userId}:${createHash4("sha256").update(value.requestIdempotencyKey.trim(), "utf8").digest("hex")}`;
     }
     return { text, mentions, botIds, ...value.replyToMessageId === void 0 ? {} : { replyToMessageId: value.replyToMessageId }, ...idempotencyKey === void 0 ? {} : { idempotencyKey } };
   }
-  async room(actor2, project) {
-    if (!project || project.tenantId !== actor2.tenantId || project.id !== actor2.projectId || !nonempty(project.id) || !nonempty(project.workspaceId)) throw new RoomMessageServiceError("INVALID_STORED_MESSAGE", 500, "Invalid authorized project");
-    const room = await this.deps.roomService.ensureMainRoom(actor2);
-    if (!exact(room, ["createdAt", "id", "name", "projectId", "tenantId", "type", "updatedAt", "workspaceId"]) || room.tenantId !== actor2.tenantId || room.projectId !== actor2.projectId || room.workspaceId !== project.workspaceId || room.type !== "main" || !nonempty(room.id) || !nonempty(room.name) || !validDate(room.createdAt) || !validDate(room.updatedAt)) throw new RoomMessageServiceError("INVALID_STORED_MESSAGE", 500, "Invalid room result");
+  async room(actor3, project) {
+    if (!project || project.tenantId !== actor3.tenantId || project.id !== actor3.projectId || !nonempty(project.id) || !nonempty(project.workspaceId)) throw new RoomMessageServiceError("INVALID_STORED_MESSAGE", 500, "Invalid authorized project");
+    const room = await this.deps.roomService.ensureMainRoom(actor3);
+    if (!exact(room, ["createdAt", "id", "name", "projectId", "tenantId", "type", "updatedAt", "workspaceId"]) || room.tenantId !== actor3.tenantId || room.projectId !== actor3.projectId || room.workspaceId !== project.workspaceId || room.type !== "main" || !nonempty(room.id) || !nonempty(room.name) || !validDate(room.createdAt) || !validDate(room.updatedAt)) throw new RoomMessageServiceError("INVALID_STORED_MESSAGE", 500, "Invalid room result");
     return room;
   }
-  async validateMentionIdentity(actor2, room, id3) {
-    const membership = await this.deps.botStore.findById(actor2.tenantId, id3);
+  async validateMentionIdentity(actor3, room, id3) {
+    const membership = await this.deps.botStore.findById(actor3.tenantId, id3);
     const snapshot = snapshotProjectBotMembership(membership);
-    if (!snapshot || snapshot.id !== id3 || !this.matchesRoom(snapshot, actor2, room)) throw new RoomMessageServiceError("UNKNOWN_MENTION", 404, "Mentioned bot membership not found");
+    if (!snapshot || snapshot.id !== id3 || !this.matchesRoom(snapshot, actor3, room)) throw new RoomMessageServiceError("UNKNOWN_MENTION", 404, "Mentioned bot membership not found");
   }
-  matchesRoom(membership, actor2, room) {
-    return membership.tenantId === actor2.tenantId && membership.projectId === actor2.projectId && membership.workspaceId === room.workspaceId && membership.roomId === room.id;
+  matchesRoom(membership, actor3, room) {
+    return membership.tenantId === actor3.tenantId && membership.projectId === actor3.projectId && membership.workspaceId === room.workspaceId && membership.roomId === room.id;
   }
-  isMessage(message, actor2, room) {
+  isMessage(message, actor3, room) {
     try {
-      this.validateMessage(message, actor2, room);
+      this.validateMessage(message, actor3, room);
       return true;
     } catch {
       return false;
     }
   }
-  validateMessage(message, actor2, room, expectedId) {
+  validateMessage(message, actor3, room, expectedId) {
     if (!exactFields(message, ["author", "content", "createdAt", "id", "mentions", "projectId", "roomId", "source", "tenantId", "workspaceId"], ["replyToMessageId", "sourceId", "idempotencyKey"])) throw new RoomMessageServiceError("INVALID_STORED_MESSAGE", 500, "Invalid stored message");
-    if (!nonempty(message.id) || expectedId !== void 0 && message.id !== expectedId || message.tenantId !== actor2.tenantId || message.workspaceId !== room.workspaceId || message.projectId !== actor2.projectId || message.roomId !== room.id || !validDate(message.createdAt) || !nonempty(message.content?.text) || !exact(message.content, ["text", "type"]) || message.content.type !== "text" || !Array.isArray(message.mentions) || !this.validAuthor(message.author) || !["user", "agent", "task", "routine", "system"].includes(message.source) || message.replyToMessageId !== void 0 && !nonempty(message.replyToMessageId) || message.sourceId !== void 0 && !nonempty(message.sourceId) || message.idempotencyKey !== void 0 && !nonempty(message.idempotencyKey)) throw new RoomMessageServiceError("INVALID_STORED_MESSAGE", 500, "Invalid stored message");
+    if (!nonempty(message.id) || expectedId !== void 0 && message.id !== expectedId || message.tenantId !== actor3.tenantId || message.workspaceId !== room.workspaceId || message.projectId !== actor3.projectId || message.roomId !== room.id || !validDate(message.createdAt) || !nonempty(message.content?.text) || !exact(message.content, ["text", "type"]) || message.content.type !== "text" || !Array.isArray(message.mentions) || !this.validAuthor(message.author) || !["user", "agent", "task", "routine", "system"].includes(message.source) || message.replyToMessageId !== void 0 && !nonempty(message.replyToMessageId) || message.sourceId !== void 0 && !nonempty(message.sourceId) || message.idempotencyKey !== void 0 && !nonempty(message.idempotencyKey)) throw new RoomMessageServiceError("INVALID_STORED_MESSAGE", 500, "Invalid stored message");
     const mentions = message.mentions.map((mention) => {
       if (exact(mention, ["type"]) && mention.type === "team") return { type: "team" };
       if (exact(mention, ["membershipId", "type"]) && mention.type === "bot" && nonempty(mention.membershipId)) return { type: "bot", membershipId: mention.membershipId };
@@ -14271,6 +14498,111 @@ function matchesNormalizedPayload(message, input) {
 import { ZodError as ZodError3 } from "zod";
 import { toProjectRoomPublicMessage } from "@axiom-lattice/protocols";
 
+// src/services/collaboration/RoomInterruptService.ts
+import { randomUUID as randomUUID17 } from "crypto";
+
+// src/router/roomInterrupt.ts
+var CLARIFY_FENCE = /^```clarify\n([\s\S]*?)\n```$/;
+function readClarifyInterrupt(state) {
+  if (typeof state !== "object" || state === null) return void 0;
+  const tasks = state.tasks;
+  if (!Array.isArray(tasks)) return void 0;
+  for (const task of tasks) {
+    const interrupts = typeof task === "object" && task !== null ? task.interrupts : void 0;
+    if (!Array.isArray(interrupts)) continue;
+    for (const interrupt of interrupts) {
+      const value = typeof interrupt === "object" && interrupt !== null ? interrupt.value : void 0;
+      if (typeof value !== "string") continue;
+      const match = CLARIFY_FENCE.exec(value.trim());
+      if (!match) continue;
+      try {
+        const parsed = JSON.parse(match[1]);
+        if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.questions)) {
+          return parsed;
+        }
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function buildClarifyResumeCommand(text) {
+  return { resume: { data: { answers: [{ questionIndex: 0, otherText: text }] } } };
+}
+function buildClarifySkipCommand() {
+  return { resume: { data: { answers: [] } } };
+}
+
+// src/services/collaboration/RoomInterruptService.ts
+var RoomInterruptServiceError = class extends Error {
+  /** Creates a stable room interrupt error. */
+  constructor(code, statusCode, message) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "RoomInterruptServiceError";
+  }
+};
+var RoomInterruptService = class {
+  /** Creates the service from explicitly injected stores and dispatcher. */
+  constructor(deps) {
+    this.deps = deps;
+    this.idFactory = deps.idFactory ?? randomUUID17;
+  }
+  /** Resolves a pending clarify interrupt with no answers. */
+  async skip(input) {
+    await this.resume(input, buildClarifySkipCommand());
+  }
+  /** Resolves a pending interrupt with an explicit resume command. */
+  async resume(input, command) {
+    await this.deps.requireAccess({ tenantId: input.tenantId, userId: input.userId, projectId: input.projectId });
+    const membership = await this.deps.resolveMembership(input);
+    if (!membership || membership.status !== "active" || !membership.roomThreadId || membership.projectId !== input.projectId) {
+      throw new RoomInterruptServiceError("ROOM_INTERRUPT_TARGET_UNAVAILABLE", 404, "Room interrupt target is unavailable");
+    }
+    const scope = {
+      tenantId: membership.tenantId,
+      assistantId: membership.assistantId,
+      threadId: membership.roomThreadId,
+      workspaceId: membership.workspaceId,
+      projectId: membership.projectId
+    };
+    const status = await this.deps.getThreadStatus(scope);
+    if (String(status) !== "interrupted") {
+      throw new RoomInterruptServiceError("ROOM_INTERRUPT_NOT_PENDING", 409, "Room interrupt is no longer pending");
+    }
+    const inputMessageId = this.idFactory();
+    await this.deps.dispatcher.dispatch(
+      {
+        tenant_id: scope.tenantId,
+        assistant_id: scope.assistantId,
+        thread_id: scope.threadId,
+        workspace_id: scope.workspaceId,
+        project_id: scope.projectId
+      },
+      { input: { id: inputMessageId, message: "Clarification answers submitted" }, command },
+      {
+        executionMode: "followup",
+        trustedRunContext: {
+          projectRoom: {
+            tenantId: membership.tenantId,
+            workspaceId: membership.workspaceId,
+            projectId: membership.projectId,
+            roomId: membership.roomId,
+            sourceRoomMessageId: `interrupt:${membership.id}`,
+            membershipId: membership.id,
+            assistantId: membership.assistantId,
+            inputMessageId,
+            role: membership.role,
+            title: membership.title,
+            ...membership.responsibility === void 0 ? {} : { responsibility: membership.responsibility }
+          }
+        }
+      }
+    );
+  }
+};
+
 // src/schemas/project-room.ts
 import { z as z9 } from "zod";
 var id2 = z9.string().trim().min(1).max(128);
@@ -14311,6 +14643,15 @@ var updateProjectBotSchema = z9.object({
   mentionName: z9.string().optional(),
   expectedUpdatedAt: isoDate
 }).strict().refine((value) => value.role !== void 0 || value.title !== void 0 || value.responsibility !== void 0 || value.mentionName !== void 0, { message: "At least one mutable field is required" });
+var resumeInterruptSchema = z9.object({
+  membershipId: id2,
+  answers: z9.array(z9.object({
+    questionIndex: z9.number().int().nonnegative(),
+    otherText: z9.string().optional(),
+    selectedOptions: z9.array(z9.string()).optional(),
+    filePath: z9.string().optional()
+  }).strict()).optional()
+}).strict();
 
 // src/routes/project-rooms.ts
 var ProjectRoomAuthError = class extends Error {
@@ -14321,7 +14662,11 @@ var ProjectRoomAuthError = class extends Error {
   }
 };
 function registerProjectRoomRoutes(app2, deps) {
-  app2.get("/api/projects/:projectId/room", async (request, reply) => run(reply, async () => ({ data: await deps.roomService.ensureMainRoom(actor(request, request.params.projectId)) })));
+  app2.get("/api/projects/:projectId/room", async (request, reply) => run(reply, async () => {
+    const requestActor = actor(request, request.params.projectId);
+    const room = deps.roomService.ensureMainRoomWithCoordinator ? await deps.roomService.ensureMainRoomWithCoordinator(requestActor) : await deps.roomService.ensureMainRoom(requestActor);
+    return { data: room };
+  }));
   app2.get("/api/projects/:projectId/room/messages", async (request, reply) => run(reply, async () => {
     const params = projectRoomParamsSchema.parse(request.params);
     const query = roomMessagesQuerySchema.parse(request.query);
@@ -14353,6 +14698,16 @@ function registerProjectRoomRoutes(app2, deps) {
     await deps.readStateService.mark(actor(request, params.projectId));
     return { data: { marked: true } };
   }));
+  app2.post("/api/projects/:projectId/room/interrupts/resume", async (request, reply) => run(reply, async () => {
+    const params = projectRoomParamsSchema.parse(request.params);
+    const requestActor = actor(request, params.projectId);
+    const body = resumeInterruptSchema.parse(request.body ?? {});
+    await deps.interruptService.resume(
+      { tenantId: requestActor.tenantId, projectId: requestActor.projectId, userId: requestActor.userId, membershipId: body.membershipId },
+      { resume: { data: { answers: body.answers ?? [] } } }
+    );
+    return { data: { resolved: true } };
+  }));
   app2.get("/api/projects/:projectId/members", async (request, reply) => run(reply, async () => {
     const memberships = await deps.membershipService.list(actor(request, projectRoomParamsSchema.parse(request.params).projectId));
     const enriched = await Promise.all(memberships.map(async (membership) => {
@@ -14393,6 +14748,7 @@ async function run(reply, operation) {
     return reply.code(result.statusCode ?? 200).send({ success: true, data: result.data });
   } catch (error) {
     if (error instanceof ZodError3) return reply.code(400).send({ success: false, error: { code: "INVALID_REQUEST", message: "Invalid request", retryable: false } });
+    if (error instanceof RoomInterruptServiceError) return reply.code(error.statusCode).send({ success: false, error: { code: error.code, message: error.message, retryable: false } });
     if (error instanceof ProjectRoomAuthError || error instanceof ProjectCollaborationError || error instanceof ProjectMembershipServiceError || error instanceof ProjectRosterServiceError || error instanceof RoomMessageServiceError) return reply.code(error.statusCode).send({ success: false, error: { code: error.code, message: error.message, retryable: error instanceof RoomMessageServiceError && error.retryable } });
     return reply.code(500).send({ success: false, error: { code: "INTERNAL_ERROR", message: "Internal server error", retryable: false } });
   }
@@ -14446,7 +14802,7 @@ async function execute(reply, operation) {
 }
 
 // src/routes/cospace.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 import { ZodError as ZodError5 } from "zod";
 import {
   generateDirectHumanProjectId,
@@ -14480,16 +14836,16 @@ async function computeUnread(deps, tenantId, userId, roomId, lastMessage) {
   });
 }
 function registerCoSpaceRoutes(app2, deps) {
-  const idFactory = deps.idFactory ?? (() => randomUUID16());
+  const idFactory = deps.idFactory ?? (() => randomUUID18());
   app2.get(
     "/api/workspaces/:workspaceId/rooms",
     async (request, reply) => {
       return run2(reply, async () => {
-        const actor2 = getActor2(request);
+        const actor3 = getActor2(request);
         const params = workspaceParamsSchema.parse(request.params);
         const query = workspaceRoomsQuerySchema.parse(request.query);
         const workspace = await deps.workspaceStore.getWorkspaceById(
-          actor2.tenantId,
+          actor3.tenantId,
           params.workspaceId
         );
         if (!workspace) {
@@ -14500,16 +14856,16 @@ function registerCoSpaceRoutes(app2, deps) {
           );
         }
         const allProjects = await deps.projectStore.getProjectsByWorkspace(
-          actor2.tenantId,
+          actor3.tenantId,
           params.workspaceId
         );
         const accessibleProjects = [];
         for (const project of allProjects) {
           if (project.kind === "public") continue;
           const membership = await deps.membershipStore.findByUser(
-            actor2.tenantId,
+            actor3.tenantId,
             project.id,
-            actor2.userId
+            actor3.userId
           );
           if (membership && membership.status === "active") {
             accessibleProjects.push(project);
@@ -14519,19 +14875,19 @@ function registerCoSpaceRoutes(app2, deps) {
         for (const project of accessibleProjects) {
           try {
             const room = await deps.roomStore.getMainRoom(
-              actor2.tenantId,
+              actor3.tenantId,
               project.id
             );
             if (!room) continue;
             const messages = await deps.messageStore.list({
-              tenantId: actor2.tenantId,
+              tenantId: actor3.tenantId,
               roomId: room.id,
               limit: 1
             });
             const lastMessage = messages[0];
             const publicLastMessage = lastMessage === void 0 ? void 0 : toProjectRoomPublicMessage2(lastMessage);
             const memberships = await deps.membershipStore.list(
-              actor2.tenantId,
+              actor3.tenantId,
               project.id
             );
             const participantNames = [];
@@ -14541,7 +14897,7 @@ function registerCoSpaceRoutes(app2, deps) {
               const user = await deps.userStore.getUserById(m.userId);
               if (user) {
                 participantNames.push(user.name);
-                if (m.userId !== actor2.userId) otherHumanNames.push(user.name);
+                if (m.userId !== actor3.userId) otherHumanNames.push(user.name);
               }
             }
             const displayName = project.kind === "personal" && otherHumanNames.length === 1 ? otherHumanNames[0] : void 0;
@@ -14556,8 +14912,8 @@ function registerCoSpaceRoutes(app2, deps) {
               ...displayName === void 0 ? {} : { displayName },
               unreadCount: await computeUnread(
                 deps,
-                actor2.tenantId,
-                actor2.userId,
+                actor3.tenantId,
+                actor3.userId,
                 room.id,
                 lastMessage
               )
@@ -14572,16 +14928,16 @@ function registerCoSpaceRoutes(app2, deps) {
           return bTime - aTime;
         });
         try {
-          const publicRoom = await deps.publicRoom.ensure(actor2.tenantId, params.workspaceId);
+          const publicRoom = await deps.publicRoom.ensure(actor3.tenantId, params.workspaceId);
           if (publicRoom) {
             const publicMessages = await deps.messageStore.list({
-              tenantId: actor2.tenantId,
+              tenantId: actor3.tenantId,
               roomId: publicRoom.room.id,
               limit: 1
             });
             const publicLastMessage = publicMessages[0];
             const publicMemberships = await deps.membershipStore.list(
-              actor2.tenantId,
+              actor3.tenantId,
               publicRoom.project.id
             );
             const publicParticipantNames = [];
@@ -14601,8 +14957,8 @@ function registerCoSpaceRoutes(app2, deps) {
               isPublic: true,
               unreadCount: await computeUnread(
                 deps,
-                actor2.tenantId,
-                actor2.userId,
+                actor3.tenantId,
+                actor3.userId,
                 publicRoom.room.id,
                 publicLastMessage
               )
@@ -14619,11 +14975,11 @@ function registerCoSpaceRoutes(app2, deps) {
     "/api/workspaces/:workspaceId/direct",
     async (request, reply) => {
       return run2(reply, async () => {
-        const actor2 = getActor2(request);
+        const actor3 = getActor2(request);
         const params = workspaceParamsSchema.parse(request.params);
         const body = createDirectRoomSchema.parse(request.body);
         const workspace = await deps.workspaceStore.getWorkspaceById(
-          actor2.tenantId,
+          actor3.tenantId,
           params.workspaceId
         );
         if (!workspace) {
@@ -14636,21 +14992,21 @@ function registerCoSpaceRoutes(app2, deps) {
         let projectId;
         if (body.type === "human") {
           projectId = generateDirectHumanProjectId(
-            actor2.tenantId,
+            actor3.tenantId,
             params.workspaceId,
-            actor2.userId,
+            actor3.userId,
             body.targetUserId
           );
         } else {
           projectId = generateDirectBotProjectId(
-            actor2.tenantId,
+            actor3.tenantId,
             params.workspaceId,
-            actor2.userId,
+            actor3.userId,
             body.assistantId
           );
         }
         let project = await deps.projectStore.getProjectById(
-          actor2.tenantId,
+          actor3.tenantId,
           projectId
         );
         if (!project) {
@@ -14660,14 +15016,14 @@ function registerCoSpaceRoutes(app2, deps) {
             displayName = targetUser?.name ?? body.targetUserId;
           } else {
             const targetAssistant = await deps.assistantStore.getAssistantById(
-              actor2.tenantId,
+              actor3.tenantId,
               body.assistantId
             );
             displayName = targetAssistant?.name ?? body.assistantId;
           }
           const name = body.type === "human" ? `Direct with ${displayName}` : `Chat with ${displayName}`;
           project = await deps.projectStore.createProject(
-            actor2.tenantId,
+            actor3.tenantId,
             params.workspaceId,
             projectId,
             {
@@ -14678,45 +15034,45 @@ function registerCoSpaceRoutes(app2, deps) {
         }
         const room = await deps.roomStore.ensureMainRoom({
           id: idFactory(),
-          tenantId: actor2.tenantId,
+          tenantId: actor3.tenantId,
           workspaceId: params.workspaceId,
           projectId: project.id,
           name: project.name
         });
         let membership = await deps.membershipStore.findByUser(
-          actor2.tenantId,
+          actor3.tenantId,
           project.id,
-          actor2.userId
+          actor3.userId
         );
         if (!membership) {
           membership = await deps.membershipStore.create({
             id: idFactory(),
-            tenantId: actor2.tenantId,
+            tenantId: actor3.tenantId,
             projectId: project.id,
-            userId: actor2.userId,
+            userId: actor3.userId,
             role: "owner",
             status: "active"
           });
         } else if (membership.status === "removed") {
           membership = await deps.membershipStore.create({
             id: idFactory(),
-            tenantId: actor2.tenantId,
+            tenantId: actor3.tenantId,
             projectId: project.id,
-            userId: actor2.userId,
+            userId: actor3.userId,
             role: membership.role,
             status: "active"
           });
         }
         if (body.type === "human" && body.targetUserId) {
           const targetMembership = await deps.membershipStore.findByUser(
-            actor2.tenantId,
+            actor3.tenantId,
             project.id,
             body.targetUserId
           );
           if (!targetMembership) {
             await deps.membershipStore.create({
               id: idFactory(),
-              tenantId: actor2.tenantId,
+              tenantId: actor3.tenantId,
               projectId: project.id,
               userId: body.targetUserId,
               role: "member",
@@ -14725,7 +15081,7 @@ function registerCoSpaceRoutes(app2, deps) {
           } else if (targetMembership.status === "removed") {
             await deps.membershipStore.create({
               id: idFactory(),
-              tenantId: actor2.tenantId,
+              tenantId: actor3.tenantId,
               projectId: project.id,
               userId: body.targetUserId,
               role: targetMembership.role,
@@ -14735,19 +15091,19 @@ function registerCoSpaceRoutes(app2, deps) {
         }
         if (body.type === "bot" && body.assistantId) {
           const existingBotMembership = await deps.botMembershipStore.findByAssistant(
-            actor2.tenantId,
+            actor3.tenantId,
             project.id,
             body.assistantId
           );
           if (!existingBotMembership || existingBotMembership.status === "removed") {
             const assistant = await deps.assistantStore.getAssistantById(
-              actor2.tenantId,
+              actor3.tenantId,
               body.assistantId
             );
             const title = assistant?.name || "Assistant";
             await deps.botMembershipStore.save({
               id: idFactory(),
-              tenantId: actor2.tenantId,
+              tenantId: actor3.tenantId,
               workspaceId: params.workspaceId,
               projectId: project.id,
               roomId: room.id,
@@ -14777,11 +15133,11 @@ function registerCoSpaceRoutes(app2, deps) {
     "/api/workspaces/:workspaceId/groups",
     async (request, reply) => {
       return run2(reply, async () => {
-        const actor2 = getActor2(request);
+        const actor3 = getActor2(request);
         const params = workspaceParamsSchema.parse(request.params);
         const body = createGroupRoomSchema.parse(request.body);
         const workspace = await deps.workspaceStore.getWorkspaceById(
-          actor2.tenantId,
+          actor3.tenantId,
           params.workspaceId
         );
         if (!workspace) {
@@ -14792,34 +15148,35 @@ function registerCoSpaceRoutes(app2, deps) {
           );
         }
         const project = await deps.projectStore.createProject(
-          actor2.tenantId,
+          actor3.tenantId,
           params.workspaceId,
           idFactory(),
           { name: body.name, kind: "business" }
         );
         const room = await deps.roomStore.ensureMainRoom({
           id: idFactory(),
-          tenantId: actor2.tenantId,
+          tenantId: actor3.tenantId,
           workspaceId: params.workspaceId,
           projectId: project.id,
           name: project.name
         });
         await deps.membershipStore.create({
           id: idFactory(),
-          tenantId: actor2.tenantId,
+          tenantId: actor3.tenantId,
           projectId: project.id,
-          userId: actor2.userId,
+          userId: actor3.userId,
           role: "owner",
           status: "active"
         });
-        const coordinator = await deps.coordinatorProvisioner.ensure(actor2.tenantId);
+        const coordinator = await deps.coordinatorProvisioner.ensure(actor3.tenantId);
+        const mentionName = await deps.getCoordinatorMentionName?.(actor3.tenantId) ?? ROOM_COORDINATOR_KEY;
         await deps.rosterService.addBot(
-          { tenantId: actor2.tenantId, userId: actor2.userId, projectId: project.id },
+          { tenantId: actor3.tenantId, userId: actor3.userId, projectId: project.id },
           {
             assistantId: coordinator.id,
             role: "coordinator",
             title: coordinator.name,
-            mentionName: ROOM_COORDINATOR_KEY
+            mentionName
           }
         );
         return { statusCode: 201, data: { project, room } };
@@ -14830,10 +15187,10 @@ function registerCoSpaceRoutes(app2, deps) {
     "/api/workspaces/:workspaceId/orgs/bots",
     async (request, reply) => {
       return run2(reply, async () => {
-        const actor2 = getActor2(request);
+        const actor3 = getActor2(request);
         const params = workspaceParamsSchema.parse(request.params);
         const workspace = await deps.workspaceStore.getWorkspaceById(
-          actor2.tenantId,
+          actor3.tenantId,
           params.workspaceId
         );
         if (!workspace) {
@@ -14844,18 +15201,18 @@ function registerCoSpaceRoutes(app2, deps) {
           );
         }
         const assistants = await deps.assistantStore.getAllAssistants(
-          actor2.tenantId
+          actor3.tenantId
         );
         const bots = [];
         for (const assistant of assistants) {
           const directProjectId = generateDirectBotProjectId(
-            actor2.tenantId,
+            actor3.tenantId,
             params.workspaceId,
-            actor2.userId,
+            actor3.userId,
             assistant.id
           );
           const existingProject = await deps.projectStore.getProjectById(
-            actor2.tenantId,
+            actor3.tenantId,
             directProjectId
           );
           const bot = {
@@ -14867,7 +15224,7 @@ function registerCoSpaceRoutes(app2, deps) {
           if (assistant.createdAt) bot.createdAt = assistant.createdAt.toISOString();
           if (existingProject) {
             const membership = await deps.botMembershipStore.findByAssistant(
-              actor2.tenantId,
+              actor3.tenantId,
               directProjectId,
               assistant.id
             );
@@ -14889,10 +15246,10 @@ function registerCoSpaceRoutes(app2, deps) {
     "/api/workspaces/:workspaceId/orgs/members",
     async (request, reply) => {
       return run2(reply, async () => {
-        const actor2 = getActor2(request);
+        const actor3 = getActor2(request);
         const params = workspaceParamsSchema.parse(request.params);
         const workspace = await deps.workspaceStore.getWorkspaceById(
-          actor2.tenantId,
+          actor3.tenantId,
           params.workspaceId
         );
         if (!workspace) {
@@ -14903,21 +15260,21 @@ function registerCoSpaceRoutes(app2, deps) {
           );
         }
         const userTenantLinks = await deps.userTenantLinkStore.getUsersByTenant(
-          actor2.tenantId
+          actor3.tenantId
         );
         const members = [];
         for (const link of userTenantLinks) {
-          if (link.userId === actor2.userId) continue;
+          if (link.userId === actor3.userId) continue;
           const user = await deps.userStore.getUserById(link.userId);
           if (!user) continue;
           const directProjectId = generateDirectHumanProjectId(
-            actor2.tenantId,
+            actor3.tenantId,
             params.workspaceId,
-            actor2.userId,
+            actor3.userId,
             link.userId
           );
           const existingProject = await deps.projectStore.getProjectById(
-            actor2.tenantId,
+            actor3.tenantId,
             directProjectId
           );
           const member = {
@@ -14938,11 +15295,11 @@ function registerCoSpaceRoutes(app2, deps) {
     "/api/workspaces/:workspaceId/rooms/:roomId/messages",
     async (request, reply) => {
       return run2(reply, async () => {
-        const actor2 = getActor2(request);
+        const actor3 = getActor2(request);
         const params = workspaceRoomParamsSchema.parse(request.params);
         const body = sendMessageSchema.parse(request.body);
         const workspace = await deps.workspaceStore.getWorkspaceById(
-          actor2.tenantId,
+          actor3.tenantId,
           params.workspaceId
         );
         if (!workspace) {
@@ -14953,14 +15310,14 @@ function registerCoSpaceRoutes(app2, deps) {
           );
         }
         const projects = await deps.projectStore.getProjectsByWorkspace(
-          actor2.tenantId,
+          actor3.tenantId,
           params.workspaceId
         );
         let targetRoom = null;
         let targetProject = null;
         for (const project of projects) {
           const room = await deps.roomStore.getMainRoom(
-            actor2.tenantId,
+            actor3.tenantId,
             project.id
           );
           if (room && room.id === params.roomId) {
@@ -14978,11 +15335,11 @@ function registerCoSpaceRoutes(app2, deps) {
         }
         const message = await deps.messageStore.create({
           id: idFactory(),
-          tenantId: actor2.tenantId,
+          tenantId: actor3.tenantId,
           workspaceId: params.workspaceId,
           projectId: targetProject.id,
           roomId: targetRoom.id,
-          author: { type: "human", userId: actor2.userId },
+          author: { type: "human", userId: actor3.userId },
           content: { type: "text", text: body.text },
           mentions: [],
           source: "user"
@@ -15031,6 +15388,59 @@ function registerCoSpaceRoutes(app2, deps) {
   }
 }
 
+// src/routes/push-notifications.ts
+import { ZodError as ZodError6, z as z10 } from "zod";
+var subscriptionSchema = z10.object({ endpoint: z10.string().min(1), keys: z10.object({ p256dh: z10.string().min(1), auth: z10.string().min(1) }).strict() }).strict();
+var deleteSchema = z10.object({ endpoint: z10.string().min(1) }).strict();
+function actor2(request) {
+  const user = request.user;
+  return user?.id && user.tenantId ? { tenantId: user.tenantId, userId: user.id } : null;
+}
+function unauthorized() {
+  return { statusCode: 401, body: { success: false, error: { code: "UNAUTHORIZED", message: "Console session required", retryable: false } } };
+}
+function registerPushNotificationRoutes(app2, deps) {
+  app2.get("/api/push/vapid-public-key", async (request, reply) => {
+    if (actor2(request) === null) return reply.code(401).send(unauthorized().body);
+    return reply.send({ success: true, data: { publicKey: deps.vapidPublicKey } });
+  });
+  app2.post("/api/push/subscriptions", async (request, reply) => {
+    const current = actor2(request);
+    if (current === null) return reply.code(401).send(unauthorized().body);
+    try {
+      const body = subscriptionSchema.parse(request.body);
+      const userAgent = request.headers["user-agent"];
+      await deps.subscriptionStore.save({
+        tenantId: current.tenantId,
+        userId: current.userId,
+        endpoint: body.endpoint,
+        keys: body.keys,
+        ...typeof userAgent === "string" && userAgent.length > 0 ? { userAgent } : {}
+      });
+      return reply.code(204).send();
+    } catch (error) {
+      if (error instanceof ZodError6) {
+        return reply.code(400).send({ success: false, error: { code: "INVALID_REQUEST", message: "Invalid request", retryable: false } });
+      }
+      return reply.code(500).send({ success: false, error: { code: "INTERNAL_ERROR", message: "Internal server error", retryable: false } });
+    }
+  });
+  app2.delete("/api/push/subscriptions", async (request, reply) => {
+    const current = actor2(request);
+    if (current === null) return reply.code(401).send(unauthorized().body);
+    try {
+      const body = deleteSchema.parse(request.body);
+      await deps.subscriptionStore.delete(current.tenantId, current.userId, body.endpoint);
+      return reply.code(204).send();
+    } catch (error) {
+      if (error instanceof ZodError6) {
+        return reply.code(400).send({ success: false, error: { code: "INVALID_REQUEST", message: "Invalid request", retryable: false } });
+      }
+      return reply.code(500).send({ success: false, error: { code: "INTERNAL_ERROR", message: "Internal server error", retryable: false } });
+    }
+  });
+}
+
 // src/services/collaboration/InternalRoomInstallationService.ts
 import { v5 as uuidv5 } from "uuid";
 var ROOM_INSTALLATION_NAMESPACE = "1b671a64-40d5-491e-99b0-da01ff1f3341";
@@ -15083,22 +15493,6 @@ var InternalRoomInstallationService = class {
   }
 };
 
-// src/services/collaboration/RoomBindingLifecycle.ts
-var NoopRoomBindingLifecycle = class {
-  /** Performs no binding work. */
-  async ensure(_membership) {
-  }
-  /** Performs no binding work. */
-  async pause(_membership) {
-  }
-  /** Performs no binding work. */
-  async resume(_membership) {
-  }
-  /** Performs no binding work. */
-  async remove(_membership) {
-  }
-};
-
 // src/services/collaboration/RoomBindingProvisioner.ts
 var RoomBindingProvisionerError = class extends Error {
   /** Creates a binding provisioning failure with a stable machine-readable code. */
@@ -15285,6 +15679,7 @@ var RoomDispatchService = class {
   async dispatch(message) {
     const source = snapshotDispatchSource(message);
     if (!source) throw new Error("Invalid project room dispatch message");
+    const anchorMessageId = source.sourceId ?? source.id;
     const entries = await this.deps.resolver.resolve(source);
     const results = [];
     for (const entry of entries) {
@@ -15304,7 +15699,7 @@ var RoomDispatchService = class {
           content: { text: source.content.text },
           conversation: { id: membership.roomId, type: "group" },
           replyTarget: { adapterChannel: "room", channelInstallationId: installation.id, rawTarget: {
-            sourceRoomMessageId: source.id,
+            sourceRoomMessageId: anchorMessageId,
             targetMembershipId: membership.id,
             inputMessageId: "pending-router-input"
           } }
@@ -15318,7 +15713,7 @@ var RoomDispatchService = class {
               workspaceId: membership.workspaceId,
               projectId: membership.projectId,
               roomId: membership.roomId,
-              sourceRoomMessageId: source.id,
+              sourceRoomMessageId: anchorMessageId,
               membershipId: membership.id,
               assistantId: membership.assistantId,
               inputMessageId: "pending-router-input",
@@ -15354,6 +15749,7 @@ function snapshotDispatchSource(value) {
   }
   const mentions = snapshotMentions(values.mentions);
   if (!mentions) return void 0;
+  if (values.sourceId !== void 0 && (typeof values.sourceId !== "string" || values.sourceId.length === 0)) return void 0;
   return {
     id: values.id,
     tenantId: values.tenantId,
@@ -15364,6 +15760,7 @@ function snapshotDispatchSource(value) {
     content: { type: "text", text: content.text },
     mentions,
     source: "user",
+    ...values.sourceId === void 0 ? {} : { sourceId: values.sourceId },
     createdAt
   };
 }
@@ -15393,7 +15790,7 @@ function exactValues(value, required, optional = []) {
 }
 
 // src/services/collaboration/CoordinatorWakeNotifier.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 import { isProjectLifecycleTask as isProjectLifecycleTask2 } from "@axiom-lattice/core";
 import {
   snapshotExactRecord as snapshotExactRecord6
@@ -15410,10 +15807,10 @@ 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 ?? randomUUID17;
+    this.idFactory = deps.idFactory ?? randomUUID19;
   }
   /** Admits one notification without awaiting any store or dispatch operation. */
-  handle(value) {
+  handle(value, anchorMessageId) {
     const notification = this.parse(value);
     if (!notification) {
       this.warn("Project task wake notification rejected", { code: "INVALID_COORDINATOR_WAKE_EVENT" });
@@ -15432,7 +15829,7 @@ var CoordinatorWakeNotifier = class {
     if (queue.keys.has(eventKey)) return queue.tail;
     if (this.pendingCount >= this.maxPending) return this.overflow(notification.taskId);
     queue.keys.add(eventKey);
-    queue.events.push(notification);
+    queue.events.push({ notification, ...anchorMessageId === void 0 ? {} : { anchorMessageId } });
     this.pendingCount += 1;
     const previousTail = queue.tail;
     queue.tail = previousTail.then(() => this.processQueue(scopeKey3, queue)).catch((error) => {
@@ -15468,17 +15865,17 @@ var CoordinatorWakeNotifier = class {
   }
   async processQueue(scopeKey3, queue) {
     while (queue.events.length > 0) {
-      const notification = queue.events.shift();
+      const entry = queue.events.shift();
       try {
-        if (!this.closed) await this.wake(notification);
+        if (!this.closed) await this.wake(entry.notification, entry.anchorMessageId);
       } finally {
-        queue.keys.delete(notification.eventKey);
+        queue.keys.delete(entry.notification.eventKey);
         this.pendingCount -= 1;
       }
     }
     if (queue.events.length === 0 && this.queues.get(scopeKey3) === queue) this.queues.delete(scopeKey3);
   }
-  async wake(notification) {
+  async wake(notification, anchorMessageId) {
     try {
       const task = snapshotTaskItem(await this.deps.tasks.getById(notification.tenantId, notification.taskId));
       if (this.closed) return;
@@ -15500,7 +15897,8 @@ var CoordinatorWakeNotifier = class {
       const coordinator = await this.findActiveCoordinator(room, notification.tenantId, notification.projectId);
       if (this.closed) return;
       if (!coordinator) return;
-      await this.dispatchWake(notification, task, room, owner, coordinator);
+      const anchor = anchorMessageId ?? readSourceMessageId(task.context);
+      await this.dispatchWake(notification, task, room, owner, coordinator, anchor);
     } catch (error) {
       this.warn("project-room:coordinator-wake-failed", { code: "COORDINATOR_WAKE_FAILED", taskId: safeId(notification.taskId), error: error instanceof Error ? error.name : "UnknownError" });
     }
@@ -15516,7 +15914,7 @@ var CoordinatorWakeNotifier = class {
     }
     return void 0;
   }
-  async dispatchWake(notification, task, room, owner, coordinator) {
+  async dispatchWake(notification, task, room, owner, coordinator, anchorMessageId) {
     const message = {
       id: this.idFactory(),
       tenantId: room.tenantId,
@@ -15527,6 +15925,7 @@ var CoordinatorWakeNotifier = class {
       content: { type: "text", text: coordinatorWakeText(task, owner, notification.status) },
       mentions: [{ type: "bot", membershipId: coordinator.id }],
       source: "user",
+      ...anchorMessageId === void 0 ? {} : { sourceId: anchorMessageId },
       createdAt: /* @__PURE__ */ new Date()
     };
     let results;
@@ -15587,6 +15986,10 @@ Failure: ${task.failureReason}` : "";
 function safeId(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function readSourceMessageId(context) {
+  const value = context?.source_message_id;
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 
 // src/services/collaboration/ProjectTaskExecutionMutex.ts
 import { snapshotExactRecord as snapshotExactRecord7 } from "@axiom-lattice/protocols";
@@ -15667,6 +16070,7 @@ var ProjectTaskExecutionMutex = class {
 };
 
 // src/services/collaboration/ProjectTaskExecutionService.ts
+import { randomUUID as randomUUID20 } from "crypto";
 import {
   ThreadStatus as ThreadStatus3,
   isProjectLifecycleTask as isProjectLifecycleTask3,
@@ -15934,7 +16338,7 @@ var ProjectTaskExecutionService = class {
     return current;
   }
   async dispatchRun(task, thread, mode, signal) {
-    const messageId = mode === "start" ? `project-task:${task.id}:${thread.id}:start` : `project-task:${task.id}:${thread.id}:resume:${task.updatedAt.toISOString()}`;
+    const messageId = (this.options.idFactory ?? randomUUID20)();
     if (signal?.aborted) return this.compensateCancellation(task, thread, messageId, false);
     const settlement = this.armSettlement(task, thread, messageId);
     try {
@@ -16018,7 +16422,7 @@ var ProjectTaskExecutionService = class {
       if (event.messageId !== messageId || !tryClaim()) return;
       cleanup();
       const error = "Project task execution interrupted without durable lifecycle transition";
-      void this.withLifecycleTimeout(this.settleInterruptedEvent(task, thread, messageId), {
+      void this.withLifecycleTimeout(this.settleInterruptedEvent(task, thread, messageId, event.state), {
         kind: "failed",
         task,
         thread,
@@ -16090,11 +16494,18 @@ var ProjectTaskExecutionService = class {
       return void 0;
     }
   }
-  async settleInterruptedEvent(task, thread, messageId) {
+  async settleInterruptedEvent(task, thread, messageId, state) {
     const current = await this.withLifecycleTimeout(this.reloadTask(task), void 0);
     if (current?.status === "interrupted" && this.matchesExecution(current, task, thread)) {
       return { kind: "interrupted", task: current, thread, messageId };
     }
+    const clarify = readClarifyInterrupt(state ?? await this.readInterruptedThreadState(task, thread));
+    if (clarify !== void 0) {
+      const interrupted = await this.interruptForClarify(current ?? task, thread, clarify);
+      if (interrupted?.status === "interrupted" && this.matchesExecution(interrupted, task, thread)) {
+        return { kind: "interrupted", task: interrupted, thread, messageId };
+      }
+    }
     return this.failSettledTaskAwaited(
       task,
       thread,
@@ -16103,6 +16514,35 @@ var ProjectTaskExecutionService = class {
       "interruption_not_durable"
     );
   }
+  /** Reads the paused thread snapshot when no interrupt event payload is available (recovery). */
+  async readInterruptedThreadState(task, thread) {
+    try {
+      return await this.deps.agentFor(task, thread).getCurrentState();
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Persists a durable `missing_input` interruption for a paused clarify question.
+   *
+   * @remarks The task must survive the pause so the room can answer it; the
+   * agent resumes the same run once the answer arrives.
+   */
+  async interruptForClarify(task, thread, clarify) {
+    const summary = clarify.questions.find(
+      (question) => typeof question.question === "string" && question.question.trim().length > 0
+    )?.question.trim() ?? "Waiting for clarification from the room";
+    const result = await this.withLifecycleTimeout(this.deps.lifecycle.interruptTask({
+      tenantId: task.tenantId,
+      taskId: task.id,
+      type: "missing_input",
+      summary,
+      actor: SYSTEM_ACTOR,
+      threadId: thread.id
+    }), void 0);
+    if (!result || !result.success) return void 0;
+    return result.task ?? await this.reloadTask(task);
+  }
   async settleEndedRecovery(input, error) {
     const current = await this.withLifecycleTimeout(this.reloadTask(input.task), void 0);
     if (current && this.matchesExecution(current, input.task, input.thread)) {
@@ -16285,6 +16725,9 @@ import {
   isProjectLifecycleTask as isProjectLifecycleTask4,
   parseExternalDependency as parseExternalDependency2
 } from "@axiom-lattice/core";
+import {
+  snapshotExactRecord as snapshotExactRecord9
+} from "@axiom-lattice/protocols";
 var SYSTEM_ACTOR2 = "system";
 var TERMINAL_ACTIONS = ["completed", "failed", "interrupted", "cancelled"];
 var MAX_LEARNING_ROUND_ANCESTORS = 8;
@@ -16355,6 +16798,10 @@ var ProjectTaskObserver = class {
       if (signal?.aborted) continue;
       const task = snapshotTaskItem(await this.deps.tasks.getById(hint.event.tenantId, hint.event.taskId));
       if (signal?.aborted) continue;
+      if (task && task.workspaceId === hint.event.workspaceId && task.projectId === hint.event.projectId) {
+        await this.projectDelegation(task);
+      }
+      if (signal?.aborted) continue;
       const eventTime = Date.parse(hint.event.updatedAt);
       if (task && task.status === "pending" && task.ownerType === "agent" && task.workspaceId === hint.event.workspaceId && task.projectId === hint.event.projectId && task.ownerId === hint.event.ownerId && task.updatedAt.getTime() >= eventTime) {
         await this.reconcileTask(task, signal);
@@ -16365,14 +16812,21 @@ var ProjectTaskObserver = class {
   async notify(event) {
     const task = snapshotTaskItem(await this.deps.tasks.getById(event.tenantId, event.taskId));
     const item = await this.deps.workItems.findByEventKey(event.tenantId, event.taskId, event.eventKey);
-    if (!task || !item || item.eventKey !== event.eventKey || item.action !== event.action || item.taskId !== event.taskId || item.tenantId !== event.tenantId || item.workspaceId !== event.workspaceId || item.projectId !== event.projectId || item.threadId !== event.threadId || task.workspaceId !== event.workspaceId || task.projectId !== event.projectId) return;
-    if (task.status === event.status && task.updatedAt.toISOString() === event.updatedAt && (event.threadId === void 0 || task.context?.thread_id === event.threadId)) {
+    if (!task || task.workspaceId !== event.workspaceId || task.projectId !== event.projectId) return;
+    const matches = item !== null && item !== void 0 && item.eventKey === event.eventKey && item.action === event.action && item.taskId === event.taskId && item.tenantId === event.tenantId && item.workspaceId === event.workspaceId && item.projectId === event.projectId && item.threadId === event.threadId;
+    let anchorMessageId;
+    if (matches && task.status === event.status && task.updatedAt.toISOString() === event.updatedAt && (event.threadId === void 0 || task.context?.thread_id === event.threadId)) {
       try {
-        await this.deps.projection.project({ task, room: await this.exactMainRoom(task), workItem: item });
+        const result = await this.deps.projection.project({ task, room: await this.exactMainRoom(task), workItem: item });
+        if (result.kind === "projected") anchorMessageId = result.message.id;
       } catch (error) {
         await this.safeWarning(task, "projection", error);
       }
     }
+    if ((event.status === "completed" || event.status === "failed") && task.status === event.status) {
+      void this.deps.coordinatorWake?.handle(event, anchorMessageId);
+    }
+    if (!matches) return;
     if (event.action === "completed" && task.status === "completed") await this.wakeParent(task);
     if (TERMINAL_ACTIONS.includes(event.action) && isTerminal(task.status)) await this.reevaluateDependents(task);
   }
@@ -16458,6 +16912,34 @@ var ProjectTaskObserver = class {
       await this.resumeIfReady(task, signal);
     }
   }
+  /**
+   * Projects the one-time delegation event for an Agent-created task assigned to another Agent.
+   *
+   * @param task Exact newly admitted Project task snapshot.
+   * @remarks Admission hints are the creation signal; idempotency lives in the projection key.
+   * Learning-round subtrees stay out of the room, matching admission and wake exemptions.
+   */
+  async projectDelegation(task) {
+    const createdBy = readCreatedBy(task.context?.created_by);
+    if (!createdBy || task.ownerType !== "agent" || createdBy.assistantId === task.ownerId) return;
+    try {
+      if (await this.belongsToLearningRound(task)) return;
+      const room = await this.exactMainRoom(task);
+      const from = await this.deps.bots.findById(task.tenantId, createdBy.membershipId) ?? await this.deps.bots.findByAssistant(task.tenantId, task.projectId, createdBy.assistantId);
+      const to = await this.deps.bots.findByAssistant(task.tenantId, task.projectId, task.ownerId);
+      const result = await this.deps.projection.projectDelegation({
+        task,
+        room,
+        fromLabel: `@${from?.mentionName ?? createdBy.assistantId}`,
+        toLabel: `@${to?.mentionName ?? task.ownerId}`
+      });
+      if (result.kind === "warning") {
+        this.deps.log.warn("Project task delegation projection failed", { taskId: task.id, code: result.warning.code });
+      }
+    } catch (error) {
+      await this.safeWarning(task, "delegation", error);
+    }
+  }
   // SCOPE-COMPAT: learning rounds (metadata.trainingRound) and their subtrees execute in the
   // architect's builder thread (canvas CopilotPanel), not the Project Room runtime. Exempting
   // them here keeps admission hints, startup reconciliation, and dependent re-evaluation from
@@ -16980,6 +17462,14 @@ function isTerminal(status) {
 function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function readCreatedBy(value) {
+  try {
+    const row = snapshotExactRecord9(value, ["assistantId", "membershipId"]);
+    return row && typeof row.assistantId === "string" && row.assistantId.length > 0 && typeof row.membershipId === "string" && row.membershipId.length > 0 ? { assistantId: row.assistantId, membershipId: row.membershipId } : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function combineSignals(left, right) {
   const signals = [left, right].filter((signal) => signal !== void 0);
   if (signals.length === 0) return void 0;
@@ -16991,10 +17481,22 @@ function combineSignals(left, right) {
 import { createHash as createHash6 } from "crypto";
 import { isProjectLifecycleTask as isProjectLifecycleTask5 } from "@axiom-lattice/core";
 import {
+  PROJECT_ROOM_TASK_DELEGATED_LABEL,
+  PROJECT_ROOM_TASK_DELEGATED_SEPARATOR,
   PROJECT_TASK_LIFECYCLE_ACTIONS,
   snapshotExactArray as snapshotExactArray2,
-  snapshotExactRecord as snapshotExactRecord9
+  snapshotExactRecord as snapshotExactRecord10
 } from "@axiom-lattice/protocols";
+var ROOM_PROJECTABLE_ACTIONS = [
+  "interrupted",
+  "failed",
+  "completed",
+  "cancelled",
+  "reassigned"
+];
+function isRoomProjectableAction(action) {
+  return ROOM_PROJECTABLE_ACTIONS.includes(action);
+}
 var RoomProjectionService = class {
   /** @param deps Message, lifecycle-event, Task, warning, logging, and ID dependencies. */
   constructor(deps) {
@@ -17010,6 +17512,7 @@ var RoomProjectionService = class {
     const parsed = parseProjectionInput(input.task, input.workItem);
     const room = snapshotProjectRoom(input.room);
     const scope = room ? { tenantId: room.tenantId, workspaceId: room.workspaceId, projectId: room.projectId } : void 0;
+    if (!parsed.ok && parsed.routine) return { kind: "skipped" };
     if (!parsed.ok || !room || parsed.task.tenantId !== room.tenantId || parsed.task.workspaceId !== room.workspaceId || parsed.task.projectId !== room.projectId || parsed.item.tenantId !== parsed.task.tenantId || parsed.item.workspaceId !== parsed.task.workspaceId || parsed.item.projectId !== parsed.task.projectId || parsed.item.taskId !== parsed.task.id) {
       return this.warning(
         "INVALID_PROJECTABLE_EVENT",
@@ -17040,6 +17543,42 @@ var RoomProjectionService = class {
       return this.warning("PROJECTION_WRITE_FAILED", { taskId: task.id, eventKey: item.eventKey }, scope);
     }
   }
+  /**
+   * Projects the one-time delegation event for an Agent-created task assigned to another Agent.
+   *
+   * @param input Untrusted Task and main room candidates plus resolved actor labels.
+   * @returns The canonical stored message or a recoverable warning result.
+   * @remarks Idempotent per task: repeated admission hints or replays never duplicate the row.
+   */
+  async projectDelegation(input) {
+    const task = snapshotTaskItem(input.task);
+    const room = snapshotProjectRoom(input.room);
+    if (!task || !room || task.tenantId !== room.tenantId || task.workspaceId !== room.workspaceId || task.projectId !== room.projectId) {
+      return { kind: "warning", warning: { code: "ROOM_TASK_PROJECTION_FAILED", ...task ? { taskId: task.id } : {} } };
+    }
+    const scope = { tenantId: task.tenantId, workspaceId: task.workspaceId, projectId: task.projectId };
+    try {
+      const candidate = {
+        id: this.deps.idFactory(),
+        tenantId: task.tenantId,
+        workspaceId: task.workspaceId,
+        projectId: task.projectId,
+        roomId: room.id,
+        author: { type: "system" },
+        content: { type: "text", text: `${PROJECT_ROOM_TASK_DELEGATED_LABEL}${PROJECT_ROOM_TASK_DELEGATED_SEPARATOR}${input.fromLabel} \u2192 ${input.toLabel}` },
+        mentions: [],
+        source: "task",
+        sourceId: task.id,
+        idempotencyKey: tupleKey("task-delegation", [task.id])
+      };
+      const canonical = await this.deps.messages.createIdempotent(candidate);
+      const message = assertCanonicalProjection(canonical, candidate);
+      void Promise.resolve().then(() => this.deps.realtime?.messageCreated(message)).catch(() => void 0);
+      return { kind: "projected", message };
+    } catch {
+      return this.warning("PROJECTION_WRITE_FAILED", { taskId: task.id, eventKey: "delegation" }, scope);
+    }
+  }
   /**
    * Replays bounded raw lifecycle pages for one exact Project scope.
    *
@@ -17054,7 +17593,7 @@ var RoomProjectionService = class {
         tenantId: input.tenantId,
         workspaceId: input.workspaceId,
         projectId: input.projectId,
-        actions: [...PROJECT_TASK_LIFECYCLE_ACTIONS],
+        actions: [...ROOM_PROJECTABLE_ACTIONS],
         before,
         limit: input.pageSize
       });
@@ -17169,6 +17708,7 @@ function parseProjectionInput(taskValue, itemValue) {
   try {
     const task = snapshotProjectTask(taskValue);
     const item = snapshotProjectableWorkItem(itemValue);
+    if (item && !isRoomProjectableAction(item.action)) return { ok: false, routine: true };
     const projection = item ? parseProjection(item) : void 0;
     return task && item && projection ? { ok: true, task, item, projection } : { ok: false, ...safeIdentity ? { safeIdentity } : {} };
   } catch {
@@ -17176,7 +17716,7 @@ function parseProjectionInput(taskValue, itemValue) {
   }
 }
 function snapshotProjectableWorkItem(value) {
-  const row = snapshotExactRecord9(value, ["id", "taskId", "tenantId", "action", "actor", "createdAt"], [
+  const row = snapshotExactRecord10(value, ["id", "taskId", "tenantId", "action", "actor", "createdAt"], [
     "workspaceId",
     "projectId",
     "threadId",
@@ -17213,11 +17753,11 @@ function parseIso(value) {
   return typeof value === "string" && value.length > 0 && Number.isFinite(Date.parse(value));
 }
 function parseInterruption(value) {
-  const common = snapshotExactRecord9(value, ["type", "summary", "requestedAt"]);
+  const common = snapshotExactRecord10(value, ["type", "summary", "requestedAt"]);
   if (common && (common.type === "missing_input" || common.type === "user_decision") && typeof common.summary === "string" && common.summary.length > 0 && parseIso(common.requestedAt)) {
     return { type: common.type, summary: common.summary, requestedAt: common.requestedAt };
   }
-  const external = snapshotExactRecord9(value, ["type", "summary", "requestedAt", "dependencyTaskIds"]);
+  const external = snapshotExactRecord10(value, ["type", "summary", "requestedAt", "dependencyTaskIds"]);
   const ids = snapshotExactArray2(external?.dependencyTaskIds);
   if (external?.type === "external_dependency" && typeof external.summary === "string" && external.summary.length > 0 && parseIso(external.requestedAt) && ids && ids.length > 0 && ids.every((id3) => typeof id3 === "string" && id3.length > 0) && new Set(ids).size === ids.length) {
     return {
@@ -17227,7 +17767,7 @@ function parseInterruption(value) {
       dependencyTaskIds: [...ids]
     };
   }
-  const review = snapshotExactRecord9(value, ["type", "evidenceId"]);
+  const review = snapshotExactRecord10(value, ["type", "evidenceId"]);
   return review?.type === "review_required" && typeof review.evidenceId === "string" && review.evidenceId.length > 0 ? { type: "review_required", evidenceId: review.evidenceId } : void 0;
 }
 function parseBeliefImpact(value) {
@@ -17235,50 +17775,36 @@ function parseBeliefImpact(value) {
   if (!rows) return void 0;
   const impacts = [];
   for (const row of rows) {
-    const entry = snapshotExactRecord9(row, ["key", "after", "basis"]);
+    const entry = snapshotExactRecord10(row, ["key", "after", "basis"]);
     if (!entry || typeof entry.key !== "string" || !entry.key || typeof entry.after !== "number" || !Number.isFinite(entry.after) || typeof entry.basis !== "string" || !entry.basis) return void 0;
     impacts.push({ key: entry.key, after: entry.after, basis: entry.basis });
   }
   return impacts;
 }
 function parseCompletion(item) {
-  const row = snapshotExactRecord9(item.detail, ["evidenceId", "eventKey", "result", "beliefImpact"]);
+  const row = snapshotExactRecord10(item.detail, ["evidenceId", "eventKey", "result", "beliefImpact"]);
   const beliefImpact = parseBeliefImpact(row?.beliefImpact);
   if (!row || typeof row.evidenceId !== "string" || !row.evidenceId || typeof row.eventKey !== "string" || !row.eventKey || item.eventKey !== `${row.eventKey}:completed` || typeof row.result !== "string" || !beliefImpact) return void 0;
   return { evidenceId: row.evidenceId, eventKey: row.eventKey, result: row.result, beliefImpact };
 }
 function parseProjection(item) {
-  if (item.action === "in_progress") {
-    const started = snapshotExactRecord9(item.detail, ["previousStatus"]);
-    if (started?.previousStatus === "pending") return { kind: "started", text: "Task started" };
-    const resumed = snapshotExactRecord9(item.detail, ["type", "previousInterruption"]);
-    if (resumed?.type === "interruption_resume" && parseInterruption(resumed.previousInterruption)) {
-      return { kind: "resumed", text: "Task resumed" };
-    }
-    const rejected = snapshotExactRecord9(item.detail, ["type", "evidenceId", "note"]);
-    if (rejected?.type === "review_rejected" && typeof rejected.evidenceId === "string" && rejected.evidenceId && typeof rejected.note === "string" && rejected.note) {
-      return { kind: "resumed", text: "Task resumed after review rejection" };
-    }
-    const stale = snapshotExactRecord9(item.detail, ["type", "evidenceId"]);
-    return stale?.type === "review_stale" && typeof stale.evidenceId === "string" && stale.evidenceId ? { kind: "resumed", text: "Task resumed after stale review" } : void 0;
-  }
   if (item.action === "interrupted") {
     return parseInterruption(item.detail) ? { kind: "interrupted", text: "Task interrupted" } : void 0;
   }
   if (item.action === "failed") {
-    const row = snapshotExactRecord9(item.detail, ["failureReason"]);
+    const row = snapshotExactRecord10(item.detail, ["failureReason"]);
     return typeof row?.failureReason === "string" && row.failureReason ? { kind: "failed", text: "Task failed" } : void 0;
   }
   if (item.action === "completed") {
     return parseCompletion(item) ? { kind: "completed", text: "Task completed" } : void 0;
   }
   if (item.action === "cancelled") {
-    const empty = snapshotExactRecord9(item.detail, []);
-    const summarized = snapshotExactRecord9(item.detail, ["summary"]);
+    const empty = snapshotExactRecord10(item.detail, []);
+    const summarized = snapshotExactRecord10(item.detail, ["summary"]);
     return empty || typeof summarized?.summary === "string" && summarized.summary ? { kind: "cancelled", text: "Task cancelled" } : void 0;
   }
   if (item.action === "reassigned") {
-    const row = snapshotExactRecord9(
+    const row = snapshotExactRecord10(
       item.detail,
       ["previousOwnerId", "previousThreadId", "ownerId", "membershipId", "threadId"]
     );
@@ -17287,7 +17813,7 @@ function parseProjection(item) {
   return void 0;
 }
 function assertCanonicalProjection(value, expected) {
-  const row = snapshotExactRecord9(value, [
+  const row = snapshotExactRecord10(value, [
     "id",
     "tenantId",
     "workspaceId",
@@ -17301,8 +17827,8 @@ function assertCanonicalProjection(value, expected) {
     "idempotencyKey",
     "createdAt"
   ]);
-  const author = snapshotExactRecord9(row?.author, ["type"]);
-  const content = snapshotExactRecord9(row?.content, ["type", "text"]);
+  const author = snapshotExactRecord10(row?.author, ["type"]);
+  const content = snapshotExactRecord10(row?.content, ["type", "text"]);
   const mentions = snapshotExactArray2(row?.mentions);
   const createdAt = cloneExactDate(row?.createdAt);
   if (!row || !createdAt || author?.type !== "system" || content?.type !== "text" || content.text !== expected.content.text || !mentions || mentions.length !== 0 || typeof row.id !== "string" || !row.id || row.tenantId !== expected.tenantId || row.workspaceId !== expected.workspaceId || row.projectId !== expected.projectId || row.roomId !== expected.roomId || row.source !== "task" || row.sourceId !== expected.sourceId || row.idempotencyKey !== expected.idempotencyKey) {
@@ -17324,7 +17850,7 @@ function assertCanonicalProjection(value, expected) {
   };
 }
 function snapshotLifecycleCursor(value) {
-  const row = snapshotExactRecord9(value, ["id", "taskId", "tenantId", "action", "actor", "createdAt"], [
+  const row = snapshotExactRecord10(value, ["id", "taskId", "tenantId", "action", "actor", "createdAt"], [
     "workspaceId",
     "projectId",
     "threadId",
@@ -17344,7 +17870,7 @@ function isRecord3(value) {
 import { taskLifecycleNotifier } from "@axiom-lattice/core";
 
 // src/services/collaboration/ProjectRoomEventBroker.ts
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID21 } from "crypto";
 import {
   parseProjectRoomEventId,
   ProjectRoomBrokerCapacityError,
@@ -17373,7 +17899,7 @@ var ProjectRoomEventBroker = class {
     this.subscriberCount = 0;
     this.usageClock = 0;
     this.closed = false;
-    this.epoch = options.epoch ?? randomUUID18();
+    this.epoch = options.epoch ?? randomUUID21();
     if (!UUID_PATTERN.test(this.epoch)) {
       throw new TypeError("Project Room event epoch must be a lowercase canonical UUID");
     }
@@ -17694,7 +18220,7 @@ function snapshotJson(value, ancestors = /* @__PURE__ */ new Set()) {
 import { createHash as createHash7 } from "crypto";
 import {
   projectRoomUserEventScope,
-  snapshotExactRecord as snapshotExactRecord10,
+  snapshotExactRecord as snapshotExactRecord11,
   snapshotProjectRoomBotMembershipRealtime,
   snapshotProjectRoomMembershipRealtime,
   snapshotProjectRoomMessageRealtime
@@ -17771,7 +18297,7 @@ var BrokerProjectRoomRealtimePublisher = class {
   /** Publishes a membership notice onto the affected user's channel scope. */
   membershipAffected(input) {
     this.publish("membership.affected", () => {
-      const value = snapshotExactRecord10(input, ["tenantId", "userId", "change", "projectId", "roomId", "sourceKey"]);
+      const value = snapshotExactRecord11(input, ["tenantId", "userId", "change", "projectId", "roomId", "sourceKey"]);
       if (!value || !safeId2(value.tenantId) || !safeId2(value.userId) || !safeId2(value.projectId) || !safeId2(value.roomId) || !safeSourceKey(value.sourceKey) || !["added", "removed", "role_changed"].includes(value.change)) {
         throw new TypeError("Invalid membership input");
       }
@@ -17791,7 +18317,7 @@ var BrokerProjectRoomRealtimePublisher = class {
   /** Publishes a read-marker update onto the acting user's channel scope. */
   readChanged(input) {
     this.publish("read.changed", () => {
-      const value = snapshotExactRecord10(input, ["tenantId", "userId", "projectId", "roomId", "lastReadAt", "sourceKey"]);
+      const value = snapshotExactRecord11(input, ["tenantId", "userId", "projectId", "roomId", "lastReadAt", "sourceKey"]);
       if (!value || !safeId2(value.tenantId) || !safeId2(value.userId) || !safeId2(value.projectId) || !safeId2(value.roomId) || !safeSourceKey(value.sourceKey) || typeof value.lastReadAt !== "string" || !Number.isFinite(Date.parse(value.lastReadAt))) {
         throw new TypeError("Invalid read input");
       }
@@ -17836,13 +18362,13 @@ var BrokerProjectRoomRealtimePublisher = class {
 };
 function snapshotInput(input, kind) {
   const keys2 = kind === "message" ? ["tenantId", "roomId", "message", "sourceKey"] : kind === "roster" ? ["tenantId", "roomId", "membership", "sourceKey"] : ["tenantId", "roomId", "membership", "sourceKey"];
-  const value = snapshotExactRecord10(input, [...keys2, "change"]);
+  const value = snapshotExactRecord11(input, [...keys2, "change"]);
   const validChange = kind === "roster" ? ["added", "updated", "paused", "resumed", "removed"].includes(value?.change) : ["added", "role_changed", "removed"].includes(value?.change);
   if (!value || !safeId2(value.tenantId) || !safeId2(value.roomId) || !safeSourceKey(value.sourceKey) || !validChange) throw new TypeError(`Invalid ${kind} input`);
   return value;
 }
 function snapshotTaskInput(input) {
-  const value = snapshotExactRecord10(input, ["tenantId", "roomId", "projectId", "taskId", "status", "ownerMembershipId", "updatedAt", "sourceKey"]);
+  const value = snapshotExactRecord11(input, ["tenantId", "roomId", "projectId", "taskId", "status", "ownerMembershipId", "updatedAt", "sourceKey"]);
   if (!value || !safeId2(value.tenantId) || !safeId2(value.roomId) || !safeSourceKey(value.sourceKey)) throw new TypeError("Invalid task input");
   if (!safeId2(value.projectId) || !safeId2(value.taskId) || !safeId2(value.ownerMembershipId) || !["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"].includes(value.status)) throw new TypeError("Invalid task input");
   if (typeof value.updatedAt !== "string") throw new TypeError("Invalid task timestamp");
@@ -17868,7 +18394,7 @@ function safeErrorCode(error) {
 
 // src/services/collaboration/ProjectRoomTaskEventSubscriber.ts
 import { isProjectLifecycleTask as isProjectLifecycleTask6 } from "@axiom-lattice/core";
-import { snapshotExactRecord as snapshotExactRecord11 } from "@axiom-lattice/protocols";
+import { snapshotExactRecord as snapshotExactRecord12 } from "@axiom-lattice/protocols";
 var ProjectRoomTaskEventSubscriber = class {
   /** Creates a bounded Project task lifecycle observer. */
   constructor(deps) {
@@ -17978,7 +18504,7 @@ var ProjectRoomTaskEventSubscriber = class {
     }
   }
   parse(value) {
-    const row = snapshotExactRecord11(value, ["tenantId", "workspaceId", "projectId", "taskId", "status", "action", "eventKey", "updatedAt"], ["threadId"]);
+    const row = snapshotExactRecord12(value, ["tenantId", "workspaceId", "projectId", "taskId", "status", "action", "eventKey", "updatedAt"], ["threadId"]);
     const actions = ["in_progress", "interrupted", "failed", "completed", "cancelled", "reassigned"];
     const statuses = ["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"];
     if (!row || !actions.includes(String(row.action)) || !statuses.includes(String(row.status)) || !["tenantId", "workspaceId", "projectId", "taskId", "eventKey", "updatedAt"].every((key) => typeof row[key] === "string" && row[key].length > 0) || !Number.isFinite(Date.parse(row.updatedAt)) || row.threadId !== void 0 && typeof row.threadId !== "string") return void 0;
@@ -18041,7 +18567,8 @@ var ProjectRoomRealtimeRuntime = class {
 };
 function createProjectRoomRealtimeRuntime(deps) {
   const broker = new ProjectRoomEventBroker({ log: deps.log });
-  const publisher = new BrokerProjectRoomRealtimePublisher({ broker, log: deps.log });
+  const basePublisher = new BrokerProjectRoomRealtimePublisher({ broker, log: deps.log });
+  const publisher = deps.pushNotifier ? withPushNotifier(basePublisher, deps.pushNotifier) : basePublisher;
   const subscriber = new ProjectRoomTaskEventSubscriber({
     tasks: deps.tasks,
     rooms: deps.rooms,
@@ -18058,6 +18585,20 @@ function createProjectRoomRealtimeRuntime(deps) {
     shutdownTimeoutMs: deps.shutdownTimeoutMs
   });
 }
+function withPushNotifier(target, notifier) {
+  return new Proxy(target, {
+    get(inner, prop, receiver) {
+      if (prop === "messageCreated") {
+        return (message) => {
+          inner.messageCreated(message);
+          void notifier.notifyMessage(message).catch(() => void 0);
+        };
+      }
+      const value = Reflect.get(inner, prop, receiver);
+      return typeof value === "function" ? value.bind(inner) : value;
+    }
+  });
+}
 async function boundedAllSettled(promises, timeoutMs) {
   if (promises.length === 0) return true;
   let timer;
@@ -18070,6 +18611,94 @@ async function boundedAllSettled(promises, timeoutMs) {
   return result;
 }
 
+// src/services/notifications/createRoomPushNotifier.ts
+import webpush from "web-push";
+
+// src/services/notifications/RoomPushNotifier.ts
+function isSubscriptionGone(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const statusCode = error.statusCode;
+  return statusCode === 404 || statusCode === 410;
+}
+var MAX_BODY = 140;
+var RoomPushNotifier = class {
+  /** Creates a notifier from explicitly injected collaborators. */
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /**
+   * Notifies the room's active human members (excluding the author) about a message.
+   *
+   * @param message - The persisted, canonical room message.
+   */
+  async notifyMessage(message) {
+    const authorId = message.author.type === "human" ? message.author.userId : void 0;
+    let memberships;
+    try {
+      memberships = await this.deps.membershipStore.list(message.tenantId, message.projectId);
+    } catch (error) {
+      this.log("membership lookup failed", message, error);
+      return;
+    }
+    const recipients = memberships.filter((membership) => membership.status === "active" && membership.userId !== authorId).map((membership) => membership.userId);
+    const title = await this.deps.resolveTitle?.(message) ?? message.roomId;
+    const payload = {
+      title,
+      body: message.content.text.slice(0, MAX_BODY),
+      tag: message.projectId,
+      url: this.deps.buildUrl?.(message) ?? "/"
+    };
+    for (const userId of recipients) {
+      let subscriptions;
+      try {
+        subscriptions = await this.deps.subscriptionStore.list(message.tenantId, userId);
+      } catch (error) {
+        this.log("subscription lookup failed", message, error);
+        continue;
+      }
+      for (const subscription of subscriptions) {
+        try {
+          await this.deps.send(subscription, payload);
+        } catch (error) {
+          if ((this.deps.isGone ?? isSubscriptionGone)(error)) {
+            await this.deps.subscriptionStore.delete(message.tenantId, userId, subscription.endpoint).catch(() => void 0);
+          } else {
+            this.log("push send failed", message, error);
+          }
+        }
+      }
+    }
+  }
+  log(message, source, error) {
+    this.deps.log?.(`[RoomPushNotifier] ${message}`, {
+      tenantId: source.tenantId,
+      projectId: source.projectId,
+      roomId: source.roomId,
+      messageId: source.id,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+};
+
+// src/services/notifications/createRoomPushNotifier.ts
+function createRoomPushNotifier(input) {
+  if (input.vapid === null) return null;
+  webpush.setVapidDetails(input.vapid.subject, input.vapid.publicKey, input.vapid.privateKey);
+  return new RoomPushNotifier({
+    membershipStore: input.membershipStore,
+    subscriptionStore: input.subscriptionStore,
+    ...input.resolveTitle === void 0 ? {} : { resolveTitle: input.resolveTitle },
+    ...input.buildUrl === void 0 ? {} : { buildUrl: input.buildUrl },
+    ...input.log === void 0 ? {} : { log: input.log },
+    send: async (subscription, payload) => {
+      await webpush.sendNotification(
+        { endpoint: subscription.endpoint, keys: subscription.keys },
+        JSON.stringify(payload)
+      );
+    }
+  });
+}
+
 // src/services/collaboration/WorkspaceRoomEventsService.ts
 import { PROJECT_ROOM_USER_CHANNEL_PROJECT, projectRoomUserEventScope as projectRoomUserEventScope2 } from "@axiom-lattice/protocols";
 
@@ -18306,7 +18935,7 @@ var WorkspaceRoomEventsService = class {
     for (const active of [...this.connections.values()]) for (const connection of [...active]) connection.close();
     this.connections.clear();
   }
-  buildConnection(actor2, workspaceId, raw) {
+  buildConnection(actor3, workspaceId, raw) {
     let phase = "initializing";
     const subscriptions = /* @__PURE__ */ new Map();
     let heartbeatTimer;
@@ -18319,7 +18948,7 @@ var WorkspaceRoomEventsService = class {
     const clear = (timer) => {
       if (timer !== void 0) clearTimeout(timer);
     };
-    const userScope = projectRoomUserEventScope2(actor2.tenantId, actor2.userId);
+    const userScope = projectRoomUserEventScope2(actor3.tenantId, actor3.userId);
     const userScopeKey = JSON.stringify([userScope.tenantId, userScope.roomId, userScope.projectId]);
     const roomScopeKey = (scope) => JSON.stringify([scope.tenantId, scope.roomId, scope.projectId]);
     const serializeScoped = (scope, event) => scope === null ? `id: ${event.id}
@@ -18343,7 +18972,7 @@ data: ${JSON.stringify({ ...event, scope })}
       for (const entry of subscriptions.values()) entry.unsubscribe();
       subscriptions.clear();
       writer.close();
-      const userKey = JSON.stringify([actor2.tenantId, actor2.userId]);
+      const userKey = JSON.stringify([actor3.tenantId, actor3.userId]);
       const active = this.connections.get(userKey);
       if (active && recordRef.current !== void 0) {
         active.delete(recordRef.current);
@@ -18362,11 +18991,11 @@ data: ${JSON.stringify({ ...event, scope })}
     recordRef.current = record;
     const rebuildSubscriptions = async () => {
       try {
-        const rooms = await this.deps.listMemberRooms({ tenantId: actor2.tenantId, userId: actor2.userId, workspaceId });
+        const rooms = await this.deps.listMemberRooms({ tenantId: actor3.tenantId, userId: actor3.userId, workspaceId });
         if (closed) return true;
         const wanted = /* @__PURE__ */ new Map();
         for (const room of rooms) {
-          const scope = { tenantId: actor2.tenantId, roomId: room.roomId, projectId: room.projectId };
+          const scope = { tenantId: actor3.tenantId, roomId: room.roomId, projectId: room.projectId };
           wanted.set(roomScopeKey(scope), scope);
         }
         for (const [key, entry] of [...subscriptions]) {
@@ -18403,7 +19032,7 @@ data: ${JSON.stringify({ ...event, scope })}
     };
     const scheduleExpiry = () => {
       if (closed) return;
-      const delay2 = actor2.tokenExpiresAt - this.now();
+      const delay2 = actor3.tokenExpiresAt - this.now();
       if (delay2 <= 0) {
         revoke("TOKEN_EXPIRED");
         return;
@@ -18430,7 +19059,7 @@ data: ${JSON.stringify({ ...event, scope })}
         accessTimer = void 0;
         if (closed) return;
         const projectIds = [...subscriptions.values()].map((entry) => entry.scope.projectId).filter((projectId) => projectId !== PROJECT_ROOM_USER_CHANNEL_PROJECT);
-        Promise.all(projectIds.map((projectId) => Promise.resolve().then(() => this.deps.requireReadAccess({ tenantId: actor2.tenantId, userId: actor2.userId, projectId })))).then(() => {
+        Promise.all(projectIds.map((projectId) => Promise.resolve().then(() => this.deps.requireReadAccess({ tenantId: actor3.tenantId, userId: actor3.userId, projectId })))).then(() => {
           if (!closed) scheduleAccessCheck();
         }, () => {
           if (!closed) revoke("PROJECT_ACCESS_REVOKED");
@@ -18472,7 +19101,7 @@ function createWorkspaceMemberRoomLister(deps) {
 }
 
 // src/routes/workspace-room-events.ts
-import { snapshotExactRecord as snapshotExactRecord12 } from "@axiom-lattice/protocols";
+import { snapshotExactRecord as snapshotExactRecord13 } from "@axiom-lattice/protocols";
 function registerWorkspaceRoomEventRoutes(app2, deps) {
   app2.get("/api/workspaces/:workspaceId/room-events", async (request, reply) => {
     try {
@@ -18480,7 +19109,7 @@ function registerWorkspaceRoomEventRoutes(app2, deps) {
       const headers = strictHeaders(request);
       if (request.body !== void 0 || Object.keys(request.query).length !== 0) return invalid(reply);
       const session = verifyConsoleSessionAuthHeader(headers.authorization, deps.tokenSecret);
-      if (!session?.tenantId) return unauthorized(reply);
+      if (!session?.tenantId) return unauthorized2(reply);
       reply.hijack();
       reply.raw.writeHead(200, {
         "Content-Type": "text/event-stream",
@@ -18500,7 +19129,7 @@ function registerWorkspaceRoomEventRoutes(app2, deps) {
   });
 }
 function exactParams(params) {
-  const value = snapshotExactRecord12(params, ["workspaceId"]);
+  const value = snapshotExactRecord13(params, ["workspaceId"]);
   if (!value || typeof value.workspaceId !== "string" || !value.workspaceId.trim()) throw new InvalidRealtimeRequestError();
   return { workspaceId: value.workspaceId };
 }
@@ -18523,7 +19152,7 @@ var InvalidRealtimeRequestError = class extends Error {
 function invalid(reply) {
   return reply.code(400).send({ success: false, error: { code: "INVALID_REQUEST", message: "Invalid request", retryable: false } });
 }
-function unauthorized(reply) {
+function unauthorized2(reply) {
   return reply.code(401).send({ success: false, error: { code: "UNAUTHORIZED", message: "Unauthorized", retryable: false } });
 }
 function routeError(reply, error) {
@@ -18643,7 +19272,7 @@ function isPublicRoomAddress(message) {
 }
 async function validateReassignmentThread(threads, input) {
   const thread = snapshotThread(await threads.getThreadById(input.tenantId, input.newThreadId));
-  const metadata = snapshotExactRecord13(thread?.metadata, [
+  const metadata = snapshotExactRecord14(thread?.metadata, [
     "source",
     "kind",
     "workspaceId",
@@ -18667,6 +19296,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
   const projectBotMembershipStore = getStoreLattice16("default", "projectBotMembership").store;
   const projectRoomMessageStore = getStoreLattice16("default", "projectRoomMessage").store;
   const projectRoomReadStateStore = getStoreLattice16("default", "projectRoomReadState").store;
+  const userPushSubscriptionStore = getStoreLattice16("default", "userPushSubscription").store;
   const threadStore = getStoreLattice16("default", "thread").store;
   const taskStore = getStoreLattice16("default", "task").store;
   const taskWorkItemStore = getStoreLattice16("default", "taskWorkItem").store;
@@ -18674,10 +19304,22 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
   const accessService = new ProjectAccessService({ projectStore, membershipStore: projectMembershipStore, userTenantLinkStore });
   const realtimeMode = resolveProjectRoomRealtimeMode();
   const realtimeLog = options.projectTaskLog ?? { warn: () => void 0 };
+  const roomPushNotifier = createRoomPushNotifier({
+    subscriptionStore: userPushSubscriptionStore,
+    membershipStore: projectMembershipStore,
+    vapid: process.env.VAPID_PUBLIC_KEY && process.env.VAPID_PRIVATE_KEY && process.env.VAPID_SUBJECT ? { publicKey: process.env.VAPID_PUBLIC_KEY, privateKey: process.env.VAPID_PRIVATE_KEY, subject: process.env.VAPID_SUBJECT } : null,
+    resolveTitle: async (message) => {
+      const project = await projectStore.getProjectById(message.tenantId, message.projectId);
+      return project?.name;
+    },
+    buildUrl: (message) => `/?room=${encodeURIComponent(message.projectId)}`,
+    log: (message, context) => realtimeLog.warn(message, context ?? {})
+  });
   const projectRoomRealtimeRuntime = realtimeMode === "single-gateway" ? options.projectRoomRealtimeRuntime ?? createProjectRoomRealtimeRuntime({
     tasks: taskStore,
     rooms: projectRoomStore,
     memberships: projectBotMembershipStore,
+    pushNotifier: roomPushNotifier,
     log: realtimeLog
   }) : void 0;
   if (projectRoomRealtimeRuntime) {
@@ -18706,10 +19348,53 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     });
   }
   const realtime = projectRoomRealtimeRuntime?.publisher;
-  const roomService = new ProjectRoomService({ accessService, roomStore: projectRoomStore });
-  const membershipService = new ProjectMembershipService({ membershipStore: projectMembershipStore, userTenantLinkStore, accessService, projectMutationMutex: projectMutationMutex2, roomStore: projectRoomStore, realtime, onRealtimeFailure: realtime && channelDeps?.warn ? ({ code, membershipId }) => channelDeps.warn?.("project-room:membership-realtime-failed", { code, membershipId }) : void 0 });
   const installation = channelDeps ? new InternalRoomInstallationService(channelDeps.installationStore) : void 0;
   const bindingLifecycle = channelDeps && installation ? new RoomBindingProvisioner({ installation, registry: channelDeps.bindingRegistry }) : new NoopRoomBindingLifecycle();
+  const coordinatorProvisioner = new RoomCoordinatorProvisioner({
+    getAssistantById: assistantStore.getAssistantById.bind(assistantStore),
+    createAssistant: assistantStore.createAssistant.bind(assistantStore),
+    updateAssistant: assistantStore.updateAssistant.bind(assistantStore)
+  });
+  const resolveCoordinatorMentionName = async (tenantId) => {
+    const tenant2 = await getStoreLattice16("default", "tenant").store.getTenantById(tenantId);
+    const value = tenant2?.metadata?.coordinatorMentionName;
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  };
+  const coordinatorEnsurer = new RoomCoordinatorEnsurer({
+    provisioner: coordinatorProvisioner,
+    membershipStore: projectBotMembershipStore,
+    threadStore,
+    bindingLifecycle,
+    resolveMentionName: resolveCoordinatorMentionName,
+    log: realtimeLog
+  });
+  const roomService = new ProjectRoomService({
+    accessService,
+    roomStore: projectRoomStore,
+    ensureCoordinator: (scope) => coordinatorEnsurer.ensure(scope),
+    log: realtimeLog
+  });
+  const roomInterruptService = new RoomInterruptService({
+    requireAccess: async ({ tenantId, userId, projectId }) => {
+      await accessService.requireProjectAccess({ tenantId, userId, projectId, capability: "send" });
+    },
+    resolveMembership: async ({ tenantId, projectId, membershipId }) => {
+      const membership = await projectBotMembershipStore.findById(tenantId, membershipId);
+      return membership !== null && membership.projectId === projectId ? membership : null;
+    },
+    getThreadStatus: async ({ tenantId, assistantId, threadId, workspaceId, projectId }) => {
+      const agent = agentInstanceManager6.getAgent({
+        tenant_id: tenantId,
+        assistant_id: assistantId,
+        thread_id: threadId,
+        workspace_id: workspaceId,
+        project_id: projectId
+      });
+      return String(await agent.getRunStatus());
+    },
+    dispatcher: createTrustedAgentMessageDispatcher((scope) => agentInstanceManager6.getAgent(scope))
+  });
+  const membershipService = new ProjectMembershipService({ membershipStore: projectMembershipStore, userTenantLinkStore, accessService, projectMutationMutex: projectMutationMutex2, roomStore: projectRoomStore, realtime, onRealtimeFailure: realtime && channelDeps?.warn ? ({ code, membershipId }) => channelDeps.warn?.("project-room:membership-realtime-failed", { code, membershipId }) : void 0 });
   const rosterService = new ProjectRosterService({ accessService, roomService, membershipStore: projectBotMembershipStore, threadStore, assistantStore, taskStore, bindingLifecycle, projectMutationMutex: projectMutationMutex2, realtime, onRealtimeFailure: realtime && channelDeps?.warn ? ({ code, membershipId }) => channelDeps.warn?.("project-room:roster-realtime-failed", { code, membershipId }) : void 0 });
   const roomAdapterAvailable = channelDeps?.adapterRegistry.get("room")?.channel === "room";
   const dispatcher = channelDeps && installation && bindingLifecycle instanceof RoomBindingProvisioner && roomAdapterAvailable ? new RoomDispatchService({
@@ -18726,11 +19411,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     log: realtimeLog
   }) : void 0;
   if (coordinatorWakeNotifier) {
-    const unsubscribeCoordinatorWake = taskLifecycleNotifier2.subscribe(((event) => {
-      void coordinatorWakeNotifier.handle(event);
-    }));
     app2.addHook("onClose", async () => {
-      unsubscribeCoordinatorWake();
       await coordinatorWakeNotifier.dispose();
     });
   }
@@ -18755,7 +19436,8 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     projectRoomMessageStore,
     threadStore,
     realtime,
-    log: options.projectTaskLog
+    log: options.projectTaskLog,
+    ...coordinatorWakeNotifier === void 0 ? {} : { coordinatorWake: coordinatorWakeNotifier }
   }) : { reason: void 0 };
   const projectTaskComposition = "composition" in projectTaskRuntime ? projectTaskRuntime.composition : void 0;
   const projectTaskUnavailableReason = "reason" in projectTaskRuntime ? projectTaskRuntime.reason : void 0;
@@ -18765,23 +19447,17 @@ 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: randomUUID19 });
+  const taskThreadService = projectTaskComposition?.lease.runtime.threads ?? new ProjectTaskThreadService({ threads: threadStore, idFactory: randomUUID22 });
   const taskLifecycle = projectTaskComposition?.lease.runtime.lifecycle ?? createTaskLifecycleService({ taskStore, workItemStore: taskWorkItemStore });
   const reassignmentAuthorizer = createProjectTaskReassignmentAuthorizer(
     new 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)
+    ensureCoordinator: (scope) => coordinatorEnsurer.ensure(scope)
   });
   const readStateService = {
     mark: async (actorRef) => {
@@ -18805,6 +19481,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     membershipService,
     messageService,
     readStateService,
+    interruptService: roomInterruptService,
     userDirectory: {
       getUserById: (id3) => getStoreLattice16("default", "user").store.getUserById(id3).then((u) => u ? { name: u.name } : null)
     }
@@ -18851,9 +19528,10 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       save: projectBotMembershipStore.save.bind(projectBotMembershipStore)
     },
     coordinatorProvisioner,
+    getCoordinatorMentionName: resolveCoordinatorMentionName,
     rosterService: {
-      addBot: async (actor2, input) => {
-        await rosterService.add(actor2, input);
+      addBot: async (actor3, input) => {
+        await rosterService.add(actor3, input);
       }
     },
     publicRoom: {
@@ -18880,7 +19558,9 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     workspaceController: new WorkspaceController(createProjectCollaborationInitializer({
       membershipStore: projectMembershipStore,
       roomStore: projectRoomStore,
-      userTenantLinkStore
+      userTenantLinkStore,
+      ensureCoordinator: (scope) => coordinatorEnsurer.ensure(scope),
+      log: realtimeLog
     })),
     taskController: createTaskController({
       access: {
@@ -19142,7 +19822,9 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
   registerWorkspaceRoutes(app2, createProjectCollaborationInitializer({
     membershipStore: projectMembershipStore,
     roomStore: projectRoomStore,
-    userTenantLinkStore
+    userTenantLinkStore,
+    ensureCoordinator: (scope) => coordinatorEnsurer.ensure(scope),
+    log: realtimeLog
   }));
   registerDatabaseConfigRoutes(app2);
   registerMetricsServerConfigRoutes(app2);
@@ -19154,6 +19836,10 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     executeDataQuery
   );
   registerMcpServerConfigRoutes(app2);
+  registerPushNotificationRoutes(app2, {
+    subscriptionStore: userPushSubscriptionStore,
+    vapidPublicKey: process.env.VAPID_PUBLIC_KEY || null
+  });
   registerUserRoutes(app2);
   registerTenantRoutes(app2);
   registerAuthRoutes(app2, {
@@ -19339,7 +20025,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: randomUUID19 });
+  const threads = new ProjectTaskThreadService({ threads: input.threadStore, idFactory: randomUUID22 });
   const lifecycle = createTaskLifecycleService({ taskStore: input.taskStore, workItemStore: input.taskWorkItemStore });
   const projection = new RoomProjectionService({
     messages: input.projectRoomMessageStore,
@@ -19348,7 +20034,7 @@ function createRuntime(input, stores, log2) {
     warnings: input.taskWorkItemStore,
     log: log2,
     realtime: input.realtime,
-    idFactory: randomUUID19
+    idFactory: randomUUID22
   });
   const agentFor = (task, thread) => agentInstanceManager6.getAgent({
     tenant_id: task.tenantId,
@@ -19385,7 +20071,8 @@ function createRuntime(input, stores, log2) {
     mutex,
     projection,
     log: log2,
-    signal: controller.signal
+    signal: controller.signal,
+    ...input.coordinatorWake === void 0 ? {} : { coordinatorWake: input.coordinatorWake }
   }, PROJECT_TASK_OBSERVER_OPTIONS);
   const taskLifecycleListener = ((event) => {
     void observer.listener(event);
@@ -20173,7 +20860,7 @@ var collectionRegistration = {
 
 // src/export_registrations/channel-installation.registration.ts
 import { getStoreLattice as getStoreLattice23 } from "@axiom-lattice/core";
-import { randomUUID as randomUUID20 } from "crypto";
+import { randomUUID as randomUUID23 } from "crypto";
 var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var PUBLIC_CHANNELS = /* @__PURE__ */ new Set(["lark", "email", "slack", "wechat"]);
 function isPublicChannel(channel) {
@@ -20332,7 +21019,7 @@ var channelInstallationRegistration = {
       }
       id3 = sourceId;
     } else {
-      id3 = randomUUID20();
+      id3 = randomUUID23();
     }
     await store.createInstallation(tenantId, id3, createInput);
     return { newId: id3 };
@@ -21218,9 +21905,9 @@ import {
 } from "@axiom-lattice/core";
 import {
   snapshotExactArray as snapshotExactArray3,
-  snapshotExactRecord as snapshotExactRecord14
+  snapshotExactRecord as snapshotExactRecord15
 } from "@axiom-lattice/protocols";
-import { randomUUID as randomUUID21 } from "crypto";
+import { randomUUID as randomUUID24 } from "crypto";
 var BindingNotFoundError = class extends Error {
   constructor(message) {
     super(message);
@@ -21248,8 +21935,13 @@ var CORRELATED_REPLY_REQUIRED_KEYS = [
   "outputText",
   "state"
 ];
+var INTERRUPT_PAUSED_NOTICE = "This assistant is paused waiting for an approval or input and will continue once it is resolved.";
+var RESUME_DEDUPE_WINDOW_MS = 3e4;
+function clarifyText(clarify) {
+  return ["```clarify", JSON.stringify({ questions: clarify.questions }), "```"].join("\n");
+}
 function exactDataValues(value, required, optional = []) {
-  return snapshotExactRecord14(value, required, optional);
+  return snapshotExactRecord15(value, required, optional);
 }
 function uniqueNonemptyStrings(value) {
   const snapshot = snapshotExactArray3(value);
@@ -21328,6 +22020,8 @@ function correlatedRoomReplyTarget(replyTarget, inputMessageId) {
 var MessageRouter = class {
   constructor(config) {
     this.replySubscriptions = /* @__PURE__ */ new Set();
+    /** Recent answer-by-message resumes per presence thread (first answer wins). */
+    this.recentResumes = /* @__PURE__ */ new Map();
     this.middlewares = [...config.middlewares];
     this.bindingRegistry = config.bindingRegistry;
     this.adapterRegistry = config.adapterRegistry;
@@ -21535,7 +22229,7 @@ var MessageRouter = class {
         }
         if (!threadId) {
           const threadStore = getStoreLattice26("default", "thread").store;
-          const newThreadId = randomUUID21();
+          const newThreadId = randomUUID24();
           console.log({
             event: "dispatch:thread:create",
             agentId,
@@ -21581,19 +22275,51 @@ var MessageRouter = class {
           workspace_id: binding?.workspaceId || "",
           project_id: binding?.projectId || ""
         });
-        const inputMessageId = randomUUID21();
+        const inputMessageId = randomUUID24();
         const replyTarget = internalRoom ? correlatedRoomReplyTarget(message.replyTarget, inputMessageId) : message.replyTarget;
         const replyAdapter = replyTarget ? this.adapterRegistry.get(replyTarget.adapterChannel) : void 0;
         if (options.trustedMessageOptions && (!this.trustedDispatcher || !replyTarget || !replyAdapter)) {
           throw new Error("Trusted dispatch requires reply target/adapter");
         }
+        let resumeCommand;
+        let interruptNotice;
+        if (internalRoom) {
+          try {
+            const status = await agent.getRunStatus();
+            if (String(status) === "interrupted") {
+              const clarify = readClarifyInterrupt(await agent.getCurrentState());
+              const lastResume = this.recentResumes.get(threadId);
+              const resumeInFlight = lastResume !== void 0 && Date.now() - lastResume < RESUME_DEDUPE_WINDOW_MS;
+              if (clarify && !resumeInFlight) {
+                await this.projectRoomInterrupt(replyTarget, replyAdapter, installation, inputMessageId, clarifyText(clarify));
+                this.recentResumes.set(threadId, Date.now());
+                if (this.recentResumes.size > 256) {
+                  for (const [key, at] of this.recentResumes) {
+                    if (Date.now() - at >= RESUME_DEDUPE_WINDOW_MS) this.recentResumes.delete(key);
+                  }
+                }
+                resumeCommand = buildClarifyResumeCommand(message.content.text);
+              } else if (!clarify) {
+                interruptNotice = INTERRUPT_PAUSED_NOTICE;
+              }
+            }
+          } catch (error) {
+            console.warn({
+              event: "dispatch:interrupt:status-failed",
+              threadId,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+        }
         const queueMessage = {
           input: { id: inputMessageId, message: message.content.text },
-          custom_run_config: message.content.metadata
+          custom_run_config: message.content.metadata,
+          ...resumeCommand ? { command: resumeCommand } : {}
         };
         let cleanupReplySubscription;
         if (replyTarget && replyAdapter) {
           let cleaned = false;
+          let onInterrupted;
           const callback = (value) => {
             const event = parseCorrelatedReplyReadyEvent(value);
             if (!event) return;
@@ -21619,12 +22345,26 @@ var MessageRouter = class {
             cleaned = true;
             clearTimeout(timer);
             agent.unsubscribe("reply:ready", callback);
+            if (onInterrupted !== void 0) agent.unsubscribe("message:interrupted", onInterrupted);
             this.replySubscriptions.delete(subscription);
           };
           const subscription = { inputMessageId, timer, cleanup };
           cleanupReplySubscription = cleanup;
           this.replySubscriptions.add(subscription);
           agent.subscribe("reply:ready", callback);
+          if (internalRoom) {
+            onInterrupted = (value) => {
+              if (cleaned) return;
+              const event = typeof value === "object" && value !== null ? value : void 0;
+              if (event?.type !== "message:interrupted" || event.messageId !== inputMessageId) return;
+              const clarify = readClarifyInterrupt(event.state);
+              void this.projectRoomInterrupt(replyTarget, replyAdapter, installation, inputMessageId, clarify ? clarifyText(clarify) : INTERRUPT_PAUSED_NOTICE);
+            };
+            agent.subscribe("message:interrupted", onInterrupted);
+          }
+        }
+        if (interruptNotice !== void 0 && replyTarget && replyAdapter) {
+          await this.projectRoomInterrupt(replyTarget, replyAdapter, installation, inputMessageId, interruptNotice);
         }
         let addResult;
         try {
@@ -21686,12 +22426,34 @@ var MessageRouter = class {
     };
     return dispatch(0);
   }
+  /**
+   * Projects a pending HITL interrupt into the room as an independent bot message.
+   *
+   * @remarks
+   * Best-effort: adapters without interrupt support and persistence failures are
+   * logged and never block dispatch or reply correlation.
+   */
+  async projectRoomInterrupt(replyTarget, replyAdapter, installation, inputMessageId, text) {
+    if (!replyTarget || !replyAdapter?.sendInterrupt || !installation) {
+      console.warn({ event: "dispatch:interrupt:unsupported", inputMessageId });
+      return;
+    }
+    try {
+      await replyAdapter.sendInterrupt(replyTarget, { text, metadata: { inputMessageId } }, installation);
+    } catch (error) {
+      console.error({
+        event: "dispatch:interrupt:failed",
+        inputMessageId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
 };
 
 // src/channels/room/RoomChannelAdapter.ts
-import { z as z10 } from "zod";
-import { snapshotExactRecord as snapshotExactRecord15 } from "@axiom-lattice/protocols";
-var roomConfigSchema = z10.object({}).strict();
+import { z as z11 } from "zod";
+import { snapshotExactRecord as snapshotExactRecord16 } from "@axiom-lattice/protocols";
+var roomConfigSchema = z11.object({}).strict();
 function createRoomChannelAdapter(writer) {
   return {
     channel: "room",
@@ -21719,6 +22481,23 @@ function createRoomChannelAdapter(writer) {
         sourceId: metadata.outputMessageId,
         idempotencyKey: `room-reply:${target.sourceRoomMessageId}:${target.targetMembershipId}:${metadata.outputMessageId}`
       });
+    },
+    async sendInterrupt(replyTarget, message, installation) {
+      const installed = installationValues(installation);
+      if (!installed) throw new Error("Invalid room installation");
+      const targetEnvelope = exactValues2(replyTarget, ["adapterChannel", "channelInstallationId", "rawTarget"]);
+      const target = exactStrings(targetEnvelope?.rawTarget, ["sourceRoomMessageId", "targetMembershipId", "inputMessageId"]);
+      const envelope = exactValues2(message, ["text", "metadata"]);
+      const metadata = exactStrings(envelope?.metadata, ["inputMessageId"]);
+      if (!targetEnvelope || targetEnvelope.adapterChannel !== "room" || targetEnvelope.channelInstallationId !== installation.id || !target || !metadata || typeof envelope?.text !== "string") throw new Error("Invalid room interrupt");
+      if (target.inputMessageId !== metadata.inputMessageId) throw new Error("Invalid room interrupt correlation");
+      await writer.postInterrupt({
+        tenantId: installed.tenantId,
+        membershipId: target.targetMembershipId,
+        text: envelope.text,
+        sourceRoomMessageId: target.sourceRoomMessageId,
+        inputMessageId: metadata.inputMessageId
+      });
     }
   };
 }
@@ -21734,7 +22513,7 @@ function exactStrings(value, keys2) {
 function exactValues2(value, required, optional = []) {
   try {
     if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-    return snapshotExactRecord15(value, required, optional);
+    return snapshotExactRecord16(value, required, optional);
   } catch {
     return void 0;
   }
@@ -22023,7 +22802,7 @@ var start = async (config) => {
     });
     try {
       const { A2AAuthService, parseEnvKeys } = await import("./A2AAuthService-7UGQ7GMW.mjs");
-      const { registerA2AStandardRoutes } = await import("./a2a-standard-VEQBXBMM.mjs");
+      const { registerA2AStandardRoutes } = await import("./a2a-standard-ALXWP7V6.mjs");
       const a2a = await import("./a2a-FGYX2HH3.mjs");
       const a2aKeyStore = getStoreLattice27("default", "a2aApiKey").store;
       const assistantStore = getStoreLattice27("default", "assistant").store;
@@ -22096,7 +22875,7 @@ var start = async (config) => {
       logger5.info("Registered sandbox manager from env configuration");
     }
     try {
-      const { ResourceController } = await import("./resources-SRQRKW5G.mjs");
+      const { ResourceController } = await import("./resources-JFKAPS45.mjs");
       const sharedResourceStore = getStoreLattice27("default", "sharedResource").store;
       const cache = new TokenCache();
       const resourceController = new ResourceController({