@axiom-lattice/gateway 4.7.0 → 4.8.0

package/dist/index.js

@@ -966,7 +966,7 @@ function outcome(task) {
   });
 }
 async function backfillTopCallerGroup(tasks, top, deps) {
-  const registry = deps.registry ?? import_core66.taskRunRegistry;
+  const registry = deps.registry ?? import_core70.taskRunRegistry;
   const results = [];
   const eligible = [];
   for (const task of tasks) {
@@ -974,7 +974,7 @@ async function backfillTopCallerGroup(tasks, top, deps) {
       results.push({ id: task.id, reason: "skipped:no_caller_link" });
       continue;
     }
-    if (registry.isLive(task.id)) {
+    if (registry.isLive(task.id) || deps.isTaskLive && await deps.isTaskLive(task)) {
       results.push({ id: task.id, reason: "skipped:live" });
       continue;
     }
@@ -1020,15 +1020,16 @@ async function recoverTask(task, deps) {
   if (task.status !== "in_progress") {
     return { kind: "skipped", reason: "not_in_progress" };
   }
-  const registry = deps.registry ?? import_core66.taskRunRegistry;
-  if (registry.isLive(task.id)) {
+  const registry = deps.registry ?? import_core70.taskRunRegistry;
+  if (registry.isLive(task.id) || deps.isTaskLive && await deps.isTaskLive(task)) {
     return { kind: "skipped", reason: "live" };
   }
-  const { convergedTasks } = await (0, import_core66.reconcileStaleTaskRuns)({
+  const { convergedTasks } = await (0, import_core70.reconcileStaleTaskRuns)({
     tasks: [task],
     actor: "system:on-demand-recovery",
     lifecycle: deps.lifecycle,
-    ...deps.registry ? { registry: deps.registry } : {}
+    ...deps.registry ? { registry: deps.registry } : {},
+    ...deps.isTaskLive ? { isTaskLive: deps.isTaskLive } : {}
   });
   const converged = convergedTasks[0];
   if (!converged) {
@@ -1044,7 +1045,8 @@ async function recoverTask(task, deps) {
   const reason = await recoverTopCaller(converged, top, {
     callerFor: deps.callerFor,
     resume: deps.resume,
-    ...deps.registry ? { registry: deps.registry } : {}
+    ...deps.registry ? { registry: deps.registry } : {},
+    ...deps.isTaskLive ? { isTaskLive: deps.isTaskLive } : {}
   });
   if (reason === "recovered") return { kind: "recovered" };
   if (reason === "skipped:no_pending_task_call") return { kind: "converged_no_call" };
@@ -1101,7 +1103,8 @@ async function runOrphanRecovery(deps) {
     try {
       const results = await backfillTopCallerGroup(tasks, top, {
         callerFor: deps.callerFor,
-        resume: deps.resume
+        resume: deps.resume,
+        ...deps.isTaskLive ? { isTaskLive: deps.isTaskLive } : {}
       });
       for (const { id: id3, reason } of results) {
         (reason === "recovered" ? recovered : skipped).push(`${id3}:${reason}`);
@@ -1117,12 +1120,41 @@ async function runOrphanRecovery(deps) {
   deps.log.info("Task orphan recovery complete", { recovered, skipped });
   return { recovered, skipped };
 }
-var import_messages, import_core66;
+var import_messages, import_core70;
 var init_TopCallerRecovery = __esm({
   "src/services/collaboration/TopCallerRecovery.ts"() {
     "use strict";
     import_messages = require("@langchain/core/messages");
-    import_core66 = require("@axiom-lattice/core");
+    import_core70 = require("@axiom-lattice/core");
+  }
+});
+
+// src/services/collaboration/taskRunLiveness.ts
+function createTaskRunLiveness() {
+  try {
+    import_core71.storeLatticeManager.getStoreLattice("default", "lease");
+  } catch {
+    return void 0;
+  }
+  return async (task) => {
+    try {
+      const store2 = import_core71.storeLatticeManager.getStoreLattice("default", "lease").store;
+      if (await store2.get((0, import_core71.taskRunLeaseKey)(task.id))) return true;
+      const threadId = typeof task.context?.thread_id === "string" ? task.context.thread_id : void 0;
+      if (threadId && task.ownerId) {
+        if (await store2.get((0, import_core71.threadRunLeaseKey)(task.tenantId, task.ownerId, threadId))) return true;
+      }
+      return false;
+    } catch {
+      return true;
+    }
+  };
+}
+var import_core71;
+var init_taskRunLiveness = __esm({
+  "src/services/collaboration/taskRunLiveness.ts"() {
+    "use strict";
+    import_core71 = require("@axiom-lattice/core");
   }
 });
 
@@ -1132,24 +1164,27 @@ __export(OrphanRecoveryRuntime_exports, {
   createOrphanRecoveryRuntime: () => createOrphanRecoveryRuntime
 });
 function createOrphanRecoveryRuntime(deps) {
-  const lifecycle = deps.lifecycle ?? (0, import_core67.createTaskLifecycleService)({
+  const lifecycle = deps.lifecycle ?? (0, import_core72.createTaskLifecycleService)({
     taskStore: deps.taskStore,
     workItemStore: deps.workItemStore
   });
   return {
     async recoverAll() {
+      const isTaskLive = deps.isTaskLive ?? createTaskRunLiveness();
       return runOrphanRecovery({
-        reconcile: () => (0, import_core67.reconcileAllTenantTaskRuns)({
+        reconcile: () => (0, import_core72.reconcileAllTenantTaskRuns)({
           actor: "system:orphan-recovery",
           tenantStore: {
             listTenants: async () => (await deps.tenantStore.getAllTenants()).map((tenant2) => ({ id: tenant2.id }))
           },
           taskStore: deps.taskStore,
           lifecycle,
-          include: (t2) => !isProjectLifecycleTask(t2)
+          include: (t2) => !isProjectLifecycleTask(t2),
+          ...isTaskLive ? { isTaskLive } : {}
         }),
         callerFor: deps.callerFor,
         resume: deps.resume,
+        ...isTaskLive ? { isTaskLive } : {},
         log: deps.log
       });
     },
@@ -1160,23 +1195,26 @@ function createOrphanRecoveryRuntime(deps) {
         return { kind: "skipped", reason: "project_task" };
       }
       const orphans = await deps.taskStore.list({ tenantId: input.tenantId, status: "in_progress" });
+      const isTaskLive = deps.isTaskLive ?? createTaskRunLiveness();
       return recoverTask(task, {
         lifecycle,
-        registry: import_core67.taskRunRegistry,
+        registry: import_core72.taskRunRegistry,
         orphans,
         callerFor: deps.callerFor,
-        resume: deps.resume
+        resume: deps.resume,
+        ...isTaskLive ? { isTaskLive } : {}
       });
     }
   };
 }
-var import_core67;
+var import_core72;
 var init_OrphanRecoveryRuntime = __esm({
   "src/services/collaboration/OrphanRecoveryRuntime.ts"() {
     "use strict";
-    import_core67 = require("@axiom-lattice/core");
+    import_core72 = require("@axiom-lattice/core");
     init_TopCallerRecovery();
     init_projectTaskScope();
+    init_taskRunLiveness();
   }
 });
 
@@ -1189,12 +1227,12 @@ function createRecoveryCallerDeps() {
   return {
     callerFor: async (top, tenantId) => {
       if (!top.assistantId) return void 0;
-      const load = import_core68.getAgentClientAsync ?? import_core68.getAgentClient;
+      const load = import_core73.getAgentClientAsync ?? import_core73.getAgentClient;
       const client = await load(tenantId, top.assistantId);
       const config = { configurable: { thread_id: top.threadId, runConfig: { tenantId, assistant_id: top.assistantId } } };
       let agent;
       try {
-        agent = import_core68.agentInstanceManager.getAgent({ assistant_id: top.assistantId, thread_id: top.threadId, tenant_id: tenantId });
+        agent = import_core73.agentInstanceManager.getAgent({ assistant_id: top.assistantId, thread_id: top.threadId, tenant_id: tenantId });
       } catch {
       }
       return agent ? { client, config, agent } : { client, config };
@@ -1211,11 +1249,11 @@ function createRecoveryCallerDeps() {
     }
   };
 }
-var import_core68;
+var import_core73;
 var init_RecoveryCallerDeps = __esm({
   "src/services/collaboration/RecoveryCallerDeps.ts"() {
     "use strict";
-    import_core68 = require("@axiom-lattice/core");
+    import_core73 = require("@axiom-lattice/core");
   }
 });
 
@@ -1805,13 +1843,13 @@ function isA2ATaskSnapshot(value) {
 function snapshotSequence(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
 }
-var import_node_crypto28, import_node_util, import_core69, TASK_STATUS_TO_A2A_STATE, TITLE_MAX_LENGTH, A2ATaskScopeConflictError, A2ATaskStoreAdapter;
+var import_node_crypto28, import_node_util, import_core74, TASK_STATUS_TO_A2A_STATE, TITLE_MAX_LENGTH, A2ATaskScopeConflictError, A2ATaskStoreAdapter;
 var init_A2ATaskStoreAdapter = __esm({
   "src/services/a2a/A2ATaskStoreAdapter.ts"() {
     "use strict";
     import_node_crypto28 = require("crypto");
     import_node_util = require("util");
-    import_core69 = require("@axiom-lattice/core");
+    import_core74 = require("@axiom-lattice/core");
     TASK_STATUS_TO_A2A_STATE = {
       pending: "submitted",
       in_progress: "working",
@@ -1837,7 +1875,7 @@ var init_A2ATaskStoreAdapter = __esm({
         this.workItemStore = options.workItemStore;
         this.lifecycle = options.lifecycle;
         this.scope = options.scope;
-        this.runBridge = (0, import_core69.createTaskRunBridge)({
+        this.runBridge = (0, import_core74.createTaskRunBridge)({
           lifecycle: this.lifecycle,
           taskStore: this.taskStore,
           workItemStore: this.workItemStore
@@ -2188,12 +2226,12 @@ function assistantHasGovernedTask(assistant) {
   const allowedTools = taskMiddleware?.allowedTools;
   return !!taskMiddleware && (allowedTools === void 0 || Array.isArray(allowedTools) && (allowedTools.length === 0 || allowedTools.includes("manage_task")));
 }
-var import_uuid11, import_core70, import_protocols35, _AxiomAgentExecutor, AxiomAgentExecutor;
+var import_uuid11, import_core75, import_protocols35, _AxiomAgentExecutor, AxiomAgentExecutor;
 var init_AxiomAgentExecutor = __esm({
   "src/services/a2a/AxiomAgentExecutor.ts"() {
     "use strict";
     import_uuid11 = require("uuid");
-    import_core70 = require("@axiom-lattice/core");
+    import_core75 = require("@axiom-lattice/core");
     import_protocols35 = require("@axiom-lattice/protocols");
     init_a2aFileRefs();
     init_task_file_refs();
@@ -2290,7 +2328,7 @@ var init_AxiomAgentExecutor = __esm({
           await this.taskStore.save(initialTask);
           bus.publish(initialTask);
           try {
-            const agent = import_core70.agentInstanceManager.getAgent(this.agentParams(threadId));
+            const agent = import_core75.agentInstanceManager.getAgent(this.agentParams(threadId));
             const requestText = inputFiles.length > 0 ? `${text}
 
 ${formatFileRefsSection(inputFiles)}` : text;
@@ -2478,7 +2516,7 @@ ${formatFileRefsSection(inputFiles)}` : text;
         const threadId = task ? asString2(task.metadata?.threadId) : void 0;
         if (threadId) {
           try {
-            const agent = import_core70.agentInstanceManager.getAgent(this.agentParams(threadId));
+            const agent = import_core75.agentInstanceManager.getAgent(this.agentParams(threadId));
             await agent.abort();
           } catch (err) {
             console.warn({
@@ -2852,10 +2890,10 @@ function isAsyncGenerator(value) {
 }
 function registerA2AStandardRoutes(app2, deps) {
   const authService = deps.authService;
-  const resolveTasks = deps.getTaskStoreLattice ?? (() => (0, import_core71.getStoreLattice)("default", "task").store);
-  const resolveTaskWorkItems = deps.getTaskWorkItemStore ?? (() => (0, import_core71.getStoreLattice)("default", "taskWorkItem").store);
-  const getAssistantStore2 = deps.getAssistantStore ?? (() => (0, import_core71.getStoreLattice)("default", "assistant").store);
-  const getProjectStore2 = deps.getProjectStore ?? (() => (0, import_core71.getStoreLattice)("default", "project").store);
+  const resolveTasks = deps.getTaskStoreLattice ?? (() => (0, import_core76.getStoreLattice)("default", "task").store);
+  const resolveTaskWorkItems = deps.getTaskWorkItemStore ?? (() => (0, import_core76.getStoreLattice)("default", "taskWorkItem").store);
+  const getAssistantStore2 = deps.getAssistantStore ?? (() => (0, import_core76.getStoreLattice)("default", "assistant").store);
+  const getProjectStore2 = deps.getProjectStore ?? (() => (0, import_core76.getStoreLattice)("default", "project").store);
   const runtimeRegistry = deps.runtimeRegistry ?? new A2ARuntimeRegistry();
   app2.addHook("onClose", async () => {
     runtimeRegistry.close();
@@ -2938,7 +2976,7 @@ function registerA2AStandardRoutes(app2, deps) {
       const taskStore = assistantHasGovernedTask(assistant) ? new A2ATaskStoreAdapter({
         taskStore: internalTasks,
         workItemStore: workItems,
-        lifecycle: (0, import_core71.createTaskLifecycleService)({
+        lifecycle: (0, import_core76.createTaskLifecycleService)({
           taskStore: internalTasks,
           workItemStore: workItems
         }),
@@ -3057,7 +3095,7 @@ data: ${JSON.stringify(errorResponse)}
       const taskStore = assistantHasGovernedTask(assistant) ? new A2ATaskStoreAdapter({
         taskStore: internalTasks,
         workItemStore: workItems,
-        lifecycle: (0, import_core71.createTaskLifecycleService)({
+        lifecycle: (0, import_core76.createTaskLifecycleService)({
           taskStore: internalTasks,
           workItemStore: workItems
         }),
@@ -3112,13 +3150,13 @@ data: ${JSON.stringify(data)}
     }
   );
 }
-var import_uuid12, import_server2, import_core71, SSE_HEADERS;
+var import_uuid12, import_server2, import_core76, SSE_HEADERS;
 var init_a2a_standard = __esm({
   "src/routes/a2a-standard.ts"() {
     "use strict";
     import_uuid12 = require("uuid");
     import_server2 = require("@a2a-js/sdk/server");
-    import_core71 = require("@axiom-lattice/core");
+    import_core76 = require("@axiom-lattice/core");
     init_A2AAuthService();
     init_A2AAgentCardBuilder();
     init_A2ATaskStoreAdapter();
@@ -3376,6 +3414,7 @@ var init_openCredentialService = __esm({
               projectId: token.projectId,
               workspaceId: token.workspaceId,
               sandboxName: token.sandboxName,
+              depth: token.depth,
               grants: token.grants
             };
           }
@@ -3869,8 +3908,8 @@ function exposedDeclarations(plugin) {
   return (plugin.meta.tools ?? []).filter((t2) => t2.expose);
 }
 async function registerExposedPluginTools() {
-  for (const key of import_core72.PluginRegistry.list()) {
-    const plugin = import_core72.PluginRegistry.get(key);
+  for (const key of import_core77.PluginRegistry.list()) {
+    const plugin = import_core77.PluginRegistry.get(key);
     if (!plugin?.middleware) continue;
     const exposed = exposedDeclarations(plugin);
     if (exposed.length === 0) continue;
@@ -3905,8 +3944,8 @@ async function registerExposedPluginTools() {
 }
 function collectExposedPluginUiResources(grants) {
   const resources = /* @__PURE__ */ new Map();
-  for (const type of import_core72.PluginRegistry.list()) {
-    const plugin = import_core72.PluginRegistry.get(type);
+  for (const type of import_core77.PluginRegistry.list()) {
+    const plugin = import_core77.PluginRegistry.get(type);
     if (!plugin?.middleware) continue;
     const exposedNames = new Set(exposedDeclarations(plugin).map((d) => d.name));
     if (exposedNames.size === 0) continue;
@@ -3930,11 +3969,11 @@ function collectExposedPluginUiResources(grants) {
   }
   return resources;
 }
-var import_core72;
+var import_core77;
 var init_registerExposedPlugins = __esm({
   "src/services/open/registerExposedPlugins.ts"() {
     "use strict";
-    import_core72 = require("@axiom-lattice/core");
+    import_core77 = require("@axiom-lattice/core");
     init_openLattice();
     init_pluginExposeAdapter();
   }
@@ -3949,14 +3988,14 @@ function toText(result) {
 }
 function defaultCatalog() {
   return {
-    getValidatedManifest: (tenantId, type) => (0, import_core73.getSandboxPluginCatalog)().getValidatedManifest(tenantId, type),
-    getExecutor: () => (0, import_core73.getSandboxPluginCatalog)().getExecutor(),
-    readPluginFile: (tenantId, type, relPath) => (0, import_core73.getSandboxPluginCatalog)().readPluginFile(tenantId, type, relPath)
+    getValidatedManifest: (tenantId, type) => (0, import_core78.getSandboxPluginCatalog)().getValidatedManifest(tenantId, type),
+    getExecutor: () => (0, import_core78.getSandboxPluginCatalog)().getExecutor(),
+    readPluginFile: (tenantId, type, relPath) => (0, import_core78.getSandboxPluginCatalog)().readPluginFile(tenantId, type, relPath)
   };
 }
 async function defaultResolveConnections(pluginType, ctx) {
   try {
-    return await (0, import_core73.resolveSandboxPluginConnections)(
+    return await (0, import_core78.resolveSandboxPluginConnections)(
       pluginType,
       { connectAll: true },
       {
@@ -3985,7 +4024,7 @@ function mergeOpenCatalog(globalCatalog, tenantTools) {
 async function buildTenantOpenPlugins(tenantId, grants, deps = {}) {
   const catalog = deps.catalog ?? defaultCatalog();
   const listPlugins = deps.listPlugins ?? (async (tenant2) => {
-    const snapshot = await (0, import_core73.getSandboxPluginCatalog)().ensureLoaded(tenant2);
+    const snapshot = await (0, import_core78.getSandboxPluginCatalog)().ensureLoaded(tenant2);
     return { plugins: snapshot.plugins, diagnostics: snapshot.diagnostics };
   });
   const resolveConnections = deps.resolveConnections ?? defaultResolveConnections;
@@ -4027,7 +4066,7 @@ async function buildTenantOpenPlugins(tenantId, grants, deps = {}) {
         domain,
         action: tool.name,
         description: tool.description,
-        schema: (0, import_core73.jsonSchemaToZod)(tool.schema),
+        schema: (0, import_core78.jsonSchemaToZod)(tool.schema),
         annotations: {
           readOnlyHint: tool.readOnly ?? false,
           destructiveHint: tool.destructive ?? false
@@ -4078,11 +4117,11 @@ async function buildTenantOpenPlugins(tenantId, grants, deps = {}) {
     }
   };
 }
-var import_core73;
+var import_core78;
 var init_tenantOpenPlugins = __esm({
   "src/services/open/tenantOpenPlugins.ts"() {
     "use strict";
-    import_core73 = require("@axiom-lattice/core");
+    import_core78 = require("@axiom-lattice/core");
     init_openLattice();
     init_pluginToolExecution();
   }
@@ -4119,13 +4158,13 @@ function emptyTenantPlugins() {
 }
 function registerOpenRoutes(app2, deps = {}) {
   const openAuth = deps.openAuth ?? new OpenCredentialService(
-    (0, import_core74.getStoreLattice)("default", "a2aApiKey").store,
-    (0, import_core74.getStoreLattice)("default", "project").store
+    (0, import_core79.getStoreLattice)("default", "a2aApiKey").store,
+    (0, import_core79.getStoreLattice)("default", "project").store
   );
   const grantsSource = deps.grantsSource ?? ((ctx) => ctx.grants);
   const audit = deps.audit ?? (() => {
     try {
-      const store2 = (0, import_core74.getStoreLattice)("default", "openAudit").store;
+      const store2 = (0, import_core79.getStoreLattice)("default", "openAudit").store;
       return new OpenAuditService(store2);
     } catch {
       return void 0;
@@ -4211,7 +4250,8 @@ function registerOpenRoutes(app2, deps = {}) {
           const isTenantRoute = tenant2.hasTool(toolName) && !globalToolNames.has(toolName);
           const runConfig = {
             sandboxName: context.sandboxName,
-            credentialId: context.credentialId
+            credentialId: context.credentialId,
+            depth: context.depth
           };
           const result = isTenantRoute ? await tenant2.invoke(toolName, args, {
             tenantId: context.tenantId,
@@ -4279,12 +4319,12 @@ function registerOpenRoutes(app2, deps = {}) {
     }
   );
 }
-var import_types, import_core74, RPC_ERROR;
+var import_types, import_core79, RPC_ERROR;
 var init_open = __esm({
   "src/routes/open.ts"() {
     "use strict";
     import_types = require("@modelcontextprotocol/sdk/types.js");
-    import_core74 = require("@axiom-lattice/core");
+    import_core79 = require("@axiom-lattice/core");
     init_openCredentialService();
     init_openAuditService();
     init_openRateLimiter();
@@ -4317,7 +4357,7 @@ function registerOpenSessionRoutes(app2) {
       if (typeof shareToken !== "string" || shareToken.length === 0) {
         return reply.status(400).send({ error: "SHARE_TOKEN_REQUIRED" });
       }
-      const store2 = (0, import_core75.getStoreLattice)("default", "sharedResource").store;
+      const store2 = (0, import_core80.getStoreLattice)("default", "sharedResource").store;
       const record = await store2.findByToken(shareToken);
       if (!record || record.revoked) {
         return reply.status(404).send({ error: "SHARE_NOT_FOUND" });
@@ -4342,11 +4382,11 @@ function registerOpenSessionRoutes(app2) {
     }
   );
 }
-var import_core75;
+var import_core80;
 var init_open_session = __esm({
   "src/routes/open-session.ts"() {
     "use strict";
-    import_core75 = require("@axiom-lattice/core");
+    import_core80 = require("@axiom-lattice/core");
     init_openToken();
     init_previewToken();
     init_openLattice();
@@ -4355,13 +4395,13 @@ var init_open_session = __esm({
 
 // src/services/open/openCatalogService.ts
 async function defaultListTenantPlugins(tenantId) {
-  return (await (0, import_core76.getSandboxPluginCatalog)().ensureLoaded(tenantId)).plugins;
+  return (await (0, import_core81.getSandboxPluginCatalog)().ensureLoaded(tenantId)).plugins;
 }
-var import_core76, OpenCatalogService;
+var import_core81, OpenCatalogService;
 var init_openCatalogService = __esm({
   "src/services/open/openCatalogService.ts"() {
     "use strict";
-    import_core76 = require("@axiom-lattice/core");
+    import_core81 = require("@axiom-lattice/core");
     init_openLattice();
     OpenCatalogService = class {
       constructor(assistantStore, lattice = openLattice, listTenantPlugins2 = defaultListTenantPlugins) {
@@ -4436,17 +4476,17 @@ function registerOpenCatalogRoutes(app2) {
     if (!tenantId) {
       return reply.status(401).send({ success: false, error: "Unauthorized" });
     }
-    const assistantStore = (0, import_core77.getStoreLattice)("default", "assistant").store;
+    const assistantStore = (0, import_core82.getStoreLattice)("default", "assistant").store;
     const service2 = new OpenCatalogService(assistantStore);
     const catalog = await service2.buildForTenant(tenantId);
     return reply.status(200).send({ success: true, data: catalog });
   });
 }
-var import_core77;
+var import_core82;
 var init_open_catalog = __esm({
   "src/routes/open-catalog.ts"() {
     "use strict";
-    import_core77 = require("@axiom-lattice/core");
+    import_core82 = require("@axiom-lattice/core");
     init_openCatalogService();
   }
 });
@@ -4458,7 +4498,14 @@ __export(sandboxProvider_exports, {
   resolveContextSandbox: () => resolveContextSandbox
 });
 async function resolveContextSandbox(ctx) {
-  return import_core78.sandboxLatticeManager.getSandboxFromConfig({
+  const sandboxName = ctx.runConfig?.sandboxName;
+  if (typeof sandboxName === "string" && sandboxName.length > 0) {
+    try {
+      return await import_core83.sandboxLatticeManager.getSandbox(sandboxName);
+    } catch {
+    }
+  }
+  return import_core83.sandboxLatticeManager.getSandboxFromConfig({
     assistant_id: "",
     thread_id: "",
     tenantId: ctx.tenantId,
@@ -4556,12 +4603,12 @@ ${truncated}`
     }
   };
 }
-var import_zod21, import_core78, MAX_OUTPUT_BYTES;
+var import_zod21, import_core83, MAX_OUTPUT_BYTES;
 var init_sandboxProvider = __esm({
   "src/services/open/providers/sandboxProvider.ts"() {
     "use strict";
     import_zod21 = require("zod");
-    import_core78 = require("@axiom-lattice/core");
+    import_core83 = require("@axiom-lattice/core");
     MAX_OUTPUT_BYTES = 64e3;
   }
 });
@@ -4583,12 +4630,12 @@ function safePath(raw) {
 }
 function registerOpenFilesRoutes(app2, deps = {}) {
   const openAuth = deps.openAuth ?? new OpenCredentialService(
-    (0, import_core79.getStoreLattice)("default", "a2aApiKey").store,
-    (0, import_core79.getStoreLattice)("default", "project").store
+    (0, import_core84.getStoreLattice)("default", "a2aApiKey").store,
+    (0, import_core84.getStoreLattice)("default", "project").store
   );
   const audit = deps.audit ?? (() => {
     try {
-      const store2 = (0, import_core79.getStoreLattice)("default", "openAudit").store;
+      const store2 = (0, import_core84.getStoreLattice)("default", "openAudit").store;
       return new OpenAuditService(store2);
     } catch {
       return void 0;
@@ -4698,11 +4745,11 @@ function registerOpenFilesRoutes(app2, deps = {}) {
     }
   });
 }
-var import_core79;
+var import_core84;
 var init_open_files = __esm({
   "src/routes/open-files.ts"() {
     "use strict";
-    import_core79 = require("@axiom-lattice/core");
+    import_core84 = require("@axiom-lattice/core");
     init_openCredentialService();
     init_openLattice();
     init_sandboxProvider();
@@ -4724,7 +4771,7 @@ function registerOpenAuditRoutes(app2) {
         return reply.status(401).send({ success: false, error: "Unauthorized" });
       }
       const status = request.query.status === "ok" || request.query.status === "error" ? request.query.status : void 0;
-      const store2 = (0, import_core80.getStoreLattice)("default", "openAudit").store;
+      const store2 = (0, import_core85.getStoreLattice)("default", "openAudit").store;
       const records = await store2.query({
         tenantId,
         credentialId: request.query.credentialId,
@@ -4739,11 +4786,11 @@ function registerOpenAuditRoutes(app2) {
     }
   );
 }
-var import_core80;
+var import_core85;
 var init_open_audit = __esm({
   "src/routes/open-audit.ts"() {
     "use strict";
-    import_core80 = require("@axiom-lattice/core");
+    import_core85 = require("@axiom-lattice/core");
   }
 });
 
@@ -4760,7 +4807,7 @@ function registerOpenExposureRoutes(app2, deps = {}) {
       if (!tenantId) {
         return reply.status(401).send({ success: false, error: "Unauthorized" });
       }
-      const keyStore = (0, import_core81.getStoreLattice)("default", "a2aApiKey").store;
+      const keyStore = (0, import_core86.getStoreLattice)("default", "a2aApiKey").store;
       const record = await keyStore.findById(request.params.id);
       if (!record || record.tenantId !== tenantId) {
         return reply.status(404).send({ success: false, error: "Key not found" });
@@ -4794,7 +4841,7 @@ function registerOpenExposureRoutes(app2, deps = {}) {
         hasUi: Boolean(t2.ui)
       }));
       const agentGrant = grants.find((g) => g.domain === "agent");
-      const assistantStore = (0, import_core81.getStoreLattice)("default", "assistant").store;
+      const assistantStore = (0, import_core86.getStoreLattice)("default", "assistant").store;
       const agents = [];
       for (const assistantId of agentGrant?.items ?? []) {
         const assistant = await assistantStore.getAssistantById(
@@ -4829,11 +4876,11 @@ function registerOpenExposureRoutes(app2, deps = {}) {
     }
   );
 }
-var import_core81, import_protocols38;
+var import_core86, import_protocols38;
 var init_open_exposure = __esm({
   "src/routes/open-exposure.ts"() {
     "use strict";
-    import_core81 = require("@axiom-lattice/core");
+    import_core86 = require("@axiom-lattice/core");
     import_protocols38 = require("@axiom-lattice/protocols");
     init_openLattice();
     init_tenantOpenPlugins();
@@ -4953,7 +5000,7 @@ function createAgentProvider(deps = {}) {
         } catch {
         }
       }
-      const agent = import_core82.agentInstanceManager.getAgent({
+      const agent = import_core87.agentInstanceManager.getAgent({
         tenant_id: ctx.tenantId,
         assistant_id: assistantId,
         thread_id: threadId,
@@ -4978,17 +5025,292 @@ function createAgentProvider(deps = {}) {
     }
   };
 }
-var import_zod23, import_core82, import_protocols39, STOP_TYPES;
+var import_zod23, import_core87, import_protocols39, STOP_TYPES;
 var init_agentProvider = __esm({
   "src/services/open/providers/agentProvider.ts"() {
     "use strict";
     import_zod23 = require("zod");
-    import_core82 = require("@axiom-lattice/core");
+    import_core87 = require("@axiom-lattice/core");
     import_protocols39 = require("@axiom-lattice/protocols");
     STOP_TYPES = [import_protocols39.MessageChunkTypes.MESSAGE_COMPLETED];
   }
 });
 
+// src/services/open/sandboxOpenReflection.ts
+function cloneGrants(grants) {
+  return grants.map((grant) => ({
+    ...grant,
+    items: grant.items ? [...grant.items] : void 0
+  }));
+}
+function normalizeOpenExpose(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const entry of value) {
+    if (typeof entry === "string") {
+      if (entry) out.push(entry);
+    } else if (entry && typeof entry === "object") {
+      const name = entry.name;
+      if (typeof name === "string" && name) out.push(name);
+    }
+  }
+  return out;
+}
+function extractMiddleware(container) {
+  if (!container || typeof container !== "object") return void 0;
+  const raw = container.middleware;
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") continue;
+    const type = entry.type;
+    if (typeof type !== "string" || type.length === 0) continue;
+    const enabled = entry.enabled;
+    const rawAllowed = entry.allowedTools;
+    const allowedTools = Array.isArray(rawAllowed) ? rawAllowed.filter((t2) => typeof t2 === "string" && t2.length > 0) : void 0;
+    out.push({ type, enabled: typeof enabled === "boolean" ? enabled : void 0, allowedTools });
+  }
+  return out;
+}
+function extractSubAgents(config) {
+  if (!config || typeof config !== "object") return void 0;
+  const raw = config.subAgents;
+  if (!Array.isArray(raw)) return void 0;
+  const out = raw.filter((id3) => typeof id3 === "string" && id3.length > 0);
+  return out.length > 0 ? out : void 0;
+}
+async function computeGrants(tenantId, assistantId, deps) {
+  await deps.ensure?.(tenantId);
+  let context = await deps.getAgentConfig?.(tenantId, assistantId);
+  if (context === void 0) {
+    const middleware = await deps.getAssistantMiddleware?.(tenantId, assistantId);
+    if (middleware === void 0) return [];
+    context = { middleware };
+  }
+  const byDomain = /* @__PURE__ */ new Map();
+  const add = (domain, items) => {
+    let bucket = byDomain.get(domain);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      byDomain.set(domain, bucket);
+    }
+    for (const item of items) bucket.add(item);
+  };
+  for (const entry of context.middleware ?? []) {
+    if (!entry || entry.enabled === false) continue;
+    if (typeof entry.type !== "string" || entry.type.length === 0) continue;
+    let actions = deps.exposedActionsByType(entry.type);
+    if (actions.length === 0) continue;
+    const allowedTools = entry.allowedTools;
+    if (Array.isArray(allowedTools) && allowedTools.length > 0) {
+      const allowed = new Set(allowedTools);
+      actions = actions.filter((action) => allowed.has(action));
+      if (actions.length === 0) continue;
+    }
+    add(entry.type, actions);
+  }
+  const subAgents = context.subAgents ?? [];
+  if (subAgents.length > 0 && deps.resolvableAssistants) {
+    const resolvable = await deps.resolvableAssistants(tenantId);
+    const kept = subAgents.filter(
+      (id3) => typeof id3 === "string" && id3.length > 0 && resolvable.has(id3)
+    );
+    if (kept.length > 0) add("agent", kept);
+  }
+  return [...byDomain].map(([domain, items]) => ({ domain, items: [...items] }));
+}
+async function resolveAgentOpenGrants(tenantId, assistantId, deps) {
+  try {
+    const key = `${tenantId}:${assistantId}`;
+    const now = deps.now ? deps.now() : Date.now();
+    const hit = cache.get(key);
+    if (hit && hit.expiresAt > now) return cloneGrants(hit.grants);
+    const grants = await computeGrants(tenantId, assistantId, deps);
+    cache.set(key, { grants, expiresAt: now + AGENT_REFLECTION_CACHE_TTL_MS });
+    return cloneGrants(grants);
+  } catch {
+    return [];
+  }
+}
+function createDefaultAgentReflectionDeps(tenantId) {
+  (0, import_core88.ensureBuiltinAgentsForTenant)(tenantId);
+  return {
+    ensure: (t2) => import_core88.agentLatticeManager.initializeStoredAssistantsForTenant(t2),
+    getAgentConfig: (t2, assistantId) => {
+      const config = import_core88.agentLatticeManager.getAgentConfigWithTenant(t2, assistantId);
+      if (!config) return void 0;
+      return {
+        middleware: extractMiddleware(config),
+        subAgents: extractSubAgents(config)
+      };
+    },
+    getAssistantMiddleware: async (t2, assistantId) => {
+      const store2 = (0, import_core88.getStoreLattice)("default", "assistant").store;
+      const assistant = await store2.getAssistantById(t2, assistantId);
+      return extractMiddleware(assistant?.graphDefinition);
+    },
+    exposedActionsByType: (type) => {
+      const plugin = import_core88.PluginRegistry.get(type);
+      return plugin ? normalizeOpenExpose(plugin.meta.openExpose) : [];
+    },
+    resolvableAssistants: async (t2) => new Set(
+      import_core88.agentLatticeManager.getAllAgentLatticesByTenant(t2).map((lattice) => lattice.config.key)
+    )
+  };
+}
+function mergeGrantsByDomain(grants) {
+  const order = [];
+  const items = /* @__PURE__ */ new Map();
+  const unrestricted = /* @__PURE__ */ new Set();
+  for (const grant of grants) {
+    if (!grant || typeof grant.domain !== "string" || grant.domain.length === 0) continue;
+    if (!items.has(grant.domain)) {
+      items.set(grant.domain, /* @__PURE__ */ new Set());
+      order.push(grant.domain);
+    }
+    if (!grant.items || grant.items.length === 0) {
+      unrestricted.add(grant.domain);
+      continue;
+    }
+    const bucket = items.get(grant.domain);
+    if (!bucket) continue;
+    for (const item of grant.items) {
+      if (typeof item === "string" && item.length > 0) bucket.add(item);
+    }
+  }
+  return order.map((domain) => {
+    if (unrestricted.has(domain)) return { domain };
+    return { domain, items: [...items.get(domain) ?? []] };
+  });
+}
+async function computePluginGrants(tenantId, deps) {
+  const grants = [...deps.globalExposedDomains?.() ?? []];
+  if (deps.tenantExposedDomains) {
+    grants.push(...await deps.tenantExposedDomains(tenantId));
+  }
+  if (deps.resolvableAssistants) {
+    const resolvable = await deps.resolvableAssistants(tenantId);
+    if (resolvable.size > 0) {
+      grants.push({ domain: "agent", items: [...resolvable] });
+    }
+  }
+  return mergeGrantsByDomain(grants);
+}
+async function resolvePluginOpenGrants(tenantId, deps) {
+  try {
+    const now = deps.now ? deps.now() : Date.now();
+    const hit = pluginCache.get(tenantId);
+    if (hit && hit.expiresAt > now) return cloneGrants(hit.grants);
+    await deps.ensure?.(tenantId);
+    const grants = await computePluginGrants(tenantId, deps);
+    pluginCache.set(tenantId, { grants, expiresAt: now + PLUGIN_REFLECTION_CACHE_TTL_MS });
+    return cloneGrants(grants);
+  } catch {
+    return [];
+  }
+}
+function buildTenantExposedGrants(manifests) {
+  const grants = [];
+  for (const manifest of manifests) {
+    const items = (manifest.tools ?? []).filter((tool) => tool.expose === true).map((tool) => tool.name);
+    if (items.length > 0) grants.push({ domain: manifest.type, items });
+  }
+  return grants;
+}
+function createDefaultPluginReflectionDeps() {
+  return {
+    ensure: (tenantId) => import_core88.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId),
+    globalExposedDomains: () => {
+      const grants = [];
+      for (const type of import_core88.PluginRegistry.list()) {
+        const plugin = import_core88.PluginRegistry.get(type);
+        const items = normalizeOpenExpose(plugin?.meta.openExpose);
+        if (items.length > 0) grants.push({ domain: type, items });
+      }
+      return grants;
+    },
+    tenantExposedDomains: async (tenantId) => {
+      const { manifests } = await (0, import_core88.getSandboxPluginCatalog)().ensureLoaded(tenantId);
+      return buildTenantExposedGrants(Object.values(manifests));
+    },
+    resolvableAssistants: async (tenantId) => new Set(
+      import_core88.agentLatticeManager.getAllAgentLatticesByTenant(tenantId).map((lattice) => lattice.config.key)
+    )
+  };
+}
+var import_core88, AGENT_REFLECTION_CACHE_TTL_MS, cache, PLUGIN_REFLECTION_CACHE_TTL_MS, pluginCache;
+var init_sandboxOpenReflection = __esm({
+  "src/services/open/sandboxOpenReflection.ts"() {
+    "use strict";
+    import_core88 = require("@axiom-lattice/core");
+    AGENT_REFLECTION_CACHE_TTL_MS = 6e4;
+    cache = /* @__PURE__ */ new Map();
+    PLUGIN_REFLECTION_CACHE_TTL_MS = 6e4;
+    pluginCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/services/open/sandboxOpenCredentialProvider.ts
+var sandboxOpenCredentialProvider_exports = {};
+__export(sandboxOpenCredentialProvider_exports, {
+  DEFAULT_SANDBOX_OPEN_GRANTS: () => DEFAULT_SANDBOX_OPEN_GRANTS,
+  MAX_SANDBOX_OPEN_DEPTH: () => MAX_SANDBOX_OPEN_DEPTH,
+  createSandboxOpenCredentialProvider: () => createSandboxOpenCredentialProvider,
+  registerGatewaySandboxOpenCredentialProvider: () => registerGatewaySandboxOpenCredentialProvider
+});
+function defaultReflection() {
+  return {
+    agent: (tenantId, assistantId) => resolveAgentOpenGrants(tenantId, assistantId, createDefaultAgentReflectionDeps(tenantId)),
+    plugin: (tenantId) => resolvePluginOpenGrants(tenantId, createDefaultPluginReflectionDeps())
+  };
+}
+function createSandboxOpenCredentialProvider(options) {
+  const reflection = options.reflection ?? defaultReflection();
+  return async (context) => {
+    if (!options.gatewayUrl) return void 0;
+    const depth = (context.depth ?? 0) + 1;
+    if (depth > MAX_SANDBOX_OPEN_DEPTH) {
+      options.onError?.(new Error("sandbox open credential depth exceeded"));
+      return void 0;
+    }
+    const reflected = context.assistantId ? await reflection.agent(context.tenantId, context.assistantId) : await reflection.plugin(context.tenantId);
+    const grants = mergeGrantsByDomain([...DEFAULT_SANDBOX_OPEN_GRANTS, ...reflected]);
+    const token = signOpenToken({
+      kind: "sandbox_token",
+      tenantId: context.tenantId,
+      workspaceId: context.workspaceId ?? "",
+      projectId: context.projectId ?? "",
+      sandboxName: context.sandboxName,
+      grants,
+      depth
+    });
+    return { gatewayUrl: options.gatewayUrl, token };
+  };
+}
+function registerGatewaySandboxOpenCredentialProvider(onError) {
+  return (0, import_core89.registerSandboxOpenCredentialProvider)(
+    createSandboxOpenCredentialProvider({
+      gatewayUrl: process.env.PUBLIC_GATEWAY_URL?.trim() || void 0,
+      onError
+    }),
+    { onError }
+  );
+}
+var import_core89, DEFAULT_SANDBOX_OPEN_GRANTS, MAX_SANDBOX_OPEN_DEPTH;
+var init_sandboxOpenCredentialProvider = __esm({
+  "src/services/open/sandboxOpenCredentialProvider.ts"() {
+    "use strict";
+    import_core89 = require("@axiom-lattice/core");
+    init_openToken();
+    init_sandboxOpenReflection();
+    DEFAULT_SANDBOX_OPEN_GRANTS = [
+      { domain: "sandbox", items: ["files_read", "files_list", "files_write", "shell_exec"] },
+      { domain: "kb", items: ["search", "entries_read"] }
+    ];
+    MAX_SANDBOX_OPEN_DEPTH = 5;
+  }
+});
+
 // src/services/open/sandboxGrants.ts
 function sanitizeShareOpenGrants(grants) {
   const out = [];
@@ -5015,12 +5337,12 @@ var resources_exports = {};
 __export(resources_exports, {
   ResourceController: () => ResourceController
 });
-var import_bcryptjs, import_core83, ResourceController;
+var import_bcryptjs, import_core90, ResourceController;
 var init_resources = __esm({
   "src/controllers/resources.ts"() {
     "use strict";
     import_bcryptjs = __toESM(require("bcryptjs"));
-    import_core83 = require("@axiom-lattice/core");
+    import_core90 = require("@axiom-lattice/core");
     init_mime();
     init_http_range();
     init_sandboxGrants();
@@ -5037,14 +5359,14 @@ var init_resources = __esm({
         if (!workspaceId || !projectId) {
           return reply.status(400).send({ error: "x-workspace-id and x-project-id headers required" });
         }
-        const payload = (0, import_core83.createSharePayload)(
+        const payload = (0, import_core90.createSharePayload)(
           tenantId,
           workspaceId,
           projectId,
           userId,
           body
         );
-        const token = (0, import_core83.generateToken)();
+        const token = (0, import_core90.generateToken)();
         try {
           await this.deps.store.create({ ...payload, token });
           this.deps.logger.info(
@@ -5196,7 +5518,7 @@ var init_resources = __esm({
             resourcePath: subPath
           }, subPath, ext, request, reply);
         }
-        const volume = (0, import_core83.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
+        const volume = (0, import_core90.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
         return this._resolveAndServe(
           volume,
           subPath,
@@ -5408,8 +5730,13 @@ var init_resources = __esm({
 var index_exports = {};
 __export(index_exports, {
   LatticeGateway: () => LatticeGateway,
+  ProjectRoomEventBroker: () => ProjectRoomEventBroker,
+  ROOM_EVENT_TOPIC: () => ROOM_EVENT_TOPIC,
   createOrphanRecoveryRuntime: () => createOrphanRecoveryRuntime,
   createRecoveryCallerDeps: () => createRecoveryCallerDeps,
+  createTaskRunLiveness: () => createTaskRunLiveness,
+  ingestRoomEvent: () => ingestRoomEvent,
+  publishRoomEvent: () => publishRoomEvent,
   recoverTask: () => recoverTask,
   recoverTopCaller: () => recoverTopCaller,
   resolveTopCaller: () => resolveTopCaller,
@@ -6324,6 +6651,24 @@ async function writeSse(raw, value, closed) {
 }
 
 // src/controllers/run.ts
+var replicaHeader = () => ({ [import_protocols2.REPLICA_HEADER]: (0, import_core3.getReplicaId)() });
+var exposeHeaders = `${import_protocols2.REPLICA_HEADER}, ${import_protocols2.AFFINITY_ECHO_HEADER}`;
+function applyAffinityEcho(request, reply) {
+  for (const [name, value] of Object.entries((0, import_protocols2.affinityEchoHeaders)(request.headers[import_protocols2.AGENT_AFFINITY_HEADER]))) {
+    reply.header(name, value);
+  }
+}
+var AFFINITY_GRACE_MS = Number.isFinite(Number(process.env.AXIOM_AFFINITY_GRACE_MS)) ? Number(process.env.AXIOM_AFFINITY_GRACE_MS) : 500;
+async function peerOwnsThread(input) {
+  if (!process.env.AXIOM_REPLICA_ID) return null;
+  if (!input.tenant_id || !input.assistant_id || !input.thread_id) return null;
+  const owner = await (0, import_core3.getThreadRunOwner)({
+    tenantId: input.tenant_id,
+    assistantId: input.assistant_id,
+    threadId: input.thread_id
+  });
+  return owner && owner !== (0, import_core3.getReplicaId)() ? owner : null;
+}
 function getUserId2(request) {
   const authUser = request.user;
   if (authUser?.id) return authUser.id;
@@ -6350,6 +6695,7 @@ var createRun = async (request, reply) => {
       ...user_id && { user_id }
     };
     if (!assistant_id) {
+      applyAffinityEcho(request, reply);
       reply.status(400).send({
         success: false,
         error: "\u52A9\u624BID\u662F\u5FC5\u9700\u7684"
@@ -6371,6 +6717,8 @@ var createRun = async (request, reply) => {
         command,
         custom_run_config: mergedConfig
       }, mode);
+      reply.header(import_protocols2.REPLICA_HEADER, (0, import_core3.getReplicaId)());
+      applyAffinityEcho(request, reply);
       reply.status(202).send({
         success: true,
         messageId: result.messageId,
@@ -6384,7 +6732,10 @@ var createRun = async (request, reply) => {
         "Content-Type": "text/event-stream",
         "Cache-Control": "no-cache",
         Connection: "keep-alive",
-        "Access-Control-Allow-Origin": "*"
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Expose-Headers": exposeHeaders,
+        ...replicaHeader(),
+        ...(0, import_protocols2.affinityEchoHeaders)(request.headers[import_protocols2.AGENT_AFFINITY_HEADER])
       });
       try {
         const messageInput = message_id ? { ...input, id: message_id } : input;
@@ -6395,6 +6746,18 @@ var createRun = async (request, reply) => {
         }, [import_protocols2.MessageChunkTypes.MESSAGE_COMPLETED, import_protocols2.MessageChunkTypes.INTERRUPT, import_protocols2.MessageChunkTypes.MESSAGE_FAILED], {
           queueMode: mode
         });
+        let peer = await peerOwnsThread({ tenant_id, assistant_id, thread_id });
+        if (peer) {
+          await new Promise((resolve4) => setTimeout(resolve4, AFFINITY_GRACE_MS));
+          peer = await peerOwnsThread({ tenant_id, assistant_id, thread_id });
+        }
+        if (peer) {
+          reply.raw.write(`data: ${JSON.stringify((0, import_protocols2.buildAffinityMissChunk)(peer, thread_id))}
+
+`);
+          reply.raw.end();
+          return;
+        }
         await pipeAsyncIterableToSse(reply.raw, result.stream, {
           onError: (error) => [{
             type: "error",
@@ -6426,12 +6789,15 @@ var createRun = async (request, reply) => {
         command,
         custom_run_config: mergedConfig
       });
+      reply.header(import_protocols2.REPLICA_HEADER, (0, import_core3.getReplicaId)());
+      applyAffinityEcho(request, reply);
       reply.status(200).send({
         success: true,
         ...result
       });
     }
   } catch (error) {
+    applyAffinityEcho(request, reply);
     reply.status(500).send({
       success: false,
       error: `\u521B\u5EFA\u8FD0\u884C\u65F6\u53D1\u751F\u9519\u8BEF: ${error.message}`
@@ -6454,9 +6820,20 @@ var resumeStream = async (request, reply) => {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
       Connection: "keep-alive",
-      "Access-Control-Allow-Origin": "*"
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Expose-Headers": exposeHeaders,
+      ...replicaHeader(),
+      ...(0, import_protocols2.affinityEchoHeaders)(request.headers[import_protocols2.AGENT_AFFINITY_HEADER])
     });
     try {
+      const peer = await peerOwnsThread({ tenant_id, assistant_id, thread_id });
+      if (peer) {
+        reply.raw.write(`data: ${JSON.stringify((0, import_protocols2.buildAffinityMissChunk)(peer, thread_id))}
+
+`);
+        reply.raw.end();
+        return;
+      }
       const agent = import_core3.agentInstanceManager.getAgent({
         assistant_id,
         thread_id,
@@ -6507,12 +6884,22 @@ var abortRun = async (request, reply) => {
       workspace_id,
       project_id
     });
+    const peer = await peerOwnsThread({ tenant_id, assistant_id: assistantId, thread_id: threadId });
+    if (peer) {
+      reply.header(import_protocols2.REPLICA_HEADER, (0, import_core3.getReplicaId)());
+      applyAffinityEcho(request, reply);
+      reply.status(409).send({ success: false, code: import_protocols2.AFFINITY_MISS_CODE, owner: peer, threadId });
+      return;
+    }
     await agent.abort();
+    reply.header(import_protocols2.REPLICA_HEADER, (0, import_core3.getReplicaId)());
+    applyAffinityEcho(request, reply);
     reply.status(200).send({
       success: true,
       message: "Agent aborted"
     });
   } catch (error) {
+    applyAffinityEcho(request, reply);
     reply.status(500).send({
       success: false,
       error: `Abort failed: ${error.message}`
@@ -6530,13 +6917,17 @@ var recoverRun = async (request, reply) => {
       workspace_id,
       project_id
     });
-    const { status } = await agent.resumeTask();
+    const { status, leaseContended } = await agent.resumeTask();
+    reply.header(import_protocols2.REPLICA_HEADER, (0, import_core3.getReplicaId)());
+    applyAffinityEcho(request, reply);
     reply.status(200).send({
       success: true,
       threadId,
-      status
+      status,
+      ...leaseContended ? { code: import_protocols2.AFFINITY_MISS_CODE } : {}
     });
   } catch (error) {
+    applyAffinityEcho(request, reply);
     reply.status(500).send({
       success: false,
       error: `Recover failed: ${error.message}`
@@ -13101,6 +13492,43 @@ function connectionRoutes(fastify2) {
 // src/controllers/mcp-configs.ts
 var import_core33 = require("@axiom-lattice/core");
 var import_crypto8 = require("crypto");
+
+// src/services/mcpConfigSync.ts
+var MCP_CONFIG_CHANGED_TOPIC = "mcp-config-changed";
+async function publishMcpConfigChanged(outbox, owner, tenantId, serverKey) {
+  if (!tenantId || !serverKey) return;
+  try {
+    await outbox.append({
+      topic: MCP_CONFIG_CHANGED_TOPIC,
+      payload: { tenantId, serverKey },
+      originReplicaId: owner
+    });
+  } catch {
+  }
+}
+async function reconcileMcpConfigChange(payload, deps) {
+  const tenantId = payload?.tenantId;
+  const serverKey = payload?.serverKey;
+  if (typeof tenantId !== "string" || tenantId.length === 0) return;
+  if (typeof serverKey !== "string" || serverKey.length === 0) return;
+  const config = await deps.store.getConfigByKey(tenantId, serverKey);
+  if (!config || config.status !== "connected") {
+    if (deps.manager.hasServer(tenantId, serverKey)) {
+      await deps.manager.removeServer(tenantId, serverKey);
+    }
+    return;
+  }
+  const connection = deps.convertToConnection(config.config);
+  deps.manager.registerServer(tenantId, serverKey, connection, {
+    timeoutMs: config.config.timeout,
+    maxAttempts: config.config.retryAttempts,
+    selectedTools: config.selectedTools
+  });
+  await deps.manager.ensureConnected(tenantId, serverKey);
+  await deps.manager.registerToolsToToolLattice(tenantId, serverKey, config.selectedTools);
+}
+
+// src/controllers/mcp-configs.ts
 function getTenantId11(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
@@ -13108,6 +13536,14 @@ function getTenantId11(request) {
   }
   return request.headers["x-tenant-id"] || "default";
 }
+function broadcastMcpConfigChanged(tenantId, serverKey) {
+  if (!tenantId || !serverKey) return;
+  try {
+    const outbox = (0, import_core33.getStoreLattice)("default", "outbox").store;
+    void publishMcpConfigChanged(outbox, (0, import_core33.getReplicaId)(), tenantId, serverKey);
+  } catch {
+  }
+}
 async function getMcpServerConfigList(request, reply) {
   const tenantId = getTenantId11(request);
   try {
@@ -13185,6 +13621,7 @@ async function createMcpServerConfig(request, reply) {
       await store2.updateConfig(tenantId, id3, { status: "error" });
       config.status = "error";
     }
+    broadcastMcpConfigChanged(tenantId, config.key);
     reply.code(201);
     return {
       success: true,
@@ -13214,7 +13651,9 @@ async function updateMcpServerConfig(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    const shouldReconnect = updates.config !== void 0;
+    const configChanged = updates.config !== void 0;
+    const toolsChanged = updates.selectedTools !== void 0;
+    const statusChanged = updates.status !== void 0;
     const updated = await store2.updateConfig(tenantId, existing.id, updates);
     if (!updated) {
       return {
@@ -13222,7 +13661,7 @@ async function updateMcpServerConfig(request, reply) {
         message: "Failed to update MCP server configuration"
       };
     }
-    if (shouldReconnect) {
+    if (configChanged) {
       try {
         const connection = (0, import_core33.convertToConnection)(updated.config);
         import_core33.mcpManager.registerServer(tenantId, key, connection, {
@@ -13238,6 +13677,22 @@ async function updateMcpServerConfig(request, reply) {
         await store2.updateConfig(tenantId, existing.id, { status: "error" });
         updated.status = "error";
       }
+    } else if (toolsChanged && import_core33.mcpManager.hasServer(tenantId, key)) {
+      try {
+        await import_core33.mcpManager.registerToolsToToolLattice(tenantId, key, updated.selectedTools);
+      } catch (error) {
+        console.warn("Failed to re-register MCP tools:", error);
+      }
+    }
+    if (statusChanged && updated.status !== "connected" && import_core33.mcpManager.hasServer(tenantId, key)) {
+      try {
+        await import_core33.mcpManager.removeServer(tenantId, key);
+      } catch (error) {
+        console.warn("Failed to remove MCP server:", error);
+      }
+    }
+    if (configChanged || toolsChanged || statusChanged) {
+      broadcastMcpConfigChanged(tenantId, key);
     }
     return {
       success: true,
@@ -13287,6 +13742,7 @@ async function deleteMcpServerConfig(request, reply) {
         message: "Failed to delete MCP server configuration"
       };
     }
+    broadcastMcpConfigChanged(tenantId, configKey);
     return {
       success: true,
       message: "MCP server configuration deleted successfully"
@@ -13361,12 +13817,17 @@ async function listMcpServerTools(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    if (!import_core33.mcpManager.isServerConnected(tenantId, key)) {
+    const wasConnected = import_core33.mcpManager.isServerConnected(tenantId, key);
+    if (!wasConnected) {
       await connectAndRegisterTools(config);
     }
-    if (config.status !== "connected") {
+    const statusStale = config.status !== "connected";
+    if (statusStale) {
       await store2.updateConfig(tenantId, config.id, { status: "connected" });
     }
+    if (!wasConnected || statusStale) {
+      broadcastMcpConfigChanged(tenantId, key);
+    }
     const tools = await import_core33.mcpManager.getServerTools(tenantId, key);
     return {
       success: true,
@@ -13401,6 +13862,7 @@ async function connectMcpServer(request, reply) {
     const updated = await store2.updateConfig(tenantId, config.id, {
       status: "connected"
     });
+    broadcastMcpConfigChanged(tenantId, key);
     return {
       success: true,
       message: "MCP server connected successfully",
@@ -13414,6 +13876,7 @@ async function connectMcpServer(request, reply) {
     if (config) {
       await store2.updateConfig(tenantId, config.id, { status: "error" });
     }
+    broadcastMcpConfigChanged(tenantId, key);
     return {
       success: false,
       message: `Failed to connect MCP server: ${error instanceof Error ? error.message : "Unknown error"}`
@@ -13440,6 +13903,7 @@ async function disconnectMcpServer(request, reply) {
     const updated = await store2.updateConfig(tenantId, config.id, {
       status: "disconnected"
     });
+    broadcastMcpConfigChanged(tenantId, key);
     return {
       success: true,
       message: "MCP server disconnected successfully",
@@ -15958,8 +16422,8 @@ function snapshotPlainObject(value) {
   }
 }
 async function getInstallationStore() {
-  const { getStoreLattice: getStoreLattice37 } = await import("@axiom-lattice/core");
-  const store2 = getStoreLattice37("default", "channelInstallation").store;
+  const { getStoreLattice: getStoreLattice39 } = await import("@axiom-lattice/core");
+  const store2 = getStoreLattice39("default", "channelInstallation").store;
   if (store2) return store2;
   const { PostgreSQLChannelInstallationStore } = await import("@axiom-lattice/pg-stores");
   const databaseUrl = process.env.DATABASE_URL;
@@ -17101,7 +17565,7 @@ function registerTaskRoutes(app2, controller) {
 }
 
 // src/routes/index.ts
-var import_core51 = require("@axiom-lattice/core");
+var import_core54 = require("@axiom-lattice/core");
 
 // src/controllers/tasks.ts
 var import_protocols13 = require("@axiom-lattice/protocols");
@@ -17680,6 +18144,10 @@ var ProjectTaskExecutionService = class {
         input.inputMessageId,
         true
       );
+      if (resumed.leaseContended) {
+        settlement.cleanup();
+        return { kind: "deferred", task: input.task, thread: input.thread, messageId: input.inputMessageId };
+      }
       if (resumed.status === import_core44.ThreadStatus.INTERRUPTED && settlement.tryClaim()) {
         settlement.cleanup();
         const outcome2 = await this.settleInterruptedEvent(input.task, input.thread, input.inputMessageId);
@@ -19368,6 +19836,7 @@ var import_zod6 = require("zod");
 // src/services/agent-web-app/AgentWebAppRuntimeService.ts
 var import_node_crypto10 = require("crypto");
 var import_protocols14 = require("@axiom-lattice/protocols");
+var import_core46 = require("@axiom-lattice/core");
 init_task_file_refs();
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -19530,6 +19999,20 @@ var AgentWebAppRuntimeService = class {
   async resumeStream(webAppId, userId, threadId, messageId, selection) {
     const runtime = await this.resolveRuntime(webAppId, selection);
     await this.requireOwnedThread(runtime, userId, threadId);
+    if (process.env.AXIOM_REPLICA_ID) {
+      const owner = await (0, import_core46.getThreadRunOwner)({
+        tenantId: runtime.webApp.tenantId,
+        assistantId: runtime.webApp.assistantId,
+        threadId
+      });
+      if (owner && owner !== (0, import_core46.getReplicaId)()) {
+        return {
+          stream: (async function* () {
+            yield (0, import_protocols14.buildAffinityMissChunk)(owner, threadId);
+          })()
+        };
+      }
+    }
     const agent = this.resolveAgent(runtime, threadId);
     return { stream: agent.chunkStream(messageId, []) };
   }
@@ -19875,6 +20358,7 @@ async function verifyWebAppToken(token, issuer, options = {}) {
 
 // src/routes/agent-web-app-runtime.ts
 var import_protocols15 = require("@axiom-lattice/protocols");
+var import_core47 = require("@axiom-lattice/core");
 var idSchema = import_zod6.z.string().min(1).max(128);
 var paramsSchema = import_zod6.z.object({ webAppId: idSchema }).strict();
 var threadParamsSchema = import_zod6.z.object({ webAppId: idSchema, threadId: idSchema }).strict();
@@ -20023,7 +20507,7 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
         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);
+        beginSse(reply, request);
         await pipeNativeWebAppStream(reply.raw, result.stream);
       } catch (error) {
         return normalizeError2(reply, error);
@@ -20035,7 +20519,7 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
         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);
+        beginSse(reply, request);
         await pipeAgentWebAppStream(reply.raw, result.stream, result);
       } catch (error) {
         return normalizeError2(reply, error);
@@ -20047,7 +20531,7 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
         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);
+        beginSse(reply, request);
         await pipeNativeWebAppStream(reply.raw, result.stream);
       } catch (error) {
         return normalizeError2(reply, error);
@@ -20080,7 +20564,7 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
         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);
+        beginSse(reply, request);
         await pipeAgentWebAppStream(reply.raw, result.stream, result);
       } catch (error) {
         return normalizeError2(reply, error);
@@ -20308,6 +20792,10 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
           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 });
+          reply.header(import_protocols15.REPLICA_HEADER, (0, import_core47.getReplicaId)());
+          for (const [name, value] of Object.entries((0, import_protocols15.affinityEchoHeaders)(request.headers[import_protocols15.AGENT_AFFINITY_HEADER]))) {
+            reply.header(name, value);
+          }
           return reply.code(202).send({ success: true, messageId, queued: true });
         } catch (error) {
           return normalizeError2(reply, error);
@@ -20328,7 +20816,7 @@ function registerAgentWebAppRuntimeRoutes(app2, deps) {
           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);
+          beginSse(reply, request);
           await pipeNativeWebAppStream(reply.raw, result.stream);
         } catch (error) {
           return normalizeError2(reply, error);
@@ -20381,14 +20869,17 @@ async function pipeNativeWebAppStream(raw, stream) {
     }]
   });
 }
-function beginSse(reply) {
+function beginSse(reply, request) {
   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",
-    "Access-Control-Allow-Origin": "*"
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Expose-Headers": `${import_protocols15.REPLICA_HEADER}, ${import_protocols15.AFFINITY_ECHO_HEADER}`,
+    [import_protocols15.REPLICA_HEADER]: (0, import_core47.getReplicaId)(),
+    ...(0, import_protocols15.affinityEchoHeaders)(request.headers[import_protocols15.AGENT_AFFINITY_HEADER])
   });
 }
 async function handle2(reply, operation) {
@@ -20624,7 +21115,7 @@ var import_zod9 = require("zod");
 
 // src/services/capability/CapabilityBundleService.ts
 var import_zod8 = require("zod");
-var import_core46 = require("@axiom-lattice/core");
+var import_core48 = require("@axiom-lattice/core");
 var CapabilityBundleServiceError = class extends Error {
   constructor(code, message, statusCode) {
     super(message);
@@ -20665,7 +21156,7 @@ function projectBundleIds(config) {
   return [...value];
 }
 function issue(error) {
-  if (error instanceof import_core46.CapabilityBundleMergeError || error instanceof import_core46.CapabilityBundleValidationError) return { code: error instanceof import_core46.CapabilityBundleValidationError && error.code === "CAPABILITY_BUNDLE_INVALID_CONFIG" ? "INVALID_BUNDLE_CONFIG" : error.code, message: error.message, bundleId: error instanceof import_core46.CapabilityBundleMergeError ? error.bundleId : void 0, capabilityType: error.capabilityType, fieldPath: error.fieldPath };
+  if (error instanceof import_core48.CapabilityBundleMergeError || error instanceof import_core48.CapabilityBundleValidationError) return { code: error instanceof import_core48.CapabilityBundleValidationError && error.code === "CAPABILITY_BUNDLE_INVALID_CONFIG" ? "INVALID_BUNDLE_CONFIG" : error.code, message: error.message, bundleId: error instanceof import_core48.CapabilityBundleMergeError ? error.bundleId : void 0, capabilityType: error.capabilityType, fieldPath: error.fieldPath };
   return { code: "CAPABILITY_BUNDLE_CONFIGURATION_ERROR", message: error instanceof Error ? error.message : "Invalid capability bundle configuration" };
 }
 var CapabilityBundleService = class {
@@ -20678,7 +21169,7 @@ var CapabilityBundleService = class {
     const errors = [];
     for (const value of values) {
       try {
-        (0, import_core46.validateCapabilityBundleInput)(value);
+        (0, import_core48.validateCapabilityBundleInput)(value);
         bundles.push(value);
       } catch {
         errors.push({ bundleId: value.id, code: "INVALID_BUNDLE_CONFIG", message: "Capability bundle record is invalid" });
@@ -20690,7 +21181,7 @@ var CapabilityBundleService = class {
     const value = await this.deps.bundleStore.getById(tenantId, id3);
     if (!value) throw new CapabilityBundleServiceError("BUNDLE_NOT_FOUND", "Capability bundle not found", 404);
     try {
-      (0, import_core46.validateCapabilityBundleInput)(value);
+      (0, import_core48.validateCapabilityBundleInput)(value);
     } catch {
       throw new CapabilityBundleServiceError("INVALID_BUNDLE_CONFIG", "Capability bundle record is invalid", 422);
     }
@@ -20698,7 +21189,7 @@ var CapabilityBundleService = class {
   }
   async create(tenantId, input) {
     rejectStableKey(input);
-    (0, import_core46.validateCapabilityBundleInput)(input);
+    (0, import_core48.validateCapabilityBundleInput)(input);
     const value = input;
     const name = value.name.trim();
     const base = slugify(name);
@@ -20709,10 +21200,10 @@ var CapabilityBundleService = class {
       let suffix = 2;
       while (keys2.has(key)) key = `${base}-${suffix++}`;
       const normalized = { ...value, key, name };
-      (0, import_core46.validateCapabilityBundleInput)(normalized);
+      (0, import_core48.validateCapabilityBundleInput)(normalized);
       try {
         const result = await this.deps.bundleStore.create(tenantId, normalized);
-        (0, import_core46.validateCapabilityBundleInput)(result);
+        (0, import_core48.validateCapabilityBundleInput)(result);
         return result;
       } catch (error) {
         if (!isDuplicate(error)) throw error;
@@ -20723,16 +21214,16 @@ var CapabilityBundleService = class {
   }
   async update(tenantId, id3, input) {
     rejectStableKey(input);
-    (0, import_core46.validateCapabilityBundleInput)(input, { partial: true });
+    (0, import_core48.validateCapabilityBundleInput)(input, { partial: true });
     if (!input || typeof input !== "object" || Array.isArray(input) || typeof input.expectedUpdatedAt !== "string" || !input.expectedUpdatedAt.trim()) throw new CapabilityBundleServiceError("INVALID_BUNDLE_CONFIG", "expectedUpdatedAt is required for capability bundle updates", 400);
     const value = input;
     const normalized = { ...value, ...value.name === void 0 ? {} : { name: value.name.trim() }, ...Object.prototype.hasOwnProperty.call(value, "description") ? { description: value.description?.trim() || void 0 } : {} };
-    (0, import_core46.validateCapabilityBundleInput)(normalized, { partial: true });
+    (0, import_core48.validateCapabilityBundleInput)(normalized, { partial: true });
     try {
       const result = await this.deps.bundleStore.update(tenantId, id3, normalized);
       if (!result) throw new CapabilityBundleServiceError("BUNDLE_NOT_FOUND", "Capability bundle not found", 404);
       if ("status" in result && result.status === "conflict") throw new CapabilityBundleServiceError("BUNDLE_CONFLICT", "Capability bundle changed after it was loaded; reload before saving", 409);
-      (0, import_core46.validateCapabilityBundleInput)(result);
+      (0, import_core48.validateCapabilityBundleInput)(result);
       return result;
     } catch (error) {
       if (error instanceof CapabilityBundleServiceError) throw error;
@@ -20767,8 +21258,8 @@ var CapabilityBundleService = class {
     if (missing.length > 0) return { bundleIds: ids, capabilities: [], overrides: [], sources: [], warnings: [], errors: missing.map((id3) => ({ code: "BUNDLE_NOT_FOUND", message: `Persisted capability bundle '${id3}' is missing`, bundleId: id3 })), revision: "" };
     try {
       const ordered = ids.map((id3) => byId.get(id3));
-      ordered.forEach((bundle) => (0, import_core46.validateCapabilityBundleInput)(bundle));
-      return (0, import_core46.mergeCapabilityBundles)(ordered);
+      ordered.forEach((bundle) => (0, import_core48.validateCapabilityBundleInput)(bundle));
+      return (0, import_core48.mergeCapabilityBundles)(ordered);
     } catch (error) {
       return { bundleIds: ids, capabilities: [], overrides: [], sources: [], warnings: [], errors: [issue(error)], revision: "" };
     }
@@ -20801,7 +21292,7 @@ var CapabilityBundleService = class {
     return ids.map((id3) => {
       const value = byId.get(id3);
       if (!value) throw new CapabilityBundleServiceError("BUNDLE_NOT_FOUND", "Capability bundle not found", 404);
-      (0, import_core46.validateCapabilityBundleInput)(value);
+      (0, import_core48.validateCapabilityBundleInput)(value);
       return value;
     });
   }
@@ -20816,7 +21307,7 @@ var CapabilityBundleService = class {
         continue;
       }
       try {
-        (0, import_core46.validateCapabilityBundleInput)(bundle);
+        (0, import_core48.validateCapabilityBundleInput)(bundle);
         valid.push(bundle);
       } catch (error) {
         errors.push({ ...issue(error), bundleId: id3 });
@@ -20824,7 +21315,7 @@ var CapabilityBundleService = class {
     }
     let preview;
     try {
-      preview = (0, import_core46.mergeCapabilityBundles)(valid);
+      preview = (0, import_core48.mergeCapabilityBundles)(valid);
     } catch (error) {
       preview = { bundleIds: ids, capabilities: [], overrides: [], sources: [], warnings: [], errors: [issue(error)], revision: "" };
     }
@@ -20976,7 +21467,7 @@ var import_zod11 = require("zod");
 // src/services/model-provider/ModelProviderService.ts
 var import_node_crypto14 = require("crypto");
 var import_protocols16 = require("@axiom-lattice/protocols");
-var import_core47 = require("@axiom-lattice/core");
+var import_core49 = require("@axiom-lattice/core");
 
 // src/services/model-provider/errors.ts
 var ModelProviderServiceError = class extends Error {
@@ -20989,6 +21480,17 @@ var ModelProviderServiceError = class extends Error {
     this.name = "ModelProviderServiceError";
   }
 };
+var UPSTREAM_ERROR_CODES = {
+  UPSTREAM_UNREACHABLE: true,
+  UPSTREAM_AUTH_FAILED: true,
+  UPSTREAM_REDIRECT_BLOCKED: true,
+  UPSTREAM_INVALID_RESPONSE: true,
+  UPSTREAM_RATE_LIMITED: true,
+  UPSTREAM_TIMEOUT: true
+};
+function isUpstreamErrorCode(code) {
+  return Object.prototype.hasOwnProperty.call(UPSTREAM_ERROR_CODES, code);
+}
 
 // src/services/model-provider/discovery.ts
 var MAX_DISCOVERED_MODELS = 1e3;
@@ -21264,6 +21766,33 @@ var ModelProviderService = class {
       models
     };
   }
+  /**
+   * Hydrates the runtime model registry from the persisted provider catalog.
+   *
+   * @returns The model keys registered in this process.
+   * @remarks Registers the Phase-1 (default tenant) enabled provider models so a
+   * replica that did not perform discovery — or that restarted — can execute
+   * them. Best-effort; the caller logs failures.
+   */
+  async hydrateRegistry() {
+    const tenantId = PHASE1_REGISTRY_TENANT;
+    if (!this.shouldRegister(tenantId)) {
+      return [];
+    }
+    const providers = await this.deps.providerStore.listProviders(tenantId);
+    const registered = [];
+    for (const provider of providers) {
+      if (!provider.enabled) {
+        continue;
+      }
+      const models = await this.deps.providerStore.listModels(
+        tenantId,
+        provider.id
+      );
+      registered.push(...this.syncRegistry(tenantId, provider, models));
+    }
+    return registered;
+  }
   /**
    * Create a provider configuration. Does not run discovery.
    */
@@ -21503,7 +22032,7 @@ var ModelProviderService = class {
         models
       };
     } catch (error) {
-      if (error instanceof ModelProviderServiceError) {
+      if (error instanceof ModelProviderServiceError && isUpstreamErrorCode(error.code)) {
         return {
           reachable: false,
           latencyMs: Date.now() - startedAt,
@@ -21742,9 +22271,9 @@ var ModelProviderService = class {
    */
   async assertSafeUrl(baseURL) {
     try {
-      await (0, import_core47.assertSafeUpstreamUrl)(baseURL);
+      await (0, import_core49.assertSafeUpstreamUrl)(baseURL);
     } catch (error) {
-      if (error instanceof import_core47.UnsafeUpstreamUrlError) {
+      if (error instanceof import_core49.UnsafeUpstreamUrlError) {
         throw new ModelProviderServiceError(
           unsafeReasonToErrorCode[error.reason],
           400,
@@ -21920,6 +22449,10 @@ var ModelProviderController = class {
       return sendError2(reply, error);
     }
   }
+  /** Hydrates the runtime model registry from persisted providers (startup). */
+  async hydrateRegistry() {
+    return this.service.hydrateRegistry();
+  }
   /** GET /api/model-providers */
   async listProviders(request, reply) {
     try {
@@ -23206,7 +23739,7 @@ async function execute(reply, operation) {
 // src/routes/cospace.ts
 var import_node_crypto20 = require("crypto");
 var import_zod15 = require("zod");
-var import_core48 = require("@axiom-lattice/core");
+var import_core50 = require("@axiom-lattice/core");
 var import_protocols19 = require("@axiom-lattice/protocols");
 var CoSpaceAuthError = class extends Error {
   constructor() {
@@ -23391,14 +23924,14 @@ function registerCoSpaceRoutes(app2, deps) {
         }
         let projectId;
         if (body.type === "human") {
-          projectId = (0, import_core48.generateDirectHumanProjectId)(
+          projectId = (0, import_core50.generateDirectHumanProjectId)(
             actor3.tenantId,
             params.workspaceId,
             actor3.userId,
             body.targetUserId
           );
         } else {
-          projectId = (0, import_core48.generateDirectBotProjectId)(
+          projectId = (0, import_core50.generateDirectBotProjectId)(
             actor3.tenantId,
             params.workspaceId,
             actor3.userId,
@@ -23605,7 +24138,7 @@ function registerCoSpaceRoutes(app2, deps) {
         );
         const bots = [];
         for (const assistant of assistants) {
-          const directProjectId = (0, import_core48.generateDirectBotProjectId)(
+          const directProjectId = (0, import_core50.generateDirectBotProjectId)(
             actor3.tenantId,
             params.workspaceId,
             actor3.userId,
@@ -23667,7 +24200,7 @@ function registerCoSpaceRoutes(app2, deps) {
           if (link.userId === actor3.userId) continue;
           const user = await deps.userStore.getUserById(link.userId);
           if (!user) continue;
-          const directProjectId = (0, import_core48.generateDirectHumanProjectId)(
+          const directProjectId = (0, import_core50.generateDirectHumanProjectId)(
             actor3.tenantId,
             params.workspaceId,
             actor3.userId,
@@ -24484,6 +25017,8 @@ function createRoomMessageRetentionJob(input) {
 
 // src/services/collaboration/ProjectTaskExecutionMutex.ts
 var import_protocols22 = require("@axiom-lattice/protocols");
+var import_core51 = require("@axiom-lattice/core");
+var MACHINE_LEASE_OPTIONS = { ttlMs: 6e4, acquireTimeoutMs: 9e4, retryDelayMs: 100 };
 function machineKey(scope) {
   const snapshot = (0, import_protocols22.snapshotExactRecord)(scope, ["tenantId", "assistantId", "projectId"]);
   if (!snapshot) throw new Error("Invalid Project task machine scope");
@@ -24507,9 +25042,12 @@ var ProjectTaskExecutionMutex = class {
    */
   async runExclusive(scope, operation, signal) {
     const key = machineKey(scope);
+    const leaseKey = `project-task-machine:${encodeURIComponent(scope.tenantId)}:${encodeURIComponent(scope.assistantId)}:${encodeURIComponent(scope.projectId)}`;
     await this.acquire(key, signal);
     try {
-      return await operation();
+      const store2 = (0, import_core51.getCoordinationLeaseStore)();
+      if (!store2) return await operation();
+      return await (0, import_core51.withLease)(store2, leaseKey, (0, import_core51.getReplicaId)(), operation, MACHINE_LEASE_OPTIONS);
     } finally {
       this.release(key);
     }
@@ -24562,8 +25100,22 @@ var ProjectTaskExecutionMutex = class {
 
 // src/services/collaboration/ProjectTaskObserver.ts
 var import_node_crypto22 = require("crypto");
-var import_core49 = require("@axiom-lattice/core");
+var import_core52 = require("@axiom-lattice/core");
 var import_protocols23 = require("@axiom-lattice/protocols");
+
+// src/services/collaboration/projectTaskDispatchMarker.ts
+var EXECUTION_REQUESTED_AT_KEY = "execution_requested_at";
+function hasExecutionRequest(task) {
+  const value = task.context?.[EXECUTION_REQUESTED_AT_KEY];
+  if (typeof value !== "string" || value.length === 0) return false;
+  const parsed = new Date(value);
+  return Number.isFinite(parsed.getTime()) && parsed.toISOString() === value;
+}
+function withExecutionRequest(context, nowIso) {
+  return { ...context ?? {}, [EXECUTION_REQUESTED_AT_KEY]: nowIso };
+}
+
+// src/services/collaboration/ProjectTaskObserver.ts
 init_projectTaskScope();
 var SYSTEM_ACTOR2 = "system";
 var TERMINAL_ACTIONS = ["completed", "failed", "interrupted", "cancelled"];
@@ -24585,7 +25137,7 @@ var ProjectTaskObserver = class {
         throw new Error(`Invalid Project task observer bound: ${name}`);
       }
     }
-    this.runBridge = (0, import_core49.createTaskRunBridge)({ lifecycle: this.deps.lifecycle });
+    this.runBridge = (0, import_core52.createTaskRunBridge)({ lifecycle: this.deps.lifecycle });
   }
   /** Fire-and-forget notifier adapter that never waits for observer work or machine acquisition. */
   async listener(event) {
@@ -24768,7 +25320,7 @@ var ProjectTaskObserver = class {
           return;
         }
       }
-      if (intent === "dispatch" && await this.isReady(task) && !signal?.aborted && !this.disposed) {
+      if ((intent === "dispatch" || hasExecutionRequest(task)) && await this.isReady(task) && !signal?.aborted && !this.disposed) {
         await this.runStart(task, signal);
       }
       return;
@@ -24885,7 +25437,7 @@ var ProjectTaskObserver = class {
     }, signal);
   }
   async mapOutcome(outcome2) {
-    if (outcome2.kind === "aborted") return;
+    if (outcome2.kind === "aborted" || outcome2.kind === "deferred") return;
     const current = snapshotTaskItem(await this.deps.tasks.getById(outcome2.task.tenantId, outcome2.task.id));
     if (!current || current.ownerId !== outcome2.thread.assistantId || current.context?.thread_id !== outcome2.thread.id) return;
     if (isTerminal(current.status) || current.status === "review") return;
@@ -25801,7 +26353,7 @@ function isRecord3(value) {
 init_projectTaskScope();
 
 // src/services/collaboration/ProjectRoomRealtimeRuntime.ts
-var import_core50 = require("@axiom-lattice/core");
+var import_core53 = require("@axiom-lattice/core");
 
 // src/services/collaboration/ProjectRoomEventBroker.ts
 var import_node_crypto24 = require("crypto");
@@ -25811,6 +26363,7 @@ var DEFAULT_MAX_EVENT_AGE_MS = 10 * 60 * 1e3;
 var DEFAULT_MAX_ROOMS = 1e3;
 var DEFAULT_MAX_GLOBAL_EVENTS = 1e5;
 var DEFAULT_MAX_GLOBAL_BYTES = 64 * 1024 * 1024;
+var DEFAULT_SOURCE_KEY_LIMIT = 2e3;
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 var ProjectRoomBrokerResourceCapacityError = class extends Error {
   constructor(resource) {
@@ -25824,6 +26377,7 @@ var ProjectRoomEventBroker = class {
   constructor(options = {}) {
     this.rooms = /* @__PURE__ */ new Map();
     this.sequenceScopes = /* @__PURE__ */ new Map();
+    this.seenSourceKeys = /* @__PURE__ */ new Map();
     this.eventCount = 0;
     this.byteCount = 0;
     this.subscriberCount = 0;
@@ -25851,6 +26405,10 @@ var ProjectRoomEventBroker = class {
       options.maxGlobalBytes ?? DEFAULT_MAX_GLOBAL_BYTES,
       "maxGlobalBytes"
     );
+    this.sourceKeyLimit = positiveSafeInteger(
+      options.sourceKeyLimit ?? DEFAULT_SOURCE_KEY_LIMIT,
+      "sourceKeyLimit"
+    );
     this.sequence = nonnegativeSafeInteger(options.initialSequence ?? 0, "initialSequence");
     this.log = options.log ?? { warn: () => void 0 };
   }
@@ -25862,8 +26420,22 @@ var ProjectRoomEventBroker = class {
   get retainedBytes() {
     return this.byteCount;
   }
-  /** Atomically stores an immutable event before queueing detached listener callbacks. */
-  publish(scope, draft) {
+  /**
+   * Installs (or clears) a hook invoked after a locally published event is stored
+   * and queued to local subscribers. Used to mirror events to other replicas via
+   * a shared transport. Best-effort: a throwing hook never affects `publish`.
+   */
+  setBroadcastHook(hook) {
+    this.broadcast = hook;
+  }
+  /**
+   * Atomically stores an immutable event before queueing detached listener callbacks.
+   *
+   * @param sourceKey Optional caller-owned fact key; when present it is retained
+   * for bounded cross-replica duplicate suppression so a later foreign copy of the
+   * same fact (or a local publish) is dropped by {@link ingestForeignEvent}.
+   */
+  publish(scope, draft, sourceKey) {
     this.assertOpen();
     const canonicalScope = snapshotScope(scope);
     const key = scopeKey2(canonicalScope);
@@ -25898,9 +26470,52 @@ var ProjectRoomEventBroker = class {
     this.sequence = nextSequence;
     this.eventCount += 1;
     this.byteCount += bytes;
+    if (sourceKey !== void 0) this.rememberSourceKey(sourceKey);
     for (const subscription of [...room.subscriptions]) this.queueCallback(subscription, serialized);
+    if (this.broadcast) {
+      try {
+        this.broadcast(canonicalScope, serialized, sourceKey);
+      } catch {
+      }
+    }
     return parseScopedEvent(serialized);
   }
+  /**
+   * Delivers one event published by ANOTHER replica to this process's local
+   * subscribers for its room, without adding it to the local replay ring or
+   * consuming a local sequence (its id carries the origin replica's epoch).
+   *
+   * @param serializedEvent A serialized scoped business event produced by a peer.
+   * @param sourceKey Optional caller-owned fact key shared by every replica's copy
+   * of the same committed fact. When it was already seen (locally published or
+   * ingested from a peer) the event is dropped to avoid N× duplicate delivery.
+   * @returns True when it was queued to at least one local subscription.
+   * @remarks Source-key deduplication is process-local and bounded, so it caps
+   * duplicate fan-out within the retention window without replacing REST, which
+   * remains the authority. A malformed payload or a room with no local
+   * subscribers is ignored.
+   */
+  ingestForeignEvent(serializedEvent, sourceKey) {
+    this.assertOpen();
+    if (sourceKey !== void 0 && this.seenSourceKeys.has(sourceKey)) return false;
+    let key;
+    try {
+      const event = parseScopedEvent(serializedEvent);
+      key = scopeKey2(snapshotScope(event.scope));
+    } catch {
+      return false;
+    }
+    if (sourceKey !== void 0) this.rememberSourceKey(sourceKey);
+    const room = this.rooms.get(key);
+    if (!room || room.subscriptions.size === 0) return false;
+    this.touch(room);
+    let queued = false;
+    for (const subscription of [...room.subscriptions]) {
+      this.queueCallback(subscription, serializedEvent);
+      queued = true;
+    }
+    return queued;
+  }
   /** Atomically resolves replay and registers a distinct subscription for live events. */
   subscribe(scope, afterEventId, listener) {
     this.assertOpen();
@@ -25940,6 +26555,7 @@ var ProjectRoomEventBroker = class {
     }
     this.rooms.clear();
     this.sequenceScopes.clear();
+    this.seenSourceKeys.clear();
     this.eventCount = 0;
     this.byteCount = 0;
     this.subscriberCount = 0;
@@ -26074,6 +26690,14 @@ var ProjectRoomEventBroker = class {
     this.usageClock += 1;
     room.lastUsed = this.usageClock;
   }
+  rememberSourceKey(key) {
+    this.seenSourceKeys.set(key, true);
+    while (this.seenSourceKeys.size > this.sourceKeyLimit) {
+      const oldest = this.seenSourceKeys.keys().next().value;
+      if (oldest === void 0) break;
+      this.seenSourceKeys.delete(oldest);
+    }
+  }
 };
 function positiveSafeInteger(value, name) {
   if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`${name} must be a positive safe integer`);
@@ -26265,7 +26889,7 @@ var BrokerProjectRoomRealtimePublisher = class {
       if (!event) throw new Error("Invalid Project Room realtime projection");
       const dedupeKey = (0, import_node_crypto25.createHash)("sha256").update(JSON.stringify([type, event.scope.tenantId, event.scope.projectId, event.scope.roomId, event.sourceKey])).digest("hex");
       if (this.sourceKeys.has(dedupeKey)) return;
-      this.deps.broker.publish(event.scope, event.draft);
+      this.deps.broker.publish(event.scope, event.draft, event.sourceKey);
       this.sourceKeys.set(dedupeKey, true);
       while (this.sourceKeys.size > this.dedupeLimit) {
         const oldest = this.sourceKeys.keys().next().value;
@@ -26504,7 +27128,7 @@ function createProjectRoomRealtimeRuntime(deps) {
     broker,
     publisher,
     subscriber,
-    subscribe: (listener) => import_core50.taskLifecycleNotifier.subscribe(listener),
+    subscribe: (listener) => import_core53.taskLifecycleNotifier.subscribe(listener),
     log: deps.log,
     shutdownTimeoutMs: deps.shutdownTimeoutMs
   });
@@ -27242,35 +27866,35 @@ function hookErrorMessage(error) {
 function wrapReassignmentThreadError(error) {
   if (error instanceof ProjectTaskThreadError) {
     if (error.code === "PROJECT_TASK_THREAD_SCOPE_INVALID") {
-      return new import_core51.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", error.message, {
+      return new import_core54.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", error.message, {
         hint: "Project task, room, or roster scope changed; re-read the task and retry."
       });
     }
     if (error.code === "PROJECT_TASK_THREAD_OWNER_INVALID") {
-      return new import_core51.ManagedTaskStartError("TASK_REASSIGN_NO_CHANGE", error.message, {
+      return new import_core54.ManagedTaskStartError("TASK_REASSIGN_NO_CHANGE", error.message, {
         hint: "The target already owns this task; re-read before dispatching."
       });
     }
-    return new import_core51.ManagedTaskStartError("TASK_THREAD_CONFLICT", error.message, {
+    return new import_core54.ManagedTaskStartError("TASK_THREAD_CONFLICT", error.message, {
       hint: "Task Thread changed concurrently; re-read the task and retry."
     });
   }
-  return new import_core51.ManagedTaskStartError("TASK_EXECUTION_ENQUEUE_FAILED", hookErrorMessage(error), {
+  return new import_core54.ManagedTaskStartError("TASK_EXECUTION_ENQUEUE_FAILED", hookErrorMessage(error), {
     hint: "Re-read the task and retry the dispatch."
   });
 }
 function wrapReassignmentAuthorizationError(error) {
-  if (error instanceof import_core51.ProjectTaskOwnerPolicyError) {
+  if (error instanceof import_core54.ProjectTaskOwnerPolicyError) {
     if (error.code === "PROJECT_TASK_CALLER_INACTIVE") {
-      return new import_core51.ManagedTaskStartError("PROJECT_TASK_CALLER_INACTIVE", error.message, {
+      return new import_core54.ManagedTaskStartError("PROJECT_TASK_CALLER_INACTIVE", error.message, {
         hint: "Dispatch from an active Project Room member bot."
       });
     }
-    return new import_core51.ManagedTaskStartError("PROJECT_TASK_OWNER_INACTIVE", error.message, {
+    return new import_core54.ManagedTaskStartError("PROJECT_TASK_OWNER_INACTIVE", error.message, {
       hint: "Dispatch to an active bot in this Project's roster."
     });
   }
-  return new import_core51.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", hookErrorMessage(error), {
+  return new import_core54.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", hookErrorMessage(error), {
     hint: "Re-read the task and roster, then retry the dispatch."
   });
 }
@@ -27299,43 +27923,43 @@ async function transferGovernedDispatchOwner(task, options, deps) {
   const agentId = options?.agentId;
   if (!agentId || agentId === task.ownerId) return void 0;
   if (!task.workspaceId || !task.projectId) {
-    throw new import_core51.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", "Task is not governed by a Project lifecycle.", {
+    throw new import_core54.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", "Task is not governed by a Project lifecycle.", {
       hint: "Dispatch governed tasks from a trusted Project run; ordinary tasks execute immediately."
     });
   }
   return deps.mutex.runExclusive({ tenantId: task.tenantId, projectId: task.projectId }, async () => {
     const current = await deps.tasks.getById(task.tenantId, task.id);
     if (!current || !isProjectLifecycleTask(current) || current.workspaceId !== task.workspaceId || current.projectId !== task.projectId) {
-      throw new import_core51.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", "Task is no longer a Project lifecycle task.", {
+      throw new import_core54.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", "Task is no longer a Project lifecycle task.", {
         hint: "Re-read the task and confirm it still belongs to this Project before dispatching."
       });
     }
     if (current.ownerType !== "agent") {
-      throw new import_core51.ManagedTaskStartError("AGENT_TASK_REQUIRED", "Project task owner must be an Agent.", {
+      throw new import_core54.ManagedTaskStartError("AGENT_TASK_REQUIRED", "Project task owner must be an Agent.", {
         hint: "Assign the task to an Agent before dispatching."
       });
     }
     if (current.status !== "pending") {
-      throw new import_core51.ManagedTaskStartError("TASK_NOT_DISPATCHABLE", "Only a `pending` Project task can be dispatched.", {
+      throw new import_core54.ManagedTaskStartError("TASK_NOT_DISPATCHABLE", "Only a `pending` Project task can be dispatched.", {
         hint: `This task is '${current.status}'. Resolve it or create a new task before dispatching.`
       });
     }
     if (agentId === current.ownerId) return current;
     const room = await deps.rooms.getMainRoom(current.tenantId, current.projectId);
     if (!room || room.tenantId !== current.tenantId || room.workspaceId !== current.workspaceId || room.projectId !== current.projectId || room.type !== "main") {
-      throw new import_core51.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", "Project main room is unavailable.", {
+      throw new import_core54.ManagedTaskStartError("PROJECT_TASK_CONTEXT_INVALID", "Project main room is unavailable.", {
         hint: "Open or repair the Project Room before dispatching."
       });
     }
     const target = await deps.botMemberships.findByAssistant(current.tenantId, current.projectId, agentId);
     if (!target || target.status !== "active" || target.tenantId !== current.tenantId || target.workspaceId !== current.workspaceId || target.projectId !== current.projectId || target.assistantId !== agentId || target.roomId !== room.id) {
-      throw new import_core51.ManagedTaskStartError("PROJECT_TASK_OWNER_INACTIVE", "Target Project task owner is not active in the exact roster.", {
+      throw new import_core54.ManagedTaskStartError("PROJECT_TASK_OWNER_INACTIVE", "Target Project task owner is not active in the exact roster.", {
         hint: "Dispatch to an active bot in this Project's roster."
       });
     }
     const caller = options?.callerMembershipId ? await deps.botMemberships.findById(current.tenantId, options.callerMembershipId) : null;
     if (!caller || !options?.callerAssistantId || caller.id !== options.callerMembershipId || caller.assistantId !== options.callerAssistantId || caller.status !== "active" || caller.tenantId !== current.tenantId || caller.workspaceId !== current.workspaceId || caller.projectId !== current.projectId || caller.roomId !== room.id) {
-      throw new import_core51.ManagedTaskStartError("PROJECT_TASK_CALLER_INACTIVE", "Current Project task caller is not active in the exact roster.", {
+      throw new import_core54.ManagedTaskStartError("PROJECT_TASK_CALLER_INACTIVE", "Current Project task caller is not active in the exact roster.", {
         hint: "Dispatch from an active Project Room member bot."
       });
     }
@@ -27370,7 +27994,7 @@ async function transferGovernedDispatchOwner(task, options, deps) {
       actor: `agent:${caller.assistantId}`
     });
     if (!result.success) {
-      throw new import_core51.ManagedTaskStartError(result.code, result.error, {
+      throw new import_core54.ManagedTaskStartError(result.code, result.error, {
         hint: result.hint ?? reassignmentFailureHint(result.code),
         ...result.retryable !== void 0 ? { retryable: result.retryable } : {}
       });
@@ -27379,19 +28003,19 @@ async function transferGovernedDispatchOwner(task, options, deps) {
   });
 }
 var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
-  const webAppStore = (0, import_core51.getStoreLattice)("default", "agentWebApp").store;
-  const assistantStore = (0, import_core51.getStoreLattice)("default", "assistant").store;
-  const projectStore = (0, import_core51.getStoreLattice)("default", "project").store;
-  const projectMembershipStore = (0, import_core51.getStoreLattice)("default", "projectMembership").store;
-  const userTenantLinkStore = (0, import_core51.getStoreLattice)("default", "userTenantLink").store;
-  const projectRoomStore = (0, import_core51.getStoreLattice)("default", "projectRoom").store;
-  const projectBotMembershipStore = (0, import_core51.getStoreLattice)("default", "projectBotMembership").store;
-  const projectRoomMessageStore = (0, import_core51.getStoreLattice)("default", "projectRoomMessage").store;
-  const projectRoomReadStateStore = (0, import_core51.getStoreLattice)("default", "projectRoomReadState").store;
-  const userPushSubscriptionStore = (0, import_core51.getStoreLattice)("default", "userPushSubscription").store;
-  const threadStore = (0, import_core51.getStoreLattice)("default", "thread").store;
-  const taskStore = (0, import_core51.getStoreLattice)("default", "task").store;
-  const taskWorkItemStore = (0, import_core51.getStoreLattice)("default", "taskWorkItem").store;
+  const webAppStore = (0, import_core54.getStoreLattice)("default", "agentWebApp").store;
+  const assistantStore = (0, import_core54.getStoreLattice)("default", "assistant").store;
+  const projectStore = (0, import_core54.getStoreLattice)("default", "project").store;
+  const projectMembershipStore = (0, import_core54.getStoreLattice)("default", "projectMembership").store;
+  const userTenantLinkStore = (0, import_core54.getStoreLattice)("default", "userTenantLink").store;
+  const projectRoomStore = (0, import_core54.getStoreLattice)("default", "projectRoom").store;
+  const projectBotMembershipStore = (0, import_core54.getStoreLattice)("default", "projectBotMembership").store;
+  const projectRoomMessageStore = (0, import_core54.getStoreLattice)("default", "projectRoomMessage").store;
+  const projectRoomReadStateStore = (0, import_core54.getStoreLattice)("default", "projectRoomReadState").store;
+  const userPushSubscriptionStore = (0, import_core54.getStoreLattice)("default", "userPushSubscription").store;
+  const threadStore = (0, import_core54.getStoreLattice)("default", "thread").store;
+  const taskStore = (0, import_core54.getStoreLattice)("default", "task").store;
+  const taskWorkItemStore = (0, import_core54.getStoreLattice)("default", "taskWorkItem").store;
   const projectTaskEnabled = options.projectTaskEnabled ?? process.env.AXIOM_PROJECT_TASK_EXECUTION_ENABLED !== "false";
   const accessService = new ProjectAccessService({ projectStore, membershipStore: projectMembershipStore, userTenantLinkStore });
   const realtimeMode = resolveProjectRoomRealtimeMode();
@@ -27457,7 +28081,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     updateAssistant: assistantStore.updateAssistant.bind(assistantStore)
   });
   const resolveCoordinatorMentionName = async (tenantId) => {
-    const tenant2 = await (0, import_core51.getStoreLattice)("default", "tenant").store.getTenantById(tenantId);
+    const tenant2 = await (0, import_core54.getStoreLattice)("default", "tenant").store.getTenantById(tenantId);
     const value = tenant2?.metadata?.coordinatorMentionName;
     return typeof value === "string" && value.length > 0 ? value : void 0;
   };
@@ -27484,7 +28108,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       return membership !== null && membership.projectId === projectId ? membership : null;
     },
     getThreadStatus: async ({ tenantId, assistantId, threadId, workspaceId, projectId }) => {
-      const agent = import_core51.agentInstanceManager.getAgent({
+      const agent = import_core54.agentInstanceManager.getAgent({
         tenant_id: tenantId,
         assistant_id: assistantId,
         thread_id: threadId,
@@ -27493,9 +28117,9 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       });
       return String(await agent.getRunStatus());
     },
-    dispatcher: (0, import_core51.createTrustedAgentMessageDispatcher)((scope) => import_core51.agentInstanceManager.getAgent(scope))
+    dispatcher: (0, import_core54.createTrustedAgentMessageDispatcher)((scope) => import_core54.agentInstanceManager.getAgent(scope))
   });
-  const membershipService = new ProjectMembershipService({ membershipStore: projectMembershipStore, userTenantLinkStore, accessService, projectMutationMutex: import_core51.projectMutationMutex, roomStore: projectRoomStore, realtime, onRealtimeFailure: realtime && channelDeps?.warn ? ({ code, membershipId }) => channelDeps.warn?.("project-room:membership-realtime-failed", { code, membershipId }) : void 0 });
+  const membershipService = new ProjectMembershipService({ membershipStore: projectMembershipStore, userTenantLinkStore, accessService, projectMutationMutex: import_core54.projectMutationMutex, 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,
@@ -27506,7 +28130,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     assistantStore,
     taskStore,
     bindingLifecycle,
-    projectMutationMutex: import_core51.projectMutationMutex,
+    projectMutationMutex: import_core54.projectMutationMutex,
     realtime,
     onRealtimeFailure: realtime && channelDeps?.warn ? ({ code, membershipId }) => channelDeps.warn?.("project-room:roster-realtime-failed", { code, membershipId }) : void 0
   });
@@ -27562,9 +28186,9 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
   }
   if (projectTaskComposition) app2.addHook("onClose", async () => projectTaskComposition.lease.release());
   const taskThreadService = projectTaskComposition?.lease.runtime.threads ?? new ProjectTaskThreadService({ threads: threadStore, idFactory: import_node_crypto26.randomUUID });
-  const taskLifecycle = projectTaskComposition?.lease.runtime.lifecycle ?? (0, import_core51.createTaskLifecycleService)({ taskStore, workItemStore: taskWorkItemStore });
-  const reassignmentAuthorizer = (0, import_core51.createProjectTaskReassignmentAuthorizer)(
-    new import_core51.ProjectTaskOwnerPolicy(projectBotMembershipStore),
+  const taskLifecycle = projectTaskComposition?.lease.runtime.lifecycle ?? (0, import_core54.createTaskLifecycleService)({ taskStore, workItemStore: taskWorkItemStore });
+  const reassignmentAuthorizer = (0, import_core54.createProjectTaskReassignmentAuthorizer)(
+    new import_core54.ProjectTaskOwnerPolicy(projectBotMembershipStore),
     (input) => validateReassignmentThread(threadStore, input)
   );
   const taskCommandService = new TaskCommandService({
@@ -27573,7 +28197,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     lifecycle: taskLifecycle,
     execution: projectTaskComposition?.lease.runtime.execution,
     threads: taskThreadService,
-    agents: { getAgent: (params) => import_core51.agentInstanceManager.getAgent(params) },
+    agents: { getAgent: (params) => import_core54.agentInstanceManager.getAgent(params) },
     taskScope: (task) => resolveCommandTaskScope(task, {
       rooms: projectRoomStore,
       bots: projectBotMembershipStore,
@@ -27611,7 +28235,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     readStateService,
     interruptService: roomInterruptService,
     userDirectory: {
-      getUserById: (id3) => (0, import_core51.getStoreLattice)("default", "user").store.getUserById(id3).then((u) => u ? { name: u.name } : null)
+      getUserById: (id3) => (0, import_core54.getStoreLattice)("default", "user").store.getUserById(id3).then((u) => u ? { name: u.name } : null)
     }
   });
   registerProjectRosterRoutes(app2, { service: rosterService });
@@ -27622,7 +28246,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       createProject: projectStore.createProject.bind(projectStore)
     },
     workspaceStore: {
-      getWorkspaceById: (tenantId, id3) => (0, import_core51.getStoreLattice)("default", "workspace").store.getWorkspaceById(tenantId, id3)
+      getWorkspaceById: (tenantId, id3) => (0, import_core54.getStoreLattice)("default", "workspace").store.getWorkspaceById(tenantId, id3)
     },
     membershipStore: {
       list: projectMembershipStore.list.bind(projectMembershipStore),
@@ -27645,7 +28269,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       getUsersByTenant: userTenantLinkStore.getUsersByTenant.bind(userTenantLinkStore)
     },
     userStore: {
-      getUserById: (id3) => (0, import_core51.getStoreLattice)("default", "user").store.getUserById(id3).then((u) => u ? { id: u.id, name: u.name, email: u.email } : null)
+      getUserById: (id3) => (0, import_core54.getStoreLattice)("default", "user").store.getUserById(id3).then((u) => u ? { id: u.id, name: u.name, email: u.email } : null)
     },
     assistantStore: {
       getAssistantById: assistantStore.getAssistantById.bind(assistantStore),
@@ -27667,28 +28291,30 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     }
   });
   registerCapabilityBundleRoutes(app2, new CapabilityBundleController({
-    bundleStore: (0, import_core51.getStoreLattice)("default", "capabilityBundle").store,
+    bundleStore: (0, import_core54.getStoreLattice)("default", "capabilityBundle").store,
     projectStore
   }, { authRequired: process.env.AUTH_REQUIRED === "true" }));
-  registerModelProviderRoutes(app2, new ModelProviderController({
-    providerStore: (0, import_core51.getStoreLattice)("default", "modelProvider").store,
+  const modelProviderController = new ModelProviderController({
+    providerStore: (0, import_core54.getStoreLattice)("default", "modelProvider").store,
     userTenantLinkStore,
     registry: {
-      register: (tenantId, modelKey2, config) => import_core51.modelLatticeManager.registerLatticeWithTenant(tenantId, modelKey2, config),
-      has: (tenantId, modelKey2) => import_core51.modelLatticeManager.hasLatticeWithTenant(tenantId, modelKey2),
-      remove: (tenantId, modelKey2) => import_core51.modelLatticeManager.removeLatticeWithTenant(tenantId, modelKey2),
-      listRegistered: (tenantId) => import_core51.modelLatticeManager.getLatticeKeysByTenant(tenantId)
-    }
-  }, { authRequired: process.env.AUTH_REQUIRED === "true" }));
+      register: (tenantId, modelKey2, config) => import_core54.modelLatticeManager.registerLatticeWithTenant(tenantId, modelKey2, config),
+      has: (tenantId, modelKey2) => import_core54.modelLatticeManager.hasLatticeWithTenant(tenantId, modelKey2),
+      remove: (tenantId, modelKey2) => import_core54.modelLatticeManager.removeLatticeWithTenant(tenantId, modelKey2),
+      listRegistered: (tenantId) => import_core54.modelLatticeManager.getLatticeKeysByTenant(tenantId)
+    }
+  }, { authRequired: process.env.AUTH_REQUIRED === "true" });
+  registerModelProviderRoutes(app2, modelProviderController);
+  void modelProviderController.hydrateRegistry().catch(() => void 0);
   registerAgentWebAppRoutes(app2, {
     service: new AgentWebAppService({
       webAppStore,
       assistantStore,
       projectStore,
-      modelRegistry: { has: (key) => import_core51.modelLatticeManager.hasLattice(key) },
+      modelRegistry: { has: (key) => import_core54.modelLatticeManager.hasLattice(key) },
       configuredAgentResolver: createConfiguredAgentResolver({
-        hydrate: (tenantId) => import_core51.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId),
-        has: (tenantId, assistantId) => import_core51.agentLatticeManager.hasAgentLatticeWithTenant(tenantId, assistantId)
+        hydrate: (tenantId) => import_core54.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId),
+        has: (tenantId, assistantId) => import_core54.agentLatticeManager.hasAgentLatticeWithTenant(tenantId, assistantId)
       })
     })
   });
@@ -27725,28 +28351,28 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
       },
       tasks: taskStore,
       workItems: taskWorkItemStore,
-      projectMutationMutex: import_core51.projectMutationMutex,
+      projectMutationMutex: import_core54.projectMutationMutex,
       ...projectTaskComposition ? { commands: taskCommandService } : {}
     }),
     service: new AgentWebAppRuntimeService({
       webAppStore,
-      threadStore: (0, import_core51.getStoreLattice)("default", "thread").store,
+      threadStore: (0, import_core54.getStoreLattice)("default", "thread").store,
       projectStore,
       assistantResolver: {
         resolve: async (tenantId, assistantId) => {
           const stored = await assistantStore.getAssistantById(tenantId, assistantId);
           if (stored) return { id: stored.id, name: stored.name, description: stored.description };
-          await import_core51.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId);
-          const config = import_core51.agentLatticeManager.getAgentConfigWithTenant(tenantId, assistantId);
+          await import_core54.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId);
+          const config = import_core54.agentLatticeManager.getAgentConfigWithTenant(tenantId, assistantId);
           return config ? { id: assistantId, name: config.name, description: config.description } : null;
         }
       },
       modelRegistry: {
-        has: (key) => import_core51.modelLatticeManager.hasLattice(key),
+        has: (key) => import_core54.modelLatticeManager.hasLattice(key),
         label: (key) => key
       },
       messageReader: {
-        getCurrentMessages: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core51.agentInstanceManager.getAgentForRead({
+        getCurrentMessages: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core54.agentInstanceManager.getAgentForRead({
           tenant_id: tenantId,
           assistant_id: assistantId,
           thread_id: threadId,
@@ -27755,7 +28381,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
         }).getCurrentMessages()
       },
       agentResolver: {
-        getAgent: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core51.agentInstanceManager.getAgent({
+        getAgent: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core54.agentInstanceManager.getAgent({
           tenant_id: tenantId,
           assistant_id: assistantId,
           thread_id: threadId,
@@ -27773,8 +28399,8 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
         if (webApp.tenantId !== preview.tenantId) return false;
         const assistant = await assistantStore.getAssistantById(preview.tenantId, webApp.assistantId);
         if (assistant) return !assistant.ownerUserId || assistant.ownerUserId === preview.userId;
-        await import_core51.agentLatticeManager.initializeStoredAssistantsForTenant(preview.tenantId);
-        return import_core51.agentLatticeManager.hasAgentLatticeWithTenant(preview.tenantId, webApp.assistantId);
+        await import_core54.agentLatticeManager.initializeStoredAssistantsForTenant(preview.tenantId);
+        return import_core54.agentLatticeManager.hasAgentLatticeWithTenant(preview.tenantId, webApp.assistantId);
       }
     })
   });
@@ -27831,14 +28457,14 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
   app2.post("/api/personal-assistant", createPersonalAssistant);
   app2.get("/api/personal-assistant", getPersonalAssistant);
   app2.delete("/api/personal-assistant", deletePersonalAssistant);
-  import_core51.executionAuthorityRegistry.register({
+  import_core54.executionAuthorityRegistry.register({
     id: "project-lifecycle",
     matches: isProjectLifecycleTask,
     code: "PROJECT_TASK_EXECUTION_MANAGED",
     message: "Project tasks are executed by the durable Project queue runtime",
     onManagedStart: async (task, options2) => {
       if (!projectTaskComposition && options2?.agentId && options2.agentId !== task.ownerId) {
-        throw new import_core51.ManagedTaskStartError(
+        throw new import_core54.ManagedTaskStartError(
           "PROJECT_TASK_RUNTIME_UNAVAILABLE",
           "Project task ownership transfer requires the Project task runtime.",
           { hint: "Project task execution is disabled; enable the Project task runtime or dispatch to the current owner." }
@@ -27851,17 +28477,21 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
         threads: taskThreadService,
         reassignmentAuthorizer,
         lifecycle: taskLifecycle,
-        mutex: import_core51.projectMutationMutex
+        mutex: import_core54.projectMutationMutex
       }) : void 0;
       const admitted = transferred ?? task;
       if (!admitted.workspaceId || !admitted.projectId) return;
-      void import_core51.projectTaskAdmissionNotifier.publish({
-        tenantId: admitted.tenantId,
-        workspaceId: admitted.workspaceId,
-        projectId: admitted.projectId,
-        taskId: admitted.id,
-        ownerId: admitted.ownerId,
-        updatedAt: admitted.updatedAt.toISOString()
+      const markerUpdated = await taskStore.update(admitted.tenantId, admitted.id, {
+        context: withExecutionRequest(admitted.context, (/* @__PURE__ */ new Date()).toISOString())
+      }).catch(() => null);
+      const eventTask = markerUpdated ?? admitted;
+      void import_core54.projectTaskAdmissionNotifier.publish({
+        tenantId: eventTask.tenantId,
+        workspaceId: eventTask.workspaceId,
+        projectId: eventTask.projectId,
+        taskId: eventTask.id,
+        ownerId: eventTask.ownerId,
+        updatedAt: eventTask.updatedAt.toISOString()
       });
     }
   });
@@ -27869,7 +28499,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
     access: accessService,
     tasks: taskStore,
     workItems: taskWorkItemStore,
-    projectMutationMutex: import_core51.projectMutationMutex,
+    projectMutationMutex: import_core54.projectMutationMutex,
     commands: taskCommandService,
     readableProjects: async ({ tenantId, userId, workspaceId }) => {
       const projects = await projectStore.getProjectsByWorkspace(tenantId, workspaceId);
@@ -28151,9 +28781,9 @@ function tryCreateProjectTaskRuntime(input) {
   let stores;
   try {
     stores = {
-      tenants: (0, import_core51.getStoreLattice)("default", "tenant").store,
-      workspaces: (0, import_core51.getStoreLattice)("default", "workspace").store,
-      queue: (0, import_core51.getStoreLattice)("default", "threadMessageQueue").store
+      tenants: (0, import_core54.getStoreLattice)("default", "tenant").store,
+      workspaces: (0, import_core54.getStoreLattice)("default", "workspace").store,
+      queue: (0, import_core54.getStoreLattice)("default", "threadMessageQueue").store
     };
     const missing = missingRuntimeMethod(input, stores);
     if (missing) return { reason: missing };
@@ -28185,7 +28815,7 @@ function createRuntime(input, stores, log2) {
   const controller = new AbortController();
   const mutex = new ProjectTaskExecutionMutex();
   const threads = new ProjectTaskThreadService({ threads: input.threadStore, idFactory: import_node_crypto26.randomUUID });
-  const lifecycle = (0, import_core51.createTaskLifecycleService)({ taskStore: input.taskStore, workItemStore: input.taskWorkItemStore });
+  const lifecycle = (0, import_core54.createTaskLifecycleService)({ taskStore: input.taskStore, workItemStore: input.taskWorkItemStore });
   const projection = new RoomProjectionService({
     messages: input.projectRoomMessageStore,
     events: input.taskWorkItemStore,
@@ -28195,7 +28825,7 @@ function createRuntime(input, stores, log2) {
     realtime: input.realtime,
     idFactory: import_node_crypto26.randomUUID
   });
-  const agentFor = (task, thread) => import_core51.agentInstanceManager.getAgent({
+  const agentFor = (task, thread) => import_core54.agentInstanceManager.getAgent({
     tenant_id: task.tenantId,
     assistant_id: task.ownerId,
     thread_id: thread.id,
@@ -28209,7 +28839,7 @@ function createRuntime(input, stores, log2) {
     bots: input.projectBotMembershipStore,
     threads,
     lifecycle,
-    dispatcher: (0, import_core51.createTrustedAgentMessageDispatcher)((scope) => import_core51.agentInstanceManager.getAgent(scope)),
+    dispatcher: (0, import_core54.createTrustedAgentMessageDispatcher)((scope) => import_core54.agentInstanceManager.getAgent(scope)),
     queue: stores.queue,
     agentFor
   }, {
@@ -28236,8 +28866,8 @@ function createRuntime(input, stores, log2) {
   const taskLifecycleListener = ((event) => {
     void observer.listener(event);
   });
-  const unsubscribe = import_core51.taskLifecycleNotifier.subscribe(taskLifecycleListener);
-  const unsubscribeAdmission = import_core51.projectTaskAdmissionNotifier.subscribe((event, signal) => {
+  const unsubscribe = import_core54.taskLifecycleNotifier.subscribe(taskLifecycleListener);
+  const unsubscribeAdmission = import_core54.projectTaskAdmissionNotifier.subscribe((event, signal) => {
     observer.admit(event, signal);
   });
   let reconciliationWork;
@@ -28384,12 +29014,12 @@ function registerResourceRoutes(app2, controller) {
 }
 
 // src/export_registrations/index.ts
-var import_core62 = require("@axiom-lattice/core");
+var import_core65 = require("@axiom-lattice/core");
 
 // src/export_registrations/skill.registration.ts
-var import_core52 = require("@axiom-lattice/core");
+var import_core55 = require("@axiom-lattice/core");
 function getStore(context) {
-  return new import_core52.SandboxSkillStore({
+  return new import_core55.SandboxSkillStore({
     workspaceId: context?.workspaceId,
     projectId: context?.projectId
   });
@@ -28407,7 +29037,7 @@ var skillRegistration = {
   async listForExport(tenantId, context) {
     const store2 = getStore(context);
     const skills = await store2.getAllSkills(tenantId, toStoreContext(context));
-    return skills.filter((s) => !(0, import_core52.isBuiltInSkill)(s.id)).map((s) => ({
+    return skills.filter((s) => !(0, import_core55.isBuiltInSkill)(s.id)).map((s) => ({
       _exportId: "",
       data: {
         id: s.id,
@@ -28472,7 +29102,7 @@ var skillRegistration = {
     const insertions = [];
     for (const entity of entities) {
       const id3 = entity.data.id;
-      if ((0, import_core52.isBuiltInSkill)(id3)) continue;
+      if ((0, import_core55.isBuiltInSkill)(id3)) continue;
       if (existingIds.has(id3)) {
         conflicts.push({
           _exportId: entity._exportId,
@@ -28531,9 +29161,9 @@ var skillRegistration = {
 };
 
 // src/export_registrations/agent.registration.ts
-var import_core53 = require("@axiom-lattice/core");
+var import_core56 = require("@axiom-lattice/core");
 function getStore2() {
-  return (0, import_core53.getStoreLattice)("default", "assistant").store;
+  return (0, import_core56.getStoreLattice)("default", "assistant").store;
 }
 var agentRegistration = {
   entityType: "agent",
@@ -28613,9 +29243,9 @@ var agentRegistration = {
 };
 
 // src/export_registrations/database-config.registration.ts
-var import_core54 = require("@axiom-lattice/core");
+var import_core57 = require("@axiom-lattice/core");
 function getStore3() {
-  return (0, import_core54.getStoreLattice)("default", "database").store;
+  return (0, import_core57.getStoreLattice)("default", "database").store;
 }
 var databaseConfigRegistration = {
   entityType: "database_config",
@@ -28695,9 +29325,9 @@ var databaseConfigRegistration = {
 };
 
 // src/export_registrations/metrics-config.registration.ts
-var import_core55 = require("@axiom-lattice/core");
+var import_core58 = require("@axiom-lattice/core");
 function getStore4() {
-  return (0, import_core55.getStoreLattice)("default", "metrics").store;
+  return (0, import_core58.getStoreLattice)("default", "metrics").store;
 }
 var metricsConfigRegistration = {
   entityType: "metrics_config",
@@ -28777,9 +29407,9 @@ var metricsConfigRegistration = {
 };
 
 // src/export_registrations/mcp-config.registration.ts
-var import_core56 = require("@axiom-lattice/core");
+var import_core59 = require("@axiom-lattice/core");
 function getStore5() {
-  return (0, import_core56.getStoreLattice)("default", "mcp").store;
+  return (0, import_core59.getStoreLattice)("default", "mcp").store;
 }
 var mcpConfigRegistration = {
   entityType: "mcp_config",
@@ -28862,9 +29492,9 @@ var mcpConfigRegistration = {
 };
 
 // src/export_registrations/connection.registration.ts
-var import_core57 = require("@axiom-lattice/core");
+var import_core60 = require("@axiom-lattice/core");
 function getStore6() {
-  return (0, import_core57.getStoreLattice)("default", "connection").store;
+  return (0, import_core60.getStoreLattice)("default", "connection").store;
 }
 async function listAllConnections(tenantId) {
   const store2 = getStore6();
@@ -28946,9 +29576,9 @@ var connectionRegistration = {
 };
 
 // src/export_registrations/collection.registration.ts
-var import_core58 = require("@axiom-lattice/core");
+var import_core61 = require("@axiom-lattice/core");
 function getStore7() {
-  return (0, import_core58.getStoreLattice)("default", "collection").store;
+  return (0, import_core61.getStoreLattice)("default", "collection").store;
 }
 var collectionRegistration = {
   entityType: "collection",
@@ -29019,7 +29649,7 @@ var collectionRegistration = {
 };
 
 // src/export_registrations/channel-installation.registration.ts
-var import_core59 = require("@axiom-lattice/core");
+var import_core62 = require("@axiom-lattice/core");
 var import_crypto11 = require("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"]);
@@ -29053,7 +29683,7 @@ function validateImportData(data) {
   };
 }
 function getStore8() {
-  return (0, import_core59.getStoreLattice)("default", "channelInstallation").store;
+  return (0, import_core62.getStoreLattice)("default", "channelInstallation").store;
 }
 function getOverwriteError(tenantId, incomingChannel, existing) {
   if (!existing) return "Channel installation overwrite target must exist";
@@ -29187,9 +29817,9 @@ var channelInstallationRegistration = {
 };
 
 // src/export_registrations/menu.registration.ts
-var import_core60 = require("@axiom-lattice/core");
+var import_core63 = require("@axiom-lattice/core");
 function getStore9() {
-  return (0, import_core60.getStoreLattice)("default", "menu").store;
+  return (0, import_core63.getStoreLattice)("default", "menu").store;
 }
 var menuRegistration = {
   entityType: "menu",
@@ -29267,9 +29897,9 @@ var menuRegistration = {
 };
 
 // src/export_registrations/eval.registration.ts
-var import_core61 = require("@axiom-lattice/core");
+var import_core64 = require("@axiom-lattice/core");
 function getStore10() {
-  return (0, import_core61.getStoreLattice)("default", "eval").store;
+  return (0, import_core64.getStoreLattice)("default", "eval").store;
 }
 var evalRegistration = {
   entityType: "eval",
@@ -29595,7 +30225,7 @@ var evalRegistration = {
 
 // src/export_registrations/index.ts
 function registerAllBuiltinEntities() {
-  const registry = import_core62.ExportableEntityRegistry.getInstance();
+  const registry = import_core65.ExportableEntityRegistry.getInstance();
   registry.register(skillRegistration);
   registry.register(agentRegistration);
   registry.register(databaseConfigRegistration);
@@ -29726,7 +30356,7 @@ function createAuditLoggerMiddleware() {
 }
 
 // src/index.ts
-var import_core84 = require("@axiom-lattice/core");
+var import_core91 = require("@axiom-lattice/core");
 
 // src/swagger.ts
 var import_swagger = __toESM(require("@fastify/swagger"));
@@ -29792,7 +30422,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 
 // src/services/agent_task_consumer.ts
 var import_node_crypto27 = require("crypto");
-var import_core63 = require("@axiom-lattice/core");
+var import_core66 = require("@axiom-lattice/core");
 var import_protocols31 = require("@axiom-lattice/protocols");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
@@ -29812,7 +30442,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       `\u5F00\u59CB\u5904\u7406\u4EFB\u52A1 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
     );
     const scope = (0, import_protocols31.resolveRunScope)(runConfig);
-    const agent = import_core63.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: scope.workspaceId, project_id: scope.projectId, custom_run_config: runConfig });
+    const agent = import_core66.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: scope.workspaceId, project_id: scope.projectId, custom_run_config: runConfig });
     if (callback_event) {
       const callbackEvent = callback_event;
       const messageId = typeof input?.id === "string" && input.id !== "" ? input.id : (0, import_node_crypto27.randomUUID)();
@@ -29833,13 +30463,13 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       const onCompleted = (evt) => {
         if (!belongsToMessage(evt)) return;
         settle(() => {
-          import_core63.eventBus.publish(callbackEvent, {
+          import_core66.eventBus.publish(callbackEvent, {
             success: true,
             state: evt.state
           });
           if (main_thread_id && main_tenant_id) {
             try {
-              const mainAgent = import_core63.agentInstanceManager.getAgent({
+              const mainAgent = import_core66.agentInstanceManager.getAgent({
                 assistant_id: main_assistant_id ?? assistant_id,
                 thread_id: main_thread_id,
                 tenant_id: main_tenant_id,
@@ -29872,7 +30502,7 @@ ${summary}`
       const onInterrupted = (evt) => {
         if (!belongsToMessage(evt)) return;
         settle(() => {
-          import_core63.eventBus.publish(callbackEvent, {
+          import_core66.eventBus.publish(callbackEvent, {
             success: true,
             state: evt.state
           });
@@ -29881,7 +30511,7 @@ ${summary}`
       const onFailed = (evt) => {
         if (!belongsToMessage(evt)) return;
         settle(() => {
-          import_core63.eventBus.publish(callbackEvent, {
+          import_core66.eventBus.publish(callbackEvent, {
             success: false,
             error: evt?.error instanceof Error ? evt.error.message : typeof evt?.error === "string" ? evt.error : "Agent execution failed"
           });
@@ -29896,13 +30526,13 @@ ${summary}`
       agent.subscribe("message:interrupted", onInterrupted);
       agent.subscribe("message:failed", onFailed);
       try {
-        await agent.addMessage({ input: { ...input, id: messageId }, command, custom_run_config: runConfig }, import_core63.QueueMode.STEER);
+        await agent.addMessage({ input: { ...input, id: messageId }, command, custom_run_config: runConfig }, import_core66.QueueMode.STEER);
       } catch (error) {
         dispose();
         throw error;
       }
     } else {
-      await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core63.QueueMode.STEER);
+      await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core66.QueueMode.STEER);
     }
     return true;
   } catch (error) {
@@ -29921,7 +30551,7 @@ ${summary}`
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core63.eventBus.publish(callback_event, {
+      import_core66.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -29958,7 +30588,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core63.eventBus.subscribe(import_core63.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core66.eventBus.subscribe(import_core66.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
     this.startPollingQueue();
     console.log("Agent\u4EFB\u52A1\u6D88\u8D39\u8005\u5DF2\u542F\u52A8\u5E76\u76D1\u542C\u4EFB\u52A1\u4E8B\u4EF6\u548C\u961F\u5217");
   }
@@ -30077,7 +30707,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
     handleAgentTask(taskRequest).catch((error) => {
       console.error("\u5904\u7406Agent\u4EFB\u52A1\u65F6\u53D1\u751F\u672A\u6355\u83B7\u7684\u9519\u8BEF:", error);
       if (taskRequest.callback_event) {
-        import_core63.eventBus.publish(taskRequest.callback_event, {
+        import_core66.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error)
         });
@@ -30092,13 +30722,13 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core85 = require("@axiom-lattice/core");
+var import_core92 = require("@axiom-lattice/core");
 
 // src/channels/ChannelInfrastructure.ts
-var import_core65 = require("@axiom-lattice/core");
+var import_core68 = require("@axiom-lattice/core");
 
 // src/router/MessageRouter.ts
-var import_core64 = require("@axiom-lattice/core");
+var import_core67 = require("@axiom-lattice/core");
 var import_protocols32 = require("@axiom-lattice/protocols");
 var import_crypto12 = require("crypto");
 var BindingNotFoundError = class extends Error {
@@ -30384,7 +31014,7 @@ var MessageRouter = class {
             channel: message.channel,
             adapterChannel: adapter.channel
           }, "Thread resolved by adapter strategy");
-          const threadStore = (0, import_core64.getStoreLattice)("default", "thread").store;
+          const threadStore = (0, import_core67.getStoreLattice)("default", "thread").store;
           try {
             await threadStore.createThread(
               tenantId,
@@ -30421,7 +31051,7 @@ var MessageRouter = class {
           }
         }
         if (!threadId) {
-          const threadStore = (0, import_core64.getStoreLattice)("default", "thread").store;
+          const threadStore = (0, import_core67.getStoreLattice)("default", "thread").store;
           const newThreadId = (0, import_crypto12.randomUUID)();
           console.log({
             event: "dispatch:thread:create",
@@ -30461,7 +31091,7 @@ var MessageRouter = class {
           senderId: message.sender.id,
           contentLength: message.content.text.length
         }, "Dispatching to agent");
-        const agent = import_core64.agentInstanceManager.getAgent({
+        const agent = import_core67.agentInstanceManager.getAgent({
           tenant_id: tenantId,
           assistant_id: agentId,
           thread_id: threadId,
@@ -30734,7 +31364,7 @@ function createChannelInfrastructure(deps) {
       onMessageCommitted: deps.onMessageCommitted ?? (deps.realtime ? (message) => deps.realtime?.messageCreated(message) : void 0),
       onCallbackFailure: (event) => deps.warn("project-room:message-commit-callback-failed", event)
     };
-    deps.adapterRegistry.register(createRoomChannelAdapter(new import_core65.RoomAgentMessageService(writerDeps)));
+    deps.adapterRegistry.register(createRoomChannelAdapter(new import_core68.RoomAgentMessageService(writerDeps)));
   } catch (error) {
     deps.warn("Room channel unavailable", { error: error instanceof Error ? error.message : String(error) });
   }
@@ -30754,11 +31384,168 @@ async function prepareProjectTaskRuntime(runtime, log2) {
   }
 }
 
+// src/services/multiReplicaReadiness.ts
+var import_core69 = require("@axiom-lattice/core");
+var SHARED_STORE_KINDS = ["lease", "outbox", "threadMessageQueue", "task", "taskWorkItem"];
+function storeClassName(kind) {
+  try {
+    return (0, import_core69.getStoreLattice)("default", kind).store.constructor?.name;
+  } catch {
+    return void 0;
+  }
+}
+function warnMultiReplicaReadiness(logger8) {
+  if (typeof process.env.AXIOM_REPLICA_ID !== "string" || process.env.AXIOM_REPLICA_ID.trim() === "") return;
+  for (const kind of SHARED_STORE_KINDS) {
+    const name = storeClassName(kind);
+    if (name === void 0 || !name.startsWith("InMemory")) continue;
+    logger8.warn(`Multi-replica: store '${kind}' is ${name} (not shared); configure a shared store`, {
+      phase: "multi_replica_readiness",
+      store: kind
+    });
+  }
+  if (!process.env.AUTH_TOKEN_SECRET?.trim() && !process.env.JWT_SECRET?.trim()) {
+    logger8.warn(
+      "Multi-replica: AUTH_TOKEN_SECRET/JWT_SECRET unset; console sessions are signed per-process and will not verify across replicas",
+      { phase: "multi_replica_readiness", env: "AUTH_TOKEN_SECRET" }
+    );
+  }
+  if (!process.env.LATTICE_ENCRYPTION_KEY?.trim()) {
+    logger8.warn(
+      "Multi-replica: LATTICE_ENCRYPTION_KEY unset; stored credentials use the shared dev default and may not decrypt across differing keys",
+      { phase: "multi_replica_readiness", env: "LATTICE_ENCRYPTION_KEY" }
+    );
+  }
+  logger8.warn(
+    "Multi-replica: agent run SSE and resume_stream are process-local; route a thread's follow-up runs to the replica streaming it (sticky routing) or share the stream/queue state",
+    { phase: "multi_replica_readiness", feature: "agent-run-sse" }
+  );
+}
+
+// src/services/OutboxRetentionJob.ts
+var HOUR_MS = 60 * 60 * 1e3;
+var DEFAULT_INTERVAL_MS2 = 6 * HOUR_MS;
+var DEFAULT_INITIAL_DELAY_MS2 = 6e4;
+var AXIOM_OUTBOX_RETENTION_HOURS_ENV = "AXIOM_OUTBOX_RETENTION_HOURS";
+var DEFAULT_RETENTION_HOURS = 24;
+function parseRetentionHours(value) {
+  if (value === void 0 || value === null) return DEFAULT_RETENTION_HOURS;
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return DEFAULT_RETENTION_HOURS;
+  const parsed = Number(trimmed);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+var OutboxRetentionJob = class {
+  /** @param deps Outbox slice, logger, and optional retention/interval bounds. */
+  constructor(deps) {
+    this.deps = deps;
+    this.running = false;
+    this.stopped = false;
+  }
+  /** Schedules one delayed sweep plus the recurring interval (both unref'd). */
+  start() {
+    if (this.stopped || this.deps.retentionMs === void 0) return;
+    if (this.initial !== void 0 || this.interval !== void 0) return;
+    this.initial = setTimeout(() => {
+      this.initial = void 0;
+      void this.runOnce();
+    }, this.deps.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS2);
+    this.initial.unref?.();
+    this.interval = setInterval(() => void this.runOnce(), this.deps.intervalMs ?? DEFAULT_INTERVAL_MS2);
+    this.interval.unref?.();
+  }
+  /**
+   * Runs one age-based prune.
+   *
+   * @returns The number of rows removed (0 when disabled, overlapping, or on failure).
+   */
+  async runOnce() {
+    const retentionMs = this.deps.retentionMs;
+    if (this.stopped || retentionMs === void 0 || this.running) return 0;
+    this.running = true;
+    try {
+      const removed = await this.deps.outbox.pruneOlderThan(retentionMs);
+      if (removed > 0) this.deps.log.info("outbox pruned", { removed });
+      return removed;
+    } catch (error) {
+      this.deps.log.warn("outbox prune failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return 0;
+    } finally {
+      this.running = false;
+    }
+  }
+  /** Stops the timers; an in-flight sweep finishes on its own. */
+  stop() {
+    this.stopped = true;
+    if (this.initial !== void 0) {
+      clearTimeout(this.initial);
+      this.initial = void 0;
+    }
+    if (this.interval !== void 0) {
+      clearInterval(this.interval);
+      this.interval = void 0;
+    }
+  }
+};
+function createOutboxRetentionJob(deps) {
+  const retentionMs = deps.retentionMs ?? resolveRetentionMs(process.env[AXIOM_OUTBOX_RETENTION_HOURS_ENV]);
+  return new OutboxRetentionJob({ ...deps, retentionMs });
+}
+function resolveRetentionMs(value) {
+  const hours = parseRetentionHours(value);
+  return hours === void 0 ? void 0 : hours * HOUR_MS;
+}
+
+// src/services/collaboration/roomEventSync.ts
+var ROOM_EVENT_TOPIC = "room-event";
+async function publishRoomEvent(outbox, owner, scope, serialized, sourceKey) {
+  try {
+    await outbox.append({
+      topic: ROOM_EVENT_TOPIC,
+      payload: { scope, serialized, sourceKey },
+      originReplicaId: owner
+    });
+  } catch {
+  }
+}
+function ingestRoomEvent(payload, broker) {
+  const record = payload;
+  const serialized = record?.serialized;
+  if (typeof serialized !== "string" || serialized.length === 0) return false;
+  const sourceKey = record?.sourceKey;
+  if (typeof sourceKey === "string" && sourceKey.length > 0) {
+    return broker.ingestForeignEvent(serialized, sourceKey);
+  }
+  return broker.ingestForeignEvent(serialized);
+}
+
+// src/services/assistantRegistrySync.ts
+var ASSISTANT_CHANGE_EVENTS = ["assistant:created", "assistant:updated", "assistant:deleted"];
+var ASSISTANT_CHANGED_TOPIC = "assistant-changed";
+function bridgeAssistantEvents(subscribe, outbox, owner) {
+  for (const event of ASSISTANT_CHANGE_EVENTS) {
+    subscribe(event, (data) => {
+      const tenantId = data?.tenantId;
+      if (typeof tenantId !== "string" || tenantId.length === 0) return;
+      void outbox.append({ topic: ASSISTANT_CHANGED_TOPIC, payload: { tenantId }, originReplicaId: owner }).catch(() => void 0);
+    });
+  }
+}
+async function handleAssistantChanged(payload, reload) {
+  const tenantId = payload?.tenantId;
+  if (typeof tenantId !== "string" || tenantId.length === 0) return;
+  await reload(tenantId);
+}
+
 // src/index.ts
 var import_protocols40 = require("@axiom-lattice/protocols");
 init_TopCallerRecovery();
 init_OrphanRecoveryRuntime();
 init_RecoveryCallerDeps();
+init_taskRunLiveness();
 process.on("unhandledRejection", (reason, promise) => {
   console.error("\u672A\u5904\u7406\u7684Promise\u62D2\u7EDD:", reason);
 });
@@ -30772,11 +31559,11 @@ var DEFAULT_LOGGER_CONFIG = {
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger7 = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core85.loggerLatticeManager.hasLattice("default")) {
-    import_core85.loggerLatticeManager.removeLattice("default");
+  if (import_core92.loggerLatticeManager.hasLattice("default")) {
+    import_core92.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core85.registerLoggerLattice)("default", config);
-  return (0, import_core85.getLoggerLattice)("default");
+  (0, import_core92.registerLoggerLattice)("default", config);
+  return (0, import_core92.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -30837,7 +31624,7 @@ app.register(import_cors.default, {
   origin: true,
   methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"],
   allowedHeaders: "*",
-  exposedHeaders: ["Content-Type", "Content-Disposition"],
+  exposedHeaders: ["Content-Type", "Content-Disposition", import_protocols40.REPLICA_HEADER, import_protocols40.AFFINITY_ECHO_HEADER],
   credentials: true
 });
 app.register(import_sensible.default);
@@ -30873,7 +31660,7 @@ app.setErrorHandler((error, request, reply) => {
 });
 function getConfiguredSandboxProvider() {
   const sandboxProviderType = process.env.SANDBOX_PROVIDER_TYPE || "microsandbox-remote";
-  return (0, import_core85.createSandboxProvider)({
+  return (0, import_core92.createSandboxProvider)({
     type: sandboxProviderType,
     remoteBaseURL: process.env.SANDBOX_BASE_URL,
     microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
@@ -30889,7 +31676,7 @@ function getConfiguredSandboxProvider() {
 }
 async function restoreMcpConnections() {
   try {
-    const storeLattice = (0, import_core85.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core92.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     if (!store2) {
       logger7.info("MCP store not configured, skipping connection restoration");
@@ -30900,25 +31687,16 @@ async function restoreMcpConnections() {
     );
     if (configs.length === 0) return;
     logger7.info(`Restoring ${configs.length} MCP server connections...`);
-    for (const config of configs) {
-      try {
-        const connection = (0, import_core85.convertToConnection)(config.config);
-        import_core85.mcpManager.registerServer(config.tenantId, config.key, connection, {
-          timeoutMs: config.config.timeout,
-          maxAttempts: config.config.retryAttempts,
-          selectedTools: config.selectedTools
-        });
-      } catch (err) {
-        logger7.warn(`Failed to prepare MCP server "${config.tenantId}/${config.key}"`, { error: err });
-      }
-    }
-    await import_core85.mcpManager.connectAll();
+    const deps = {
+      store: store2,
+      manager: import_core92.mcpManager,
+      convertToConnection: import_core92.convertToConnection
+    };
     const results = await Promise.allSettled(
       configs.map(
-        (config) => import_core85.mcpManager.registerToolsToToolLattice(
-          config.tenantId,
-          config.key,
-          config.selectedTools
+        (config) => reconcileMcpConfigChange(
+          { tenantId: config.tenantId, serverKey: config.key },
+          deps
         )
       )
     );
@@ -30926,7 +31704,7 @@ async function restoreMcpConnections() {
       if (result.status === "rejected") {
         const config = configs[index];
         logger7.warn(
-          `Failed to register tools for MCP server "${config.tenantId}/${config.key}"`,
+          `Failed to restore MCP server "${config.tenantId}/${config.key}"`,
           { error: result.reason }
         );
       }
@@ -30953,9 +31731,9 @@ var start = async (config) => {
     let projectRoomRealtimeRuntime;
     if (projectRoomRealtimeMode === "single-gateway") {
       projectRoomRealtimeRuntime = createProjectRoomRealtimeRuntime({
-        tasks: (0, import_core85.getStoreLattice)("default", "task").store,
-        rooms: (0, import_core85.getStoreLattice)("default", "projectRoom").store,
-        memberships: (0, import_core85.getStoreLattice)("default", "projectBotMembership").store,
+        tasks: (0, import_core92.getStoreLattice)("default", "task").store,
+        rooms: (0, import_core92.getStoreLattice)("default", "projectRoom").store,
+        memberships: (0, import_core92.getStoreLattice)("default", "projectBotMembership").store,
         log: { warn: (message, context) => logger7.warn(message, context) }
       });
     }
@@ -30969,7 +31747,7 @@ var start = async (config) => {
       const infrastructure = createChannelInfrastructure({
         adapterRegistry,
         getStore: ((kind) => getStore11("default", kind).store),
-        trustedDispatcher: (0, import_core85.createTrustedAgentMessageDispatcher)((scope) => import_core85.agentInstanceManager.getAgent(scope)),
+        trustedDispatcher: (0, import_core92.createTrustedAgentMessageDispatcher)((scope) => import_core92.agentInstanceManager.getAgent(scope)),
         middlewares: [
           createDeduplicationMiddleware(),
           createRateLimitMiddleware(),
@@ -30980,7 +31758,7 @@ var start = async (config) => {
       });
       const bindingStore = infrastructure.bindingRegistry;
       const installationStore = infrastructure.installationStore;
-      (0, import_core84.setBindingRegistry)(bindingStore);
+      (0, import_core91.setBindingRegistry)(bindingStore);
       const router = infrastructure.router;
       app.addHook("onClose", async () => router.dispose());
       channelDeps = {
@@ -30996,10 +31774,10 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    (0, import_core84.setEvalRunService)(evalRunner);
+    (0, import_core91.setEvalRunService)(evalRunner);
     try {
-      const menuStore = (0, import_core85.getStoreLattice)("default", "menu").store;
-      (0, import_core84.setMenuRegistry)(menuStore);
+      const menuStore = (0, import_core92.getStoreLattice)("default", "menu").store;
+      (0, import_core91.setMenuRegistry)(menuStore);
       logger7.info("Menu registry initialized");
     } catch {
     }
@@ -31016,10 +31794,10 @@ var start = async (config) => {
       const { A2AAuthService: A2AAuthService2, parseEnvKeys: parseEnvKeys2 } = await Promise.resolve().then(() => (init_A2AAuthService(), A2AAuthService_exports));
       const { registerA2AStandardRoutes: registerA2AStandardRoutes2 } = await Promise.resolve().then(() => (init_a2a_standard(), a2a_standard_exports));
       const a2a = await Promise.resolve().then(() => (init_a2a(), a2a_exports));
-      const a2aKeyStore = (0, import_core85.getStoreLattice)("default", "a2aApiKey").store;
-      const assistantStore = (0, import_core85.getStoreLattice)("default", "assistant").store;
-      const projectStore = (0, import_core85.getStoreLattice)("default", "project").store;
-      const taskStore = (0, import_core85.getStoreLattice)("default", "task").store;
+      const a2aKeyStore = (0, import_core92.getStoreLattice)("default", "a2aApiKey").store;
+      const assistantStore = (0, import_core92.getStoreLattice)("default", "assistant").store;
+      const projectStore = (0, import_core92.getStoreLattice)("default", "project").store;
+      const taskStore = (0, import_core92.getStoreLattice)("default", "task").store;
       const authService = new A2AAuthService2({
         keyStore: a2aKeyStore,
         assistantStore,
@@ -31058,8 +31836,8 @@ var start = async (config) => {
       const { CollectionService: CollectionService2 } = await Promise.resolve().then(() => (init_collection_service(), collection_service_exports));
       openLattice2.register(createKbProvider2(new CollectionService2()));
       openLattice2.register(createOpenSandboxProvider2());
-      const threadStore = (0, import_core85.getStoreLattice)("default", "thread").store;
-      const assistantStore = (0, import_core85.getStoreLattice)("default", "assistant").store;
+      const threadStore = (0, import_core92.getStoreLattice)("default", "thread").store;
+      const assistantStore = (0, import_core92.getStoreLattice)("default", "assistant").store;
       openLattice2.register(
         createAgentProvider2({
           threadStore,
@@ -31082,18 +31860,29 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    if (!import_core85.sandboxLatticeManager.hasLattice("default")) {
-      import_core85.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
+    try {
+      const { registerGatewaySandboxOpenCredentialProvider: registerGatewaySandboxOpenCredentialProvider2 } = await Promise.resolve().then(() => (init_sandboxOpenCredentialProvider(), sandboxOpenCredentialProvider_exports));
+      registerGatewaySandboxOpenCredentialProvider2((error) => {
+        logger7.warn("sandbox open-credential provider failed", { error });
+      });
+      logger7.info("Sandbox open-credential provider registered");
+    } catch (err) {
+      logger7.warn("Sandbox open-credential provider unavailable", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    if (!import_core92.sandboxLatticeManager.hasLattice("default")) {
+      import_core92.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
       logger7.info("Registered sandbox manager from env configuration");
     }
     try {
       const { ResourceController: ResourceController2 } = await Promise.resolve().then(() => (init_resources(), resources_exports));
-      const sharedResourceStore = (0, import_core85.getStoreLattice)("default", "sharedResource").store;
-      const cache = new import_core85.TokenCache();
+      const sharedResourceStore = (0, import_core92.getStoreLattice)("default", "sharedResource").store;
+      const cache2 = new import_core92.TokenCache();
       const resourceController = new ResourceController2({
         store: sharedResourceStore,
-        sandboxManager: import_core85.sandboxLatticeManager,
-        cache,
+        sandboxManager: import_core92.sandboxLatticeManager,
+        cache: cache2,
         logger: logger7
       });
       registerResourceRoutes(app, resourceController);
@@ -31117,30 +31906,98 @@ var start = async (config) => {
       }
     }
     const target_port = config?.port || Number(process.env.PORT) || 4001;
-    if (routes.projectTaskRuntime) {
-      await prepareProjectTaskRuntime(routes.projectTaskRuntime, logger7);
+    (0, import_core92.configureCoordinationLeaseStore)((0, import_core92.getStoreLattice)("default", "lease").store);
+    const outboxStore = (0, import_core92.getStoreLattice)("default", "outbox").store;
+    import_core92.taskLifecycleNotifier.setOutbox(outboxStore);
+    import_core92.projectTaskAdmissionNotifier.setOutbox(outboxStore);
+    (0, import_core92.configurePluginCatalogSync)({ outbox: outboxStore, owner: (0, import_core92.getReplicaId)() });
+    bridgeAssistantEvents(
+      (event, cb) => import_core92.eventBus.subscribe(event, cb),
+      outboxStore,
+      (0, import_core92.getReplicaId)()
+    );
+    if (projectRoomRealtimeRuntime) {
+      projectRoomRealtimeRuntime.broker.setBroadcastHook((scope, serialized, sourceKey) => {
+        void publishRoomEvent(outboxStore, (0, import_core92.getReplicaId)(), scope, serialized, sourceKey);
+      });
     }
-    if (process.env.AXIOM_TASK_ORPHAN_RECOVERY === "true") {
-      try {
-        const { createOrphanRecoveryRuntime: createOrphanRecoveryRuntime2 } = await Promise.resolve().then(() => (init_OrphanRecoveryRuntime(), OrphanRecoveryRuntime_exports));
-        const { createRecoveryCallerDeps: createRecoveryCallerDeps2 } = await Promise.resolve().then(() => (init_RecoveryCallerDeps(), RecoveryCallerDeps_exports));
-        const taskStore = (0, import_core85.getStoreLattice)("default", "task").store;
-        const workItemStore = (0, import_core85.getStoreLattice)("default", "taskWorkItem").store;
-        const tenantStore = (0, import_core85.getStoreLattice)("default", "tenant").store;
-        const runtime = createOrphanRecoveryRuntime2({
-          taskStore,
-          workItemStore,
-          tenantStore,
-          ...createRecoveryCallerDeps2(),
-          log: logger7
-        });
-        await runtime.recoverAll();
-      } catch (err) {
-        logger7.warn("Task orphan recovery failed", { error: err instanceof Error ? err.message : String(err) });
+    const outboxPoller = new import_core92.OutboxPoller({
+      store: outboxStore,
+      owner: (0, import_core92.getReplicaId)(),
+      handlers: {
+        "task-lifecycle": (payload) => import_core92.taskLifecycleNotifier.deliverFromOutbox(payload),
+        "project-task-admission": (payload) => import_core92.projectTaskAdmissionNotifier.deliverFromOutbox(payload),
+        [ROOM_EVENT_TOPIC]: async (payload) => {
+          if (projectRoomRealtimeRuntime) ingestRoomEvent(payload, projectRoomRealtimeRuntime.broker);
+        },
+        "assistant-changed": (payload) => handleAssistantChanged(payload, (tenantId) => import_core92.agentLatticeManager.initializeStoredAssistantsForTenant(tenantId)),
+        [MCP_CONFIG_CHANGED_TOPIC]: (payload) => reconcileMcpConfigChange(payload, {
+          store: (0, import_core92.getStoreLattice)("default", "mcp").store,
+          manager: import_core92.mcpManager,
+          convertToConnection: import_core92.convertToConnection
+        }),
+        [import_core92.PLUGIN_CATALOG_CHANGED_TOPIC]: async (payload) => {
+          const tenantId = payload?.tenantId;
+          if (typeof tenantId === "string" && tenantId.length > 0) (0, import_core92.getSandboxPluginCatalog)().invalidate(tenantId);
+        }
+      },
+      log: logger7
+    });
+    try {
+      await outboxPoller.start();
+    } catch (err) {
+      logger7.warn("Outbox poller failed to start", { error: err instanceof Error ? err.message : String(err) });
+    }
+    const leaseStore = (0, import_core92.getStoreLattice)("default", "lease").store;
+    if (leaseStore.constructor?.name === "InMemoryLeaseStore") {
+      logger7.warn(
+        "Startup recovery leader gate uses a non-distributed lease store (per-process only); configure a shared 'lease' store for multi-replica deployments",
+        { phase: "startup_recovery" }
+      );
+    }
+    warnMultiReplicaReadiness(logger7);
+    const startup = await (0, import_core92.runAsLeader)(leaseStore, "startup-recovery", async () => {
+      if (routes.projectTaskRuntime) {
+        await prepareProjectTaskRuntime(routes.projectTaskRuntime, logger7);
       }
+      if (process.env.AXIOM_TASK_ORPHAN_RECOVERY === "true") {
+        try {
+          const { createOrphanRecoveryRuntime: createOrphanRecoveryRuntime2 } = await Promise.resolve().then(() => (init_OrphanRecoveryRuntime(), OrphanRecoveryRuntime_exports));
+          const { createRecoveryCallerDeps: createRecoveryCallerDeps2 } = await Promise.resolve().then(() => (init_RecoveryCallerDeps(), RecoveryCallerDeps_exports));
+          const runtime = createOrphanRecoveryRuntime2({
+            taskStore: (0, import_core92.getStoreLattice)("default", "task").store,
+            workItemStore: (0, import_core92.getStoreLattice)("default", "taskWorkItem").store,
+            tenantStore: (0, import_core92.getStoreLattice)("default", "tenant").store,
+            ...createRecoveryCallerDeps2(),
+            log: logger7
+          });
+          await runtime.recoverAll();
+        } catch (err) {
+          logger7.warn("Task orphan recovery failed", { error: err instanceof Error ? err.message : String(err) });
+        }
+      }
+      if (import_core92.scheduleLatticeManager.hasLattice("default")) {
+        try {
+          const restored = await import_core92.scheduleLatticeManager.getScheduleLattice("default").restore();
+          logger7.info("Scheduled tasks restored", { phase: "startup_recovery", restored });
+        } catch (err) {
+          logger7.warn("Scheduled task restore failed", {
+            phase: "startup_recovery",
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+    }, { hold: true, ttlMs: 5 * 6e4 });
+    if (!startup.ran) {
+      logger7.info("Startup recovery skipped (another replica leads)", { phase: "startup_recovery" });
     }
     await app.listen({ port: target_port, host: "0.0.0.0" });
     logger7.info(`Lattice Gateway is running on port: ${target_port}`);
+    const outboxRetention = createOutboxRetentionJob({
+      outbox: outboxStore,
+      log: logger7
+    });
+    outboxRetention.start();
     const queueServiceConfig = config?.queueServiceConfig;
     if (queueServiceConfig) {
       setQueueServiceType(queueServiceConfig.type);
@@ -31167,8 +32024,13 @@ var LatticeGateway = {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LatticeGateway,
+  ProjectRoomEventBroker,
+  ROOM_EVENT_TOPIC,
   createOrphanRecoveryRuntime,
   createRecoveryCallerDeps,
+  createTaskRunLiveness,
+  ingestRoomEvent,
+  publishRoomEvent,
   recoverTask,
   recoverTopCaller,
   resolveTopCaller,