@axiom-lattice/gateway 4.6.1 → 4.7.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,298 @@ 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_core66.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)) {
+      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_core66.taskRunRegistry;
+  if (registry.isLive(task.id)) {
+    return { kind: "skipped", reason: "live" };
+  }
+  const { convergedTasks } = await (0, import_core66.reconcileStaleTaskRuns)({
+    tasks: [task],
+    actor: "system:on-demand-recovery",
+    lifecycle: deps.lifecycle,
+    ...deps.registry ? { registry: deps.registry } : {}
+  });
+  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 } : {}
+  });
+  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
+      });
+      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_core66;
+var init_TopCallerRecovery = __esm({
+  "src/services/collaboration/TopCallerRecovery.ts"() {
+    "use strict";
+    import_messages = require("@langchain/core/messages");
+    import_core66 = 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_core67.createTaskLifecycleService)({
+    taskStore: deps.taskStore,
+    workItemStore: deps.workItemStore
+  });
+  return {
+    async recoverAll() {
+      return runOrphanRecovery({
+        reconcile: () => (0, import_core67.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)
+        }),
+        callerFor: deps.callerFor,
+        resume: deps.resume,
+        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" });
+      return recoverTask(task, {
+        lifecycle,
+        registry: import_core67.taskRunRegistry,
+        orphans,
+        callerFor: deps.callerFor,
+        resume: deps.resume
+      });
+    }
+  };
+}
+var import_core67;
+var init_OrphanRecoveryRuntime = __esm({
+  "src/services/collaboration/OrphanRecoveryRuntime.ts"() {
+    "use strict";
+    import_core67 = require("@axiom-lattice/core");
+    init_TopCallerRecovery();
+    init_projectTaskScope();
+  }
+});
+
+// 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_core68.getAgentClientAsync ?? import_core68.getAgentClient;
+      const client = await load(tenantId, top.assistantId);
+      const config = { configurable: { thread_id: top.threadId, runConfig: { tenantId, assistant_id: top.assistantId } } };
+      let agent;
+      try {
+        agent = import_core68.agentInstanceManager.getAgent({ assistant_id: top.assistantId, thread_id: top.threadId, tenant_id: tenantId });
+      } 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_core68;
+var init_RecoveryCallerDeps = __esm({
+  "src/services/collaboration/RecoveryCallerDeps.ts"() {
+    "use strict";
+    import_core68 = require("@axiom-lattice/core");
+  }
+});
+
 // src/channels/wechat/context-store.ts
 function makeKey(installationId, senderId) {
   return `${installationId}::${senderId}`;
@@ -1179,11 +1509,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 +1568,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 +1805,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_core69, 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_core69 = require("@axiom-lattice/core");
     TASK_STATUS_TO_A2A_STATE = {
       pending: "submitted",
       in_progress: "working",
@@ -1507,7 +1837,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_core69.createTaskRunBridge)({
           lifecycle: this.lifecycle,
           taskStore: this.taskStore,
           workItemStore: this.workItemStore
@@ -1858,13 +2188,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_core70, 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_core70 = require("@axiom-lattice/core");
+    import_protocols35 = require("@axiom-lattice/protocols");
     init_a2aFileRefs();
     init_task_file_refs();
     _AxiomAgentExecutor = class _AxiomAgentExecutor {
@@ -1897,16 +2227,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 +2259,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 +2283,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_core70.agentInstanceManager.getAgent(this.agentParams(threadId));
             const requestText = inputFiles.length > 0 ? `${text}
 
 ${formatFileRefsSection(inputFiles)}` : text;
@@ -1963,7 +2308,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 +2316,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 +2426,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 +2478,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_core70.agentInstanceManager.getAgent(this.agentParams(threadId));
             await agent.abort();
           } catch (err) {
             console.warn({
@@ -2151,6 +2489,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 +2852,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_core71.getStoreLattice)("default", "task").store);
+  const resolveTaskWorkItems = deps.getTaskWorkItemStore ?? (() => (0, import_core71.getStoreLattice)("default", "taskWorkItem").store);
+  const getAssistantStore2 = deps.getAssistantStore ?? (() => (0, import_core71.getStoreLattice)("default", "assistant").store);
+  const getProjectStore2 = deps.getProjectStore ?? (() => (0, import_core71.getStoreLattice)("default", "project").store);
   const runtimeRegistry = deps.runtimeRegistry ?? new A2ARuntimeRegistry();
   app2.addHook("onClose", async () => {
     runtimeRegistry.close();
@@ -2580,7 +2938,7 @@ function registerA2AStandardRoutes(app2, deps) {
       const taskStore = assistantHasGovernedTask(assistant) ? new A2ATaskStoreAdapter({
         taskStore: internalTasks,
         workItemStore: workItems,
-        lifecycle: (0, import_core68.createTaskLifecycleService)({
+        lifecycle: (0, import_core71.createTaskLifecycleService)({
           taskStore: internalTasks,
           workItemStore: workItems
         }),
@@ -2699,7 +3057,7 @@ data: ${JSON.stringify(errorResponse)}
       const taskStore = assistantHasGovernedTask(assistant) ? new A2ATaskStoreAdapter({
         taskStore: internalTasks,
         workItemStore: workItems,
-        lifecycle: (0, import_core68.createTaskLifecycleService)({
+        lifecycle: (0, import_core71.createTaskLifecycleService)({
           taskStore: internalTasks,
           workItemStore: workItems
         }),
@@ -2731,6 +3089,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 +3112,13 @@ data: ${JSON.stringify(data)}
     }
   );
 }
-var import_uuid12, import_server2, import_core68, SSE_HEADERS;
+var import_uuid12, import_server2, import_core71, 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_core71 = require("@axiom-lattice/core");
     init_A2AAuthService();
     init_A2AAgentCardBuilder();
     init_A2ATaskStoreAdapter();
@@ -2958,11 +3326,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 +3344,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 +3352,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 {
@@ -3501,8 +3869,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_core72.PluginRegistry.list()) {
+    const plugin = import_core72.PluginRegistry.get(key);
     if (!plugin?.middleware) continue;
     const exposed = exposedDeclarations(plugin);
     if (exposed.length === 0) continue;
@@ -3537,8 +3905,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_core72.PluginRegistry.list()) {
+    const plugin = import_core72.PluginRegistry.get(type);
     if (!plugin?.middleware) continue;
     const exposedNames = new Set(exposedDeclarations(plugin).map((d) => d.name));
     if (exposedNames.size === 0) continue;
@@ -3562,11 +3930,11 @@ function collectExposedPluginUiResources(grants) {
   }
   return resources;
 }
-var import_core69;
+var import_core72;
 var init_registerExposedPlugins = __esm({
   "src/services/open/registerExposedPlugins.ts"() {
     "use strict";
-    import_core69 = require("@axiom-lattice/core");
+    import_core72 = require("@axiom-lattice/core");
     init_openLattice();
     init_pluginExposeAdapter();
   }
@@ -3581,14 +3949,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_core73.getSandboxPluginCatalog)().getValidatedManifest(tenantId, type),
+    getExecutor: () => (0, import_core73.getSandboxPluginCatalog)().getExecutor(),
+    readPluginFile: (tenantId, type, relPath) => (0, import_core73.getSandboxPluginCatalog)().readPluginFile(tenantId, type, relPath)
   };
 }
 async function defaultResolveConnections(pluginType, ctx) {
   try {
-    return await (0, import_core70.resolveSandboxPluginConnections)(
+    return await (0, import_core73.resolveSandboxPluginConnections)(
       pluginType,
       { connectAll: true },
       {
@@ -3617,7 +3985,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_core73.getSandboxPluginCatalog)().ensureLoaded(tenant2);
     return { plugins: snapshot.plugins, diagnostics: snapshot.diagnostics };
   });
   const resolveConnections = deps.resolveConnections ?? defaultResolveConnections;
@@ -3659,7 +4027,7 @@ async function buildTenantOpenPlugins(tenantId, grants, deps = {}) {
         domain,
         action: tool.name,
         description: tool.description,
-        schema: (0, import_core70.jsonSchemaToZod)(tool.schema),
+        schema: (0, import_core73.jsonSchemaToZod)(tool.schema),
         annotations: {
           readOnlyHint: tool.readOnly ?? false,
           destructiveHint: tool.destructive ?? false
@@ -3710,11 +4078,11 @@ async function buildTenantOpenPlugins(tenantId, grants, deps = {}) {
     }
   };
 }
-var import_core70;
+var import_core73;
 var init_tenantOpenPlugins = __esm({
   "src/services/open/tenantOpenPlugins.ts"() {
     "use strict";
-    import_core70 = require("@axiom-lattice/core");
+    import_core73 = require("@axiom-lattice/core");
     init_openLattice();
     init_pluginToolExecution();
   }
@@ -3751,13 +4119,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_core74.getStoreLattice)("default", "a2aApiKey").store,
+    (0, import_core74.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_core74.getStoreLattice)("default", "openAudit").store;
       return new OpenAuditService(store2);
     } catch {
       return void 0;
@@ -3911,12 +4279,12 @@ function registerOpenRoutes(app2, deps = {}) {
     }
   );
 }
-var import_types, import_core71, RPC_ERROR;
+var import_types, import_core74, 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_core74 = require("@axiom-lattice/core");
     init_openCredentialService();
     init_openAuditService();
     init_openRateLimiter();
@@ -3949,7 +4317,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_core75.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 +4342,11 @@ function registerOpenSessionRoutes(app2) {
     }
   );
 }
-var import_core72;
+var import_core75;
 var init_open_session = __esm({
   "src/routes/open-session.ts"() {
     "use strict";
-    import_core72 = require("@axiom-lattice/core");
+    import_core75 = require("@axiom-lattice/core");
     init_openToken();
     init_previewToken();
     init_openLattice();
@@ -3987,13 +4355,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_core76.getSandboxPluginCatalog)().ensureLoaded(tenantId)).plugins;
 }
-var import_core73, OpenCatalogService;
+var import_core76, OpenCatalogService;
 var init_openCatalogService = __esm({
   "src/services/open/openCatalogService.ts"() {
     "use strict";
-    import_core73 = require("@axiom-lattice/core");
+    import_core76 = require("@axiom-lattice/core");
     init_openLattice();
     OpenCatalogService = class {
       constructor(assistantStore, lattice = openLattice, listTenantPlugins2 = defaultListTenantPlugins) {
@@ -4068,17 +4436,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_core77.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_core77;
 var init_open_catalog = __esm({
   "src/routes/open-catalog.ts"() {
     "use strict";
-    import_core74 = require("@axiom-lattice/core");
+    import_core77 = require("@axiom-lattice/core");
     init_openCatalogService();
   }
 });
@@ -4090,7 +4458,7 @@ __export(sandboxProvider_exports, {
   resolveContextSandbox: () => resolveContextSandbox
 });
 async function resolveContextSandbox(ctx) {
-  return import_core75.sandboxLatticeManager.getSandboxFromConfig({
+  return import_core78.sandboxLatticeManager.getSandboxFromConfig({
     assistant_id: "",
     thread_id: "",
     tenantId: ctx.tenantId,
@@ -4188,12 +4556,12 @@ ${truncated}`
     }
   };
 }
-var import_zod21, import_core75, MAX_OUTPUT_BYTES;
+var import_zod21, import_core78, 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_core78 = require("@axiom-lattice/core");
     MAX_OUTPUT_BYTES = 64e3;
   }
 });
@@ -4215,12 +4583,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_core79.getStoreLattice)("default", "a2aApiKey").store,
+    (0, import_core79.getStoreLattice)("default", "project").store
   );
   const audit = deps.audit ?? (() => {
     try {
-      const store2 = (0, import_core76.getStoreLattice)("default", "openAudit").store;
+      const store2 = (0, import_core79.getStoreLattice)("default", "openAudit").store;
       return new OpenAuditService(store2);
     } catch {
       return void 0;
@@ -4330,11 +4698,11 @@ function registerOpenFilesRoutes(app2, deps = {}) {
     }
   });
 }
-var import_core76;
+var import_core79;
 var init_open_files = __esm({
   "src/routes/open-files.ts"() {
     "use strict";
-    import_core76 = require("@axiom-lattice/core");
+    import_core79 = require("@axiom-lattice/core");
     init_openCredentialService();
     init_openLattice();
     init_sandboxProvider();
@@ -4356,7 +4724,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_core80.getStoreLattice)("default", "openAudit").store;
       const records = await store2.query({
         tenantId,
         credentialId: request.query.credentialId,
@@ -4371,11 +4739,11 @@ function registerOpenAuditRoutes(app2) {
     }
   );
 }
-var import_core77;
+var import_core80;
 var init_open_audit = __esm({
   "src/routes/open-audit.ts"() {
     "use strict";
-    import_core77 = require("@axiom-lattice/core");
+    import_core80 = require("@axiom-lattice/core");
   }
 });
 
@@ -4392,12 +4760,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_core81.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 +4794,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_core81.getStoreLattice)("default", "assistant").store;
       const agents = [];
       for (const assistantId of agentGrant?.items ?? []) {
         const assistant = await assistantStore.getAssistantById(
@@ -4461,12 +4829,12 @@ function registerOpenExposureRoutes(app2, deps = {}) {
     }
   );
 }
-var import_core78, import_protocols37;
+var import_core81, 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_core81 = require("@axiom-lattice/core");
+    import_protocols38 = require("@axiom-lattice/protocols");
     init_openLattice();
     init_tenantOpenPlugins();
     init_A2AAgentCardBuilder();
@@ -4585,7 +4953,7 @@ function createAgentProvider(deps = {}) {
         } catch {
         }
       }
-      const agent = import_core79.agentInstanceManager.getAgent({
+      const agent = import_core82.agentInstanceManager.getAgent({
         tenant_id: ctx.tenantId,
         assistant_id: assistantId,
         thread_id: threadId,
@@ -4599,8 +4967,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 +4978,14 @@ function createAgentProvider(deps = {}) {
     }
   };
 }
-var import_zod23, import_core79, import_protocols38, STOP_TYPES;
+var import_zod23, import_core82, 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_core82 = require("@axiom-lattice/core");
+    import_protocols39 = require("@axiom-lattice/protocols");
+    STOP_TYPES = [import_protocols39.MessageChunkTypes.MESSAGE_COMPLETED];
   }
 });
 
@@ -4647,12 +5015,12 @@ var resources_exports = {};
 __export(resources_exports, {
   ResourceController: () => ResourceController
 });
-var import_bcryptjs, import_core80, ResourceController;
+var import_bcryptjs, import_core83, ResourceController;
 var init_resources = __esm({
   "src/controllers/resources.ts"() {
     "use strict";
     import_bcryptjs = __toESM(require("bcryptjs"));
-    import_core80 = require("@axiom-lattice/core");
+    import_core83 = require("@axiom-lattice/core");
     init_mime();
     init_http_range();
     init_sandboxGrants();
@@ -4669,14 +5037,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_core83.createSharePayload)(
           tenantId,
           workspaceId,
           projectId,
           userId,
           body
         );
-        const token = (0, import_core80.generateToken)();
+        const token = (0, import_core83.generateToken)();
         try {
           await this.deps.store.create({ ...payload, token });
           this.deps.logger.info(
@@ -4828,7 +5196,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_core83.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
         return this._resolveAndServe(
           volume,
           subPath,
@@ -5039,7 +5407,13 @@ var init_resources = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  LatticeGateway: () => LatticeGateway
+  LatticeGateway: () => LatticeGateway,
+  createOrphanRecoveryRuntime: () => createOrphanRecoveryRuntime,
+  createRecoveryCallerDeps: () => createRecoveryCallerDeps,
+  recoverTask: () => recoverTask,
+  recoverTopCaller: () => recoverTopCaller,
+  resolveTopCaller: () => resolveTopCaller,
+  runOrphanRecovery: () => runOrphanRecovery
 });
 module.exports = __toCommonJS(index_exports);
 var import_config2 = require("dotenv/config");
@@ -5715,7 +6089,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 +6226,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);
@@ -5953,9 +6342,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 = {
@@ -6054,9 +6441,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,
@@ -6114,9 +6499,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,
@@ -6139,9 +6522,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,
@@ -6229,7 +6610,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 +6642,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 +8453,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 +10612,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";
   }
 };
@@ -15309,7 +15690,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 +15698,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;
   }
@@ -16929,40 +17310,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 +17427,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```$/;
@@ -17332,16 +17682,16 @@ var ProjectTaskExecutionService = class {
       );
       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 +17703,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 +17712,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 +17931,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 +18024,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) {
@@ -22413,8 +22763,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 +22813,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) {
@@ -23843,6 +24193,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 +24251,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() {
@@ -24213,6 +24564,7 @@ var ProjectTaskExecutionMutex = class {
 var import_node_crypto22 = require("crypto");
 var import_core49 = require("@axiom-lattice/core");
 var import_protocols23 = require("@axiom-lattice/protocols");
+init_projectTaskScope();
 var SYSTEM_ACTOR2 = "system";
 var TERMINAL_ACTIONS = ["completed", "failed", "interrupted", "cancelled"];
 var ProjectTaskObserver = class {
@@ -24412,7 +24764,7 @@ 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;
         }
       }
@@ -24511,7 +24863,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 +24884,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") 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 +24927,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 +25130,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 +25427,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,6 +25797,9 @@ 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");
 
@@ -25961,6 +26318,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 +26373,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() {
@@ -27388,7 +27746,7 @@ var registerLatticeRoutes = (app2, channelDeps, options = {}) => {
         label: (key) => key
       },
       messageReader: {
-        getCurrentMessages: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core51.agentInstanceManager.getAgent({
+        getCurrentMessages: ({ tenantId, assistantId, threadId, workspaceId, projectId }) => import_core51.agentInstanceManager.getAgentForRead({
           tenant_id: tenantId,
           assistant_id: assistantId,
           thread_id: threadId,
@@ -29368,7 +29726,7 @@ function createAuditLoggerMiddleware() {
 }
 
 // src/index.ts
-var import_core81 = require("@axiom-lattice/core");
+var import_core84 = require("@axiom-lattice/core");
 
 // src/swagger.ts
 var import_swagger = __toESM(require("@fastify/swagger"));
@@ -29435,6 +29793,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 // src/services/agent_task_consumer.ts
 var import_node_crypto27 = require("crypto");
 var import_core63 = require("@axiom-lattice/core");
+var import_protocols31 = require("@axiom-lattice/protocols");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -29452,7 +29811,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_core63.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)();
@@ -29483,8 +29843,8 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
                 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;
@@ -29732,14 +30092,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_core85 = require("@axiom-lattice/core");
 
 // src/channels/ChannelInfrastructure.ts
 var import_core65 = require("@axiom-lattice/core");
 
 // src/router/MessageRouter.ts
 var import_core64 = require("@axiom-lattice/core");
-var import_protocols31 = require("@axiom-lattice/protocols");
+var import_protocols32 = require("@axiom-lattice/protocols");
 var import_crypto12 = require("crypto");
 var BindingNotFoundError = class extends Error {
   constructor(message) {
@@ -29774,10 +30134,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;
@@ -30289,7 +30649,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 +30710,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;
   }
@@ -30395,25 +30755,28 @@ async function prepareProjectTaskRuntime(runtime, log2) {
 }
 
 // src/index.ts
-var import_protocols39 = require("@axiom-lattice/protocols");
+var import_protocols40 = require("@axiom-lattice/protocols");
+init_TopCallerRecovery();
+init_OrphanRecoveryRuntime();
+init_RecoveryCallerDeps();
 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_core85.loggerLatticeManager.hasLattice("default")) {
+    import_core85.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core82.registerLoggerLattice)("default", config);
-  return (0, import_core82.getLoggerLattice)("default");
+  (0, import_core85.registerLoggerLattice)("default", config);
+  return (0, import_core85.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -30510,7 +30873,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_core85.createSandboxProvider)({
     type: sandboxProviderType,
     remoteBaseURL: process.env.SANDBOX_BASE_URL,
     microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
@@ -30526,7 +30889,7 @@ function getConfiguredSandboxProvider() {
 }
 async function restoreMcpConnections() {
   try {
-    const storeLattice = (0, import_core82.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core85.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     if (!store2) {
       logger7.info("MCP store not configured, skipping connection restoration");
@@ -30539,8 +30902,8 @@ async function restoreMcpConnections() {
     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, {
+        const connection = (0, import_core85.convertToConnection)(config.config);
+        import_core85.mcpManager.registerServer(config.tenantId, config.key, connection, {
           timeoutMs: config.config.timeout,
           maxAttempts: config.config.retryAttempts,
           selectedTools: config.selectedTools
@@ -30549,10 +30912,10 @@ async function restoreMcpConnections() {
         logger7.warn(`Failed to prepare MCP server "${config.tenantId}/${config.key}"`, { error: err });
       }
     }
-    await import_core82.mcpManager.connectAll();
+    await import_core85.mcpManager.connectAll();
     const results = await Promise.allSettled(
       configs.map(
-        (config) => import_core82.mcpManager.registerToolsToToolLattice(
+        (config) => import_core85.mcpManager.registerToolsToToolLattice(
           config.tenantId,
           config.key,
           config.selectedTools
@@ -30590,9 +30953,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_core85.getStoreLattice)("default", "task").store,
+        rooms: (0, import_core85.getStoreLattice)("default", "projectRoom").store,
+        memberships: (0, import_core85.getStoreLattice)("default", "projectBotMembership").store,
         log: { warn: (message, context) => logger7.warn(message, context) }
       });
     }
@@ -30606,7 +30969,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_core85.createTrustedAgentMessageDispatcher)((scope) => import_core85.agentInstanceManager.getAgent(scope)),
         middlewares: [
           createDeduplicationMiddleware(),
           createRateLimitMiddleware(),
@@ -30617,7 +30980,7 @@ var start = async (config) => {
       });
       const bindingStore = infrastructure.bindingRegistry;
       const installationStore = infrastructure.installationStore;
-      (0, import_core81.setBindingRegistry)(bindingStore);
+      (0, import_core84.setBindingRegistry)(bindingStore);
       const router = infrastructure.router;
       app.addHook("onClose", async () => router.dispose());
       channelDeps = {
@@ -30633,10 +30996,10 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    (0, import_core81.setEvalRunService)(evalRunner);
+    (0, import_core84.setEvalRunService)(evalRunner);
     try {
-      const menuStore = (0, import_core82.getStoreLattice)("default", "menu").store;
-      (0, import_core81.setMenuRegistry)(menuStore);
+      const menuStore = (0, import_core85.getStoreLattice)("default", "menu").store;
+      (0, import_core84.setMenuRegistry)(menuStore);
       logger7.info("Menu registry initialized");
     } catch {
     }
@@ -30653,10 +31016,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_core85.getStoreLattice)("default", "a2aApiKey").store;
+      const assistantStore = (0, import_core85.getStoreLattice)("default", "assistant").store;
+      const projectStore = (0, import_core85.getStoreLattice)("default", "project").store;
+      const taskStore = (0, import_core85.getStoreLattice)("default", "task").store;
       const authService = new A2AAuthService2({
         keyStore: a2aKeyStore,
         assistantStore,
@@ -30695,8 +31058,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_core85.getStoreLattice)("default", "thread").store;
+      const assistantStore = (0, import_core85.getStoreLattice)("default", "assistant").store;
       openLattice2.register(
         createAgentProvider2({
           threadStore,
@@ -30719,17 +31082,17 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    if (!import_core82.sandboxLatticeManager.hasLattice("default")) {
-      import_core82.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
+    if (!import_core85.sandboxLatticeManager.hasLattice("default")) {
+      import_core85.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_core85.getStoreLattice)("default", "sharedResource").store;
+      const cache = new import_core85.TokenCache();
       const resourceController = new ResourceController2({
         store: sharedResourceStore,
-        sandboxManager: import_core82.sandboxLatticeManager,
+        sandboxManager: import_core85.sandboxLatticeManager,
         cache,
         logger: logger7
       });
@@ -30757,6 +31120,25 @@ var start = async (config) => {
     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 taskStore = (0, import_core85.getStoreLattice)("default", "task").store;
+        const workItemStore = (0, import_core85.getStoreLattice)("default", "taskWorkItem").store;
+        const tenantStore = (0, import_core85.getStoreLattice)("default", "tenant").store;
+        const runtime = createOrphanRecoveryRuntime2({
+          taskStore,
+          workItemStore,
+          tenantStore,
+          ...createRecoveryCallerDeps2(),
+          log: logger7
+        });
+        await runtime.recoverAll();
+      } catch (err) {
+        logger7.warn("Task orphan recovery failed", { error: err instanceof Error ? err.message : String(err) });
+      }
+    }
     await app.listen({ port: target_port, host: "0.0.0.0" });
     logger7.info(`Lattice Gateway is running on port: ${target_port}`);
     const queueServiceConfig = config?.queueServiceConfig;
@@ -30767,13 +31149,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 +31166,12 @@ var LatticeGateway = {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  LatticeGateway
+  LatticeGateway,
+  createOrphanRecoveryRuntime,
+  createRecoveryCallerDeps,
+  recoverTask,
+  recoverTopCaller,
+  resolveTopCaller,
+  runOrphanRecovery
 });
 //# sourceMappingURL=index.js.map