@axiom-lattice/core 5.0.0 → 6.0.0

package/dist/index.mjs

@@ -28847,7 +28847,7 @@ var agentArchitectConfig = {
     "delete_agent",
     "manage_binding"
   ],
-  subAgents: ["document-parser-benchmark"],
+  subAgents: ["document-parser", "document-parser-benchmark"],
   middleware: [
     {
       id: "filesystem",
@@ -30552,6 +30552,7 @@ async function removeCollectionVectorStore(name, tenantId2) {
 
 // src/mcp_lattice/McpLatticeManager.ts
 import { MultiServerMCPClient } from "@langchain/mcp-adapters";
+import { DynamicStructuredTool as DynamicStructuredTool2 } from "@langchain/core/tools";
 
 // src/mcp_lattice/reconnectPolicy.ts
 var DEFAULT_CONNECT_TIMEOUT_MS = 15e3;
@@ -30560,6 +30561,13 @@ var DEFAULT_DELAY_MS = 1e3;
 var MAX_BACKOFF_MS = 3e4;
 var HEALTH_CHECK_INTERVAL_MS = 3e4;
 var HEALTH_CHECK_TIMEOUT_MS = 5e3;
+function isMcpConnectionError(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  if (!message) return false;
+  return /not connected|connection closed|session not found|no session|maximum reconnection/i.test(
+    message
+  );
+}
 function nextBackoffDelay(attempt, base = DEFAULT_DELAY_MS, max = MAX_BACKOFF_MS) {
   if (attempt <= 0) return base;
   return Math.min(base * Math.pow(2, attempt - 1), max);
@@ -30584,12 +30592,21 @@ async function withTimeout(operation, ms, onTimeout) {
 
 // src/mcp_lattice/McpLatticeManager.ts
 var realClientFactory = ({ mcpServers }) => new MultiServerMCPClient({ mcpServers });
+function extractRawCall(tool68) {
+  const rawCall = tool68._call;
+  if (typeof rawCall === "function") return rawCall.bind(tool68);
+  return async (...args) => {
+    const invoke = tool68.invoke.bind(tool68);
+    return invoke(args[0], args[2]);
+  };
+}
 var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
   constructor() {
     super(...arguments);
     this.runtimes = /* @__PURE__ */ new Map();
     this.clientFactory = realClientFactory;
     this.healthCheckInFlight = false;
+    this.reconnectPromises = /* @__PURE__ */ new Map();
   }
   static getInstance() {
     if (!_McpLatticeManager._instance) {
@@ -30847,6 +30864,64 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     rt.attempt = 0;
     await this.reconnectRuntime(rt);
   }
+  /**
+   * Single-flight a forced reconnect per `(tenantId, serverKey)` so concurrent
+   * tool calls that all hit the same dead session reconnect once, not once each.
+   */
+  reconnectShared(rt) {
+    const key5 = this.compositeKey(rt.id.tenantId, rt.id.serverKey);
+    const existing = this.reconnectPromises.get(key5);
+    if (existing) return existing;
+    const work = this.reconnectServer(rt.id.tenantId, rt.id.serverKey).finally(() => {
+      if (this.reconnectPromises.get(key5) === work) this.reconnectPromises.delete(key5);
+    });
+    this.reconnectPromises.set(key5, work);
+    return work;
+  }
+  /**
+   * Wrap a raw MCP tool so a call landing on a torn-down session
+   * (`Not connected` / `Connection closed` / session expiry) transparently
+   * forces a reconnect and retries once against the fresh client, instead of
+   * failing the surrounding run. Non-connection errors propagate untouched.
+   */
+  wrapToolForResilience(rt, raw) {
+    const call = extractRawCall(raw);
+    return new DynamicStructuredTool2({
+      name: raw.name,
+      description: raw.description,
+      schema: raw.schema,
+      responseFormat: raw.responseFormat,
+      defaultConfig: raw.defaultConfig,
+      metadata: raw.metadata,
+      returnDirect: raw.returnDirect,
+      func: async (...args) => this.invokeResilient(rt, raw.name, call, args)
+    });
+  }
+  async invokeResilient(rt, toolName2, call, args) {
+    try {
+      await this.ensureConnected(rt.id.tenantId, rt.id.serverKey);
+      return await call(...args);
+    } catch (error) {
+      if (!isMcpConnectionError(error) || !this.isActive(rt)) throw error;
+      console.warn(
+        `[MCP] ${rt.id.tenantId}/${rt.id.serverKey}: tool "${toolName2}" hit a dead session; reconnecting and retrying once`,
+        error instanceof Error ? error.message : error
+      );
+      try {
+        await this.reconnectShared(rt);
+      } catch (reconnectError) {
+        console.warn(
+          `[MCP] ${rt.id.tenantId}/${rt.id.serverKey}: reconnect for tool "${toolName2}" failed`,
+          reconnectError instanceof Error ? reconnectError.message : reconnectError
+        );
+        throw error;
+      }
+      const fresh = await this.getRawTools(rt.id.tenantId, rt.id.serverKey);
+      const match = fresh.find((t) => t.name === toolName2);
+      if (!match) throw error;
+      return await extractRawCall(match)(...args);
+    }
+  }
   async checkHealth() {
     if (this.healthCheckInFlight) return;
     this.healthCheckInFlight = true;
@@ -30865,8 +30940,12 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
           await withTimeout(session.listTools(), HEALTH_CHECK_TIMEOUT_MS, async () => {
           });
           if (!this.isActive(rt) || rt.state !== "connected") continue;
-        } catch {
+        } catch (error) {
           if (this.isActive(rt) && rt.state === "connected") {
+            console.warn(
+              `[MCP] ${rt.id.tenantId}/${rt.id.serverKey}: health check failed; scheduling reconnect`,
+              error instanceof Error ? error.message : error
+            );
             rt.state = "failed";
             this.scheduleReconnect(rt);
           }
@@ -31072,7 +31151,8 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
       const visibility = Array.isArray(rawVisibility) ? rawVisibility : typeof rawVisibility === "string" ? [rawVisibility] : void 0;
       if (visibility && !visibility.includes("model")) continue;
       const ref = extractAppsRef(meta, serverKey);
-      const registered = ref ? wrapMcpToolWithUi(tool68, ref) : tool68;
+      const resilient = this.wrapToolForResilience(rt, tool68);
+      const registered = ref ? wrapMcpToolWithUi(resilient, ref) : resilient;
       const toolKey = _McpLatticeManager.buildToolKey(serverKey, tool68.name);
       try {
         toolLatticeManager.registerExistingToolWithTenant(tenantId2, toolKey, registered);
@@ -31141,6 +31221,7 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
       }
     }
     this.runtimes.clear();
+    this.reconnectPromises.clear();
   }
 };
 var mcpManager = McpLatticeManager.getInstance();
@@ -35240,7 +35321,7 @@ function snapshotDate(value) {
 
 // src/services/TaskLifecycleService.ts
 import { createHash as createHash6 } from "crypto";
-import { parseTaskBeliefState, replaceTaskBeliefState, snapshotExactArray as snapshotExactArray2, snapshotExactRecord as snapshotExactRecord7, taskBeliefStatesEqual } from "@axiom-lattice/protocols";
+import { parseTaskBeliefState, replaceTaskBeliefState, taskBeliefStatesEqual } from "@axiom-lattice/protocols";
 
 // src/middlewares/taskBelief.ts
 import { createHash as createHash5 } from "crypto";
@@ -35352,14 +35433,6 @@ async function applyBeliefImpacts(taskStore, owner, impacts) {
   }
   return { description: current.description ?? "", task: current };
 }
-function parseExternalDependency(value) {
-  const row = snapshotExactRecord7(value, ["type", "summary", "requestedAt", "dependencyTaskIds"]);
-  const ids = snapshotExactArray2(row?.dependencyTaskIds);
-  if (!row || row.type !== "external_dependency" || typeof row.summary !== "string" || !row.summary.trim() || typeof row.requestedAt !== "string" || !Number.isFinite(Date.parse(row.requestedAt)) || !ids || ids.length === 0 || ids.some((id) => typeof id !== "string" || !id.trim())) return void 0;
-  const trimmed = ids.map((id) => id.trim());
-  if (new Set(trimmed).size !== trimmed.length) return void 0;
-  return { type: "external_dependency", summary: row.summary, requestedAt: row.requestedAt, dependencyTaskIds: trimmed };
-}
 function unsupportedTaskStatus() {
   return failure2(
     "TASK_STATUS_UNSUPPORTED",
@@ -35658,9 +35731,6 @@ var TaskLifecycleService = class {
       if (interruption && typeof interruption === "object" && interruption.type === "review_required") {
         return failure2("REVIEW_APPROVAL_REQUIRED", "Review interruption requires explicit approval or rejection.");
       }
-      if (interruption && typeof interruption === "object" && interruption.type === "external_dependency" && !parseExternalDependency(interruption)) {
-        return failure2("INVALID_EXTERNAL_DEPENDENCY", "Stored external dependency interruption is malformed.");
-      }
       const previousInterruption = interruption && typeof interruption === "object" ? interruption : {};
       const resumeKey = this.resumeEventKey(task);
       const audit = { eventKey: resumeKey, previousInterruption };
@@ -35841,6 +35911,108 @@ var TaskLifecycleService = class {
       detail: { previousStatus: "failed" }
     });
   }
+  /**
+   * Reopens a terminal agent task by returning it to in_progress.
+   *
+   * @param input Task, actor, and optional thread.
+   * @returns Structured lifecycle result. `completed` and `cancelled` tasks
+   *   reopen to `in_progress`; an already-`in_progress` task is acknowledged
+   *   without mutation; any other status or a lost CAS yields
+   *   `TASK_STATUS_CONFLICT`.
+   * @remarks This is the single reverse edge of the terminal-irreversibility
+   *   relaxation. It records the status change only; re-dispatch is owned by
+   *   the application layer and is never triggered here.
+   */
+  async reopenTask(input) {
+    return this.transitionAgentTask({
+      ...input,
+      targetStatus: "in_progress",
+      expectedStatuses: ["completed", "cancelled"],
+      updates: { status: "in_progress", failureReason: null, result: null },
+      summary: "Task reopened",
+      detail: { type: "reopen" }
+    });
+  }
+  /**
+   * Transfers a human-authored task's ownership to a chosen Agent before dispatch.
+   *
+   * @param input Task, actor, destination Agent, and optional Task Thread.
+   * @returns Structured result with the reassigned owner and an `owner_assigned` audit.
+   * @remarks Only tasks with `context.source === "user"` can be assigned this way.
+   *   Repeated assignment to the same owner is idempotent (repair-writes the audit
+   *   without a CAS). This changes owner only, never status, so it publishes no
+   *   Project lifecycle notification.
+   */
+  async assignOwner(input) {
+    let task;
+    try {
+      task = await this.deps.taskStore.getById(input.tenantId, input.taskId);
+    } catch {
+      return failure2("TASK_STORE_READ_FAILED", "Failed to read task lifecycle state.");
+    }
+    if (!task) return failure2("TASK_NOT_FOUND", "Task was not found.");
+    if (task.context?.source !== "user") {
+      return failure2("TASK_NOT_HUMAN_MANAGED", "Only user-authored tasks can be assigned to an Agent.");
+    }
+    const storedThreadId = typeof task.context?.thread_id === "string" && task.context.thread_id.length > 0 ? task.context.thread_id : void 0;
+    const effectiveThreadId = storedThreadId ?? input.threadId;
+    const detail = { type: "owner_assigned", fromOwnerType: task.ownerType, toOwnerId: input.ownerId };
+    if (task.ownerType === "agent" && task.ownerId === input.ownerId && (input.threadId === void 0 || storedThreadId === input.threadId)) {
+      const eventKey2 = this.statusEventKey(task, "owner_assigned", detail);
+      const event2 = await this.writeStatusEvent(
+        task,
+        input.actor,
+        effectiveThreadId,
+        "activity",
+        "Task owner assigned",
+        detail,
+        eventKey2
+      );
+      return {
+        success: true,
+        task,
+        mutated: false,
+        eventKey: event2.eventKey,
+        ...event2.warning ? { warnings: [event2.warning] } : {}
+      };
+    }
+    const context = { ...task.context ?? {} };
+    if (input.threadId && !storedThreadId) context.thread_id = input.threadId;
+    let updated;
+    try {
+      updated = await this.deps.taskStore.updateIfStatusAndUpdatedAt(
+        input.tenantId,
+        input.taskId,
+        { ownerType: "agent", ownerId: input.ownerId, context },
+        [task.status],
+        task.updatedAt
+      );
+    } catch {
+      return failure2(
+        "TASK_STORE_WRITE_FAILED",
+        "Failed to assign the task owner.",
+        "The store rejected the write."
+      );
+    }
+    if (!updated) return failure2("TASK_STATUS_CONFLICT", "Task changed concurrently.");
+    const eventKey = this.statusEventKey(updated, "owner_assigned", detail);
+    const event = await this.writeStatusEvent(
+      updated,
+      input.actor,
+      effectiveThreadId,
+      "activity",
+      "Task owner assigned",
+      detail,
+      eventKey
+    );
+    return {
+      success: true,
+      task: updated,
+      mutated: true,
+      eventKey: event.eventKey,
+      ...event.warning ? { warnings: [event.warning] } : {}
+    };
+  }
   /** Atomically cancels a nonterminal agent task and records an idempotent status event. */
   async cancelTask(input) {
     return this.transitionAgentTask({
@@ -35921,19 +36093,7 @@ var TaskLifecycleService = class {
   async interruptTask(input) {
     const summary = input.summary.trim();
     if (!summary) return failure2("MISSING_INTERRUPTION_SUMMARY", "Agent interruption requires a nonblank summary.");
-    if (input.type !== "external_dependency" && input.dependencyTaskIds !== void 0) {
-      return failure2("INVALID_EXTERNAL_DEPENDENCY", "dependencyTaskIds are only valid for external dependencies.");
-    }
     const requestedAt = this.now().toISOString();
-    const external = input.type === "external_dependency" ? parseExternalDependency({
-      type: input.type,
-      summary,
-      requestedAt,
-      dependencyTaskIds: input.dependencyTaskIds
-    }) : void 0;
-    if (input.type === "external_dependency" && !external) {
-      return failure2("INVALID_EXTERNAL_DEPENDENCY", "External dependencies require exact, unique nonblank task IDs.");
-    }
     let task;
     try {
       task = await this.deps.taskStore.getById(input.tenantId, input.taskId);
@@ -35947,29 +36107,17 @@ var TaskLifecycleService = class {
     if (threadFailure) return threadFailure;
     const currentInterruption = task.context?.interruption;
     if (task.status === "interrupted" && currentInterruption && typeof currentInterruption === "object") {
-      const storedExternal = parseExternalDependency(currentInterruption);
-      if (input.type === "external_dependency") {
-        if (!external || !storedExternal || storedExternal.summary !== external.summary || canonicalJson(storedExternal.dependencyTaskIds) !== canonicalJson(external.dependencyTaskIds)) {
-          return failure2(
-            "TASK_STATUS_CONFLICT",
-            "Task is already interrupted by a different or malformed external dependency.",
-            "Use manage_task get to inspect the existing interruption in task context.interruption."
-          );
-        }
-      } else if (currentInterruption.type !== input.type || currentInterruption.summary !== summary) {
+      if (currentInterruption.type !== input.type || currentInterruption.summary !== summary) {
         return failure2(
           "TASK_STATUS_CONFLICT",
           "Task is already interrupted by a different request.",
           "Use manage_task get to inspect the existing interruption, or resume it first."
         );
       }
-      const detail = storedExternal ? { ...storedExternal } : currentInterruption;
+      const detail = currentInterruption;
       const eventKey2 = this.statusEventKey(task, "interrupted", detail);
       const event2 = await this.writeStatusEvent(task, input.actor, input.threadId, "interrupted", summary, detail, eventKey2);
       const warnings2 = event2.warning ? [event2.warning] : [];
-      if (storedExternal && task.workspaceId && task.projectId) {
-        return this.finishExternalDependencyInterruption(task, input, storedExternal, event2, warnings2, false);
-      }
       return {
         success: true,
         task,
@@ -35985,11 +36133,7 @@ var TaskLifecycleService = class {
         "Only pending or in_progress tasks can be interrupted. Use manage_task get to check the current status."
       );
     }
-    if (external && task.workspaceId && task.projectId) {
-      const dependencyFailure = await this.validateExternalDependencies(task, external.dependencyTaskIds);
-      if (dependencyFailure) return dependencyFailure;
-    }
-    const interruption = external ? { ...external } : { type: input.type, summary, requestedAt };
+    const interruption = { type: input.type, summary, requestedAt };
     let updated;
     try {
       updated = await this.deps.taskStore.updateIfStatusAndUpdatedAt(input.tenantId, input.taskId, {
@@ -36011,9 +36155,6 @@ var TaskLifecycleService = class {
     const eventKey = this.statusEventKey(updated, "interrupted", interruption);
     const event = await this.writeStatusEvent(updated, input.actor, input.threadId, "interrupted", summary, interruption, eventKey);
     const warnings = event.warning ? [event.warning] : await this.notifyWinningTransition(updated, "interrupted", event);
-    if (external && updated.workspaceId && updated.projectId) {
-      return this.finishExternalDependencyInterruption(updated, input, external, event, warnings, true);
-    }
     return {
       success: true,
       task: updated,
@@ -37252,7 +37393,9 @@ var TaskLifecycleService = class {
       };
     }
     if (!input.expectedStatuses.includes(task.status)) return failure2("TASK_STATUS_CONFLICT", "Task status cannot make this transition.");
-    const updates = { ...input.updates, context: clearInterruptionContext(task.context) };
+    const clearedContext = clearInterruptionContext(task.context);
+    const withThread = input.threadId && task.context?.thread_id === void 0 ? { ...clearedContext ?? {}, thread_id: input.threadId } : clearedContext;
+    const updates = { ...input.updates, context: withThread };
     let updated;
     try {
       updated = await this.deps.taskStore.updateIfStatusAndUpdatedAt(
@@ -37340,85 +37483,6 @@ var TaskLifecycleService = class {
       return [{ code: "LIFECYCLE_NOTIFICATION_FAILED", taskId: task.id, eventKey: event.eventKey }];
     }
   }
-  async validateExternalDependencies(task, dependencyTaskIds) {
-    const declared = new Set(task.dependencies ?? []);
-    if (dependencyTaskIds.some((id) => id === task.id || !declared.has(id))) {
-      return failure2("INVALID_EXTERNAL_DEPENDENCY", "External dependency IDs must be declared non-self dependencies.");
-    }
-    try {
-      for (const id of dependencyTaskIds) {
-        const dependency = await this.deps.taskStore.getById(task.tenantId, id);
-        if (!dependency || dependency.workspaceId !== task.workspaceId || dependency.projectId !== task.projectId || dependency.status === "completed") {
-          return failure2("INVALID_EXTERNAL_DEPENDENCY", "External dependencies must exist, remain incomplete, and share exact scope.");
-        }
-      }
-    } catch {
-      return failure2("TASK_STORE_READ_FAILED", "Failed to validate external dependencies.");
-    }
-    return void 0;
-  }
-  async externalDependencyReadiness(task, dependencyTaskIds) {
-    try {
-      for (const id of dependencyTaskIds) {
-        const dependency = await this.deps.taskStore.getById(task.tenantId, id);
-        if (!dependency || dependency.workspaceId !== task.workspaceId || dependency.projectId !== task.projectId || dependency.status !== "completed") return { kind: "blocked" };
-      }
-      return { kind: "ready" };
-    } catch {
-      return {
-        kind: "error",
-        warning: { code: "DEPENDENCY_READ_FAILED", taskId: task.id }
-      };
-    }
-  }
-  async finishExternalDependencyInterruption(task, input, interruption, event, warnings, mutated) {
-    if (event.warning) {
-      return { success: true, task, mutated, eventKey: event.eventKey, warnings };
-    }
-    const readiness = await this.externalDependencyReadiness(task, interruption.dependencyTaskIds);
-    if (readiness.kind === "blocked") {
-      return { success: true, task, mutated, eventKey: event.eventKey, ...warnings.length ? { warnings } : {} };
-    }
-    if (readiness.kind === "error") {
-      return {
-        success: true,
-        task,
-        mutated,
-        eventKey: event.eventKey,
-        warnings: [...warnings, { ...readiness.warning, eventKey: event.eventKey }]
-      };
-    }
-    const resumed = await this.resumeInterruption({
-      tenantId: input.tenantId,
-      taskId: input.taskId,
-      actor: input.actor,
-      threadId: input.threadId
-    });
-    if (resumed.success) {
-      const combined = [...warnings, ...resumed.warnings ?? []];
-      return {
-        ...resumed,
-        mutated: mutated || resumed.mutated,
-        ...combined.length ? { warnings: combined } : {}
-      };
-    }
-    let current;
-    try {
-      current = await this.deps.taskStore.getById(input.tenantId, input.taskId);
-    } catch {
-      return resumed;
-    }
-    if (current?.status === "in_progress" && (!current.context?.thread_id || current.context?.thread_id === input.threadId)) {
-      return {
-        success: true,
-        task: current,
-        mutated,
-        eventKey: event.eventKey,
-        ...warnings.length ? { warnings } : {}
-      };
-    }
-    return resumed;
-  }
   async clearAuditMarker(task, key5) {
     const context = withoutContextKey(task.context, key5);
     try {
@@ -41316,6 +41380,9 @@ function trustedRosterScope(trusted) {
     callerAssistantId: context.assistantId
   };
 }
+function trustedRosterExempt(trusted) {
+  return trusted.projectTask?.rosterExempt === true;
+}
 async function requireTrustedOwner(trusted, targetAssistantId) {
   const context = trusted.projectTask ?? trusted.projectRoom;
   const memberships = getStoreLattice("default", "projectBotMembership").store;
@@ -41580,6 +41647,7 @@ async function validateTrustedChildDependencyWait(store, tenantId2, parent, depe
     if (dependency.status === "completed") continue;
     if (!["pending", "in_progress", "interrupted"].includes(dependency.status) || dependency.parentId !== parent.id || dependency.ownerType !== "agent" || !hasExactContextSource(dependency, expectedSource)) return void 0;
     incompleteChildren += 1;
+    if (trustedRosterExempt(trusted)) continue;
     try {
       await requireTrustedOwner(trusted, dependency.ownerId);
     } catch (error) {
@@ -41654,7 +41722,6 @@ var manageTaskSchema = z70.object({
   ownerId: z70.string().optional().describe("Owner ID. Auto-filled from current user/agent if omitted"),
   requireReview: z70.boolean().optional().describe("If true, agent completion pauses as interrupted(review_required) for HITL approval"),
   dependencies: z70.array(z70.string()).optional().describe("List of task IDs that must be completed before this task can start"),
-  dependencyTaskIds: z70.array(z70.string().trim().min(1)).optional().describe("Exact blocking task IDs required for an external_dependency interruption"),
   result: z70.string().optional().describe("Result summary. Used with set_status status='completed' or update status='completed'"),
   failureReason: z70.string().optional().describe("Failure reason. Used with set_status status='failed' or update status='failed'"),
   files: z70.array(z70.object({
@@ -41823,7 +41890,7 @@ function createTaskMiddleware(options = {}) {
     const workspaceId = trustedScope?.workspaceId ?? rc.workspaceId;
     const projectId = trustedScope?.projectId ?? rc.projectId;
     const revalidateCaller = async () => {
-      if (!trustedProject) return void 0;
+      if (!trustedProject || trustedRosterExempt(trustedProject)) return void 0;
       try {
         await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
       } catch (error) {
@@ -41831,7 +41898,7 @@ function createTaskMiddleware(options = {}) {
       }
       return void 0;
     };
-    if (trustedProject) {
+    if (trustedProject && !trustedRosterExempt(trustedProject)) {
       try {
         await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
       } catch (error) {
@@ -41864,10 +41931,12 @@ function createTaskMiddleware(options = {}) {
       if (trustedProject) {
         const snapshot = taskMutationSnapshot(existing);
         if (!snapshot) return trustedContextError();
-        try {
-          await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
-        } catch (error) {
-          return projectPolicyError(error);
+        if (!trustedRosterExempt(trustedProject)) {
+          try {
+            await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
+          } catch (error) {
+            return projectPolicyError(error);
+          }
         }
         deleted = await store.deleteIfSnapshot(tenantId2, id, snapshot);
       } else {
@@ -41920,13 +41989,15 @@ function createTaskMiddleware(options = {}) {
               "Target Project task owner is not active in the exact roster."
             ));
           }
-          try {
-            await requireTrustedOwner(trustedProject, ownerId);
-          } catch (error) {
-            return projectPolicyError(error instanceof ProjectTaskOwnerPolicyError ? error : new ProjectTaskOwnerPolicyError(
-              "PROJECT_TASK_OWNER_INACTIVE",
-              "Target Project task owner is not active in the exact roster."
-            ));
+          if (!trustedRosterExempt(trustedProject)) {
+            try {
+              await requireTrustedOwner(trustedProject, ownerId);
+            } catch (error) {
+              return projectPolicyError(error instanceof ProjectTaskOwnerPolicyError ? error : new ProjectTaskOwnerPolicyError(
+                "PROJECT_TASK_OWNER_INACTIVE",
+                "Target Project task owner is not active in the exact roster."
+              ));
+            }
           }
         }
         if (effectiveOwnerType === "agent" && (input.result !== void 0 || input.failureReason !== void 0)) {
@@ -41974,10 +42045,12 @@ function createTaskMiddleware(options = {}) {
             )) return trustedContextError("Parent or dependency task changed before creation.");
             const callerError = await revalidateCaller();
             if (callerError) return callerError;
-            try {
-              await requireTrustedOwner(trustedProject, ownerId);
-            } catch (error) {
-              return projectPolicyError(error);
+            if (!trustedRosterExempt(trustedProject)) {
+              try {
+                await requireTrustedOwner(trustedProject, ownerId);
+              } catch (error) {
+                return projectPolicyError(error);
+              }
             }
           }
           return store.create({
@@ -42235,18 +42308,6 @@ function createTaskMiddleware(options = {}) {
             return trustedFailure;
           }
         }
-        if (trustedProject && input.dependencyTaskIds !== void 0) {
-          const interruption = input.context?.interruption;
-          const interruptionType2 = interruption && typeof interruption === "object" ? interruption.type : void 0;
-          if (input.status !== "interrupted" || interruptionType2 !== "external_dependency") {
-            taskUpdateBlocked(input.id, "INVALID_EXTERNAL_DEPENDENCY", {});
-            return JSON.stringify({
-              success: false,
-              code: "INVALID_EXTERNAL_DEPENDENCY",
-              error: "dependencyTaskIds are only valid for external dependency interruptions."
-            });
-          }
-        }
         if (trustedProject && (input.ownerType !== void 0 && input.ownerType !== existing.ownerType || input.ownerId !== void 0 && input.ownerId !== existing.ownerId)) {
           taskUpdateBlocked(input.id, "TASK_OWNERSHIP_VIA_DISPATCH_REQUIRED", {
             inputOwnerType: input.ownerType,
@@ -42438,7 +42499,7 @@ function createTaskMiddleware(options = {}) {
             return trustedContextError("Parent or dependency task changed before update.");
           }
         }
-        if (trustedProject) {
+        if (trustedProject && !trustedRosterExempt(trustedProject)) {
           try {
             await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
           } catch (error) {
@@ -42478,7 +42539,7 @@ function createTaskMiddleware(options = {}) {
         const workItemSummary = input.summary;
         let activityWarnings;
         try {
-          if (trustedProject) {
+          if (trustedProject && !trustedRosterExempt(trustedProject)) {
             try {
               await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
             } catch (error) {
@@ -42563,18 +42624,6 @@ function createTaskMiddleware(options = {}) {
             return trustedFailure;
           }
         }
-        if (trustedProject && input.dependencyTaskIds !== void 0) {
-          const interruption = input.context?.interruption;
-          const interruptionType2 = interruption && typeof interruption === "object" ? interruption.type : void 0;
-          if (input.status !== "interrupted" || interruptionType2 !== "external_dependency") {
-            taskUpdateBlocked(input.id, "INVALID_EXTERNAL_DEPENDENCY", {});
-            return JSON.stringify({
-              success: false,
-              code: "INVALID_EXTERNAL_DEPENDENCY",
-              error: "dependencyTaskIds are only valid for external dependency interruptions."
-            });
-          }
-        }
         if (trustedProject && (input.ownerType !== void 0 && input.ownerType !== existing.ownerType || input.ownerId !== void 0 && input.ownerId !== existing.ownerId)) {
           taskUpdateBlocked(input.id, "TASK_OWNERSHIP_VIA_DISPATCH_REQUIRED", {});
           return JSON.stringify({
@@ -42656,11 +42705,11 @@ function createTaskMiddleware(options = {}) {
           const interruption = input.context?.interruption;
           const explicitType = interruption && typeof interruption === "object" ? interruption.type : void 0;
           const type = explicitType ?? "missing_input";
-          if (type !== "missing_input" && type !== "external_dependency" && type !== "user_decision") {
+          if (type !== "missing_input" && type !== "user_decision") {
             return JSON.stringify({
               success: false,
               code: "INVALID_INTERRUPTION_TYPE",
-              error: "Agent interruption type must be missing_input, external_dependency, or user_decision."
+              error: "Agent interruption type must be missing_input or user_decision."
             });
           }
           await validateExecutionResult();
@@ -42672,8 +42721,7 @@ function createTaskMiddleware(options = {}) {
             type,
             summary: input.summary ?? "",
             actor,
-            threadId: statusThreadId,
-            dependencyTaskIds: input.dependencyTaskIds
+            threadId: statusThreadId
           });
           return lifecycleMutationResponse(interrupted);
         }
@@ -43381,7 +43429,6 @@ canonical Belief State:
 };
 
 // src/middlewares/documentLearningMiddleware.ts
-import { AgentType as AgentType9 } from "@axiom-lattice/protocols";
 import { createMiddleware as createMiddleware24 } from "langchain";
 
 // src/middlewares/documentLearningSkills.ts
@@ -43626,15 +43673,6 @@ var createDocumentLearningMiddleware = () => createMiddleware24({
   contextSchema,
   tools: []
 });
-var DOCUMENT_LEARNER_SYSTEM_PROMPT = `You are a capability learning specialist.
-
-CRITICAL FIRST ACTION \u2014 before any response about the task:
-1. Call the \`skill\` tool with skill_name: "agent-architecture" to load the
-authoritative Charter.
-2. Call the \`skill\` tool with skill_name: "document-learning-learn-capability" to
-load the source-to-capability workflow.
-Never announce that you will follow a skill. Load both in this order and follow
-their content. If either load fails, retry it once, then report the failure.`;
 var documentLearningPlugin = {
   meta: {
     type: "document-learning",
@@ -43643,92 +43681,6 @@ var documentLearningPlugin = {
     description: "\u4ECE\u6587\u6863\u4E2D\u5B66\u4E60\u77E5\u8BC6\uFF0C\u81EA\u52A8\u6784\u5EFA\u6280\u80FD\u4F53\u7CFB\u548C\u8BC4\u6D4B\u3002 Learn knowledge from documents and build structured skill systems with evaluations.",
     recommends: ["skill", "eval"]
   },
-  agents: {
-    "document-learner": {
-      key: "document-learner",
-      name: "Document Learning Agent",
-      description: "Read documents and build structured skill systems with evaluations. Use this agent when you need to extract knowledge from documents and turn it into reusable, testable agent skills.",
-      type: AgentType9.DEEP_AGENT,
-      prompt: DOCUMENT_LEARNER_SYSTEM_PROMPT,
-      subAgents: ["document-parser-benchmark"],
-      tools: [
-        "invoke_agent",
-        "list_agents",
-        "create_agent",
-        "update_agent",
-        "delete_agent",
-        "get_agent",
-        "list_tools",
-        "list_middleware_types"
-      ],
-      middleware: [
-        {
-          id: "skill",
-          type: "skill",
-          name: "Skill",
-          description: "Skill creation and loading",
-          enabled: true,
-          config: { readAll: true }
-        },
-        {
-          id: "document-learning",
-          type: "document-learning",
-          name: "Document Learning",
-          description: "Source-to-capability learning workflow",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "eval",
-          type: "eval",
-          name: "Eval",
-          description: "Evaluation design and execution",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "task",
-          type: "task",
-          name: "Task",
-          description: "Training process tracking with approval gates",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "widget",
-          type: "widget",
-          name: "Widget",
-          description: "Visualize benchmark results and eval dashboards",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "ask_user_to_clarify",
-          type: "ask_user_to_clarify",
-          name: "Ask User",
-          description: "Wait for user input at approval gates",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "filesystem",
-          type: "filesystem",
-          name: "Filesystem",
-          description: "Read documents, write skill files",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "document-parser",
-          type: "document-parser",
-          name: "Document Parser",
-          description: "Parse documents with the chosen engine",
-          enabled: true,
-          config: { connectAll: true }
-        }
-      ]
-    }
-  },
   skills: {
     "document-learning-learn-capability": {
       version: "1.0.0",
@@ -43957,7 +43909,7 @@ function createParseDocumentTool({
 }
 
 // src/middlewares/documentParserMiddleware.ts
-import { AgentType as AgentType10 } from "@axiom-lattice/protocols";
+import { AgentType as AgentType9 } from "@axiom-lattice/protocols";
 
 // src/middlewares/documentBenchmarkWorkflow.ts
 var DOCUMENT_PARSER_BENCHMARK_YAML = `name: document-parser-benchmark
@@ -44410,6 +44362,23 @@ function createDocumentParserMiddleware(config) {
     tools: [createParseDocumentTool({ connectAll, connections, baseUrl, apiKey })]
   });
 }
+var DOCUMENT_PARSER_SYSTEM_PROMPT = `You are the Document Parser. Turn documents (pdf, docx, images, spreadsheets, and similar) into clean Markdown.
+
+CRITICAL FIRST ACTION: call the \`skill\` tool with skill_name: "document-parser-markitdown" and follow it. Never announce skill loads.
+
+DEFAULT \u2014 local MarkItDown:
+- Single file: run \`markitdown <input> -o <output.md>\` via shell.
+- Batch or literature collections: use the scripts bundled in the skill.
+- After converting, verify the output is non-empty and its structure/tables are intact, then report the exact input -> output paths.
+
+ESCALATION \u2014 remote parse_document:
+- Call parse_document only when local conversion fails, the format is unsupported, the output is empty or materially incomplete, the structure is badly damaged, OCR quality is inadequate, or the user explicitly asks for professional parsing.
+- When the user is unsatisfied with quality, use ask_user_to_clarify to ask whether to switch to a remote engine, and recommend one engine based on the observed file features and the user's feedback. If the user names an engine, use it.
+
+BENCHMARK:
+- Only when the user explicitly asks to compare engines. Confirm with ask_user_to_clarify first, then delegate to the document-parser-benchmark subagent. Never benchmark by default.
+
+Report only what you actually produced; never claim success without inspecting the output file.`;
 var documentParserPlugin = {
   meta: {
     type: "document-parser",
@@ -44480,9 +44449,59 @@ var documentParserPlugin = {
   },
   middleware: (config) => createDocumentParserMiddleware(config),
   agents: {
+    "document-parser": {
+      key: "document-parser",
+      type: AgentType9.DEEP_AGENT,
+      name: "Document Parser",
+      description: "Parse documents (pdf, docx, images, spreadsheets) into clean Markdown. Defaults to local MarkItDown; escalates to remote engines only when quality or format needs it; runs engine benchmarking only on explicit request.",
+      prompt: DOCUMENT_PARSER_SYSTEM_PROMPT,
+      subAgents: ["document-parser-benchmark"],
+      middleware: [
+        {
+          id: "skill",
+          type: "skill",
+          name: "Skill",
+          description: "Load the local MarkItDown parsing procedure",
+          enabled: true,
+          config: { readAll: true }
+        },
+        {
+          id: "filesystem",
+          type: "filesystem",
+          name: "Filesystem",
+          description: "Read source documents and write Markdown output",
+          enabled: true,
+          config: { vmIsolation: "project" }
+        },
+        {
+          id: "code_eval",
+          type: "code_eval",
+          name: "Code Runner",
+          description: "Run the markitdown CLI and bundled conversion scripts",
+          enabled: true,
+          config: { vmIsolation: "project" }
+        },
+        {
+          id: "document-parser",
+          type: "document-parser",
+          name: "Document Parser",
+          description: "Remote parse_document fallback for hard documents",
+          enabled: true,
+          config: { connectAll: true }
+        },
+        {
+          id: "ask_user_to_clarify",
+          type: "ask_user_to_clarify",
+          name: "Ask User",
+          description: "Confirm engine switches and benchmark runs",
+          enabled: true,
+          config: {}
+        }
+      ]
+    },
     "document-parser-benchmark": {
       key: "document-parser-benchmark",
-      type: AgentType10.WORKFLOW,
+      type: AgentType9.WORKFLOW,
       name: "Document Parser Benchmark",
       description: "Benchmark document parsing engines. Parses a document with 5 engines in parallel, scores results, and produces a ranking report. Use this when you need to evaluate which parsing engine works best for a given document.",
       prompt: "Benchmark document parsing engines: parse with 5 engines, score, and rank results.",
@@ -44522,8 +44541,8 @@ import { createHash as createHash7 } from "crypto";
 import {
   descriptorDataValue as descriptorDataValue2,
   parseTrustedRunContext as parseTrustedRunContext3,
-  snapshotExactArray as snapshotExactArray3,
-  snapshotExactRecord as snapshotExactRecord8
+  snapshotExactArray as snapshotExactArray2,
+  snapshotExactRecord as snapshotExactRecord7
 } from "@axiom-lattice/protocols";
 import { createMiddleware as createMiddleware26, tool as tool66 } from "langchain";
 import { z as z72 } from "zod";
@@ -44571,7 +44590,7 @@ function readTrustedRoomScope(config) {
 }
 function exactValues2(value, required, optional = []) {
   try {
-    return snapshotExactRecord8(value, required, optional);
+    return snapshotExactRecord7(value, required, optional);
   } catch {
     return void 0;
   }
@@ -44607,7 +44626,7 @@ function snapshotMembership3(value) {
   return { ...values, joinedAt, updatedAt };
 }
 function snapshotRows(value) {
-  return snapshotExactArray3(value) ?? [];
+  return snapshotExactArray2(value) ?? [];
 }
 async function hasActiveCurrentMembership(scope) {
   const memberships = getStoreLattice("default", "projectBotMembership").store;
@@ -44694,7 +44713,7 @@ var projectRoomPlugin = {
 // src/middlewares/sandboxPluginsMiddleware.ts
 import { createMiddleware as createMiddleware27, tool as tool67 } from "langchain";
 import { z as z73 } from "zod";
-import { AgentType as AgentType11 } from "@axiom-lattice/protocols";
+import { AgentType as AgentType10 } from "@axiom-lattice/protocols";
 
 // src/middlewares/sandboxPluginsSkills.ts
 var PLUGIN_JSON_TEMPLATE = `{
@@ -45444,7 +45463,7 @@ var sandboxPluginsPlugin = {
       key: "plugin-builder",
       name: "Plugin Builder",
       description: "Author and manage tenant plugins in the shared sandbox: clarify goal, inputs/outputs, credentials, and whether a UI is needed; then write the manifest and JS handlers, add an optional HTML MCP App UI, and validate/test with the manage_plugin tool.",
-      type: AgentType11.DEEP_AGENT,
+      type: AgentType10.DEEP_AGENT,
       prompt: PLUGIN_BUILDER_PROMPT,
       middleware: [
         {
@@ -46356,6 +46375,7 @@ export {
   invokeWithRetry,
   isBuiltInSkill,
   isDirectRoom,
+  isMcpConnectionError,
   isPluginSkillAuthorizedInSandbox,
   isPluginSkillManagedInSandbox,
   isUsingDefaultKey,
@@ -46378,7 +46398,6 @@ export {
   parallelLimit,
   parseCronExpression,
   parseDirectRoomType,
-  parseExternalDependency,
   parseJudgeVerdict,
   parsePackSize,
   parseQueuedExecutionMode,