@axiom-lattice/gateway 4.6.1 → 4.8.0

package/dist/index.js

@@ -874,6 +874,44 @@ var init_wechat_client = __esm({
   }
 });
 
+// src/services/collaboration/projectTaskScope.ts
+function isProjectLifecycleTask(task) {
+  const source = task.context?.source;
+  return typeof task.workspaceId === "string" && task.workspaceId.length > 0 && typeof task.projectId === "string" && task.projectId.length > 0 && (source === "project_room" || source === "project_task" || source === "user");
+}
+function isRosterExemptProject(project) {
+  return project?.kind === "public";
+}
+function resolveTaskOwnerMembership(task, project, room, membership) {
+  const active = membership && membership.status === "active" && membership.tenantId === task.tenantId && membership.workspaceId === task.workspaceId && membership.projectId === task.projectId && membership.assistantId === task.ownerId && membership.roomId === room.id;
+  if (active) return membership;
+  if (!isRosterExemptProject(project)) return void 0;
+  return syntheticPublicProjectOwnerMembership(task, room);
+}
+function syntheticPublicProjectOwnerMembership(task, room) {
+  const threadId = typeof task.context?.thread_id === "string" && task.context.thread_id.length > 0 ? task.context.thread_id : task.ownerId;
+  return {
+    id: `public-project-owner:${task.projectId}:${task.ownerId}`,
+    tenantId: task.tenantId,
+    workspaceId: task.workspaceId,
+    projectId: task.projectId,
+    roomId: room.id,
+    assistantId: task.ownerId,
+    role: "specialist",
+    title: task.ownerId,
+    mentionName: task.ownerId,
+    status: "active",
+    roomThreadId: threadId,
+    joinedAt: task.createdAt,
+    updatedAt: task.updatedAt
+  };
+}
+var init_projectTaskScope = __esm({
+  "src/services/collaboration/projectTaskScope.ts"() {
+    "use strict";
+  }
+});
+
 // src/services/files/task-file-refs.ts
 function formatFileRefsSection(refs) {
   const lines = refs.map((ref) => {
@@ -889,6 +927,336 @@ var init_task_file_refs = __esm({
   }
 });
 
+// src/services/collaboration/TopCallerRecovery.ts
+function hasPendingInterrupts(state) {
+  return (state.tasks ?? []).some((t2) => (t2.interrupts?.length ?? 0) > 0);
+}
+function pendingTaskCalls(state) {
+  const messages = state.values?.messages ?? [];
+  const resolved = new Set(
+    messages.filter((m) => m.tool_call_id).map((m) => m.tool_call_id)
+  );
+  const calls = [];
+  for (const m of messages) {
+    const typed = m;
+    if (typeof typed.getType !== "function" || typed.getType() !== "ai") continue;
+    const toolCalls = m.tool_calls;
+    if (!Array.isArray(toolCalls)) continue;
+    for (const c2 of toolCalls) {
+      if (c2.name !== "task" || !c2.id || resolved.has(c2.id)) continue;
+      const taskId = typeof c2.args?.taskId === "string" ? c2.args.taskId : void 0;
+      calls.push({ id: c2.id, ...taskId ? { taskId } : {} });
+    }
+  }
+  return calls;
+}
+function outcome(task) {
+  if (task.status === "completed") {
+    return JSON.stringify({ success: true, taskId: task.id, result: task.result ?? "" });
+  }
+  if (task.status === "failed") {
+    return JSON.stringify({ success: false, code: "TASK_FAILED", retryable: false, taskId: task.id, error: task.failureReason ?? "" });
+  }
+  return JSON.stringify({
+    success: false,
+    code: "TASK_INTERRUPTED",
+    retryable: false,
+    taskId: task.id,
+    error: "Run ended before completion; the task is interrupted and awaiting a decision."
+  });
+}
+async function backfillTopCallerGroup(tasks, top, deps) {
+  const registry = deps.registry ?? import_core70.taskRunRegistry;
+  const results = [];
+  const eligible = [];
+  for (const task of tasks) {
+    if (!task.context?.caller_thread_id) {
+      results.push({ id: task.id, reason: "skipped:no_caller_link" });
+      continue;
+    }
+    if (registry.isLive(task.id) || deps.isTaskLive && await deps.isTaskLive(task)) {
+      results.push({ id: task.id, reason: "skipped:live" });
+      continue;
+    }
+    eligible.push(task);
+  }
+  if (eligible.length === 0) return results;
+  const target = await deps.callerFor(top, eligible[0].tenantId);
+  if (!target) {
+    return [...results, ...eligible.map((task) => ({ id: task.id, reason: "skipped:no_caller_client" }))];
+  }
+  const state = await target.client.getState(target.config);
+  if (hasPendingInterrupts(state)) {
+    return [...results, ...eligible.map((task) => ({ id: task.id, reason: "skipped:hitl" }))];
+  }
+  const nodeName = (state.tasks ?? [])[0]?.name;
+  if (!nodeName) {
+    return [...results, ...eligible.map((task) => ({ id: task.id, reason: "skipped:no_pending_node" }))];
+  }
+  const calls = pendingTaskCalls(state);
+  const matched = [];
+  for (const task of eligible) {
+    const call = calls.find((candidate) => candidate.taskId === task.id);
+    if (!call) {
+      results.push({ id: task.id, reason: "skipped:no_pending_task_call" });
+      continue;
+    }
+    matched.push({ task, call });
+  }
+  if (matched.length === 0) return results;
+  await target.client.updateState(target.config, {
+    messages: matched.map(({ task, call }) => new import_messages.ToolMessage({ content: outcome(task), tool_call_id: call.id, name: "task" }))
+  }, nodeName);
+  await deps.resume(target.client, target.config, target.agent);
+  return [...results, ...matched.map(({ task }) => ({ id: task.id, reason: "recovered" }))];
+}
+async function recoverTopCaller(task, top, deps) {
+  if (!task.context?.caller_thread_id) return "skipped:no_caller_link";
+  if (task.context.caller_thread_id !== top.threadId) return "skipped:middle";
+  const [first] = await backfillTopCallerGroup([task], top, deps);
+  return first?.reason ?? "skipped:no_pending_task_call";
+}
+async function recoverTask(task, deps) {
+  if (task.status !== "in_progress") {
+    return { kind: "skipped", reason: "not_in_progress" };
+  }
+  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_core70.reconcileStaleTaskRuns)({
+    tasks: [task],
+    actor: "system:on-demand-recovery",
+    lifecycle: deps.lifecycle,
+    ...deps.registry ? { registry: deps.registry } : {},
+    ...deps.isTaskLive ? { isTaskLive: deps.isTaskLive } : {}
+  });
+  const converged = convergedTasks[0];
+  if (!converged) {
+    return { kind: "skipped", reason: "convergence_failed" };
+  }
+  const top = resolveTopCaller(converged, deps.orphans ?? [converged]);
+  if (!top) {
+    return { kind: "skipped", reason: "no_top_caller" };
+  }
+  if (converged.context?.caller_thread_id !== top.threadId) {
+    return { kind: "skipped", reason: "middle" };
+  }
+  const reason = await recoverTopCaller(converged, top, {
+    callerFor: deps.callerFor,
+    resume: deps.resume,
+    ...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" };
+  return { kind: "skipped", reason: reason.replace(/^skipped:/, "") };
+}
+function resolveTopCaller(task, orphans) {
+  const tenantId = task.tenantId;
+  const runThreadToTask = new Map(
+    orphans.map((orphan) => [`${orphan.tenantId}:${orphan.context?.thread_id}`, orphan])
+  );
+  let threadId = task.context?.caller_thread_id;
+  let assistantId = task.context?.caller_assistant_id;
+  const seen = /* @__PURE__ */ new Set();
+  while (threadId) {
+    const scopeKey3 = `${tenantId}:${threadId}`;
+    if (!runThreadToTask.has(scopeKey3) || seen.has(scopeKey3)) break;
+    seen.add(scopeKey3);
+    const parent = runThreadToTask.get(scopeKey3);
+    threadId = parent.context?.caller_thread_id;
+    assistantId = parent.context?.caller_assistant_id;
+  }
+  return threadId ? { threadId, ...assistantId ? { assistantId } : {} } : void 0;
+}
+async function runOrphanRecovery(deps) {
+  let convergedTasks;
+  try {
+    ({ convergedTasks } = await deps.reconcile());
+  } catch (error) {
+    deps.log.warn("Task orphan recovery reconcile failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return { recovered: [], skipped: ["reconcile:error"] };
+  }
+  const orphans = convergedTasks;
+  const recovered = [];
+  const skipped = [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const task of orphans) {
+    const top = resolveTopCaller(task, orphans);
+    if (!top) {
+      skipped.push(`${task.id}:skipped:no_top_caller`);
+      continue;
+    }
+    if (task.context?.caller_thread_id !== top.threadId) {
+      skipped.push(`${task.id}:skipped:middle`);
+      continue;
+    }
+    const key = `${task.tenantId}:${top.threadId}`;
+    const group = groups.get(key);
+    if (group) group.tasks.push(task);
+    else groups.set(key, { top, tasks: [task] });
+  }
+  for (const { top, tasks } of groups.values()) {
+    try {
+      const results = await backfillTopCallerGroup(tasks, top, {
+        callerFor: deps.callerFor,
+        resume: deps.resume,
+        ...deps.isTaskLive ? { isTaskLive: deps.isTaskLive } : {}
+      });
+      for (const { id: id3, reason } of results) {
+        (reason === "recovered" ? recovered : skipped).push(`${id3}:${reason}`);
+      }
+    } catch (error) {
+      for (const task of tasks) skipped.push(`${task.id}:error`);
+      deps.log.warn("Task orphan recovery group failed", {
+        threadId: top.threadId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  deps.log.info("Task orphan recovery complete", { recovered, skipped });
+  return { recovered, skipped };
+}
+var import_messages, import_core70;
+var init_TopCallerRecovery = __esm({
+  "src/services/collaboration/TopCallerRecovery.ts"() {
+    "use strict";
+    import_messages = require("@langchain/core/messages");
+    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");
+  }
+});
+
+// src/services/collaboration/OrphanRecoveryRuntime.ts
+var OrphanRecoveryRuntime_exports = {};
+__export(OrphanRecoveryRuntime_exports, {
+  createOrphanRecoveryRuntime: () => createOrphanRecoveryRuntime
+});
+function createOrphanRecoveryRuntime(deps) {
+  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_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),
+          ...isTaskLive ? { isTaskLive } : {}
+        }),
+        callerFor: deps.callerFor,
+        resume: deps.resume,
+        ...isTaskLive ? { isTaskLive } : {},
+        log: deps.log
+      });
+    },
+    async recoverTask(input) {
+      const task = await deps.taskStore.getById(input.tenantId, input.taskId);
+      if (!task) return { kind: "skipped", reason: "not_found" };
+      if (isProjectLifecycleTask(task)) {
+        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_core72.taskRunRegistry,
+        orphans,
+        callerFor: deps.callerFor,
+        resume: deps.resume,
+        ...isTaskLive ? { isTaskLive } : {}
+      });
+    }
+  };
+}
+var import_core72;
+var init_OrphanRecoveryRuntime = __esm({
+  "src/services/collaboration/OrphanRecoveryRuntime.ts"() {
+    "use strict";
+    import_core72 = require("@axiom-lattice/core");
+    init_TopCallerRecovery();
+    init_projectTaskScope();
+    init_taskRunLiveness();
+  }
+});
+
+// src/services/collaboration/RecoveryCallerDeps.ts
+var RecoveryCallerDeps_exports = {};
+__export(RecoveryCallerDeps_exports, {
+  createRecoveryCallerDeps: () => createRecoveryCallerDeps
+});
+function createRecoveryCallerDeps() {
+  return {
+    callerFor: async (top, tenantId) => {
+      if (!top.assistantId) return void 0;
+      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_core73.agentInstanceManager.getAgent({ assistant_id: top.assistantId, thread_id: top.threadId, tenant_id: tenantId });
+      } catch {
+      }
+      return agent ? { client, config, agent } : { client, config };
+    },
+    resume: async (client, config, agent) => {
+      if (agent && typeof agent.resumeTask === "function") {
+        try {
+          await agent.resumeTask();
+          return;
+        } catch {
+        }
+      }
+      await client.invoke(null, config);
+    }
+  };
+}
+var import_core73;
+var init_RecoveryCallerDeps = __esm({
+  "src/services/collaboration/RecoveryCallerDeps.ts"() {
+    "use strict";
+    import_core73 = require("@axiom-lattice/core");
+  }
+});
+
 // src/channels/wechat/context-store.ts
 function makeKey(installationId, senderId) {
   return `${installationId}::${senderId}`;
@@ -1179,11 +1547,11 @@ function devModeDefaults() {
   const projectId = process.env[DEFAULT_PROJECT_ENV] || void 0;
   return { tenantId, projectId };
 }
-var import_protocols33, A2AAuthError, DEFAULT_TENANT_ENV, DEFAULT_TENANT_ID, DEFAULT_PROJECT_ENV, BEARER_SCHEME_RE, A2AAuthService;
+var import_protocols34, A2AAuthError, DEFAULT_TENANT_ENV, DEFAULT_TENANT_ID, DEFAULT_PROJECT_ENV, BEARER_SCHEME_RE, A2AAuthService;
 var init_A2AAuthService = __esm({
   "src/services/a2a/A2AAuthService.ts"() {
     "use strict";
-    import_protocols33 = require("@axiom-lattice/protocols");
+    import_protocols34 = require("@axiom-lattice/protocols");
     A2AAuthError = class extends Error {
       constructor(message, statusCode) {
         super(message);
@@ -1238,7 +1606,7 @@ var init_A2AAuthService = __esm({
         const entry = merged.get(token);
         if (!entry) return { authenticated: false };
         const hasExplicitGrants = Array.isArray(entry.grants) && entry.grants.length > 0;
-        const agentGrant = (0, import_protocols33.effectiveGrants)(entry).find((g) => g.domain === "agent");
+        const agentGrant = (0, import_protocols34.effectiveGrants)(entry).find((g) => g.domain === "agent");
         const assistantIds = hasExplicitGrants ? agentGrant?.items ?? [] : entry.assistantIds;
         return {
           authenticated: true,
@@ -1475,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_core66, 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_core66 = require("@axiom-lattice/core");
+    import_core74 = require("@axiom-lattice/core");
     TASK_STATUS_TO_A2A_STATE = {
       pending: "submitted",
       in_progress: "working",
@@ -1507,7 +1875,7 @@ var init_A2ATaskStoreAdapter = __esm({
         this.workItemStore = options.workItemStore;
         this.lifecycle = options.lifecycle;
         this.scope = options.scope;
-        this.runBridge = (0, import_core66.createTaskRunBridge)({
+        this.runBridge = (0, import_core74.createTaskRunBridge)({
           lifecycle: this.lifecycle,
           taskStore: this.taskStore,
           workItemStore: this.workItemStore
@@ -1858,13 +2226,13 @@ 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_core67, import_protocols34, _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_core67 = require("@axiom-lattice/core");
-    import_protocols34 = require("@axiom-lattice/protocols");
+    import_core75 = require("@axiom-lattice/core");
+    import_protocols35 = require("@axiom-lattice/protocols");
     init_a2aFileRefs();
     init_task_file_refs();
     _AxiomAgentExecutor = class _AxiomAgentExecutor {
@@ -1897,16 +2265,31 @@ var init_AxiomAgentExecutor = __esm({
           status: { state: "working", timestamp: isoNow() },
           metadata: { threadId, dependencies, inputFiles }
         });
-        const publishFailed = (err) => {
-          bus.publish({
-            kind: "status-update",
-            taskId: ctx.taskId,
-            contextId: ctx.contextId,
+        const failTask = async (baseTask, err) => {
+          const failedTask = {
+            ...baseTask,
             status: {
               state: "failed",
               message: agentMessage(err instanceof Error ? err.message : String(err)),
               timestamp: isoNow()
-            },
+            }
+          };
+          if (this.taskStore) {
+            try {
+              await this.taskStore.save(failedTask);
+            } catch (saveError) {
+              console.warn({
+                event: "a2a:settle:save_failed",
+                taskId: ctx.taskId,
+                error: saveError instanceof Error ? saveError.message : String(saveError)
+              });
+            }
+          }
+          bus.publish({
+            kind: "status-update",
+            taskId: ctx.taskId,
+            contextId: ctx.contextId,
+            status: failedTask.status,
             final: true
           });
         };
@@ -1914,7 +2297,7 @@ var init_AxiomAgentExecutor = __esm({
           if (!this.taskStore) {
             const initialTask2 = createTask([]);
             bus.publish(initialTask2);
-            publishFailed(new Error("A2A execution requires a canonical task store"));
+            await failTask(initialTask2, new Error("A2A execution requires a canonical task store"));
             return;
           }
           const governed = this.hasGovernedTaskCapability();
@@ -1938,14 +2321,14 @@ var init_AxiomAgentExecutor = __esm({
             const initialTask2 = createTask([]);
             if (this.taskStore) await this.taskStore.save(initialTask2);
             bus.publish(initialTask2);
-            publishFailed(err);
+            await failTask(initialTask2, err);
             return;
           }
           const initialTask = createTask(inputFiles);
           await this.taskStore.save(initialTask);
           bus.publish(initialTask);
           try {
-            const agent = import_core67.agentInstanceManager.getAgent(this.agentParams(threadId));
+            const agent = import_core75.agentInstanceManager.getAgent(this.agentParams(threadId));
             const requestText = inputFiles.length > 0 ? `${text}
 
 ${formatFileRefsSection(inputFiles)}` : text;
@@ -1963,7 +2346,7 @@ ${formatFileRefsSection(inputFiles)}` : text;
               custom_run_config: { taskId: ctx.taskId, execution: { taskId: ctx.taskId } }
             });
             const stream = agent.chunkStream(messageId, [
-              import_protocols34.MessageChunkTypes.MESSAGE_COMPLETED
+              import_protocols35.MessageChunkTypes.MESSAGE_COMPLETED
             ]);
             let outputText = "";
             let interrupted = false;
@@ -1971,14 +2354,14 @@ ${formatFileRefsSection(inputFiles)}` : text;
               if (execution.canceled) return;
               const chunkType = chunk.type;
               const chunkText = chunk.data?.content ?? "";
-              if (chunkType === import_protocols34.MessageChunkTypes.INTERRUPT) {
+              if (chunkType === import_protocols35.MessageChunkTypes.INTERRUPT) {
                 interrupted = true;
                 break;
               }
-              if (chunkType === import_protocols34.MessageChunkTypes.AI && chunkText) {
+              if (chunkType === import_protocols35.MessageChunkTypes.AI && chunkText) {
                 outputText += chunkText;
               }
-              if (chunkType === import_protocols34.MessageChunkTypes.AI || chunkType === import_protocols34.MessageChunkTypes.TOOL) {
+              if (chunkType === import_protocols35.MessageChunkTypes.AI || chunkType === import_protocols35.MessageChunkTypes.TOOL) {
                 if (chunkText) {
                   bus.publish({
                     kind: "status-update",
@@ -2081,19 +2464,12 @@ ${formatFileRefsSection(inputFiles)}` : text;
               });
               return;
             }
-            bus.publish({
-              kind: "status-update",
-              taskId: ctx.taskId,
-              contextId: ctx.contextId,
-              status: {
-                state: "failed",
-                message: agentMessage("Agent did not complete governed task lifecycle"),
-                timestamp: isoNow()
-              },
-              final: true
-            });
+            await failTask(
+              createTask(inputFiles),
+              new Error("Agent did not complete governed task lifecycle")
+            );
           } catch (err) {
-            publishFailed(err);
+            await failTask(createTask(inputFiles), err);
           }
         } finally {
           active.delete(execution);
@@ -2140,7 +2516,7 @@ ${formatFileRefsSection(inputFiles)}` : text;
         const threadId = task ? asString2(task.metadata?.threadId) : void 0;
         if (threadId) {
           try {
-            const agent = import_core67.agentInstanceManager.getAgent(this.agentParams(threadId));
+            const agent = import_core75.agentInstanceManager.getAgent(this.agentParams(threadId));
             await agent.abort();
           } catch (err) {
             console.warn({
@@ -2151,6 +2527,26 @@ ${formatFileRefsSection(inputFiles)}` : text;
             });
           }
         }
+        if (this.taskStore) {
+          const canceledTask = {
+            ...task ?? {
+              kind: "task",
+              id: taskId,
+              contextId: "",
+              status: { state: "canceled" }
+            },
+            status: { state: "canceled", timestamp: isoNow() }
+          };
+          try {
+            await this.taskStore.save(canceledTask);
+          } catch (saveError) {
+            console.warn({
+              event: "a2a:settle:save_failed",
+              taskId,
+              error: saveError instanceof Error ? saveError.message : String(saveError)
+            });
+          }
+        }
         bus.publish({
           kind: "status-update",
           taskId,
@@ -2494,10 +2890,10 @@ function isAsyncGenerator(value) {
 }
 function registerA2AStandardRoutes(app2, deps) {
   const authService = deps.authService;
-  const resolveTasks = deps.getTaskStoreLattice ?? (() => (0, import_core68.getStoreLattice)("default", "task").store);
-  const resolveTaskWorkItems = deps.getTaskWorkItemStore ?? (() => (0, import_core68.getStoreLattice)("default", "taskWorkItem").store);
-  const getAssistantStore2 = deps.getAssistantStore ?? (() => (0, import_core68.getStoreLattice)("default", "assistant").store);
-  const getProjectStore2 = deps.getProjectStore ?? (() => (0, import_core68.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();
@@ -2580,7 +2976,7 @@ function registerA2AStandardRoutes(app2, deps) {
       const taskStore = assistantHasGovernedTask(assistant) ? new A2ATaskStoreAdapter({
         taskStore: internalTasks,
         workItemStore: workItems,
-        lifecycle: (0, import_core68.createTaskLifecycleService)({
+        lifecycle: (0, import_core76.createTaskLifecycleService)({
           taskStore: internalTasks,
           workItemStore: workItems
         }),
@@ -2699,7 +3095,7 @@ data: ${JSON.stringify(errorResponse)}
       const taskStore = assistantHasGovernedTask(assistant) ? new A2ATaskStoreAdapter({
         taskStore: internalTasks,
         workItemStore: workItems,
-        lifecycle: (0, import_core68.createTaskLifecycleService)({
+        lifecycle: (0, import_core76.createTaskLifecycleService)({
           taskStore: internalTasks,
           workItemStore: workItems
         }),
@@ -2731,6 +3127,16 @@ data: ${JSON.stringify(data)}
         await executor.execute(requestContext, bus);
       } catch (err) {
         request.log.error({ err }, "a2a:test-call:execution");
+        try {
+          await taskStore.save({
+            kind: "task",
+            id: taskId,
+            contextId,
+            status: { state: "failed", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+          });
+        } catch (saveError) {
+          request.log.error({ err: saveError }, "a2a:test-call:settle");
+        }
         sendEvent("status-update", {
           kind: "status-update",
           taskId,
@@ -2744,13 +3150,13 @@ data: ${JSON.stringify(data)}
     }
   );
 }
-var import_uuid12, import_server2, import_core68, 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_core68 = require("@axiom-lattice/core");
+    import_core76 = require("@axiom-lattice/core");
     init_A2AAuthService();
     init_A2AAgentCardBuilder();
     init_A2ATaskStoreAdapter();
@@ -2958,11 +3364,11 @@ var init_a2a = __esm({
 });
 
 // src/services/open/openAuthService.ts
-var import_protocols35, OpenAuthService;
+var import_protocols36, OpenAuthService;
 var init_openAuthService = __esm({
   "src/services/open/openAuthService.ts"() {
     "use strict";
-    import_protocols35 = require("@axiom-lattice/protocols");
+    import_protocols36 = require("@axiom-lattice/protocols");
     OpenAuthService = class {
       constructor(keyStore) {
         this.keyStore = keyStore;
@@ -2976,7 +3382,7 @@ var init_openAuthService = __esm({
           kind: "api_key",
           tenantId: record.tenantId,
           projectId: record.projectId,
-          grants: (0, import_protocols35.effectiveGrants)(record)
+          grants: (0, import_protocols36.effectiveGrants)(record)
         };
       }
     };
@@ -2984,11 +3390,11 @@ var init_openAuthService = __esm({
 });
 
 // src/services/open/openCredentialService.ts
-var import_protocols36, OpenCredentialService;
+var import_protocols37, OpenCredentialService;
 var init_openCredentialService = __esm({
   "src/services/open/openCredentialService.ts"() {
     "use strict";
-    import_protocols36 = require("@axiom-lattice/protocols");
+    import_protocols37 = require("@axiom-lattice/protocols");
     init_openToken();
     init_openAuthService();
     OpenCredentialService = class {
@@ -3008,6 +3414,7 @@ var init_openCredentialService = __esm({
               projectId: token.projectId,
               workspaceId: token.workspaceId,
               sandboxName: token.sandboxName,
+              depth: token.depth,
               grants: token.grants
             };
           }
@@ -3501,8 +3908,8 @@ function exposedDeclarations(plugin) {
   return (plugin.meta.tools ?? []).filter((t2) => t2.expose);
 }
 async function registerExposedPluginTools() {
-  for (const key of import_core69.PluginRegistry.list()) {
-    const plugin = import_core69.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;
@@ -3537,8 +3944,8 @@ async function registerExposedPluginTools() {
 }
 function collectExposedPluginUiResources(grants) {
   const resources = /* @__PURE__ */ new Map();
-  for (const type of import_core69.PluginRegistry.list()) {
-    const plugin = import_core69.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;
@@ -3562,11 +3969,11 @@ function collectExposedPluginUiResources(grants) {
   }
   return resources;
 }
-var import_core69;
+var import_core77;
 var init_registerExposedPlugins = __esm({
   "src/services/open/registerExposedPlugins.ts"() {
     "use strict";
-    import_core69 = require("@axiom-lattice/core");
+    import_core77 = require("@axiom-lattice/core");
     init_openLattice();
     init_pluginExposeAdapter();
   }
@@ -3581,14 +3988,14 @@ function toText(result) {
 }
 function defaultCatalog() {
   return {
-    getValidatedManifest: (tenantId, type) => (0, import_core70.getSandboxPluginCatalog)().getValidatedManifest(tenantId, type),
-    getExecutor: () => (0, import_core70.getSandboxPluginCatalog)().getExecutor(),
-    readPluginFile: (tenantId, type, relPath) => (0, import_core70.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_core70.resolveSandboxPluginConnections)(
+    return await (0, import_core78.resolveSandboxPluginConnections)(
       pluginType,
       { connectAll: true },
       {
@@ -3617,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_core70.getSandboxPluginCatalog)().ensureLoaded(tenant2);
+    const snapshot = await (0, import_core78.getSandboxPluginCatalog)().ensureLoaded(tenant2);
     return { plugins: snapshot.plugins, diagnostics: snapshot.diagnostics };
   });
   const resolveConnections = deps.resolveConnections ?? defaultResolveConnections;
@@ -3659,7 +4066,7 @@ async function buildTenantOpenPlugins(tenantId, grants, deps = {}) {
         domain,
         action: tool.name,
         description: tool.description,
-        schema: (0, import_core70.jsonSchemaToZod)(tool.schema),
+        schema: (0, import_core78.jsonSchemaToZod)(tool.schema),
         annotations: {
           readOnlyHint: tool.readOnly ?? false,
           destructiveHint: tool.destructive ?? false
@@ -3710,11 +4117,11 @@ async function buildTenantOpenPlugins(tenantId, grants, deps = {}) {
     }
   };
 }
-var import_core70;
+var import_core78;
 var init_tenantOpenPlugins = __esm({
   "src/services/open/tenantOpenPlugins.ts"() {
     "use strict";
-    import_core70 = require("@axiom-lattice/core");
+    import_core78 = require("@axiom-lattice/core");
     init_openLattice();
     init_pluginToolExecution();
   }
@@ -3751,13 +4158,13 @@ function emptyTenantPlugins() {
 }
 function registerOpenRoutes(app2, deps = {}) {
   const openAuth = deps.openAuth ?? new OpenCredentialService(
-    (0, import_core71.getStoreLattice)("default", "a2aApiKey").store,
-    (0, import_core71.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_core71.getStoreLattice)("default", "openAudit").store;
+      const store2 = (0, import_core79.getStoreLattice)("default", "openAudit").store;
       return new OpenAuditService(store2);
     } catch {
       return void 0;
@@ -3843,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,
@@ -3911,12 +4319,12 @@ function registerOpenRoutes(app2, deps = {}) {
     }
   );
 }
-var import_types, import_core71, 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_core71 = require("@axiom-lattice/core");
+    import_core79 = require("@axiom-lattice/core");
     init_openCredentialService();
     init_openAuditService();
     init_openRateLimiter();
@@ -3949,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_core72.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" });
@@ -3974,11 +4382,11 @@ function registerOpenSessionRoutes(app2) {
     }
   );
 }
-var import_core72;
+var import_core80;
 var init_open_session = __esm({
   "src/routes/open-session.ts"() {
     "use strict";
-    import_core72 = require("@axiom-lattice/core");
+    import_core80 = require("@axiom-lattice/core");
     init_openToken();
     init_previewToken();
     init_openLattice();
@@ -3987,13 +4395,13 @@ var init_open_session = __esm({
 
 // src/services/open/openCatalogService.ts
 async function defaultListTenantPlugins(tenantId) {
-  return (await (0, import_core73.getSandboxPluginCatalog)().ensureLoaded(tenantId)).plugins;
+  return (await (0, import_core81.getSandboxPluginCatalog)().ensureLoaded(tenantId)).plugins;
 }
-var import_core73, OpenCatalogService;
+var import_core81, OpenCatalogService;
 var init_openCatalogService = __esm({
   "src/services/open/openCatalogService.ts"() {
     "use strict";
-    import_core73 = require("@axiom-lattice/core");
+    import_core81 = require("@axiom-lattice/core");
     init_openLattice();
     OpenCatalogService = class {
       constructor(assistantStore, lattice = openLattice, listTenantPlugins2 = defaultListTenantPlugins) {
@@ -4068,17 +4476,17 @@ function registerOpenCatalogRoutes(app2) {
     if (!tenantId) {
       return reply.status(401).send({ success: false, error: "Unauthorized" });
     }
-    const assistantStore = (0, import_core74.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_core74;
+var import_core82;
 var init_open_catalog = __esm({
   "src/routes/open-catalog.ts"() {
     "use strict";
-    import_core74 = require("@axiom-lattice/core");
+    import_core82 = require("@axiom-lattice/core");
     init_openCatalogService();
   }
 });
@@ -4090,7 +4498,14 @@ __export(sandboxProvider_exports, {
   resolveContextSandbox: () => resolveContextSandbox
 });
 async function resolveContextSandbox(ctx) {
-  return import_core75.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,
@@ -4188,12 +4603,12 @@ ${truncated}`
     }
   };
 }
-var import_zod21, import_core75, 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_core75 = require("@axiom-lattice/core");
+    import_core83 = require("@axiom-lattice/core");
     MAX_OUTPUT_BYTES = 64e3;
   }
 });
@@ -4215,12 +4630,12 @@ function safePath(raw) {
 }
 function registerOpenFilesRoutes(app2, deps = {}) {
   const openAuth = deps.openAuth ?? new OpenCredentialService(
-    (0, import_core76.getStoreLattice)("default", "a2aApiKey").store,
-    (0, import_core76.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_core76.getStoreLattice)("default", "openAudit").store;
+      const store2 = (0, import_core84.getStoreLattice)("default", "openAudit").store;
       return new OpenAuditService(store2);
     } catch {
       return void 0;
@@ -4330,11 +4745,11 @@ function registerOpenFilesRoutes(app2, deps = {}) {
     }
   });
 }
-var import_core76;
+var import_core84;
 var init_open_files = __esm({
   "src/routes/open-files.ts"() {
     "use strict";
-    import_core76 = require("@axiom-lattice/core");
+    import_core84 = require("@axiom-lattice/core");
     init_openCredentialService();
     init_openLattice();
     init_sandboxProvider();
@@ -4356,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_core77.getStoreLattice)("default", "openAudit").store;
+      const store2 = (0, import_core85.getStoreLattice)("default", "openAudit").store;
       const records = await store2.query({
         tenantId,
         credentialId: request.query.credentialId,
@@ -4371,11 +4786,11 @@ function registerOpenAuditRoutes(app2) {
     }
   );
 }
-var import_core77;
+var import_core85;
 var init_open_audit = __esm({
   "src/routes/open-audit.ts"() {
     "use strict";
-    import_core77 = require("@axiom-lattice/core");
+    import_core85 = require("@axiom-lattice/core");
   }
 });
 
@@ -4392,12 +4807,12 @@ function registerOpenExposureRoutes(app2, deps = {}) {
       if (!tenantId) {
         return reply.status(401).send({ success: false, error: "Unauthorized" });
       }
-      const keyStore = (0, import_core78.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" });
       }
-      const grants = (0, import_protocols37.effectiveGrants)(record);
+      const grants = (0, import_protocols38.effectiveGrants)(record);
       const forwardedHost = request.headers["x-forwarded-host"];
       const host = (Array.isArray(forwardedHost) ? forwardedHost[0] : forwardedHost) ?? (Array.isArray(request.headers.host) ? request.headers.host[0] : request.headers.host) ?? request.hostname;
       const baseUrl = `${request.protocol}://${host}`;
@@ -4426,7 +4841,7 @@ function registerOpenExposureRoutes(app2, deps = {}) {
         hasUi: Boolean(t2.ui)
       }));
       const agentGrant = grants.find((g) => g.domain === "agent");
-      const assistantStore = (0, import_core78.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(
@@ -4461,12 +4876,12 @@ function registerOpenExposureRoutes(app2, deps = {}) {
     }
   );
 }
-var import_core78, import_protocols37;
+var import_core86, import_protocols38;
 var init_open_exposure = __esm({
   "src/routes/open-exposure.ts"() {
     "use strict";
-    import_core78 = require("@axiom-lattice/core");
-    import_protocols37 = require("@axiom-lattice/protocols");
+    import_core86 = require("@axiom-lattice/core");
+    import_protocols38 = require("@axiom-lattice/protocols");
     init_openLattice();
     init_tenantOpenPlugins();
     init_A2AAgentCardBuilder();
@@ -4585,7 +5000,7 @@ function createAgentProvider(deps = {}) {
         } catch {
         }
       }
-      const agent = import_core79.agentInstanceManager.getAgent({
+      const agent = import_core87.agentInstanceManager.getAgent({
         tenant_id: ctx.tenantId,
         assistant_id: assistantId,
         thread_id: threadId,
@@ -4599,8 +5014,8 @@ function createAgentProvider(deps = {}) {
       const stream = agent.chunkStream(messageId, [...STOP_TYPES]);
       for await (const chunk of stream) {
         const text = chunk.data?.content;
-        if (chunk.type === import_protocols38.MessageChunkTypes.INTERRUPT) break;
-        if (chunk.type === import_protocols38.MessageChunkTypes.AI && text) {
+        if (chunk.type === import_protocols39.MessageChunkTypes.INTERRUPT) break;
+        if (chunk.type === import_protocols39.MessageChunkTypes.AI && text) {
           parts.push(text);
         }
       }
@@ -4610,14 +5025,289 @@ function createAgentProvider(deps = {}) {
     }
   };
 }
-var import_zod23, import_core79, import_protocols38, 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_core79 = require("@axiom-lattice/core");
-    import_protocols38 = require("@axiom-lattice/protocols");
-    STOP_TYPES = [import_protocols38.MessageChunkTypes.MESSAGE_COMPLETED];
+    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;
   }
 });
 
@@ -4647,12 +5337,12 @@ var resources_exports = {};
 __export(resources_exports, {
   ResourceController: () => ResourceController
 });
-var import_bcryptjs, import_core80, ResourceController;
+var import_bcryptjs, import_core90, ResourceController;
 var init_resources = __esm({
   "src/controllers/resources.ts"() {
     "use strict";
     import_bcryptjs = __toESM(require("bcryptjs"));
-    import_core80 = require("@axiom-lattice/core");
+    import_core90 = require("@axiom-lattice/core");
     init_mime();
     init_http_range();
     init_sandboxGrants();
@@ -4669,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_core80.createSharePayload)(
+        const payload = (0, import_core90.createSharePayload)(
           tenantId,
           workspaceId,
           projectId,
           userId,
           body
         );
-        const token = (0, import_core80.generateToken)();
+        const token = (0, import_core90.generateToken)();
         try {
           await this.deps.store.create({ ...payload, token });
           this.deps.logger.info(
@@ -4828,7 +5518,7 @@ var init_resources = __esm({
             resourcePath: subPath
           }, subPath, ext, request, reply);
         }
-        const volume = (0, import_core80.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
+        const volume = (0, import_core90.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
         return this._resolveAndServe(
           volume,
           subPath,
@@ -5039,7 +5729,18 @@ var init_resources = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  LatticeGateway: () => LatticeGateway
+  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,
+  runOrphanRecovery: () => runOrphanRecovery
 });
 module.exports = __toCommonJS(index_exports);
 var import_config2 = require("dotenv/config");
@@ -5715,7 +6416,7 @@ var getAgentGraph = async (request, reply) => {
   try {
     const { assistantId } = request.params;
     const tenant_id = getTenantId(request);
-    const agent = import_core.agentInstanceManager.getAgent({ assistant_id: assistantId, tenant_id, thread_id: "" });
+    const agent = import_core.agentInstanceManager.getAgentForRead({ assistant_id: assistantId, tenant_id, thread_id: "" });
     const imageData = await agent.get_draw_graph();
     reply.header("Content-Type", "application/json").send({
       image: imageData
@@ -5852,6 +6553,21 @@ var import_uuid = require("uuid");
 var import_core3 = require("@axiom-lattice/core");
 var import_protocols2 = require("@axiom-lattice/protocols");
 
+// src/utils/agentScope.ts
+function headerValue(value) {
+  if (Array.isArray(value)) return value[0];
+  return value;
+}
+function resolveAgentScope(request) {
+  const workspace = headerValue(request.headers["x-workspace-id"]);
+  const project = headerValue(request.headers["x-project-id"]);
+  return {
+    tenant_id: headerValue(request.headers["x-tenant-id"]),
+    workspace_id: workspace || "default",
+    project_id: project || void 0
+  };
+}
+
 // src/services/agents/ScopedAgentExecution.ts
 async function executeScopedAgentMessage(agent, request, stopTypes, options) {
   const { messageId } = options === void 0 ? await agent.addMessage(request) : await agent.addMessage(request, options.queueMode);
@@ -5935,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;
@@ -5953,9 +6687,7 @@ var createRun = async (request, reply) => {
       mode,
       ...input
     } = request.body;
-    const tenant_id = request.headers["x-tenant-id"];
-    const workspace_id = request.headers["x-workspace-id"];
-    const project_id = request.headers["x-project-id"];
+    const { tenant_id, workspace_id, project_id } = resolveAgentScope(request);
     const x_request_id = request.headers["x-request-id"] || (0, import_uuid.v4)();
     const user_id = getUserId2(request);
     const mergedConfig = {
@@ -5963,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"
@@ -5984,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,
@@ -5997,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;
@@ -6008,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",
@@ -6039,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}`
@@ -6054,9 +6807,7 @@ var createRun = async (request, reply) => {
 var resumeStream = async (request, reply) => {
   try {
     const { thread_id, message_id, assistant_id, known_content, poll_interval } = request.body;
-    const tenant_id = request.headers["x-tenant-id"];
-    const workspace_id = request.headers["x-workspace-id"];
-    const project_id = request.headers["x-project-id"];
+    const { tenant_id, workspace_id, project_id } = resolveAgentScope(request);
     if (!thread_id || !message_id || !assistant_id || known_content === void 0) {
       reply.status(400).send({
         success: false,
@@ -6069,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,
@@ -6114,9 +6876,7 @@ var resumeStream = async (request, reply) => {
 var abortRun = async (request, reply) => {
   try {
     const { assistantId, threadId } = request.params;
-    const tenant_id = request.headers["x-tenant-id"];
-    const workspace_id = request.headers["x-workspace-id"] || "default";
-    const project_id = request.headers["x-project-id"] || "default";
+    const { tenant_id, workspace_id, project_id } = resolveAgentScope(request);
     const agent = import_core3.agentInstanceManager.getAgent({
       assistant_id: assistantId,
       thread_id: threadId,
@@ -6124,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}`
@@ -6139,9 +6909,7 @@ var abortRun = async (request, reply) => {
 var recoverRun = async (request, reply) => {
   try {
     const { assistantId, threadId } = request.params;
-    const tenant_id = request.headers["x-tenant-id"];
-    const workspace_id = request.headers["x-workspace-id"] || "default";
-    const project_id = request.headers["x-project-id"];
+    const { tenant_id, workspace_id, project_id } = resolveAgentScope(request);
     const agent = import_core3.agentInstanceManager.getAgent({
       assistant_id: assistantId,
       thread_id: threadId,
@@ -6149,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}`
@@ -6229,7 +7001,7 @@ var getAllMemoryItems = async (request, reply) => {
       });
       return;
     }
-    const agent = import_core4.agentInstanceManager.getAgent({ assistant_id: assistantId, tenant_id, thread_id });
+    const agent = import_core4.agentInstanceManager.getAgentForRead({ assistant_id: assistantId, tenant_id, thread_id });
     const result = await agent.getCurrentMessages();
     if (!result) {
       reply.status(500).send(result);
@@ -6261,7 +7033,7 @@ var getAgentState = async (request, reply) => {
       return;
     }
     const tenant_id = request.headers["x-tenant-id"];
-    const agent = import_core4.agentInstanceManager.getAgent({ assistant_id: assistantId, tenant_id, thread_id });
+    const agent = import_core4.agentInstanceManager.getAgentForRead({ assistant_id: assistantId, tenant_id, thread_id });
     const result = await agent.getCurrentState();
     const pendingMessages = await agent.getPendingMessages();
     if (!result) {
@@ -8072,7 +8844,7 @@ async function getInboxItems(request, reply) {
           store2.getRunSteps(r.id).catch(() => []),
           (async () => {
             try {
-              return import_core15.agentInstanceManager.getAgent({
+              return import_core15.agentInstanceManager.getAgentForRead({
                 assistant_id: r.assistantId,
                 thread_id: r.threadId,
                 tenant_id: r.tenantId
@@ -10231,9 +11003,9 @@ function isRoomPresenceMetadata(metadata, expected) {
 // src/services/collaboration/RoomCoordinatorEnsurer.ts
 var RoomCoordinatorEnsureError = class extends Error {
   /** Creates a typed ensure failure with the underlying store outcome. */
-  constructor(outcome) {
-    super(`Room coordinator could not be ensured: ${outcome}`);
-    this.outcome = outcome;
+  constructor(outcome2) {
+    super(`Room coordinator could not be ensured: ${outcome2}`);
+    this.outcome = outcome2;
     this.name = "RoomCoordinatorEnsureError";
   }
 };
@@ -12720,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) {
@@ -12727,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 {
@@ -12804,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,
@@ -12833,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 {
@@ -12841,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, {
@@ -12853,11 +13673,27 @@ async function updateMcpServerConfig(request, reply) {
         await store2.updateConfig(tenantId, existing.id, { status: "connected" });
         updated.status = "connected";
       } catch (error) {
-        console.warn("Failed to reconnect MCP server:", error);
-        await store2.updateConfig(tenantId, existing.id, { status: "error" });
-        updated.status = "error";
+        console.warn("Failed to reconnect MCP server:", error);
+        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,
       message: "MCP server configuration updated successfully",
@@ -12906,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"
@@ -12980,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,
@@ -13020,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",
@@ -13033,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"}`
@@ -13059,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",
@@ -15309,7 +16154,7 @@ function verifyLarkParsedBody(body, config) {
   }
   return extractVerificationToken(body) === config.verificationToken;
 }
-function headerValue(request, name) {
+function headerValue2(request, name) {
   const value = request.headers[name];
   return Array.isArray(value) ? value[0] : value;
 }
@@ -15317,9 +16162,9 @@ function verifyLarkRequestSignature(request, config) {
   if (!config.encryptKey) {
     return true;
   }
-  const timestamp = headerValue(request, "x-lark-request-timestamp");
-  const nonce = headerValue(request, "x-lark-request-nonce");
-  const signature = headerValue(request, "x-lark-signature");
+  const timestamp = headerValue2(request, "x-lark-request-timestamp");
+  const nonce = headerValue2(request, "x-lark-request-nonce");
+  const signature = headerValue2(request, "x-lark-signature");
   if (!timestamp || !nonce || !signature) {
     return false;
   }
@@ -15577,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;
@@ -16720,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");
@@ -16929,40 +17774,8 @@ function isTaskFileRef(value) {
   return !!row && typeof row.uri === "string" && !!row.uri && (row.name === void 0 || typeof row.name === "string") && (row.mimeType === void 0 || typeof row.mimeType === "string") && (row.addedBy === void 0 || row.addedBy === "user" || row.addedBy === "agent");
 }
 
-// src/services/collaboration/projectTaskScope.ts
-function isProjectLifecycleTask(task) {
-  const source = task.context?.source;
-  return typeof task.workspaceId === "string" && task.workspaceId.length > 0 && typeof task.projectId === "string" && task.projectId.length > 0 && (source === "project_room" || source === "project_task" || source === "user");
-}
-function isRosterExemptProject(project) {
-  return project?.kind === "public";
-}
-function resolveTaskOwnerMembership(task, project, room, membership) {
-  const active = membership && membership.status === "active" && membership.tenantId === task.tenantId && membership.workspaceId === task.workspaceId && membership.projectId === task.projectId && membership.assistantId === task.ownerId && membership.roomId === room.id;
-  if (active) return membership;
-  if (!isRosterExemptProject(project)) return void 0;
-  return syntheticPublicProjectOwnerMembership(task, room);
-}
-function syntheticPublicProjectOwnerMembership(task, room) {
-  const threadId = typeof task.context?.thread_id === "string" && task.context.thread_id.length > 0 ? task.context.thread_id : task.ownerId;
-  return {
-    id: `public-project-owner:${task.projectId}:${task.ownerId}`,
-    tenantId: task.tenantId,
-    workspaceId: task.workspaceId,
-    projectId: task.projectId,
-    roomId: room.id,
-    assistantId: task.ownerId,
-    role: "specialist",
-    title: task.ownerId,
-    mentionName: task.ownerId,
-    status: "active",
-    roomThreadId: threadId,
-    joinedAt: task.createdAt,
-    updatedAt: task.updatedAt
-  };
-}
-
 // src/services/collaboration/ProjectTaskThreadService.ts
+init_projectTaskScope();
 var ProjectTaskThreadError = class extends Error {
   /**
    * @param code Stable machine-readable failure code.
@@ -17078,6 +17891,7 @@ var import_node_crypto9 = require("crypto");
 var import_node_crypto8 = require("crypto");
 var import_core44 = require("@axiom-lattice/core");
 var import_protocols12 = require("@axiom-lattice/protocols");
+init_projectTaskScope();
 
 // src/router/roomInterrupt.ts
 var CLARIFY_FENCE = /^```clarify\n([\s\S]*?)\n```$/;
@@ -17330,18 +18144,22 @@ 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 outcome = await this.settleInterruptedEvent(input.task, input.thread, input.inputMessageId);
-        settlement.resolve(outcome);
-        return outcome;
+        const outcome2 = await this.settleInterruptedEvent(input.task, input.thread, input.inputMessageId);
+        settlement.resolve(outcome2);
+        return outcome2;
       }
       if ((resumed.status === import_core44.ThreadStatus.IDLE || resumed.status === import_core44.ThreadStatus.ERROR) && settlement.tryClaim()) {
         settlement.cleanup();
         const reason = resumed.status === import_core44.ThreadStatus.IDLE ? "Project task execution ended without lifecycle transition" : "Recovered Agent execution is in error state";
-        const outcome = await this.settleEndedRecovery(input, reason);
-        settlement.resolve(outcome);
-        return outcome;
+        const outcome2 = await this.settleEndedRecovery(input, reason);
+        settlement.resolve(outcome2);
+        return outcome2;
       }
       return await this.awaitSettlementCancellation(
         settlement,
@@ -17353,7 +18171,7 @@ var ProjectTaskExecutionService = class {
     } catch (error) {
       if (!settlement.tryClaim()) return settlement.promise;
       settlement.cleanup();
-      const outcome = {
+      const outcome2 = {
         kind: "failed",
         task: input.task,
         thread: input.thread,
@@ -17362,8 +18180,8 @@ var ProjectTaskExecutionService = class {
         cause: "recovery_ended",
         lifecycleHandled: false
       };
-      settlement.resolve(outcome);
-      return outcome;
+      settlement.resolve(outcome2);
+      return outcome2;
     }
   }
   /** Classifies one exact Task Thread queue fact with transition-safe repeated reads. */
@@ -17581,9 +18399,9 @@ var ProjectTaskExecutionService = class {
   async claimDispatchFailure(settlement, task, thread, messageId, error) {
     if (!settlement.tryClaim()) return settlement.promise;
     settlement.cleanup();
-    const outcome = await this.failSettledTaskAwaited(task, thread, messageId, error);
-    settlement.resolve(outcome);
-    return outcome;
+    const outcome2 = await this.failSettledTaskAwaited(task, thread, messageId, error);
+    settlement.resolve(outcome2);
+    return outcome2;
   }
   armSettlement(task, thread, messageId) {
     let claimed = false;
@@ -17674,9 +18492,9 @@ var ProjectTaskExecutionService = class {
       } catch {
       }
     }
-    const outcome = await this.compensateCancellation(task, thread, messageId, false);
-    settlement.resolve(outcome);
-    return outcome;
+    const outcome2 = await this.compensateCancellation(task, thread, messageId, false);
+    settlement.resolve(outcome2);
+    return outcome2;
   }
   compensateCancellation(task, thread, messageId, abortAgent) {
     if (abortAgent) {
@@ -19018,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);
@@ -19180,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, []) };
   }
@@ -19525,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();
@@ -19673,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);
@@ -19685,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);
@@ -19697,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);
@@ -19730,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);
@@ -19958,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);
@@ -19978,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);
@@ -20031,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) {
@@ -20274,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);
@@ -20315,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 {
@@ -20328,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" });
@@ -20340,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);
     }
@@ -20348,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);
@@ -20359,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;
@@ -20373,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;
@@ -20417,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: "" };
     }
@@ -20451,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;
     });
   }
@@ -20466,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 });
@@ -20474,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: "" };
     }
@@ -20626,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 {
@@ -20639,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;
@@ -20914,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.
    */
@@ -21153,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,
@@ -21392,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,
@@ -21570,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 {
@@ -22413,8 +23296,8 @@ var RoomMessageService = class {
       const resolved = await promise;
       return this.resultForCaller(resolved, resolved.replayed);
     }
-    const outcome = await this.createAndDispatchOutcome(actor3, normalized, room);
-    return this.resultForCaller(outcome, outcome.replayed);
+    const outcome2 = await this.createAndDispatchOutcome(actor3, normalized, room);
+    return this.resultForCaller(outcome2, outcome2.replayed);
   }
   async createAndDispatchOutcome(actor3, input, room) {
     const persisted = await this.persistNormalizedHumanMessage(actor3, input, room);
@@ -22463,8 +23346,8 @@ var RoomMessageService = class {
     }
     throw new RoomMessageServiceError("ROOM_DISPATCH_OVERLOADED", 429, "Room dispatch capacity is full", true);
   }
-  resultForCaller(outcome, replayed) {
-    return { message: cloneRoomMessage(outcome.message), dispatch: outcome.dispatch.map((entry) => ({ ...entry })), replayed };
+  resultForCaller(outcome2, replayed) {
+    return { message: cloneRoomMessage(outcome2.message), dispatch: outcome2.dispatch.map((entry) => ({ ...entry })), replayed };
   }
   /** Retries an existing human message using the current roster without creating a copy. */
   async retry(actor3, messageId) {
@@ -22856,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() {
@@ -23041,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,
@@ -23255,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,
@@ -23317,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,
@@ -23843,6 +24726,7 @@ function exactValues(value, required, optional = []) {
 // src/services/collaboration/CoordinatorWakeNotifier.ts
 var import_node_crypto21 = require("crypto");
 var import_protocols21 = require("@axiom-lattice/protocols");
+init_projectTaskScope();
 var SYNTHETIC_WAKE_AUTHOR = "coordinator-wake";
 var CoordinatorWakeNotifier = class {
   /** Creates a bounded Project Task lifecycle observer that wakes the Room Coordinator. */
@@ -23900,10 +24784,10 @@ var CoordinatorWakeNotifier = class {
       timer = setTimeout(() => resolve4("timeout"), timeoutMs);
       timer.unref?.();
     });
-    const outcome = await Promise.race([work.then(() => "drained"), timeout]);
+    const outcome2 = await Promise.race([work.then(() => "drained"), timeout]);
     if (timer) clearTimeout(timer);
     this.closed = true;
-    if (outcome === "timeout") this.queues.clear();
+    if (outcome2 === "timeout") this.queues.clear();
   }
   /** Closes admission and drains accepted work. */
   async dispose() {
@@ -24133,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");
@@ -24156,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);
     }
@@ -24211,8 +25100,23 @@ 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"];
 var ProjectTaskObserver = class {
@@ -24233,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) {
@@ -24412,11 +25316,11 @@ var ProjectTaskObserver = class {
         try {
           await this.requireActiveOwner(task);
         } catch (error) {
-          await this.convergeInterrupted(task, `No active executor: ${errorMessage3(error)}`);
+          await this.convergeFailed(task, `No active executor: ${errorMessage3(error)}`);
           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;
@@ -24511,7 +25415,7 @@ var ProjectTaskObserver = class {
         const classification = await this.deps.execution.classifyRecovery(current, ensured.thread);
         if (signal?.aborted || this.disposed) return;
         if (classification.kind === "invalid") {
-          await this.convergeInterrupted(
+          await this.convergeFailed(
             current,
             `Task execution state is not recoverable: ${classification.reason}`
           );
@@ -24532,40 +25436,40 @@ var ProjectTaskObserver = class {
       }
     }, signal);
   }
-  async mapOutcome(outcome) {
-    if (outcome.kind === "aborted") return;
-    const current = snapshotTaskItem(await this.deps.tasks.getById(outcome.task.tenantId, outcome.task.id));
-    if (!current || current.ownerId !== outcome.thread.assistantId || current.context?.thread_id !== outcome.thread.id) return;
+  async mapOutcome(outcome2) {
+    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;
-    if (outcome.kind === "completed") {
+    if (outcome2.kind === "completed") {
       const result2 = await this.runBridge.settleRun({
         tenantId: current.tenantId,
         task: current,
         actor: SYSTEM_ACTOR2,
-        threadId: outcome.thread.id,
+        threadId: outcome2.thread.id,
         outcome: { kind: "completed" }
       });
       await this.checkLifecycle(current, "outcome-completed", result2);
       return;
     }
-    if (outcome.kind === "cancelled") {
+    if (outcome2.kind === "cancelled") {
       const result2 = await this.runBridge.settleRun({
         tenantId: current.tenantId,
         task: current,
         actor: SYSTEM_ACTOR2,
-        threadId: outcome.thread.id,
+        threadId: outcome2.thread.id,
         outcome: { kind: "cancelled" }
       });
       await this.checkLifecycle(current, "outcome-cancelled", result2);
       return;
     }
-    if (outcome.kind === "failed" && outcome.lifecycleHandled) return;
-    if (outcome.kind === "interrupted") {
+    if (outcome2.kind === "failed" && outcome2.lifecycleHandled) return;
+    if (outcome2.kind === "interrupted") {
       const result2 = await this.runBridge.settleRun({
         tenantId: current.tenantId,
         task: current,
         actor: SYSTEM_ACTOR2,
-        threadId: outcome.thread.id,
+        threadId: outcome2.thread.id,
         outcome: { kind: "interrupted" }
       });
       await this.checkLifecycle(current, "outcome-interrupted", result2);
@@ -24575,10 +25479,10 @@ var ProjectTaskObserver = class {
       tenantId: current.tenantId,
       task: current,
       actor: SYSTEM_ACTOR2,
-      threadId: outcome.thread.id,
-      outcome: { kind: "failed", lifecycleHandled: false, error: outcome.error }
+      threadId: outcome2.thread.id,
+      outcome: { kind: "failed", lifecycleHandled: false, error: outcome2.error }
     });
-    await this.checkLifecycle(current, `outcome-${outcome.cause}`, result);
+    await this.checkLifecycle(current, `outcome-${outcome2.cause}`, result);
   }
   async collectDependentIds(task) {
     const rows = /* @__PURE__ */ new Map();
@@ -24778,25 +25682,26 @@ var ProjectTaskObserver = class {
     }
   }
   /**
-   * Converges an unexecutable task to a durable interruption.
+   * Converges a mechanically unexecutable task to a durable failure.
    *
    * @param task Exact task snapshot that cannot make progress through automation.
-   * @param summary Human-readable reason recorded with the interruption.
+   * @param failureReason Human-readable reason recorded with the failure.
    * @remarks Never leaves a task silently pending behind a warning; an `in_progress`
    * task with no dispatched queue rows is intentionally left untouched by recovery.
-   * The interruption is visible and resumable once an executor is available.
+   * A no-executor/unrecoverable state is a mechanical failure (`failed`), not HITL
+   * (ADR-143); `failed` remains retryable.
    */
-  async convergeInterrupted(task, summary) {
+  async convergeFailed(task, failureReason) {
     if (this.disposed) return;
     try {
       const result = await this.runBridge.settleRun({
         tenantId: task.tenantId,
         task,
         actor: SYSTEM_ACTOR2,
-        outcome: { kind: "interrupted", summary }
+        outcome: { kind: "failed", lifecycleHandled: false, error: failureReason }
       });
       if (!result.success && result.code !== "TASK_STATUS_CONFLICT") {
-        await this.safeWarning(task, "converge", `${result.code ?? "LIFECYCLE_REJECTED"}: ${result.error ?? summary}`);
+        await this.safeWarning(task, "converge", `${result.code ?? "LIFECYCLE_REJECTED"}: ${result.error ?? failureReason}`);
       }
     } catch (error) {
       await this.safeWarning(task, "converge", error);
@@ -25074,6 +25979,7 @@ function combineSignals(left, right) {
 // src/services/collaboration/RoomProjectionService.ts
 var import_node_crypto23 = require("crypto");
 var import_protocols24 = require("@axiom-lattice/protocols");
+init_projectTaskScope();
 var ROOM_PROJECTABLE_ACTIONS = [
   "interrupted",
   "failed",
@@ -25443,8 +26349,11 @@ function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/routes/index.ts
+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");
@@ -25454,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) {
@@ -25467,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;
@@ -25494,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 };
   }
@@ -25505,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);
@@ -25541,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();
@@ -25583,6 +26555,7 @@ var ProjectRoomEventBroker = class {
     }
     this.rooms.clear();
     this.sequenceScopes.clear();
+    this.seenSourceKeys.clear();
     this.eventCount = 0;
     this.byteCount = 0;
     this.subscriberCount = 0;
@@ -25717,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`);
@@ -25908,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;
@@ -25961,6 +26942,7 @@ function safeErrorCode(error) {
 
 // src/services/collaboration/ProjectRoomTaskEventSubscriber.ts
 var import_protocols27 = require("@axiom-lattice/protocols");
+init_projectTaskScope();
 var ProjectRoomTaskEventSubscriber = class {
   /** Creates a bounded Project task lifecycle observer. */
   constructor(deps) {
@@ -26015,10 +26997,10 @@ var ProjectRoomTaskEventSubscriber = class {
       timer = setTimeout(() => resolve4("timeout"), timeoutMs);
       timer.unref?.();
     });
-    const outcome = await Promise.race([work.then(() => "drained"), timeout]);
+    const outcome2 = await Promise.race([work.then(() => "drained"), timeout]);
     if (timer) clearTimeout(timer);
     this.closed = true;
-    if (outcome === "timeout") this.queues.clear();
+    if (outcome2 === "timeout") this.queues.clear();
   }
   /** Closes admission and drains accepted work. */
   async dispose() {
@@ -26146,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
   });
@@ -26884,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."
   });
 }
@@ -26941,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."
       });
     }
@@ -27012,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 } : {}
       });
@@ -27021,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();
@@ -27099,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;
   };
@@ -27126,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,
@@ -27135,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,
@@ -27148,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
   });
@@ -27204,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({
@@ -27215,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,
@@ -27253,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 });
@@ -27264,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),
@@ -27287,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),
@@ -27309,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)
       })
     })
   });
@@ -27367,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.getAgent({
+        getCurrentMessages: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core54.agentInstanceManager.getAgentForRead({
           tenant_id: tenantId,
           assistant_id: assistantId,
           thread_id: threadId,
@@ -27397,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,
@@ -27415,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);
       }
     })
   });
@@ -27473,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." }
@@ -27493,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()
       });
     }
   });
@@ -27511,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);
@@ -27793,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 };
@@ -27827,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,
@@ -27837,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,
@@ -27851,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
   }, {
@@ -27878,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;
@@ -28026,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
   });
@@ -28049,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,
@@ -28114,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,
@@ -28173,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",
@@ -28255,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",
@@ -28337,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",
@@ -28419,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",
@@ -28504,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();
@@ -28588,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",
@@ -28661,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"]);
@@ -28695,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";
@@ -28829,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",
@@ -28909,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",
@@ -29237,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);
@@ -29368,7 +30356,7 @@ function createAuditLoggerMiddleware() {
 }
 
 // src/index.ts
-var import_core81 = require("@axiom-lattice/core");
+var import_core91 = require("@axiom-lattice/core");
 
 // src/swagger.ts
 var import_swagger = __toESM(require("@fastify/swagger"));
@@ -29434,7 +30422,8 @@ 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 {
     assistant_id,
@@ -29452,7 +30441,8 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
     console.log(
       `\u5F00\u59CB\u5904\u7406\u4EFB\u52A1 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
     );
-    const agent = import_core63.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
+    const scope = (0, import_protocols31.resolveRunScope)(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)();
@@ -29473,18 +30463,18 @@ 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,
-                workspace_id: runConfig?.workspaceId,
-                project_id: runConfig?.projectId
+                workspace_id: scope.workspaceId,
+                project_id: scope.projectId
               });
               if (mainAgent) {
                 const messages = evt.state?.values?.messages;
@@ -29512,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
           });
@@ -29521,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"
           });
@@ -29536,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) {
@@ -29561,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)
       });
@@ -29598,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");
   }
@@ -29717,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)
         });
@@ -29732,14 +30722,14 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core82 = 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_protocols31 = require("@axiom-lattice/protocols");
+var import_core67 = require("@axiom-lattice/core");
+var import_protocols32 = require("@axiom-lattice/protocols");
 var import_crypto12 = require("crypto");
 var BindingNotFoundError = class extends Error {
   constructor(message) {
@@ -29774,10 +30764,10 @@ function clarifyText(clarify) {
   return ["```clarify", JSON.stringify({ questions: clarify.questions }), "```"].join("\n");
 }
 function exactDataValues(value, required, optional = []) {
-  return (0, import_protocols31.snapshotExactRecord)(value, required, optional);
+  return (0, import_protocols32.snapshotExactRecord)(value, required, optional);
 }
 function uniqueNonemptyStrings(value) {
-  const snapshot = (0, import_protocols31.snapshotExactArray)(value);
+  const snapshot = (0, import_protocols32.snapshotExactArray)(value);
   if (!snapshot || snapshot.length === 0 || snapshot.some((entry) => typeof entry !== "string" || entry.length === 0)) return void 0;
   const values = snapshot;
   return new Set(values).size === values.length ? values : void 0;
@@ -30024,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,
@@ -30061,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",
@@ -30101,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,
@@ -30289,7 +31279,7 @@ var MessageRouter = class {
 
 // src/channels/room/RoomChannelAdapter.ts
 var import_zod17 = require("zod");
-var import_protocols32 = require("@axiom-lattice/protocols");
+var import_protocols33 = require("@axiom-lattice/protocols");
 var roomConfigSchema = import_zod17.z.object({}).strict();
 function createRoomChannelAdapter(writer) {
   return {
@@ -30350,7 +31340,7 @@ function exactStrings(value, keys2) {
 function exactValues2(value, required, optional = []) {
   try {
     if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-    return (0, import_protocols32.snapshotExactRecord)(value, required, optional);
+    return (0, import_protocols33.snapshotExactRecord)(value, required, optional);
   } catch {
     return void 0;
   }
@@ -30374,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) });
   }
@@ -30394,26 +31384,186 @@ 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_protocols39 = require("@axiom-lattice/protocols");
+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);
 });
 var DEFAULT_LOGGER_CONFIG = {
   name: "default",
   description: "Default logger for lattice-gateway service",
-  type: import_protocols39.LoggerType.PINO,
+  type: import_protocols40.LoggerType.PINO,
   serviceName: "lattice/gateway",
   loggerName: "lattice/gateway"
 };
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger7 = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core82.loggerLatticeManager.hasLattice("default")) {
-    import_core82.loggerLatticeManager.removeLattice("default");
+  if (import_core92.loggerLatticeManager.hasLattice("default")) {
+    import_core92.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core82.registerLoggerLattice)("default", config);
-  return (0, import_core82.getLoggerLattice)("default");
+  (0, import_core92.registerLoggerLattice)("default", config);
+  return (0, import_core92.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -30474,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);
@@ -30510,7 +31660,7 @@ app.setErrorHandler((error, request, reply) => {
 });
 function getConfiguredSandboxProvider() {
   const sandboxProviderType = process.env.SANDBOX_PROVIDER_TYPE || "microsandbox-remote";
-  return (0, import_core82.createSandboxProvider)({
+  return (0, import_core92.createSandboxProvider)({
     type: sandboxProviderType,
     remoteBaseURL: process.env.SANDBOX_BASE_URL,
     microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
@@ -30526,7 +31676,7 @@ function getConfiguredSandboxProvider() {
 }
 async function restoreMcpConnections() {
   try {
-    const storeLattice = (0, import_core82.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");
@@ -30537,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_core82.convertToConnection)(config.config);
-        import_core82.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_core82.mcpManager.connectAll();
+    const deps = {
+      store: store2,
+      manager: import_core92.mcpManager,
+      convertToConnection: import_core92.convertToConnection
+    };
     const results = await Promise.allSettled(
       configs.map(
-        (config) => import_core82.mcpManager.registerToolsToToolLattice(
-          config.tenantId,
-          config.key,
-          config.selectedTools
+        (config) => reconcileMcpConfigChange(
+          { tenantId: config.tenantId, serverKey: config.key },
+          deps
         )
       )
     );
@@ -30563,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 }
         );
       }
@@ -30590,9 +31731,9 @@ var start = async (config) => {
     let projectRoomRealtimeRuntime;
     if (projectRoomRealtimeMode === "single-gateway") {
       projectRoomRealtimeRuntime = createProjectRoomRealtimeRuntime({
-        tasks: (0, import_core82.getStoreLattice)("default", "task").store,
-        rooms: (0, import_core82.getStoreLattice)("default", "projectRoom").store,
-        memberships: (0, import_core82.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) }
       });
     }
@@ -30606,7 +31747,7 @@ var start = async (config) => {
       const infrastructure = createChannelInfrastructure({
         adapterRegistry,
         getStore: ((kind) => getStore11("default", kind).store),
-        trustedDispatcher: (0, import_core82.createTrustedAgentMessageDispatcher)((scope) => import_core82.agentInstanceManager.getAgent(scope)),
+        trustedDispatcher: (0, import_core92.createTrustedAgentMessageDispatcher)((scope) => import_core92.agentInstanceManager.getAgent(scope)),
         middlewares: [
           createDeduplicationMiddleware(),
           createRateLimitMiddleware(),
@@ -30617,7 +31758,7 @@ var start = async (config) => {
       });
       const bindingStore = infrastructure.bindingRegistry;
       const installationStore = infrastructure.installationStore;
-      (0, import_core81.setBindingRegistry)(bindingStore);
+      (0, import_core91.setBindingRegistry)(bindingStore);
       const router = infrastructure.router;
       app.addHook("onClose", async () => router.dispose());
       channelDeps = {
@@ -30633,10 +31774,10 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    (0, import_core81.setEvalRunService)(evalRunner);
+    (0, import_core91.setEvalRunService)(evalRunner);
     try {
-      const menuStore = (0, import_core82.getStoreLattice)("default", "menu").store;
-      (0, import_core81.setMenuRegistry)(menuStore);
+      const menuStore = (0, import_core92.getStoreLattice)("default", "menu").store;
+      (0, import_core91.setMenuRegistry)(menuStore);
       logger7.info("Menu registry initialized");
     } catch {
     }
@@ -30653,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_core82.getStoreLattice)("default", "a2aApiKey").store;
-      const assistantStore = (0, import_core82.getStoreLattice)("default", "assistant").store;
-      const projectStore = (0, import_core82.getStoreLattice)("default", "project").store;
-      const taskStore = (0, import_core82.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,
@@ -30695,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_core82.getStoreLattice)("default", "thread").store;
-      const assistantStore = (0, import_core82.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,
@@ -30719,18 +31860,29 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    if (!import_core82.sandboxLatticeManager.hasLattice("default")) {
-      import_core82.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_core82.getStoreLattice)("default", "sharedResource").store;
-      const cache = new import_core82.TokenCache();
+      const sharedResourceStore = (0, import_core92.getStoreLattice)("default", "sharedResource").store;
+      const cache2 = new import_core92.TokenCache();
       const resourceController = new ResourceController2({
         store: sharedResourceStore,
-        sandboxManager: import_core82.sandboxLatticeManager,
-        cache,
+        sandboxManager: import_core92.sandboxLatticeManager,
+        cache: cache2,
         logger: logger7
       });
       registerResourceRoutes(app, resourceController);
@@ -30754,11 +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);
+      });
+    }
+    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);
@@ -30767,13 +32006,6 @@ var start = async (config) => {
         agentTaskConsumer.startPollingQueue();
       }
     }
-    if (process.env.AXIOM_RESTORE_PENDING_ON_STARTUP === "true") {
-      import_core82.agentInstanceManager.restore().then((stats) => {
-        logger7.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
-      }).catch((error) => {
-        logger7.error("Agent recovery failed", { error });
-      });
-    }
     restoreMcpConnections().catch((error) => {
       logger7.error("MCP connection restoration failed", { error });
     });
@@ -30791,6 +32023,17 @@ var LatticeGateway = {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  LatticeGateway
+  LatticeGateway,
+  ProjectRoomEventBroker,
+  ROOM_EVENT_TOPIC,
+  createOrphanRecoveryRuntime,
+  createRecoveryCallerDeps,
+  createTaskRunLiveness,
+  ingestRoomEvent,
+  publishRoomEvent,
+  recoverTask,
+  recoverTopCaller,
+  resolveTopCaller,
+  runOrphanRecovery
 });
 //# sourceMappingURL=index.js.map