@axiom-lattice/gateway 4.1.6 → 4.1.7

package/dist/index.mjs

@@ -6424,14 +6424,202 @@ function registerWorkspaceRoutes(app2, projectCollaboration) {
     "/api/filesystem/browse",
     controller.browseFilesystem.bind(controller)
   );
+  return controller;
 }
 
+// src/services/collaboration/ProjectAccessService.ts
+import { randomUUID as randomUUID6 } from "crypto";
+var ProjectCollaborationError = class extends Error {
+  /** Creates a project collaboration error. */
+  constructor(code, statusCode, message) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "ProjectCollaborationError";
+  }
+};
+var allowedRoles = {
+  read: /* @__PURE__ */ new Set(["owner", "admin", "member", "viewer"]),
+  send: /* @__PURE__ */ new Set(["owner", "admin", "member"]),
+  manage: /* @__PURE__ */ new Set(["owner", "admin"])
+};
+var membershipConflictNames = /* @__PURE__ */ new Set([
+  "DuplicateProjectMembershipError",
+  "ProjectMembershipIdConflictError"
+]);
+function isProjectMembershipConflict(error) {
+  return error instanceof Error && membershipConflictNames.has(error.name);
+}
+var ProjectAccessService = class {
+  /** Creates a project access service from explicitly injected stores. */
+  constructor(deps) {
+    this.deps = deps;
+    this.idFactory = deps.idFactory ?? randomUUID6;
+  }
+  /** Returns the project and active membership when the user has the requested capability. */
+  async requireProjectAccess(input) {
+    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
+    if (!project) {
+      throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
+    }
+    if (project.kind === "public") {
+      return this.requirePublicProjectAccess(project, input);
+    }
+    const membership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (membership?.status === "active") {
+      this.requireCapability(membership, input.capability);
+      return { project, membership };
+    }
+    const memberships = await this.deps.membershipStore.list(input.tenantId, input.projectId);
+    if (memberships.length !== 0) this.accessDenied();
+    if (project.kind === "personal") this.accessDenied();
+    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
+    if (tenantLink?.role !== "owner" && tenantLink?.role !== "admin") this.accessDenied();
+    let claim;
+    try {
+      claim = await this.deps.membershipStore.createInitialOwner({
+        id: this.idFactory(),
+        tenantId: input.tenantId,
+        projectId: input.projectId,
+        userId: input.userId
+      });
+    } catch (error) {
+      if (isProjectMembershipConflict(error)) {
+        throw new ProjectCollaborationError(
+          "PROJECT_MEMBERSHIP_CONFLICT",
+          409,
+          "Project membership could not be initialized"
+        );
+      }
+      throw error;
+    }
+    if (claim.kind === "created" || claim.kind === "existing") {
+      return { project, membership: claim.membership };
+    }
+    const racedMembership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (racedMembership?.status !== "active") this.accessDenied();
+    this.requireCapability(racedMembership, input.capability);
+    return { project, membership: racedMembership };
+  }
+  /** Authorizes an already-existing membership, or any tenant member for public rooms; never mutates persistence. */
+  async requireExistingProjectAccess(input) {
+    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
+    if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
+    if (project.kind === "public") {
+      return this.requireExistingPublicProjectAccess(project, input);
+    }
+    const membership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (!membership || membership.tenantId !== input.tenantId || membership.projectId !== input.projectId || membership.userId !== input.userId || membership.status !== "active") this.accessDenied();
+    this.requireCapability(membership, input.capability);
+    return { project, membership };
+  }
+  /** Authorizes roster visibility: read for public rooms, manage elsewhere. */
+  async requireRosterAccess(input) {
+    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
+    if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
+    return this.requireProjectAccess({
+      ...input,
+      capability: project.kind === "public" ? "read" : "manage"
+    });
+  }
+  async requirePublicProjectAccess(project, input) {
+    const membership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (membership?.status === "active") {
+      this.requireCapability(membership, input.capability);
+      return { project, membership };
+    }
+    const materialized = await this.materializePublicMembership(input);
+    this.requireCapability(materialized, input.capability);
+    return { project, membership: materialized };
+  }
+  async requireExistingPublicProjectAccess(project, input) {
+    const membership = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (membership?.status === "active") {
+      this.requireCapability(membership, input.capability);
+      return { project, membership };
+    }
+    if (membership) this.accessDenied();
+    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
+    if (!tenantLink) this.accessDenied();
+    const role = tenantLink.role === "owner" || tenantLink.role === "admin" ? "admin" : "member";
+    const synthetic = {
+      id: `public:${input.userId}`,
+      tenantId: input.tenantId,
+      projectId: input.projectId,
+      userId: input.userId,
+      role,
+      status: "active",
+      joinedAt: project.createdAt,
+      updatedAt: project.updatedAt
+    };
+    this.requireCapability(synthetic, input.capability);
+    return { project, membership: synthetic };
+  }
+  async materializePublicMembership(input) {
+    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
+    if (!tenantLink) this.accessDenied();
+    const existing = await this.deps.membershipStore.findByUser(
+      input.tenantId,
+      input.projectId,
+      input.userId
+    );
+    if (existing) this.accessDenied();
+    const role = tenantLink.role === "owner" || tenantLink.role === "admin" ? "admin" : "member";
+    try {
+      return await this.deps.membershipStore.create({
+        id: this.idFactory(),
+        tenantId: input.tenantId,
+        projectId: input.projectId,
+        userId: input.userId,
+        role,
+        status: "active"
+      });
+    } catch (error) {
+      if (isProjectMembershipConflict(error)) {
+        const raced = await this.deps.membershipStore.findByUser(
+          input.tenantId,
+          input.projectId,
+          input.userId
+        );
+        if (raced?.status === "active") return raced;
+      }
+      throw error;
+    }
+  }
+  requireCapability(membership, capability2) {
+    if (!allowedRoles[capability2].has(membership.role)) this.accessDenied();
+  }
+  accessDenied() {
+    throw new ProjectCollaborationError("PROJECT_ACCESS_DENIED", 403, "Project access denied");
+  }
+};
+
 // src/controllers/database-configs.ts
 import {
   getStoreLattice as getStoreLattice7,
   sqlDatabaseManager
 } from "@axiom-lattice/core";
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 function getTenantId9(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
@@ -6509,7 +6697,7 @@ async function createDatabaseConfig(request, reply) {
         message: "Database configuration with this key already exists"
       };
     }
-    const id3 = body.id || randomUUID6();
+    const id3 = body.id || randomUUID7();
     const config = await store.createConfig(tenantId, id3, body);
     try {
       sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
@@ -6714,7 +6902,7 @@ import {
   metricsServerManager as metricsServerManager2,
   SemanticMetricsClient as SemanticMetricsClient2
 } from "@axiom-lattice/core";
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 function getTenantId10(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
@@ -6795,7 +6983,7 @@ async function createMetricsServerConfig(request, reply) {
         message: "selectedDataSources is required for semantic metrics servers"
       };
     }
-    const id3 = body.id || randomUUID7();
+    const id3 = body.id || randomUUID8();
     const configData = {
       key: body.key,
       name: body.name,
@@ -9302,7 +9490,7 @@ function registerChannelRoutes(app2, dependencies) {
 }
 
 // src/controllers/channel-installations.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import {
   descriptorDataValue
 } from "@axiom-lattice/protocols";
@@ -9506,7 +9694,7 @@ async function createChannelInstallation(request, reply) {
       };
     }
     const store = await getInstallationStore();
-    const installationId = randomUUID8();
+    const installationId = randomUUID9();
     const createInput = {
       channel: body.channel,
       name: body.name,
@@ -10466,7 +10654,7 @@ async function getLocalA2ATemplates(_request, reply) {
 }
 
 // src/routes/a2a-test-connection.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 function describeTestConnectionError(error, agentCardUrl) {
   if (!(error instanceof Error)) {
     return `Failed to fetch agent card from ${agentCardUrl}: ${String(error)}`;
@@ -10506,7 +10694,7 @@ async function ensureLocalRuntimeForConnectionTest(localRuntime, agentCardUrl) {
     return { error: portValidation.error };
   }
   const state = await localA2AService.startProvider(
-    `test-${randomUUID9()}`,
+    `test-${randomUUID10()}`,
     testRuntime
   );
   if (state.status === "running") return { runtimeId: state.runtimeId };
@@ -10523,264 +10711,77 @@ function registerA2ATestConnectionRoute(app2) {
     const { agentCardUrl, apiKey, localRuntime } = request.body ?? {};
     const normalizedAgentCardUrl = normalizeA2AAgentCardUrl(
       agentCardUrl,
-      localRuntime ? "http://" : "https://"
-    );
-    if (!normalizedAgentCardUrl) {
-      return reply.status(400).send({ success: false, error: "agentCardUrl is required" });
-    }
-    let testRuntimeId = null;
-    try {
-      const headers = {};
-      if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
-      if (localRuntime) {
-        const localStartResult = await ensureLocalRuntimeForConnectionTest(localRuntime, normalizedAgentCardUrl);
-        if ("error" in localStartResult) {
-          return reply.send({ success: true, data: { reachable: false, error: localStartResult.error } });
-        }
-        testRuntimeId = localStartResult.runtimeId;
-      }
-      const resp = await fetch(normalizedAgentCardUrl, { headers, signal: AbortSignal.timeout(8e3) });
-      if (!resp.ok) {
-        const body = await readShortResponseBody(resp);
-        const suffix = body ? `: ${body}` : "";
-        return reply.send({ success: true, data: { reachable: false, error: `HTTP ${resp.status} ${resp.statusText}${suffix}` } });
-      }
-      const card = await resp.json();
-      return reply.send({ success: true, data: { reachable: true, agentName: card.name, agentCard: card } });
-    } catch (error) {
-      return reply.send({
-        success: true,
-        data: {
-          reachable: false,
-          error: describeTestConnectionError(error, normalizedAgentCardUrl)
-        }
-      });
-    } finally {
-      if (testRuntimeId) {
-        localA2AService.removeState(testRuntimeId);
-      }
-    }
-  });
-}
-
-// src/routes/task-routes.ts
-function registerTaskRoutes(app2, controller) {
-  app2.get("/api/tasks", controller.list);
-  app2.get("/api/tasks/:id", controller.get);
-  app2.post("/api/tasks", controller.create);
-  app2.put("/api/tasks/:id", controller.update);
-  app2.patch("/api/tasks/:id", controller.update);
-  app2.delete("/api/tasks/:id", controller.remove);
-  app2.patch("/api/tasks/:id/complete", controller.complete);
-  app2.get("/api/tasks/:id/work-items", controller.workItems);
-  app2.post("/api/projects/:projectId/tasks/:id/reassign", controller.reassign);
-}
-
-// src/routes/index.ts
-import {
-  agentInstanceManager as agentInstanceManager6,
-  agentLatticeManager as agentLatticeManager4,
-  createProjectTaskReassignmentAuthorizer,
-  createTaskLifecycleService,
-  createTrustedAgentMessageDispatcher,
-  getStoreLattice as getStoreLattice16,
-  modelLatticeManager as modelLatticeManager3,
-  ProjectTaskOwnerPolicy,
-  projectMutationMutex as projectMutationMutex2,
-  projectTaskAdmissionNotifier as projectTaskAdmissionNotifier2,
-  taskLifecycleNotifier as taskLifecycleNotifier2
-} from "@axiom-lattice/core";
-
-// src/controllers/tasks.ts
-import { snapshotExactRecord as snapshotExactRecord3 } from "@axiom-lattice/protocols";
-import { ProjectTaskOwnerPolicyError, projectTaskAdmissionNotifier } from "@axiom-lattice/core";
-
-// src/services/collaboration/ProjectAccessService.ts
-import { randomUUID as randomUUID10 } from "crypto";
-var ProjectCollaborationError = class extends Error {
-  /** Creates a project collaboration error. */
-  constructor(code, statusCode, message) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.name = "ProjectCollaborationError";
-  }
-};
-var allowedRoles = {
-  read: /* @__PURE__ */ new Set(["owner", "admin", "member", "viewer"]),
-  send: /* @__PURE__ */ new Set(["owner", "admin", "member"]),
-  manage: /* @__PURE__ */ new Set(["owner", "admin"])
-};
-var membershipConflictNames = /* @__PURE__ */ new Set([
-  "DuplicateProjectMembershipError",
-  "ProjectMembershipIdConflictError"
-]);
-function isProjectMembershipConflict(error) {
-  return error instanceof Error && membershipConflictNames.has(error.name);
-}
-var ProjectAccessService = class {
-  /** Creates a project access service from explicitly injected stores. */
-  constructor(deps) {
-    this.deps = deps;
-    this.idFactory = deps.idFactory ?? randomUUID10;
-  }
-  /** Returns the project and active membership when the user has the requested capability. */
-  async requireProjectAccess(input) {
-    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
-    if (!project) {
-      throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
-    }
-    if (project.kind === "public") {
-      return this.requirePublicProjectAccess(project, input);
-    }
-    const membership = await this.deps.membershipStore.findByUser(
-      input.tenantId,
-      input.projectId,
-      input.userId
-    );
-    if (membership?.status === "active") {
-      this.requireCapability(membership, input.capability);
-      return { project, membership };
-    }
-    const memberships = await this.deps.membershipStore.list(input.tenantId, input.projectId);
-    if (memberships.length !== 0) this.accessDenied();
-    if (project.kind === "personal") this.accessDenied();
-    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
-    if (tenantLink?.role !== "owner" && tenantLink?.role !== "admin") this.accessDenied();
-    let claim;
-    try {
-      claim = await this.deps.membershipStore.createInitialOwner({
-        id: this.idFactory(),
-        tenantId: input.tenantId,
-        projectId: input.projectId,
-        userId: input.userId
-      });
-    } catch (error) {
-      if (isProjectMembershipConflict(error)) {
-        throw new ProjectCollaborationError(
-          "PROJECT_MEMBERSHIP_CONFLICT",
-          409,
-          "Project membership could not be initialized"
-        );
-      }
-      throw error;
-    }
-    if (claim.kind === "created" || claim.kind === "existing") {
-      return { project, membership: claim.membership };
-    }
-    const racedMembership = await this.deps.membershipStore.findByUser(
-      input.tenantId,
-      input.projectId,
-      input.userId
-    );
-    if (racedMembership?.status !== "active") this.accessDenied();
-    this.requireCapability(racedMembership, input.capability);
-    return { project, membership: racedMembership };
-  }
-  /** Authorizes an already-existing membership, or any tenant member for public rooms; never mutates persistence. */
-  async requireExistingProjectAccess(input) {
-    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
-    if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
-    if (project.kind === "public") {
-      return this.requireExistingPublicProjectAccess(project, input);
-    }
-    const membership = await this.deps.membershipStore.findByUser(
-      input.tenantId,
-      input.projectId,
-      input.userId
-    );
-    if (!membership || membership.tenantId !== input.tenantId || membership.projectId !== input.projectId || membership.userId !== input.userId || membership.status !== "active") this.accessDenied();
-    this.requireCapability(membership, input.capability);
-    return { project, membership };
-  }
-  /** Authorizes roster visibility: read for public rooms, manage elsewhere. */
-  async requireRosterAccess(input) {
-    const project = await this.deps.projectStore.getProjectById(input.tenantId, input.projectId);
-    if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
-    return this.requireProjectAccess({
-      ...input,
-      capability: project.kind === "public" ? "read" : "manage"
-    });
-  }
-  async requirePublicProjectAccess(project, input) {
-    const membership = await this.deps.membershipStore.findByUser(
-      input.tenantId,
-      input.projectId,
-      input.userId
-    );
-    if (membership?.status === "active") {
-      this.requireCapability(membership, input.capability);
-      return { project, membership };
-    }
-    const materialized = await this.materializePublicMembership(input);
-    this.requireCapability(materialized, input.capability);
-    return { project, membership: materialized };
-  }
-  async requireExistingPublicProjectAccess(project, input) {
-    const membership = await this.deps.membershipStore.findByUser(
-      input.tenantId,
-      input.projectId,
-      input.userId
-    );
-    if (membership?.status === "active") {
-      this.requireCapability(membership, input.capability);
-      return { project, membership };
-    }
-    if (membership) this.accessDenied();
-    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
-    if (!tenantLink) this.accessDenied();
-    const role = tenantLink.role === "owner" || tenantLink.role === "admin" ? "admin" : "member";
-    const synthetic = {
-      id: `public:${input.userId}`,
-      tenantId: input.tenantId,
-      projectId: input.projectId,
-      userId: input.userId,
-      role,
-      status: "active",
-      joinedAt: project.createdAt,
-      updatedAt: project.updatedAt
-    };
-    this.requireCapability(synthetic, input.capability);
-    return { project, membership: synthetic };
-  }
-  async materializePublicMembership(input) {
-    const tenantLink = await this.deps.userTenantLinkStore.getLink(input.userId, input.tenantId);
-    if (!tenantLink) this.accessDenied();
-    const existing = await this.deps.membershipStore.findByUser(
-      input.tenantId,
-      input.projectId,
-      input.userId
-    );
-    if (existing) this.accessDenied();
-    const role = tenantLink.role === "owner" || tenantLink.role === "admin" ? "admin" : "member";
-    try {
-      return await this.deps.membershipStore.create({
-        id: this.idFactory(),
-        tenantId: input.tenantId,
-        projectId: input.projectId,
-        userId: input.userId,
-        role,
-        status: "active"
-      });
+      localRuntime ? "http://" : "https://"
+    );
+    if (!normalizedAgentCardUrl) {
+      return reply.status(400).send({ success: false, error: "agentCardUrl is required" });
+    }
+    let testRuntimeId = null;
+    try {
+      const headers = {};
+      if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+      if (localRuntime) {
+        const localStartResult = await ensureLocalRuntimeForConnectionTest(localRuntime, normalizedAgentCardUrl);
+        if ("error" in localStartResult) {
+          return reply.send({ success: true, data: { reachable: false, error: localStartResult.error } });
+        }
+        testRuntimeId = localStartResult.runtimeId;
+      }
+      const resp = await fetch(normalizedAgentCardUrl, { headers, signal: AbortSignal.timeout(8e3) });
+      if (!resp.ok) {
+        const body = await readShortResponseBody(resp);
+        const suffix = body ? `: ${body}` : "";
+        return reply.send({ success: true, data: { reachable: false, error: `HTTP ${resp.status} ${resp.statusText}${suffix}` } });
+      }
+      const card = await resp.json();
+      return reply.send({ success: true, data: { reachable: true, agentName: card.name, agentCard: card } });
     } catch (error) {
-      if (isProjectMembershipConflict(error)) {
-        const raced = await this.deps.membershipStore.findByUser(
-          input.tenantId,
-          input.projectId,
-          input.userId
-        );
-        if (raced?.status === "active") return raced;
+      return reply.send({
+        success: true,
+        data: {
+          reachable: false,
+          error: describeTestConnectionError(error, normalizedAgentCardUrl)
+        }
+      });
+    } finally {
+      if (testRuntimeId) {
+        localA2AService.removeState(testRuntimeId);
       }
-      throw error;
     }
-  }
-  requireCapability(membership, capability2) {
-    if (!allowedRoles[capability2].has(membership.role)) this.accessDenied();
-  }
-  accessDenied() {
-    throw new ProjectCollaborationError("PROJECT_ACCESS_DENIED", 403, "Project access denied");
-  }
-};
+  });
+}
+
+// src/routes/task-routes.ts
+function registerTaskRoutes(app2, controller) {
+  app2.get("/api/tasks", controller.list);
+  app2.get("/api/tasks/:id", controller.get);
+  app2.post("/api/tasks", controller.create);
+  app2.put("/api/tasks/:id", controller.update);
+  app2.patch("/api/tasks/:id", controller.update);
+  app2.delete("/api/tasks/:id", controller.remove);
+  app2.patch("/api/tasks/:id/complete", controller.complete);
+  app2.get("/api/tasks/:id/work-items", controller.workItems);
+  app2.post("/api/projects/:projectId/tasks/:id/reassign", controller.reassign);
+}
+
+// src/routes/index.ts
+import {
+  agentInstanceManager as agentInstanceManager6,
+  agentLatticeManager as agentLatticeManager4,
+  createProjectTaskReassignmentAuthorizer,
+  createTaskLifecycleService,
+  createTrustedAgentMessageDispatcher,
+  getStoreLattice as getStoreLattice16,
+  modelLatticeManager as modelLatticeManager3,
+  ProjectTaskOwnerPolicy,
+  projectMutationMutex as projectMutationMutex2,
+  projectTaskAdmissionNotifier as projectTaskAdmissionNotifier2,
+  taskLifecycleNotifier as taskLifecycleNotifier2
+} from "@axiom-lattice/core";
+
+// src/controllers/tasks.ts
+import { snapshotExactRecord as snapshotExactRecord3 } from "@axiom-lattice/protocols";
+import { ProjectTaskOwnerPolicyError, projectTaskAdmissionNotifier } from "@axiom-lattice/core";
 
 // src/services/collaboration/ProjectTaskThreadService.ts
 import { isProjectLifecycleTask } from "@axiom-lattice/core";
@@ -11320,9 +11321,6 @@ function governedUpdate(task, body) {
   if (has("ownerType") && body.ownerType !== task.ownerType || has("ownerId") && body.ownerId !== task.ownerId) {
     return "TASK_OWNERSHIP_IMMUTABLE";
   }
-  if (task.ownerType !== "agent") return void 0;
-  if (has("parentId") && body.parentId !== task.parentId || has("dependencies") || has("requireReview") || has("result") || has("failureReason") || has("status")) return "TASK_LIFECYCLE_TRANSITION_REQUIRED";
-  if (has("context") || has("description")) return "COMPLETION_CONTEXT_MUTATION";
   return void 0;
 }
 function lifecycleStatus(code) {
@@ -11763,7 +11761,8 @@ var AgentWebAppService = class {
       integration: current.integration,
       scope: { ...current.scope, ...patch.scope },
       features: { ...current.features, ...patch.features },
-      appearance: { ...current.appearance, ...patch.appearance }
+      appearance: { ...current.appearance, ...patch.appearance },
+      identity: patch.identity ?? current.identity
     };
     await this.validateAssistant(context, current.assistantId);
     const validated = await this.validateConfig(context.tenantId, effective);
@@ -11772,7 +11771,8 @@ var AgentWebAppService = class {
       ...Object.prototype.hasOwnProperty.call(patch, "description") ? { description: validated.description } : {},
       ...patch.scope ? { scope: validated.scope } : {},
       ...patch.features ? { features: validated.features } : {},
-      ...patch.appearance ? { appearance: validated.appearance } : {}
+      ...patch.appearance ? { appearance: validated.appearance } : {},
+      ...patch.identity !== void 0 ? { identity: patch.identity } : {}
     };
     return this.writeSnapshot(context, current, update);
   }
@@ -11885,13 +11885,28 @@ var agentWebAppFeaturesSchema = z4.object({
   threadManagement: z4.boolean(),
   attachments: z4.boolean(),
   hitl: z4.boolean(),
-  genUI: z4.boolean()
+  genUI: z4.boolean(),
+  files: z4.boolean().optional()
 }).strict();
 var agentWebAppAppearanceSchema = z4.object({
   title: z4.string().max(120).optional(),
   welcomeMessage: z4.string().max(1e3).optional(),
   primaryColor: z4.string().regex(/^#[0-9A-Fa-f]{6}$/).optional()
 }).strict();
+var agentWebAppIssuerSchema = z4.object({
+  iss: z4.string().min(1).max(255),
+  aud: z4.string().min(1).max(255),
+  alg: z4.enum(["HS256", "RS256"]),
+  secret: z4.string().min(1).max(512).optional(),
+  jwksUrl: z4.string().url().max(2048).optional()
+}).strict().refine(
+  (value) => value.alg === "HS256" ? value.secret !== void 0 : value.jwksUrl !== void 0,
+  { message: "HS256 requires secret; RS256 requires jwksUrl" }
+);
+var agentWebAppIdentitySchema = z4.object({
+  policy: z4.enum(["unverified", "verified", "both"]),
+  issuers: z4.array(agentWebAppIssuerSchema).min(1).max(10)
+}).strict();
 var createAgentWebAppSchema = z4.object({
   assistantId: externalId,
   name: z4.string().min(1).max(120),
@@ -11899,14 +11914,16 @@ var createAgentWebAppSchema = z4.object({
   integration: z4.object({ type: z4.literal("react_sdk") }).strict(),
   scope: agentWebAppScopeSchema,
   features: agentWebAppFeaturesSchema,
-  appearance: agentWebAppAppearanceSchema
+  appearance: agentWebAppAppearanceSchema,
+  identity: agentWebAppIdentitySchema.optional()
 }).strict();
 var updateAgentWebAppSchema = z4.object({
   name: z4.string().min(1).max(120).optional(),
   description: z4.string().max(1e3).optional(),
   scope: agentWebAppScopeSchema.partial().strict().optional(),
   features: agentWebAppFeaturesSchema.partial().strict().optional(),
-  appearance: agentWebAppAppearanceSchema.partial().strict().optional()
+  appearance: agentWebAppAppearanceSchema.partial().strict().optional(),
+  identity: agentWebAppIdentitySchema.optional()
 }).strict().refine((value) => Object.keys(value).length > 0, "Patch must not be empty");
 var listAgentWebAppsQuerySchema = z4.object({
   assistantId: externalId.optional()
@@ -11993,6 +12010,7 @@ function invalidRequest(reply, statusCode) {
 }
 
 // src/routes/agent-web-app-runtime.ts
+import { createHmac as createHmac3 } from "crypto";
 import { z as z5, ZodError as ZodError2 } from "zod";
 
 // src/services/agent-web-app/AgentWebAppRuntimeService.ts
@@ -12013,7 +12031,16 @@ var AgentWebAppRuntimeService = class {
   constructor(deps) {
     this.deps = deps;
   }
-  async bootstrap(webAppId, userId, selection) {
+  /** Identity policy configuration for the web app, or null when the app is missing/unconfigured. */
+  async getIdentityConfig(webAppId) {
+    try {
+      const runtime = await this.resolveRuntime(webAppId, {});
+      return runtime.webApp.identity ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async bootstrap(webAppId, userId, selection, identity) {
     const runtime = await this.resolveRuntime(webAppId, selection);
     const assistant = await this.deps.assistantResolver.resolve(
       runtime.webApp.tenantId,
@@ -12046,7 +12073,7 @@ var AgentWebAppRuntimeService = class {
         defaultModelKey: runtime.webApp.scope.defaultModelKey,
         features: runtime.webApp.features,
         appearance: runtime.webApp.appearance,
-        identityAssurance: "unverified"
+        identityAssurance: identity?.assurance ?? "unverified"
       },
       projects,
       models
@@ -12067,6 +12094,14 @@ var AgentWebAppRuntimeService = class {
     this.requireFeature(runtime.webApp.features.threadManagement);
     return this.createOwnedThread(runtime, userId, input.label);
   }
+  /** Fetch one owned thread. */
+  async getThread(webAppId, userId, threadId, selection) {
+    const runtime = await this.resolveRuntime(webAppId, selection);
+    await this.requireOwnedThread(runtime, userId, threadId);
+    const thread = await this.deps.threadStore.getThreadById(runtime.webApp.tenantId, threadId);
+    if (!thread) this.threadNotFound();
+    return toRuntimeThread(thread);
+  }
   /** Update a thread label; omitted or blank labels preserve the existing label. */
   async updateThread(webAppId, userId, threadId, input) {
     const runtime = await this.resolveRuntime(webAppId, input);
@@ -12101,6 +12136,60 @@ var AgentWebAppRuntimeService = class {
       return [{ id: message.id, role: message.role, ...content && (typeof content === "string" || content.length > 0) ? { content } : {} }];
     });
   }
+  async getState(webAppId, userId, threadId, selection) {
+    const runtime = await this.resolveRuntime(webAppId, selection);
+    await this.requireOwnedThread(runtime, userId, threadId);
+    const agent = this.resolveAgent(runtime, threadId);
+    const state = await agent.getCurrentState();
+    const pendingMessages = await agent.getPendingMessages();
+    const normalized = pendingMessages.map((message) => ({
+      ...message,
+      content: typeof message.content === "object" && message.content !== null ? "message" in message.content ? message.content.message : JSON.stringify(message.content) : String(message.content ?? "")
+    }));
+    return { ...state && typeof state === "object" ? state : {}, pendingMessages: normalized };
+  }
+  /** Raw stored messages (Console memory contract, tool/interrupt preserved). */
+  async getConsoleMessages(webAppId, userId, threadId, selection) {
+    const runtime = await this.resolveRuntime(webAppId, selection);
+    await this.requireOwnedThread(runtime, userId, threadId);
+    return this.deps.messageReader.getCurrentMessages({
+      tenantId: runtime.webApp.tenantId,
+      assistantId: runtime.webApp.assistantId,
+      threadId,
+      workspaceId: runtime.project.workspaceId,
+      projectId: runtime.project.id
+    });
+  }
+  /** Background enqueue only (ADR-026): returns the message id; delivery happens over resume_stream. */
+  async enqueueMessage(webAppId, userId, threadId, content, selection) {
+    const runtime = await this.resolveOwnedRuntime(webAppId, userId, threadId, selection);
+    const agent = this.resolveAgent(runtime, threadId);
+    const execution = await this.execute(agent, runtime, { input: { message: content } });
+    return { messageId: execution.messageId };
+  }
+  async removePendingMessage(webAppId, userId, threadId, messageId, selection) {
+    const runtime = await this.resolveRuntime(webAppId, selection);
+    await this.requireOwnedThread(runtime, userId, threadId);
+    const agent = this.resolveAgent(runtime, threadId);
+    if (!await agent.removePendingMessage(messageId)) this.threadNotFound();
+  }
+  /** Thread-lifetime SSE resume from the last known client message id. */
+  async resumeStream(webAppId, userId, threadId, messageId, selection) {
+    const runtime = await this.resolveRuntime(webAppId, selection);
+    await this.requireOwnedThread(runtime, userId, threadId);
+    const agent = this.resolveAgent(runtime, threadId);
+    return { stream: agent.chunkStream(messageId, []) };
+  }
+  async resolveFileScope(webAppId, selection) {
+    const runtime = await this.resolveRuntime(webAppId, selection);
+    return {
+      tenantId: runtime.webApp.tenantId,
+      workspaceId: runtime.project.workspaceId,
+      projectId: runtime.project.id,
+      assistantId: runtime.webApp.assistantId,
+      enabled: runtime.webApp.features.files === true
+    };
+  }
   async streamMessage(webAppId, userId, threadId, input) {
     const runtime = await this.resolveOwnedRuntime(webAppId, userId, threadId, input);
     const refs = this.resolveAttachmentRefs(runtime, userId, threadId, input.attachmentRefs ?? []);
@@ -12345,96 +12434,102 @@ function toRuntimeThread(thread) {
   };
 }
 
-// src/services/agent-web-app/AgentWebAppStreamProjector.ts
-import {
-  MessageChunkTypes as MessageChunkTypes4,
-  parseAgentWebAppGenUIBlock as parseAgentWebAppGenUIBlock2
-} from "@axiom-lattice/protocols";
-function createAgentWebAppStreamProjectionContext(options = {}) {
-  return { startedToolIds: /* @__PURE__ */ new Set(), allowInterrupts: options.allowInterrupts ?? true, allowGenUI: options.allowGenUI ?? false };
-}
-function projectAgentWebAppChunk(chunk, context) {
-  if (chunk.type === MessageChunkTypes4.AI) {
-    const events = [];
-    const startedToolIds = context?.startedToolIds ?? /* @__PURE__ */ new Set();
-    if (typeof chunk.data.content === "string" && chunk.data.content) events.push({ type: "message.delta", text: chunk.data.content });
-    if (context?.allowGenUI && Array.isArray(chunk.data.content)) {
-      for (const value of chunk.data.content) {
-        const block = parseAgentWebAppGenUIBlock2(value);
-        if (block) events.push({ type: "genui.render", block });
-      }
-    }
-    for (const call of chunk.data.tool_call_chunks ?? []) {
-      if (call.id && call.name && !startedToolIds.has(call.id)) {
-        startedToolIds.add(call.id);
-        events.push({ type: "tool.started", id: call.id, name: call.name });
-      }
-    }
-    for (const call of chunk.data.tool_calls ?? []) {
-      if (!startedToolIds.has(call.id)) {
-        startedToolIds.add(call.id);
-        events.push({ type: "tool.started", id: call.id, name: call.name });
-      }
-    }
-    return events;
-  }
-  if (chunk.type === MessageChunkTypes4.TOOL && chunk.data.tool_call_id) {
-    return [{ type: "tool.completed", id: chunk.data.tool_call_id }];
-  }
-  if (chunk.type === MessageChunkTypes4.INTERRUPT) {
-    if (context && !context.allowInterrupts) return [{ type: "stream.completed" }];
-    const interrupt = publicInterrupt(chunk);
-    return interrupt ? [{ type: "interrupt.created", interrupt }, { type: "stream.completed" }] : [{ type: "stream.completed" }];
-  }
-  if (chunk.type === MessageChunkTypes4.MESSAGE_COMPLETED) {
-    return [
-      { type: "message.completed", messageId: chunk.data.id },
-      { type: "stream.completed" }
-    ];
-  }
-  if (chunk.type === MessageChunkTypes4.MESSAGE_FAILED) {
-    return [
-      { type: "error", error: { code: "STREAM_FAILED", message: "Stream failed", retryable: true } },
-      { type: "stream.completed" }
-    ];
+// src/services/agent-web-app/AgentWebAppTokenVerifier.ts
+import { createHmac as createHmac2, createPublicKey, timingSafeEqual as timingSafeEqual2, verify as cryptoVerify } from "crypto";
+var WebAppTokenError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebAppTokenError";
   }
-  return [];
-}
-function publicInterrupt(chunk) {
-  const value = parseInterruptContent(chunk.data.content);
-  if (!value) return void 0;
-  const topLevelId = chunk.id;
-  const id3 = typeof topLevelId === "string" ? topLevelId : chunk.data.id;
-  if (!id3) return void 0;
-  return {
-    id: id3,
-    type: typeof value.type === "string" ? value.type : "input",
-    prompt: typeof value.prompt === "string" ? value.prompt : typeof value.message === "string" ? value.message : "Input required",
-    ...isRecord3(value.data) ? { data: value.data } : {}
-  };
-}
-function parseInterruptContent(content) {
-  if (!content) return {};
-  if (isRecord3(content)) return content;
-  if (typeof content !== "string") return void 0;
+};
+var MAX_TOKEN_BYTES = 8 * 1024;
+var CLOCK_SKEW_SECONDS = 60;
+var JWKS_TTL_MS = 10 * 60 * 1e3;
+var jwksCache = /* @__PURE__ */ new Map();
+function decodeSegment(segment) {
+  const json = Buffer.from(segment, "base64url").toString("utf8");
+  let value;
   try {
-    const parsed = JSON.parse(content);
-    return isRecord3(parsed) ? parsed : { prompt: content };
+    value = JSON.parse(json);
   } catch {
-    return { prompt: content };
+    throw new WebAppTokenError("Malformed token segment");
   }
+  if (typeof value !== "object" || value === null) throw new WebAppTokenError("Malformed token segment");
+  return value;
 }
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+async function resolveKey(issuer, kid, fetchImpl) {
+  const cacheKey = issuer.jwksUrl ?? "";
+  const load = async () => {
+    const response = await fetchImpl(issuer.jwksUrl ?? "");
+    if (!response.ok) throw new WebAppTokenError("JWKS fetch failed");
+    const document = await response.json();
+    const keys2 = document.keys;
+    const entry2 = { keys: Array.isArray(keys2) ? keys2 : [], fetchedAt: Date.now() };
+    jwksCache.set(cacheKey, entry2);
+    return entry2;
+  };
+  const cached = jwksCache.get(cacheKey);
+  let entry = cached && Date.now() - cached.fetchedAt < JWKS_TTL_MS ? cached : await load();
+  let jwk = entry.keys.find((key) => kid === void 0 ? true : key.kid === kid);
+  if (!jwk && kid !== void 0) {
+    entry = await load();
+    jwk = entry.keys.find((key) => key.kid === kid);
+  }
+  if (!jwk) throw new WebAppTokenError("No matching JWKS key");
+  return createPublicKey({ key: jwk, format: "jwk" });
+}
+async function verifyWebAppToken(token, issuer, options = {}) {
+  const nowMs = options.now ? options.now() : Date.now();
+  const now = Math.floor(nowMs / 1e3);
+  if (token.length === 0 || Buffer.byteLength(token) > MAX_TOKEN_BYTES) throw new WebAppTokenError("Token size invalid");
+  const parts = token.split(".");
+  if (parts.length !== 3) throw new WebAppTokenError("Token structure invalid");
+  const [rawHeader, rawPayload, rawSignature] = parts;
+  const header2 = decodeSegment(rawHeader);
+  const payload = decodeSegment(rawPayload);
+  if (header2.alg !== issuer.alg) throw new WebAppTokenError("Token algorithm mismatch");
+  if (payload.iss !== issuer.iss) throw new WebAppTokenError("Token issuer mismatch");
+  if (payload.aud !== issuer.aud) throw new WebAppTokenError("Token audience mismatch");
+  const exp = typeof payload.exp === "number" ? payload.exp : void 0;
+  if (exp === void 0 || exp + CLOCK_SKEW_SECONDS < now) throw new WebAppTokenError("Token expired");
+  const nbf = typeof payload.nbf === "number" ? payload.nbf : void 0;
+  if (nbf !== void 0 && nbf - CLOCK_SKEW_SECONDS > now) throw new WebAppTokenError("Token not yet valid");
+  const signature = Buffer.from(rawSignature, "base64url");
+  const data = Buffer.from(`${rawHeader}.${rawPayload}`);
+  if (issuer.alg === "HS256") {
+    if (typeof issuer.secret !== "string" || issuer.secret.length === 0) throw new WebAppTokenError("Issuer secret missing");
+    const expected = createHmac2("sha256", issuer.secret).update(data).digest();
+    if (signature.length !== expected.length || !timingSafeEqual2(signature, expected)) {
+      throw new WebAppTokenError("Token signature invalid");
+    }
+  } else {
+    if (typeof issuer.jwksUrl !== "string") throw new WebAppTokenError("Issuer JWKS URL missing");
+    const key = await resolveKey(issuer, typeof header2.kid === "string" ? header2.kid : void 0, options.fetchImpl ?? fetch);
+    let valid = false;
+    try {
+      valid = cryptoVerify("RSA-SHA256", data, key, signature);
+    } catch {
+      valid = false;
+    }
+    if (!valid) throw new WebAppTokenError("Token signature invalid");
+  }
+  const sub = payload.sub;
+  if (typeof sub !== "string" || sub.length === 0 || sub.length > 128 || !/^[A-Za-z0-9._:@-]+$/.test(sub)) {
+    throw new WebAppTokenError("Token subject invalid");
+  }
+  return sub;
 }
 
 // src/routes/agent-web-app-runtime.ts
+import { createAgentWebAppStreamProjectionContext, projectAgentWebAppChunk } from "@axiom-lattice/protocols";
 var idSchema = z5.string().min(1).max(128);
 var paramsSchema = z5.object({ webAppId: idSchema }).strict();
 var threadParamsSchema = z5.object({ webAppId: idSchema, threadId: idSchema }).strict();
 var interruptParamsSchema = z5.object({ webAppId: idSchema, threadId: idSchema, interruptId: idSchema }).strict();
+var pendingMessageParamsSchema = z5.object({ webAppId: idSchema, threadId: idSchema, messageId: idSchema }).strict();
 var bootstrapQuerySchema = z5.object({ projectId: idSchema.optional(), modelKey: idSchema.optional() }).strict();
 var projectQuerySchema = z5.object({ projectId: idSchema.optional() }).strict();
+var projectQueryLenientSchema = projectQuerySchema.passthrough();
 var threadBodySchema = z5.object({ projectId: idSchema.optional(), label: z5.string().max(128).optional() }).strict();
 var streamBodySchema = z5.object({
   content: z5.string().trim().min(1).max(32768),
@@ -12453,8 +12548,27 @@ var resumeBodySchema = z5.object({
   ])
 }).strict();
 var MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+var stateQuerySchema = z5.object({
+  threadId: idSchema,
+  projectId: idSchema.optional(),
+  modelKey: idSchema.optional()
+}).strict();
+var resumeSchema = z5.object({
+  messageId: idSchema,
+  projectId: idSchema.optional(),
+  modelKey: idSchema.optional()
+}).strict();
+var devTokenSchema = z5.object({
+  iss: z5.string().min(1).max(255).optional(),
+  sub: z5.string().regex(/^[A-Za-z0-9._:@-]+$/).max(128).optional(),
+  hours: z5.number().gt(0).max(720).optional()
+}).strict();
+var fileQuerySchema = z5.object({
+  projectId: idSchema.optional(),
+  modelKey: idSchema.optional()
+}).passthrough();
 function createExternalHeaderIdentityResolver() {
-  return { resolve(request) {
+  return { async resolve(request) {
     const raw = request.headers["x-axiom-external-user-id"];
     if (raw === void 0) throw new AgentWebAppRuntimeError("USER_ID_REQUIRED", 401, "External user id is required");
     if (Array.isArray(raw) || typeof raw !== "string") throw new AgentWebAppRuntimeError("INVALID_USER_ID", 400, "External user id is invalid");
@@ -12463,47 +12577,109 @@ function createExternalHeaderIdentityResolver() {
     return { userId, assurance: "unverified" };
   } };
 }
+function createWebAppIdentityResolver(deps) {
+  const headerResolver = createExternalHeaderIdentityResolver();
+  return {
+    async resolve(request, webAppId) {
+      let config;
+      try {
+        config = await deps.getIdentityConfig(webAppId);
+      } catch {
+        config = void 0;
+      }
+      const policy = config?.policy ?? "unverified";
+      const authHeader = request.headers.authorization;
+      const bearer = typeof authHeader === "string" && authHeader.startsWith("Bearer ") ? authHeader.slice(7).trim() : void 0;
+      if (policy !== "unverified" && bearer !== void 0) {
+        const issuers = config?.issuers ?? [];
+        if (issuers.length === 0) throw new AgentWebAppRuntimeError("INVALID_REQUEST", 401, "No trusted issuer configured");
+        let lastError = new AgentWebAppRuntimeError("INVALID_REQUEST", 401, "Invalid identity token");
+        for (const issuer of issuers) {
+          try {
+            const sub = await verifyWebAppToken(bearer, issuer);
+            return { userId: sub, assurance: "verified" };
+          } catch (error) {
+            if (error instanceof WebAppTokenError) {
+              lastError = error;
+              continue;
+            }
+            throw error;
+          }
+        }
+        const message = lastError instanceof WebAppTokenError ? `Invalid identity token: ${lastError.message}` : "Invalid identity token";
+        throw new AgentWebAppRuntimeError("INVALID_REQUEST", 401, message);
+      }
+      if (policy === "verified") throw new AgentWebAppRuntimeError("USER_ID_REQUIRED", 401, "A verified identity token is required");
+      return headerResolver.resolve(request, webAppId);
+    }
+  };
+}
 function registerAgentWebAppRuntimeRoutes(app2, deps) {
-  const identities = deps.identityResolver ?? createExternalHeaderIdentityResolver();
+  const identities = deps.identityResolver ?? createWebAppIdentityResolver({ getIdentityConfig: (webAppId) => deps.service.getIdentityConfig(webAppId) });
   app2.register(async (routes) => {
     routes.setErrorHandler((error, _request, reply) => normalizeError2(reply, error));
     routes.get("/api/web-apps/:webAppId/runtime/bootstrap", async (request, reply) => handle2(reply, async () => {
       const { webAppId } = paramsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
-      return { data: await deps.service.bootstrap(webAppId, identity.userId, withPreview(bootstrapQuerySchema.parse(request.query), identity.preview)) };
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+      return { data: await deps.service.bootstrap(webAppId, identity.userId, withPreview(bootstrapQuerySchema.parse(request.query), identity.preview), { assurance: identity.assurance ?? "unverified" }) };
     }));
     routes.get("/api/web-apps/:webAppId/runtime/threads", async (request, reply) => handle2(reply, async () => {
       const { webAppId } = paramsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       const records = await deps.service.listThreads(webAppId, identity.userId, withPreview(projectQuerySchema.parse(request.query), identity.preview));
       return { data: { records, total: records.length } };
     }));
     routes.post("/api/web-apps/:webAppId/runtime/threads", async (request, reply) => handle2(reply, async () => {
       const { webAppId } = paramsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       return { statusCode: 201, data: await deps.service.createThread(webAppId, identity.userId, withPreview(threadBodySchema.parse(request.body), identity.preview)) };
     }));
     routes.patch("/api/web-apps/:webAppId/runtime/threads/:threadId", async (request, reply) => handle2(reply, async () => {
       const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       return { data: await deps.service.updateThread(webAppId, identity.userId, threadId, withPreview(threadBodySchema.parse(request.body), identity.preview)) };
     }));
     routes.delete("/api/web-apps/:webAppId/runtime/threads/:threadId", async (request, reply) => handle2(reply, async () => {
       const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       await deps.service.deleteThread(webAppId, identity.userId, threadId, withPreview(projectQuerySchema.parse(request.query), identity.preview));
       return { data: { id: threadId } };
     }));
     routes.get("/api/web-apps/:webAppId/runtime/threads/:threadId/messages", async (request, reply) => handle2(reply, async () => {
       const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       const messages = await deps.service.getMessages(webAppId, identity.userId, threadId, withPreview(projectQuerySchema.parse(request.query), identity.preview));
       return { data: { messages } };
     }));
+    routes.get("/api/web-apps/:webAppId/runtime/state", async (request, reply) => handle2(reply, async () => {
+      const { webAppId } = paramsSchema.parse(request.params);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+      const { threadId, projectId, modelKey: modelKey2 } = stateQuerySchema.parse(request.query);
+      const state = await deps.service.getState(webAppId, identity.userId, threadId, withPreview({ projectId, modelKey: modelKey2 }, identity.preview));
+      return { data: state };
+    }));
+    routes.delete("/api/web-apps/:webAppId/runtime/threads/:threadId/pending-messages/:messageId", async (request, reply) => handle2(reply, async () => {
+      const { webAppId, threadId, messageId } = pendingMessageParamsSchema.parse(request.params);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+      await deps.service.removePendingMessage(webAppId, identity.userId, threadId, messageId, withPreview(projectQuerySchema.parse(request.query), identity.preview));
+      return { data: { removed: true } };
+    }));
     routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/messages/stream", async (request, reply) => {
       try {
         const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-        const identity = resolveRuntimeIdentity(request, webAppId, identities);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const input = streamBodySchema.parse(request.body);
+        const result = await deps.service.streamMessage(webAppId, identity.userId, threadId, withPreview(input, identity.preview));
+        beginSse(reply);
+        await pipeNativeWebAppStream(reply.raw, result.stream);
+      } catch (error) {
+        return normalizeError2(reply, error);
+      }
+    });
+    routes.post("/api/web-apps/:webAppId/runtime/v1/threads/:threadId/messages/stream", async (request, reply) => {
+      try {
+        const { webAppId, threadId } = threadParamsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
         const input = streamBodySchema.parse(request.body);
         const result = await deps.service.streamMessage(webAppId, identity.userId, threadId, withPreview(input, identity.preview));
         beginSse(reply);
@@ -12512,15 +12688,27 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
         return normalizeError2(reply, error);
       }
     });
+    routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/resume", async (request, reply) => {
+      try {
+        const { webAppId, threadId } = threadParamsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const { messageId, projectId, modelKey: modelKey2 } = resumeSchema.parse(request.body);
+        const result = await deps.service.resumeStream(webAppId, identity.userId, threadId, messageId, withPreview({ projectId, modelKey: modelKey2 }, identity.preview));
+        beginSse(reply);
+        await pipeNativeWebAppStream(reply.raw, result.stream);
+      } catch (error) {
+        return normalizeError2(reply, error);
+      }
+    });
     routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/abort", async (request, reply) => handle2(reply, async () => {
       const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       await deps.service.abort(webAppId, identity.userId, threadId, withPreview(projectQuerySchema.parse(request.query), identity.preview));
       return { data: { aborted: true } };
     }));
     routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/attachments", async (request, reply) => handle2(reply, async () => {
       const { webAppId, threadId } = threadParamsSchema.parse(request.params);
-      const identity = resolveRuntimeIdentity(request, webAppId, identities);
+      const identity = await resolveRuntimeIdentity(request, webAppId, identities);
       if (!request.isMultipart()) throw new ZodError2([]);
       const part = await request.file({ limits: { files: 1, fileSize: MAX_ATTACHMENT_BYTES } });
       if (!part || !part.filename || part.filename.length > 255) throw new ZodError2([]);
@@ -12536,7 +12724,7 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
     routes.post("/api/web-apps/:webAppId/runtime/threads/:threadId/interrupts/:interruptId/resume", async (request, reply) => {
       try {
         const { webAppId, threadId, interruptId } = interruptParamsSchema.parse(request.params);
-        const identity = resolveRuntimeIdentity(request, webAppId, identities);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
         const { projectId, modelKey: modelKey2, message, response } = resumeBodySchema.parse(request.body);
         const result = await deps.service.resumeInterrupt(webAppId, identity.userId, threadId, interruptId, withPreview({ projectId, modelKey: modelKey2 }, identity.preview), { message, response });
         beginSse(reply);
@@ -12545,13 +12733,257 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
         return normalizeError2(reply, error);
       }
     });
+    routes.post("/api/web-apps/:webAppId/dev/token", async (request, reply) => handle2(reply, async () => {
+      if (process.env.WEB_APP_DEV_TOKEN_ENABLED !== "true") {
+        throw new AgentWebAppRuntimeError("FEATURE_DISABLED", 403, "Dev token issuance is disabled (set WEB_APP_DEV_TOKEN_ENABLED=true)");
+      }
+      const { webAppId } = paramsSchema.parse(request.params);
+      const { iss, sub, hours } = devTokenSchema.parse(request.body ?? {});
+      const config = await deps.service.getIdentityConfig(webAppId);
+      const issuer = (config?.issuers ?? []).find((entry) => entry.alg === "HS256" && (iss === void 0 || entry.iss === iss));
+      if (!issuer || typeof issuer.secret !== "string") {
+        throw new AgentWebAppRuntimeError("INVALID_REQUEST", 400, "Web app has no HS256 issuer configured");
+      }
+      const now = Math.floor(Date.now() / 1e3);
+      const expiresIn = (hours ?? 24) * 3600;
+      const subject = sub ?? "dev-user";
+      const b64url = (input) => Buffer.from(input).toString("base64url");
+      const body = `${b64url(JSON.stringify({ alg: "HS256", typ: "JWT" }))}.${b64url(JSON.stringify({ sub: subject, iss: issuer.iss, aud: issuer.aud, iat: now, exp: now + expiresIn }))}`;
+      const token = `${body}.${createHmac3("sha256", issuer.secret).update(body).digest("base64url")}`;
+      return { data: { token, tokenType: "Bearer", expiresIn, subject } };
+    }));
+    if (deps.taskController) {
+      const tasks = deps.taskController;
+      const withSubject = (handler) => async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const proxy = Object.create(request);
+        proxy.headers = { ...request.headers, "x-user-id": identity.userId };
+        return handler(proxy, reply);
+      };
+      routes.get("/api/web-apps/:webAppId/runtime/tasks", withSubject((request, reply) => tasks.list(request, reply)));
+      routes.post("/api/web-apps/:webAppId/runtime/tasks", withSubject((request, reply) => tasks.create(request, reply)));
+      routes.get("/api/web-apps/:webAppId/runtime/tasks/:taskId", withSubject((request, reply) => tasks.get(request, reply)));
+      routes.put("/api/web-apps/:webAppId/runtime/tasks/:taskId", withSubject((request, reply) => tasks.update(request, reply)));
+      routes.patch("/api/web-apps/:webAppId/runtime/tasks/:taskId", withSubject((request, reply) => tasks.update(request, reply)));
+      routes.delete("/api/web-apps/:webAppId/runtime/tasks/:taskId", withSubject((request, reply) => tasks.remove(request, reply)));
+      routes.patch("/api/web-apps/:webAppId/runtime/tasks/:taskId/complete", withSubject((request, reply) => tasks.complete(request, reply)));
+      routes.get("/api/web-apps/:webAppId/runtime/tasks/:taskId/work-items", withSubject((request, reply) => tasks.workItems(request, reply)));
+    }
+    if (deps.workspaceController) {
+      const workspace = deps.workspaceController;
+      const fileScope = async (webAppId, selection) => {
+        const scope = await deps.service.resolveFileScope(webAppId, selection);
+        if (!scope.enabled) throw new AgentWebAppRuntimeError("FEATURE_DISABLED", 403, "Files are disabled for this web app");
+        return scope;
+      };
+      const scopedRequest = (request, scope, params, query) => {
+        const proxy = Object.create(request);
+        proxy.params = params;
+        proxy.query = query;
+        proxy.headers = { ...request.headers, "x-tenant-id": scope.tenantId };
+        return proxy;
+      };
+      const unwrap = (result) => ({ data: result.data });
+      routes.get("/api/web-apps/:webAppId/runtime/files/listpath", async (request) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        const result = await workspace.listPath(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query));
+        return unwrap(result);
+      });
+      routes.get("/api/web-apps/:webAppId/runtime/files/readfile", async (request) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        const result = await workspace.readFile(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query));
+        return unwrap(result);
+      });
+      routes.post("/api/web-apps/:webAppId/runtime/files/uploadfile", async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const scoped = scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, { assistantId: scope.assistantId });
+        await workspace.uploadFile(scoped, reply);
+        return reply;
+      });
+      routes.get("/api/web-apps/:webAppId/runtime/files/viewfile", async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        await workspace.viewFile(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query), reply);
+        return reply;
+      });
+      routes.get("/api/web-apps/:webAppId/runtime/files/downloadfile", async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        await workspace.downloadFile(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query), reply);
+        return reply;
+      });
+      routes.get("/api/web-apps/:webAppId/runtime/files/downloadfolder", async (request, reply) => {
+        const { webAppId } = paramsSchema.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        await workspace.downloadFolder(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query), reply);
+        return reply;
+      });
+      const genuiSandboxParams = z5.object({ webAppId: idSchema, assistantId: idSchema, threadId: idSchema }).strict();
+      const delegateGenuiFile = (method) => async (request, reply) => {
+        const { webAppId } = genuiSandboxParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const scope = await fileScope(webAppId, fileQuerySchema.parse(request.query));
+        const query = { ...request.query, assistantId: scope.assistantId };
+        await method(scopedRequest(request, scope, { workspaceId: scope.workspaceId, projectId: scope.projectId }, query), reply);
+        return reply;
+      };
+      routes.get("/api/web-apps/:webAppId/runtime/assistants/:assistantId/threads/:threadId/sandbox/downloadfile", delegateGenuiFile(workspace.downloadFile.bind(workspace)));
+      routes.get("/api/web-apps/:webAppId/runtime/assistants/:assistantId/threads/:threadId/sandbox/viewfile", delegateGenuiFile(workspace.viewFile.bind(workspace)));
+    }
+    const mirrorThreadParams = z5.object({ webAppId: idSchema, assistantId: idSchema, threadId: idSchema }).strict();
+    const mirrorBody = z5.object({ metadata: z5.object({ label: z5.string().max(300).optional() }).strict().optional(), projectId: idSchema.optional(), modelKey: idSchema.optional() }).strict();
+    const toConsoleThread = (thread, assistantId) => ({
+      id: thread.id,
+      assistantId,
+      metadata: thread.label ? { label: thread.label } : {},
+      createdAt: thread.createdAt,
+      updatedAt: thread.updatedAt
+    });
+    const mirrorAssistantParams = z5.object({ webAppId: idSchema, assistantId: idSchema }).strict();
+    const mirrorPendingParams = z5.object({ webAppId: idSchema, assistantId: idSchema, threadId: idSchema, messageId: idSchema }).strict();
+    const registerMirror = (prefix) => {
+      routes.get(`${prefix}/assistants/:assistantId/threads`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, assistantId } = mirrorAssistantParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const threads = await deps.service.listThreads(webAppId, identity.userId, projectQueryLenientSchema.parse(request.query));
+        return { data: { records: threads.map((thread) => toConsoleThread(thread, assistantId)) } };
+      }));
+      routes.post(`${prefix}/assistants/:assistantId/threads`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, assistantId } = mirrorAssistantParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const body = mirrorBody.parse(request.body ?? {});
+        const created = await deps.service.createThread(webAppId, identity.userId, { label: body.metadata?.label, ...body.projectId ? { projectId: body.projectId } : {} });
+        return { statusCode: 201, data: { id: created.id } };
+      }));
+      routes.get(`${prefix}/assistants/:assistantId/threads/:threadId`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, assistantId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const thread = await deps.service.getThread(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+        return { data: toConsoleThread(thread, assistantId) };
+      }));
+      routes.put(`${prefix}/assistants/:assistantId/threads/:threadId`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, assistantId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const body = mirrorBody.parse(request.body ?? {});
+        const updated = await deps.service.updateThread(webAppId, identity.userId, threadId, { label: body.metadata?.label, ...body.projectId ? { projectId: body.projectId } : {} });
+        return { data: toConsoleThread(updated, assistantId) };
+      }));
+      routes.delete(`${prefix}/assistants/:assistantId/threads/:threadId`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        await deps.service.deleteThread(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+        return { data: { success: true, message: "Thread deleted" } };
+      }));
+      routes.post(`${prefix}/assistants/:assistantId/threads/:threadId/sandbox/uploadfile`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        if (!request.isMultipart()) throw new ZodError2([]);
+        const part = await request.file({ limits: { files: 1, fileSize: MAX_ATTACHMENT_BYTES } });
+        if (!part || !part.filename || part.filename.length > 255) throw new ZodError2([]);
+        const bytes = await part.toBuffer();
+        if (bytes.length === 0 || part.file.truncated) throw new ZodError2([]);
+        const uploaded = await deps.service.uploadAttachment(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query), {
+          name: part.filename,
+          mimeType: part.mimetype || "application/octet-stream",
+          bytes
+        });
+        return { statusCode: 201, data: { id: uploaded.ref, path: uploaded.ref, name: uploaded.name, mimeType: uploaded.mimeType, size: uploaded.size } };
+      }));
+      routes.get(`${prefix}/assistants/:assistantId/:threadId/memory`, async (request) => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        const messages = await deps.service.getConsoleMessages(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+        return messages;
+      });
+      routes.get(`${prefix}/assistants/:assistantId/:threadId/state`, async (request) => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        return deps.service.getState(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+      });
+      routes.delete(`${prefix}/assistants/:assistantId/threads/:threadId/pending-messages/:messageId`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, threadId, messageId } = mirrorPendingParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        await deps.service.removePendingMessage(webAppId, identity.userId, threadId, messageId, projectQueryLenientSchema.parse(request.query));
+        return { data: { removed: true } };
+      }));
+      routes.post(`${prefix}/assistants/:assistantId/threads/:threadId/abort`, async (request, reply) => handle2(reply, async () => {
+        const { webAppId, threadId } = mirrorThreadParams.parse(request.params);
+        const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+        await deps.service.abort(webAppId, identity.userId, threadId, projectQueryLenientSchema.parse(request.query));
+        return { data: { aborted: true } };
+      }));
+      const runsBodySchema = z5.object({
+        thread_id: idSchema.optional(),
+        assistant_id: idSchema.optional(),
+        messages: z5.array(z5.object({ content: z5.string().min(1).max(32768) }).passthrough()).min(1).max(20),
+        background: z5.boolean().optional(),
+        streaming: z5.boolean().optional(),
+        projectId: idSchema.optional(),
+        modelKey: idSchema.optional()
+      }).passthrough();
+      routes.post(`${prefix}/runs`, async (request, reply) => {
+        try {
+          const { webAppId } = paramsSchema.parse(request.params);
+          const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+          const body = runsBodySchema.parse(request.body ?? {});
+          if (!body.background || body.streaming) {
+            throw new AgentWebAppRuntimeError("INVALID_REQUEST", 400, "Mirror runs supports only background enqueue (stream via resume_stream)");
+          }
+          const threadId = body.thread_id ?? "";
+          if (!threadId) throw new AgentWebAppRuntimeError("INVALID_REQUEST", 400, "thread_id is required");
+          const content = body.messages.map((message) => message.content).join("\n");
+          const { messageId } = await deps.service.enqueueMessage(webAppId, identity.userId, threadId, content, { projectId: body.projectId, modelKey: body.modelKey });
+          return reply.code(202).send({ success: true, messageId, queued: true });
+        } catch (error) {
+          return normalizeError2(reply, error);
+        }
+      });
+      const resumeStreamSchema2 = z5.object({
+        assistant_id: idSchema.optional(),
+        thread_id: idSchema,
+        message_id: idSchema,
+        known_content: z5.string().optional(),
+        poll_interval: z5.number().optional(),
+        projectId: idSchema.optional(),
+        modelKey: idSchema.optional()
+      }).strict();
+      routes.post(`${prefix}/resume_stream`, async (request, reply) => {
+        try {
+          const { webAppId } = paramsSchema.parse(request.params);
+          const identity = await resolveRuntimeIdentity(request, webAppId, identities);
+          const body = resumeStreamSchema2.parse(request.body ?? {});
+          const result = await deps.service.resumeStream(webAppId, identity.userId, body.thread_id, body.message_id, { projectId: body.projectId, modelKey: body.modelKey });
+          beginSse(reply);
+          await pipeNativeWebAppStream(reply.raw, result.stream);
+        } catch (error) {
+          return normalizeError2(reply, error);
+        }
+      });
+    };
+    registerMirror("/api/web-apps/:webAppId/runtime");
+    registerMirror("/api/web-apps/:webAppId/runtime/api");
   });
 }
-function resolveRuntimeIdentity(request, webAppId, identities) {
-  if (request.headers["x-axiom-web-app-preview"] !== "true") return identities.resolve(request);
+async function resolveRuntimeIdentity(request, webAppId, identities) {
+  if (request.headers["x-axiom-web-app-preview"] !== "true") return identities.resolve(request, webAppId);
   const user = request.user;
   if (!user?.id || !user.tenantId) throw new AgentWebAppRuntimeError("USER_ID_REQUIRED", 401, "Authenticated Console preview is required");
-  return { userId: `console-preview:${user.id}:${webAppId}`, preview: { tenantId: user.tenantId, userId: user.id } };
+  return { userId: `console-preview:${user.id}:${webAppId}`, assurance: "unverified", preview: { tenantId: user.tenantId, userId: user.id } };
 }
 function withPreview(selection, preview) {
   return { ...selection, ...preview ? { preview } : {} };
@@ -12566,13 +12998,22 @@ async function pipeAgentWebAppStream(raw, stream, options = {}) {
     ]
   });
 }
+async function pipeNativeWebAppStream(raw, stream) {
+  await pipeAsyncIterableToSse(raw, stream, {
+    onError: () => [{
+      type: "error",
+      data: { id: "", content: "Stream failed" }
+    }]
+  });
+}
 function beginSse(reply) {
   reply.hijack();
   reply.raw.writeHead(200, {
     "Content-Type": "text/event-stream; charset=utf-8",
     "Cache-Control": "no-cache, no-transform",
     Connection: "keep-alive",
-    "X-Accel-Buffering": "no"
+    "X-Accel-Buffering": "no",
+    "Access-Control-Allow-Origin": "*"
   });
 }
 async function handle2(reply, operation) {
@@ -16604,7 +17045,7 @@ function snapshotProjectableWorkItem(value) {
   if (!row || !createdAt || typeof row.id !== "string" || !row.id || typeof row.taskId !== "string" || !row.taskId || typeof row.tenantId !== "string" || !row.tenantId || typeof row.workspaceId !== "string" || !row.workspaceId || typeof row.projectId !== "string" || !row.projectId || typeof row.actor !== "string" || !row.actor || typeof row.eventKey !== "string" || !row.eventKey || !PROJECT_TASK_LIFECYCLE_ACTIONS.includes(row.action) || row.threadId !== void 0 && typeof row.threadId !== "string" || row.summary !== void 0 && typeof row.summary !== "string" || row.attempt !== void 0 && (typeof row.attempt !== "number" || !Number.isFinite(row.attempt))) return void 0;
   try {
     const detail = row.detail === void 0 ? void 0 : snapshotJsonValue(row.detail);
-    if (detail !== void 0 && !isRecord4(detail)) return void 0;
+    if (detail !== void 0 && !isRecord3(detail)) return void 0;
     return {
       id: row.id,
       taskId: row.taskId,
@@ -16751,7 +17192,7 @@ function snapshotLifecycleCursor(value) {
   const createdAt = cloneExactDate(row?.createdAt);
   return row && typeof row.id === "string" && row.id.length > 0 && createdAt ? { id: row.id, createdAt } : void 0;
 }
-function isRecord4(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -18209,6 +18650,46 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     })
   });
   registerAgentWebAppRuntimeRoutes(app2, {
+    workspaceController: new WorkspaceController(createProjectCollaborationInitializer({
+      membershipStore: projectMembershipStore,
+      roomStore: projectRoomStore,
+      userTenantLinkStore
+    })),
+    taskController: createTaskController({
+      access: {
+        requireProjectAccess: async (input) => {
+          const apps = await webAppStore.list(input.tenantId);
+          const allowed = apps.some((app3) => app3.status === "active" && app3.scope.allowedProjectIds.includes(input.projectId));
+          if (!allowed) throw new ProjectCollaborationError("PROJECT_ACCESS_DENIED", 403, "Project is not exposed through this web app");
+          const project = await projectStore.getProjectById(input.tenantId, input.projectId);
+          if (!project) throw new ProjectCollaborationError("PROJECT_NOT_FOUND", 404, "Project not found");
+          return {
+            project,
+            membership: {
+              id: `webapp_guest_${input.projectId}_${input.userId}`,
+              tenantId: input.tenantId,
+              projectId: input.projectId,
+              userId: input.userId,
+              role: "member",
+              status: "active",
+              joinedAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date()
+            }
+          };
+        }
+      },
+      tasks: taskStore,
+      workItems: taskWorkItemStore,
+      bots: projectBotMembershipStore,
+      rooms: projectRoomStore,
+      threadService: taskThreadService,
+      reassignmentAuthorizer,
+      lifecycle: taskLifecycle,
+      projectMutationMutex: projectMutationMutex2,
+      executionMutex: projectTaskComposition?.mutex ?? {
+        runExclusive: (_scope, operation) => operation()
+      }
+    }),
     service: new AgentWebAppRuntimeService({
       webAppStore,
       threadStore: getStoreLattice16("default", "thread").store,
@@ -18216,7 +18697,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       assistantResolver: {
         resolve: async (tenantId, assistantId) => {
           const stored = await assistantStore.getAssistantById(tenantId, assistantId);
-          if (stored) return stored;
+          if (stored) return { id: stored.id, name: stored.name, description: stored.description };
           await agentLatticeManager4.initializeStoredAssistantsForTenant(tenantId);
           const config = agentLatticeManager4.getAgentConfigWithTenant(tenantId, assistantId);
           return config ? { id: assistantId, name: config.name, description: config.description } : null;
@@ -21329,7 +21810,7 @@ var start = async (config) => {
     });
     try {
       const { A2AAuthService, parseEnvKeys } = await import("./A2AAuthService-DK5X6VIL.mjs");
-      const { registerA2AStandardRoutes } = await import("./a2a-standard-G3J5ZHQ7.mjs");
+      const { registerA2AStandardRoutes } = await import("./a2a-standard-WC2BSOFV.mjs");
       const a2a = await import("./a2a-7N3WDAOP.mjs");
       const a2aKeyStore = getStoreLattice27("default", "a2aApiKey").store;
       const assistantStore = getStoreLattice27("default", "assistant").store;