@axiom-lattice/core 4.3.0 → 4.4.0

package/dist/index.mjs

@@ -11238,7 +11238,7 @@ function readLoopBreakerConfig(env = process.env) {
   return {
     repeatWarn: parse(env.AGENT_REPEATED_TOOL_CALL_WARN, 3),
     repeatStop: parse(env.AGENT_REPEATED_TOOL_CALL_STOP, 5),
-    runLimit: parse(env.AGENT_TOOL_CALL_RUN_LIMIT, 120),
+    runLimit: parse(env.AGENT_TOOL_CALL_RUN_LIMIT, 300),
     skillRunLimit: parse(env.AGENT_SKILL_CALL_RUN_LIMIT, 8)
   };
 }
@@ -14938,6 +14938,41 @@ var AgentManager = class _AgentManager {
   }
 };
 
+// src/services/TaskExecutionContext.ts
+var DELEGATED_WORKER_SCOPE_TOKEN = Symbol("delegated-worker-scope");
+var delegatedWorkerScopeSecret = Object.freeze({});
+function createDelegatedWorkerRunConfig(taskId) {
+  return {
+    taskId,
+    delegatedTaskId: taskId,
+    taskExecutionRole: "worker",
+    execution: { taskId },
+    [DELEGATED_WORKER_SCOPE_TOKEN]: delegatedWorkerScopeSecret
+  };
+}
+function getDelegatedTaskId(runConfig) {
+  return runConfig[DELEGATED_WORKER_SCOPE_TOKEN] === delegatedWorkerScopeSecret && runConfig.taskExecutionRole === "worker" && typeof runConfig.taskId === "string" && runConfig.taskId.trim() !== "" && typeof runConfig.delegatedTaskId === "string" && runConfig.taskId === runConfig.delegatedTaskId ? runConfig.taskId : void 0;
+}
+function hasDelegatedWorkerToken(runConfig) {
+  return Object.prototype.hasOwnProperty.call(runConfig, DELEGATED_WORKER_SCOPE_TOKEN);
+}
+function preserveDelegatedWorkerContext(source, target) {
+  const delegatedTaskId = getDelegatedTaskId(source);
+  if (!delegatedTaskId) return;
+  target.taskId = delegatedTaskId;
+  target.delegatedTaskId = delegatedTaskId;
+  target.taskExecutionRole = "worker";
+  target.execution = { taskId: delegatedTaskId };
+  target[DELEGATED_WORKER_SCOPE_TOKEN] = delegatedWorkerScopeSecret;
+}
+function stripDelegatedWorkerContext(target) {
+  delete target.taskId;
+  delete target.delegatedTaskId;
+  delete target.taskExecutionRole;
+  delete target.execution;
+  delete target[DELEGATED_WORKER_SCOPE_TOKEN];
+}
+
 // src/agent_worker/agent_worker_graph.ts
 var AgentWorkerState = Annotation.Root({
   // Input parameters
@@ -14962,6 +14997,13 @@ var AgentWorkerState = Annotation.Root({
     reducer: (x, y) => y ?? x,
     default: () => void 0
   }),
+  // Optional persistent TaskItem binding. Rebuilt into an authentic delegated
+  // worker scope on every execute (the in-process scope symbol cannot survive
+  // LangGraph checkpointing, so it is re-derived from this plain task id).
+  taskId: Annotation({
+    reducer: (x, y) => y ?? x,
+    default: () => ""
+  }),
   // Execution result
   result: Annotation({
     reducer: (x, y) => y ?? x,
@@ -14979,14 +15021,15 @@ var AgentWorkerState = Annotation.Root({
   })
 });
 async function executeNode(state) {
-  const { assistant_id, thread_id, input, command2, runConfig } = state;
+  const { assistant_id, thread_id, input, command2, runConfig, taskId } = state;
+  const effectiveRunConfig = taskId ? { ...runConfig ?? {}, ...createDelegatedWorkerRunConfig(taskId) } : runConfig;
   const callParams = {
     assistant_id,
     "x-tenant-id": runConfig?.tenantId,
     thread_id,
     input,
     command: command2,
-    runConfig
+    runConfig: effectiveRunConfig
   };
   const result = await AgentManager.getInstance().callAgentInQueue(
     callParams,
@@ -16337,38 +16380,6 @@ var CapabilityRuntimeResolver = class {
   }
 };
 
-// src/services/TaskExecutionContext.ts
-var DELEGATED_WORKER_SCOPE_TOKEN = Symbol("delegated-worker-scope");
-var delegatedWorkerScopeSecret = Object.freeze({});
-function createDelegatedWorkerRunConfig(taskId) {
-  return {
-    taskId,
-    delegatedTaskId: taskId,
-    taskExecutionRole: "worker",
-    [DELEGATED_WORKER_SCOPE_TOKEN]: delegatedWorkerScopeSecret
-  };
-}
-function getDelegatedTaskId(runConfig) {
-  return runConfig[DELEGATED_WORKER_SCOPE_TOKEN] === delegatedWorkerScopeSecret && runConfig.taskExecutionRole === "worker" && typeof runConfig.taskId === "string" && runConfig.taskId.trim() !== "" && typeof runConfig.delegatedTaskId === "string" && runConfig.taskId === runConfig.delegatedTaskId ? runConfig.taskId : void 0;
-}
-function hasDelegatedWorkerToken(runConfig) {
-  return Object.prototype.hasOwnProperty.call(runConfig, DELEGATED_WORKER_SCOPE_TOKEN);
-}
-function preserveDelegatedWorkerContext(source, target) {
-  const delegatedTaskId = getDelegatedTaskId(source);
-  if (!delegatedTaskId) return;
-  target.taskId = delegatedTaskId;
-  target.delegatedTaskId = delegatedTaskId;
-  target.taskExecutionRole = "worker";
-  target[DELEGATED_WORKER_SCOPE_TOKEN] = delegatedWorkerScopeSecret;
-}
-function stripDelegatedWorkerContext(target) {
-  delete target.taskId;
-  delete target.delegatedTaskId;
-  delete target.taskExecutionRole;
-  delete target[DELEGATED_WORKER_SCOPE_TOKEN];
-}
-
 // src/services/TrustedAgentDispatchCapability.ts
 var TRUSTED_AGENT_DISPATCH = Symbol("axiom.trustedAgentDispatch");
 
@@ -16532,8 +16543,22 @@ function sanitizeCallerRunConfig(value, preserveDelegatedContext = true) {
   } else {
     stripDelegatedWorkerContext(callerRunConfig);
   }
+  preserveExecutionBinding(value, callerRunConfig);
   return callerRunConfig;
 }
+function preserveExecutionBinding(source, target) {
+  if (typeof source !== "object" || source === null || Array.isArray(source)) return;
+  const execution = descriptorDataValue(Object.getOwnPropertyDescriptor(source, "execution"))?.value;
+  if (typeof execution !== "object" || execution === null || Array.isArray(execution)) return;
+  const taskId = descriptorDataValue(Object.getOwnPropertyDescriptor(execution, "taskId"))?.value;
+  if (typeof taskId !== "string" || taskId.trim() === "") return;
+  Object.defineProperty(target, "execution", {
+    value: { taskId },
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
 function sanitizeExecutionRunConfig(value) {
   return cloneRunConfig(value, false);
 }
@@ -16653,6 +16678,7 @@ function checkpointCapabilityRevision(state) {
 }
 var QUEUE_PROCESSOR_RETRY_BASE_MS = 100;
 var QUEUE_PROCESSOR_MAX_RETRIES = 3;
+var AGENT_RECURSION_LIMIT = 1e3;
 function hasExactKeys(record, required, optional = []) {
   const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
   return required.every((key5) => Object.prototype.hasOwnProperty.call(record, key5)) && Reflect.ownKeys(record).every((key5) => typeof key5 === "string" && allowed.has(key5));
@@ -16705,7 +16731,7 @@ var Agent = class {
               ...executionRunConfig,
               runConfig: executionRunConfig
             },
-            recursionLimit: 200,
+            recursionLimit: AGENT_RECURSION_LIMIT,
             signal
           }
         );
@@ -16780,7 +16806,7 @@ var Agent = class {
             },
             streamMode: ["updates", "messages"],
             subgraphs: false,
-            recursionLimit: 200,
+            recursionLimit: AGENT_RECURSION_LIMIT,
             signal
           }
         );
@@ -17278,6 +17304,15 @@ var Agent = class {
       configurable: true,
       writable: true
     });
+    const trustedTaskId = parsed.projectTask?.taskId;
+    if (trustedTaskId) {
+      Object.defineProperty(base, "execution", {
+        value: { taskId: trustedTaskId },
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
     return base;
   }
   getHumanPendingContent(message) {
@@ -17481,7 +17516,7 @@ var Agent = class {
           ...executionRunConfig,
           runConfig: executionRunConfig
         },
-        recursionLimit: 200,
+        recursionLimit: AGENT_RECURSION_LIMIT,
         signal
       }
     );
@@ -17592,7 +17627,7 @@ var Agent = class {
         },
         streamMode: ["updates", "messages"],
         subgraphs: false,
-        recursionLimit: 200,
+        recursionLimit: AGENT_RECURSION_LIMIT,
         signal
       }
     );
@@ -18349,6 +18384,20 @@ var agentInstanceManager = AgentInstanceManager.getInstance();
 var DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools.";
 var EXCLUDED_STATE_KEYS = ["messages", "todos", "jumpTo"];
 var DEFAULT_GENERAL_PURPOSE_DESCRIPTION = "General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. This agent has access to all tools as the main agent.";
+function createGeneralPurposeAgent(options) {
+  const middleware = [...options.middleware];
+  if (options.interruptOn) {
+    middleware.push(humanInTheLoopMiddleware({ interruptOn: options.interruptOn }));
+  }
+  return createAgent2({
+    model: options.model,
+    systemPrompt: DEFAULT_SUBAGENT_PROMPT,
+    tools: options.tools,
+    middleware,
+    checkpointer: getCheckpointSaver("default"),
+    name: "general-purpose"
+  });
+}
 function getTaskToolDescription(subagentDescriptions) {
   return subagentDescriptions.length > 0 ? `
 Launch an ephemeral subagent to handle complex, multi-step independent tasks with isolated context windows.
@@ -18528,21 +18577,12 @@ function getSubagents(options) {
   const agents = {};
   const subagentDescriptions = [];
   if (generalPurposeAgent) {
-    const generalPurposeMiddleware = [...defaultSubagentMiddleware];
-    if (defaultInterruptOn) {
-      generalPurposeMiddleware.push(
-        humanInTheLoopMiddleware({ interruptOn: defaultInterruptOn })
-      );
-    }
-    const generalPurposeSubagent = createAgent2({
+    agents["general-purpose"] = createGeneralPurposeAgent({
       model: defaultModel,
-      systemPrompt: DEFAULT_SUBAGENT_PROMPT,
       tools: defaultTools,
-      middleware: generalPurposeMiddleware,
-      checkpointer: getCheckpointSaver("default"),
-      name: "general-purpose"
+      middleware: defaultSubagentMiddleware,
+      interruptOn: defaultInterruptOn
     });
-    agents["general-purpose"] = generalPurposeSubagent;
     subagentDescriptions.push(
       `- general-purpose: ${DEFAULT_GENERAL_PURPOSE_DESCRIPTION}`
     );
@@ -21987,6 +22027,7 @@ ${BASE_PROMPT}` : BASE_PROMPT;
 }
 
 // src/agent_lattice/builders/DeepAgentGraphBuilder.ts
+import { AgentType as AgentType2 } from "@axiom-lattice/protocols";
 var DeepAgentGraphBuilder = class {
   /**
    * 构建Deep Agent Graph
@@ -22035,6 +22076,28 @@ var DeepAgentGraphBuilder = class {
       backend: filesystemBackend,
       middleware: middlewares
     });
+    if (middlewares.some((candidate) => candidate.name === "TaskMiddleware") && agentLattice.config.key) {
+      const tenantId2 = params.tenantId ?? "default";
+      const generalPurposeKey = `${agentLattice.config.key}-general-purpose`;
+      if (!agentLatticeManager.hasAgentLatticeWithTenant(tenantId2, generalPurposeKey)) {
+        const generalPurposeAgent = createGeneralPurposeAgent({
+          model: params.model,
+          tools,
+          middleware: middlewares
+        });
+        agentLatticeManager.registerWithTenant(tenantId2, generalPurposeKey, {
+          config: {
+            key: generalPurposeKey,
+            name: "general-purpose",
+            description: DEFAULT_GENERAL_PURPOSE_DESCRIPTION,
+            type: AgentType2.REACT,
+            prompt: DEFAULT_SUBAGENT_PROMPT,
+            tenantId: tenantId2
+          },
+          client: generalPurposeAgent
+        });
+      }
+    }
     return deepAgent;
   }
 };
@@ -23982,10 +24045,10 @@ _A2ARemoteClient.MAX_CACHED_TASKS = 100;
 var A2ARemoteClient = _A2ARemoteClient;
 
 // src/agent_lattice/builders/RemoteAgentGraphBuilder.ts
-import { AgentType as AgentType2 } from "@axiom-lattice/protocols";
+import { AgentType as AgentType3 } from "@axiom-lattice/protocols";
 var RemoteAgentGraphBuilder = class {
   async build(agentLattice, params) {
-    if (agentLattice.config.type !== AgentType2.A2A_REMOTE) {
+    if (agentLattice.config.type !== AgentType3.A2A_REMOTE) {
       throw new Error(
         `RemoteAgentGraphBuilder received wrong agent type: ${agentLattice.config.type}`
       );
@@ -24755,9 +24818,15 @@ For human judgment, use the actual HITL payload \`status: "interrupted"\` plus
 handled by the configured HITL lifecycle; \`review_required\` is not a task status.
 
 Create the active parent and each started subtask as records: \`manage_task
-create\` always persists \`pending\`. Execution starts only via
-\`task(taskId, agentId)\` dispatch, or the agent works inline and keeps the status
-truthful with \`set_status\`. Use \`pending\` only for future or
+create\` always persists \`pending\`. **Process the task you were assigned in this
+run: set it \`in_progress\` with \`manage_task set_status\` when you start (a
+dispatched task is claimed automatically by the engine).** To bring
+in a more suitable expert, create a subtask (\`pending\`) and dispatch THAT with
+\`task { taskId, agentId }\` (a specialist, or agentId "general-purpose" to run your
+own capabilities in an isolated run). **Never re-dispatch the task you are
+currently processing** \u2014 delegating to an expert means giving them a child task,
+not handing over your own. Report the outcome with \`set_status completed\` (result
++ beliefImpact), \`failed\`, or \`interrupted\`. Use \`pending\` only for future or
 dependency-blocked work.
 Before marking the parent completed, call \`list(parentId)\`: every child must
 be completed or cancelled, while a failed or interrupted child blocks completion
@@ -26048,34 +26117,24 @@ Renew HITL approval when a foundational assumption or authority boundary changes
 
 ## Skill Loading Policy
 
-Visible in <available_skills> does not mean loaded. Follow these three tiers.
-
-### Tier 1 \u2014 Session start (mandatory, unconditional)
-Load before any other work; the bootstrap prompt enforces this:
-- [[agent-architecture]] (this skill) \u2014 shared policy and routing.
-- [[task-tracking]] \u2014 before your first \`manage_task\` call; Task management is
-  the planning surface and is gated again under Architect Task Policy.
-
-### Tier 2 \u2014 Scenario gates (mandatory before entering the scenario)
-Load the owning skill with the \`skill\` tool BEFORE the first action of that
-scenario. Never execute a scenario without its owning skill loaded:
-- Creating or modifying a Capability (\`react\`) or Orchestra (\`deep_agent\`)
-  Agent \u2192 [[agent-build]]
-- Creating or modifying a Workflow (stable enumerable pipelines) \u2192 [[design-workflow]]
-- Learning a capability from source material \u2192 [[document-learning-learn-capability]]
-- Designing evals, running evals, or fixing eval failures \u2192 [[eval-verify]]
-- Claiming work is complete or delivered \u2192 [[completion-gate]]
-- Final configuration pre-check before delivery \u2192 [[review-agent]]
-- Placing or authoring knowledge files (company vs project level) \u2192 [[knowledge-management]]
-
-If a Tier 2 load fails, retry once, then stop and tell the user which
-capability is unavailable. Do not improvise the scenario from partial knowledge.
-
-### Tier 3 \u2014 Reference (load on demand, never preload)
-Deep details reachable through wiki-links inside loaded skills, and plugin
-skills outside this chain (for example task-definition for non-architect
-agents, or sandbox-plugins-authoring for the \`plugin-builder\` agent). Load one
-only when the current step actually needs it.
+Visible in <available_skills> does not mean loaded. Load a skill only when the
+current step actually requires its procedure \u2014 one at a time, never preloaded.
+Do not load skills speculatively or to "see what exists": inspect existing
+assets with a bounded read-only survey, not by loading skill content.
+
+- [[agent-architecture]] (this skill) \u2014 loaded at session start by the bootstrap
+  prompt; it is the shared policy and router.
+- [[task-tracking]] \u2014 load right before your first \`manage_task\` call; Task
+  management is the planning surface (gated again under Architect Task Policy).
+- Procedure skills \u2014 [[agent-build]], [[design-workflow]],
+  [[document-learning-learn-capability]], [[eval-verify]], [[completion-gate]],
+  [[review-agent]], [[knowledge-management]]: load the ONE that owns the step you
+  are about to perform, immediately before performing it. Never preload the chain.
+- Reference and plugin skills (deep wiki-links, task-definition, sandbox authoring,
+  and any plugin skills): load only when the current step needs them; never preload.
+
+Loading a skill is a tool call, not a plan. If a required load fails, retry once,
+then stop and tell the user which capability is unavailable.
 
 ## Agent Forms and Routing
 - **Capability** (\`react\`) for bounded direct work: [[agent-build]]
@@ -26088,9 +26147,19 @@ only when the current step actually needs it.
 - **Tenant plugin** (sandbox-authored tool + optional HTML UI) \u2192 use the \`plugin-builder\` agent, or load [[sandbox-plugins-authoring]].
 
 ## Architect Task Policy
-The Agent Architect uses persistent TaskItems as its planning surface. Architect must not use
-\`write_todos\`. Create a persistent child only for an independently verifiable
+The Agent Architect MUST use persistent TaskItems as its single working surface;
+Architect must not use \`write_todos\` for independently verifiable outcomes, and
+working without a corresponding TaskItem is a policy violation.
+Create a persistent child only for an independently verifiable
 outcome; tool calls and file reads are actions inside the active Task.
+**Each task is your evidence ledger**: its Acceptance Criteria + Belief State define
+what counts as evidence, the work runs inside your own run (eval / \`invoke_agent\` for
+subject agents) and produces that evidence, and the parent completes only when the
+evidence is sufficient. Process the task you were assigned in this run; set it
+\`in_progress\` with \`manage_task set_status\` when you start. Delegate a subtask only
+when it belongs to another agent \u2014 create it (\`pending\`) and dispatch it with
+\`task { taskId, agentId }\`. To exercise a designed/subject agent, use eval /
+\`invoke_agent\` inside your own run instead of \`task\` dispatch.
 **MANDATORY: before your first \`manage_task\` call in this session, load
 [[task-tracking]] with the \`skill\` tool.** Do not create, update, or transition
 any Task until it is loaded. If the load fails, retry once, then tell the user
@@ -26161,11 +26230,11 @@ When a room request is actionable work, decide between two paths:
   \`assistantId\`, then dispatch it with
   \`task { taskId, agentId: <bot assistantId> }\` so the specialist actually runs
   (creating the task alone starts nothing). \`task\` transfers the task owner to
-  \`agentId\` and requires a **task-capable** bot (enabled \`task\` middleware that
-  exposes \`manage_task\`); a non-capable target is rejected with
-  \`TASK_DELEGATE_TARGET_NOT_CAPABLE\`. State the expected output and
-  acceptance criteria in the task description so the assigned bot can verify its
-  own work.
+  \`agentId\` and runs it in an isolated thread; the target does not need task
+  tools \u2014 if it has \`manage_task\` it records status itself, otherwise reconcile
+  its returned \`executionResultId\` with \`manage_task\` update. State the expected output
+  and acceptance criteria in the task description so the assigned bot can
+  verify its own work.
 
 ## Discovering bots
 Before delegating, call \`list_room_roster\` to see the active room bots and their
@@ -26316,9 +26385,15 @@ criteria are truly met \u2014 never as a workaround.
   uncertainties, with no required minimum and a maximum of seven:
   \`manage_task create(title: <goal>, description: <contract + Belief State>, ownerType: "agent")\`
   \`create\` always yields a \`pending\` record \u2014 it never starts execution. Record
-  the returned parent task id, then run it by dispatching
-  \`task { taskId, agentId }\` (a fresh isolated thread); otherwise work inline and
-  \`set_status\` as you go.
+  the returned parent task id, then **process it in this run**, setting it
+  \`in_progress\` with \`manage_task set_status\` when you start. To decompose, create each subtask
+  with \`manage_task create\` (\`pending\`) and delegate it with \`task { taskId,
+  agentId }\` to the agent that should execute it (a specialist, or
+  "general-purpose" for your own capabilities). The executor does not need
+  \`manage_task\`: it returns an observation and \`executionResultId\`, and the caller
+  records the outcome with \`manage_task\`. To exercise a subject application agent,
+  use eval cases / \`invoke_agent\` inside your own run \u2014 \`task\` dispatch is
+  delegation of persistent work, not an evaluation mechanism.
 - **Create a subtask for a verifiable result**, not per phase: identify its
   deliverable, define observable acceptance criteria and required evidence, and
   state positive and negative result branches under Targets / Expected Impact
@@ -26343,10 +26418,15 @@ ${TASK_BELIEF_REFERENCE_EXAMPLE}
 
 ## Status discipline \u2014 MANDATORY
 
+- Execution ownership: process the task you were assigned in this run; set it
+  \`in_progress\` with \`manage_task set_status\` when you start. To involve a more
+  suitable expert, create a subtask and dispatch it with \`task { taskId, agentId }\`
+  \u2014 never re-dispatch the task you are processing. Report the outcome with
+  \`set_status completed\` (result + beliefImpact), \`failed\`, or \`interrupted\`.
 - All status transitions go through \`manage_task set_status\` (with
   \`result\` on completed, \`failureReason\` on failed). \`update\` is for
   content fields only and rejects a status field.
-- A subtask is \`completed\` ONLY when its work is actually finished.
+- A task is \`completed\` ONLY when its work is actually finished.
   While fixing eval failures, keep it \`in_progress\` \u2014 never mark
   \`completed\` as a workaround (the state machine rejects illegal
   transitions).
@@ -26946,6 +27026,11 @@ its evidence projection, not an independent source of goals or expectations.
      touching any eval project. An eval project created without a real, confirmed
      subject is a hard error. If the agent is only planned (not yet materialized),
      evaluation must wait until materialization returns its id.
+   - **Exercise the subject through eval \u2014 never through \`task\` dispatch.** The
+     subject agent is invoked by eval cases / \`invoke_agent\`; do NOT create a
+     TaskItem assigned to the subject and dispatch it. \`task\` is for delegated
+     execution of persistent work, not an evaluation mechanism. Use eval cases to
+     measure the subject; keep \`task\` dispatch for executors running real work.
    - **Check existence before creating; reuse is the rule, creation is the exception.**
      Project names are unique per tenant. 1) Name it exactly \`eval-{agent-id}\`.
      2) \`read_eval list_projects({ name: "eval-{agent-id}" })\` \u2014 a name-scoped lookup,
@@ -27933,7 +28018,7 @@ var InMemoryMenuStore = class {
 // src/agent_lattice/agentArchitectTools.ts
 import z52 from "zod";
 import { v4 as v43 } from "uuid";
-import { AgentType as AgentType3 } from "@axiom-lattice/protocols";
+import { AgentType as AgentType4 } from "@axiom-lattice/protocols";
 function getTenantId2(exeConfig) {
   const runConfig = exeConfig?.configurable?.runConfig || {};
   return runConfig.tenantId || "default";
@@ -27983,7 +28068,7 @@ function getStringMetadata(config) {
 }
 function isUndecidedLearningPlaceholder(config) {
   const metadata = getStringMetadata(config);
-  return config.type === AgentType3.REACT && metadata.learningPlaceholder === "true" && metadata.architectureStatus === "undecided";
+  return config.type === AgentType4.REACT && metadata.learningPlaceholder === "true" && metadata.architectureStatus === "undecided";
 }
 function requireSkillDeclaration(skillLoaded) {
   if (skillLoaded !== true) {
@@ -28136,7 +28221,7 @@ registerToolLattice(
         key: id,
         name: input.name,
         description: input.description || "",
-        type: input.type === "deep_agent" ? AgentType3.DEEP_AGENT : AgentType3.REACT,
+        type: input.type === "deep_agent" ? AgentType4.DEEP_AGENT : AgentType4.REACT,
         prompt: input.prompt,
         ...input.tools && input.tools.length > 0 ? { tools: input.tools } : {},
         ...input.middleware && input.middleware.length > 0 ? { middleware: input.middleware } : {},
@@ -28193,7 +28278,7 @@ registerToolLattice(
         key: id,
         name: input.name,
         description: input.description || "",
-        type: AgentType3.WORKFLOW,
+        type: AgentType4.WORKFLOW,
         prompt: input.description || `Workflow: ${input.name}`,
         workflowYaml: input.yaml,
         ...input.tools && input.tools.length > 0 ? { tools: input.tools } : {},
@@ -28230,7 +28315,7 @@ registerToolLattice(
         return JSON.stringify({ error: `Agent '${input.id}' not found` });
       }
       const graphDef = agent.graphDefinition;
-      if (!graphDef || graphDef.type !== AgentType3.WORKFLOW) {
+      if (!graphDef || graphDef.type !== AgentType4.WORKFLOW) {
         return JSON.stringify({ error: `Agent '${input.id}' is not a workflow agent` });
       }
       const yaml = graphDef.workflowYaml;
@@ -28345,7 +28430,7 @@ registerToolLattice(
         return JSON.stringify({ error: `Agent '${input.id}' not found` });
       }
       const existingConfig = existing.graphDefinition || {};
-      const isWorkflow = existingConfig.type === AgentType3.WORKFLOW;
+      const isWorkflow = existingConfig.type === AgentType4.WORKFLOW;
       const isPlaceholder = isUndecidedLearningPlaceholder(existingConfig);
       if (!isWorkflow && !isPlaceholder) {
         console.log(`[update_workflow] ERROR: not a workflow agent: ${input.id}`);
@@ -28361,7 +28446,7 @@ registerToolLattice(
       const mergedConfig = {
         ...existingConfig,
         ...isPlaceholder ? {
-          type: AgentType3.WORKFLOW,
+          type: AgentType4.WORKFLOW,
           workflowYaml: input.yaml,
           metadata: {
             ...getStringMetadata(existingConfig),
@@ -28467,14 +28552,14 @@ registerToolLattice(
       const mergedConfig = { ...existingConfig, ...input.config };
       const isPlaceholder = isUndecidedLearningPlaceholder(existingConfigRecord);
       const materializedType = input.config.type;
-      const isMaterializingPlaceholder = isPlaceholder && (materializedType === AgentType3.REACT || materializedType === AgentType3.DEEP_AGENT);
+      const isMaterializingPlaceholder = isPlaceholder && (materializedType === AgentType4.REACT || materializedType === AgentType4.DEEP_AGENT);
       if (isMaterializingPlaceholder) {
         mergedConfig.metadata = {
           ...getStringMetadata(existingConfigRecord),
           ...input.config.metadata ?? {},
           learningPlaceholder: "false",
           architectureStatus: "materialized",
-          architectureForm: materializedType === AgentType3.DEEP_AGENT ? "orchestra" : "capability"
+          architectureForm: materializedType === AgentType4.DEEP_AGENT ? "orchestra" : "capability"
         };
       } else if (isPlaceholder && input.config.metadata !== void 0) {
         const metadata = {
@@ -28724,100 +28809,20 @@ import { AgentType as AgentType5 } from "@axiom-lattice/protocols";
 // src/agent_lattice/agentArchitectPrompt.ts
 var AGENT_ARCHITECT_PROMPT = `You are the Agent Architect.
 
-CRITICAL FIRST ACTION: Before any response or other action, call the \`skill\`
-tool with skill_name: "agent-architecture" to load agent-architecture and follow it.
-Immediately after it loads, call the \`skill\` tool again with skill_name:
-"task-tracking" \u2014 persistent Task management is your core planning surface and
-you must have its operation reference before creating or updating any Task.
-Never announce skill loads. If a load fails, retry once, then stop and
-explicitly report that the required skill could not be loaded.`;
-
-// src/agent_lattice/agentReviewerConfig.ts
-import { AgentType as AgentType4 } from "@axiom-lattice/protocols";
-
-// src/agent_lattice/agentReviewerPrompt.ts
-var AGENT_REVIEWER_PROMPT = `# Agent Reviewer
-
-You are an **Agent Reviewer** \u2014 a quality assurance specialist for AI agents. Your job is to review agent configurations for correctness and test them by invoking them with realistic messages.
-
-## Your Tools
-
-- **get_agent** \u2014 Fetch an agent's full configuration
-- **list_agents** \u2014 List all agents in the workspace
-- **list_tools** \u2014 List all available tools that can be assigned to agents
-- **invoke_agent** \u2014 Test an agent by sending a message and getting its response. This spawns a completely fresh agent context \u2014 clean, isolated, and realistic.
-
-## Your Workflow
-
-### When asked to review an agent:
-
-1. Call **get_agent** to fetch the agent's config
-2. Review the configuration for:
-   - **Completeness** \u2014 Are name, description, prompt present? Is the prompt clear and actionable?
-   - **Tool validity** \u2014 Do the referenced tools exist? Call **list_tools** to verify.
-   - **Middleware correctness** \u2014 Is every middleware entry complete (id, type, name, description, enabled, config)?
-   - **Sub-agent references** \u2014 Do referenced sub-agent IDs exist? Call **list_agents** to verify.
-   - **Type consistency** \u2014 Does the agent type match its configuration shape? (e.g., PROCESSING must have edges, DEEP_AGENT may have subAgents)
-3. Report your findings clearly. For each issue, state:
-   - Severity (ERROR / WARNING / INFO)
-   - What the problem is
-   - How to fix it
-
-### When asked to test an agent:
-
-1. Call **get_agent** to understand the agent's purpose and expected behavior
-2. Craft a realistic test message that exercises the agent's core responsibility \u2014 what would a real user say?
-3. Call **invoke_agent(id, message)** to send the test message
-4. Analyze the response:
-   - **If result.__interrupt__ is present** (an array of interrupt objects): The agent hit a human-in-the-loop interrupt (e.g., ask_user_to_clarify or interrupt() in a workflow). This is NOT an error \u2014 it means the agent paused execution waiting for user feedback. Each interrupt has a value (the question/request) and optionally an id. Report this as: "The agent successfully paused and is waiting for user input: <describe the interrupt value>." The messages array may contain the agent's output up to the point of interruption.
-   - **Otherwise, result.messages contains the agent's output**: The agent completed without interruption. Check:
-     - Did the agent understand the request?
-     - Was the response relevant and accurate?
-     - Did the agent use the right tools?
-     - Were there any errors or unexpected behaviors?
-   - **If result.error is present**: The invocation itself failed (agent not found, compilation error, etc.). Report the error clearly.
-5. Report your findings with the agent's actual response
-
-### When results are wrong:
-
-If the agent's response is incorrect or unexpected:
-1. Point out specifically what went wrong
-2. Suggest what might need to change in the prompt or middleware config
-3. Offer to re-test after fixes are applied
-
-## Important Rules
-
-- **Always use invoke_agent for testing.** This is the ONLY way to test \u2014 it spawns a fresh agent context isolated from all other conversations.
-- **Be specific in your feedback.** Say "the agent failed to call the sql tool because the middleware config is missing databaseKeys" not "the agent didn't work."
-- **One agent at a time.** Focus on one agent per review or test request. Don't try to review multiple agents simultaneously.
-- **Be concise but thorough.** Cover all the checks, but present findings clearly without fluff.
-`;
+Your working surface is persistent **TaskItems**. Every independently verifiable
+outcome MUST be a TaskItem created and kept truthful through \`manage_task\`; do NOT
+keep a separate todo list \u2014 the TaskItem is your only planning and evidence surface.
+Gather evidence through tasks, and treat the parent as done only when its
+acceptance evidence is sufficient. If the \`task\` tools are unavailable, stop and
+report that task management is unavailable instead of working around it.
 
-// src/agent_lattice/agentReviewerConfig.ts
-var AGENT_REVIEWER_KEY = "agent-reviewer";
-var agentReviewerConfig = {
-  key: AGENT_REVIEWER_KEY,
-  name: "Agent Reviewer",
-  description: "Review and test AI agents. Use this agent to check agent configurations for correctness and to test agents by invoking them with realistic messages.",
-  type: AgentType4.REACT,
-  prompt: AGENT_REVIEWER_PROMPT,
-  tools: [
-    "invoke_agent",
-    "get_agent",
-    "list_agents",
-    "list_tools"
-  ],
-  middleware: [
-    {
-      id: "widget",
-      type: "widget",
-      name: "Widget",
-      description: "Render interactive HTML widgets and SVG diagrams",
-      enabled: true,
-      config: {}
-    }
-  ]
-};
+CRITICAL FIRST ACTION: Before any response or other action, call the \`skill\`
+tool with skill_name: "agent-architecture" to load the shared policy and router,
+and follow it. Load every OTHER skill only when the current step actually
+requires its procedure \u2014 one at a time, never preloaded. Load "task-tracking"
+right before your first \`manage_task\` call. Never announce skill loads. If a
+required load fails, retry once, then stop and explicitly report that the
+required skill could not be loaded.`;
 
 // src/agent_lattice/agentArchitectConfig.ts
 var AGENT_ARCHITECT_KEY = "agent-architect";
@@ -28843,7 +28848,6 @@ var agentArchitectConfig = {
     "manage_binding"
   ],
   subAgents: ["document-parser-benchmark"],
-  internalSubAgents: [agentReviewerConfig],
   middleware: [
     {
       id: "filesystem",
@@ -28928,9 +28932,96 @@ var agentArchitectConfig = {
   ]
 };
 
-// src/agent_lattice/roomCoordinatorConfig.ts
+// src/agent_lattice/agentReviewerConfig.ts
 import { AgentType as AgentType6 } from "@axiom-lattice/protocols";
 
+// src/agent_lattice/agentReviewerPrompt.ts
+var AGENT_REVIEWER_PROMPT = `# Agent Reviewer
+
+You are an **Agent Reviewer** \u2014 a quality assurance specialist for AI agents. Your job is to review agent configurations for correctness and test them by invoking them with realistic messages.
+
+## Your Tools
+
+- **get_agent** \u2014 Fetch an agent's full configuration
+- **list_agents** \u2014 List all agents in the workspace
+- **list_tools** \u2014 List all available tools that can be assigned to agents
+- **invoke_agent** \u2014 Test an agent by sending a message and getting its response. This spawns a completely fresh agent context \u2014 clean, isolated, and realistic.
+
+## Your Workflow
+
+### When asked to review an agent:
+
+1. Call **get_agent** to fetch the agent's config
+2. Review the configuration for:
+   - **Completeness** \u2014 Are name, description, prompt present? Is the prompt clear and actionable?
+   - **Tool validity** \u2014 Do the referenced tools exist? Call **list_tools** to verify.
+   - **Middleware correctness** \u2014 Is every middleware entry complete (id, type, name, description, enabled, config)?
+   - **Sub-agent references** \u2014 Do referenced sub-agent IDs exist? Call **list_agents** to verify.
+   - **Type consistency** \u2014 Does the agent type match its configuration shape? (e.g., PROCESSING must have edges, DEEP_AGENT may have subAgents)
+3. Report your findings clearly. For each issue, state:
+   - Severity (ERROR / WARNING / INFO)
+   - What the problem is
+   - How to fix it
+
+### When asked to test an agent:
+
+1. Call **get_agent** to understand the agent's purpose and expected behavior
+2. Craft a realistic test message that exercises the agent's core responsibility \u2014 what would a real user say?
+3. Call **invoke_agent(id, message)** to send the test message
+4. Analyze the response:
+   - **If result.__interrupt__ is present** (an array of interrupt objects): The agent hit a human-in-the-loop interrupt (e.g., ask_user_to_clarify or interrupt() in a workflow). This is NOT an error \u2014 it means the agent paused execution waiting for user feedback. Each interrupt has a value (the question/request) and optionally an id. Report this as: "The agent successfully paused and is waiting for user input: <describe the interrupt value>." The messages array may contain the agent's output up to the point of interruption.
+   - **Otherwise, result.messages contains the agent's output**: The agent completed without interruption. Check:
+     - Did the agent understand the request?
+     - Was the response relevant and accurate?
+     - Did the agent use the right tools?
+     - Were there any errors or unexpected behaviors?
+   - **If result.error is present**: The invocation itself failed (agent not found, compilation error, etc.). Report the error clearly.
+5. Report your findings with the agent's actual response
+
+### When results are wrong:
+
+If the agent's response is incorrect or unexpected:
+1. Point out specifically what went wrong
+2. Suggest what might need to change in the prompt or middleware config
+3. Offer to re-test after fixes are applied
+
+## Important Rules
+
+- **Always use invoke_agent for testing.** This is the ONLY way to test \u2014 it spawns a fresh agent context isolated from all other conversations.
+- **Be specific in your feedback.** Say "the agent failed to call the sql tool because the middleware config is missing databaseKeys" not "the agent didn't work."
+- **One agent at a time.** Focus on one agent per review or test request. Don't try to review multiple agents simultaneously.
+- **Be concise but thorough.** Cover all the checks, but present findings clearly without fluff.
+`;
+
+// src/agent_lattice/agentReviewerConfig.ts
+var AGENT_REVIEWER_KEY = "agent-reviewer";
+var agentReviewerConfig = {
+  key: AGENT_REVIEWER_KEY,
+  name: "Agent Reviewer",
+  description: "Review and test AI agents. Use this agent to check agent configurations for correctness and to test agents by invoking them with realistic messages.",
+  type: AgentType6.REACT,
+  prompt: AGENT_REVIEWER_PROMPT,
+  tools: [
+    "invoke_agent",
+    "get_agent",
+    "list_agents",
+    "list_tools"
+  ],
+  middleware: [
+    {
+      id: "widget",
+      type: "widget",
+      name: "Widget",
+      description: "Render interactive HTML widgets and SVG diagrams",
+      enabled: true,
+      config: {}
+    }
+  ]
+};
+
+// src/agent_lattice/roomCoordinatorConfig.ts
+import { AgentType as AgentType7 } from "@axiom-lattice/protocols";
+
 // src/agent_lattice/roomCoordinatorPrompt.ts
 var ROOM_COORDINATOR_PROMPT = `You are the Room Coordinator. CRITICAL FIRST ACTION: Before any response or other action, call the \`skill\` tool with skill_name: "room-coordination" to load room-coordination and follow it. Never announce the skill load. If it fails, retry once, then stop and explicitly report that the required room-coordination skill could not be loaded.`;
 
@@ -28940,7 +29031,7 @@ var roomCoordinatorConfig = {
   key: ROOM_COORDINATOR_KEY,
   name: "Room Coordinator",
   description: "Manages project room conversations: replies when no bot is mentioned, coordinates room members, and organizes project work.",
-  type: AgentType6.DEEP_AGENT,
+  type: AgentType7.DEEP_AGENT,
   prompt: ROOM_COORDINATOR_PROMPT,
   tools: [],
   middleware: [
@@ -29575,17 +29666,6 @@ var getAgentClient = (tenantId2, key5, options) => agentLatticeManager.initializ
 var getAgentClientAsync = async (tenantId2, key5, options) => agentLatticeManager.initializeClientAsync(tenantId2, key5, options);
 var createAgentClientFromAgentLattice = async (agentLattice, options) => await agentLatticeManager.createAgentClientFromConfig(agentLattice, options);
 
-// src/agent_lattice/taskCapability.ts
-function agentHasManagedTaskCapability(config) {
-  const middleware = config?.middleware;
-  const taskMiddleware = Array.isArray(middleware) ? middleware.find((entry) => entry?.type === "task" && entry?.enabled === true) : void 0;
-  if (!taskMiddleware) {
-    return false;
-  }
-  const allowedTools = taskMiddleware.allowedTools;
-  return allowedTools === void 0 || Array.isArray(allowedTools) && (allowedTools.length === 0 || allowedTools.includes("manage_task"));
-}
-
 // src/vectorstore_lattice/VectorStoreLatticeManager.ts
 var VectorStoreLatticeManager = class _VectorStoreLatticeManager extends BaseLatticeManager {
   /**
@@ -34167,7 +34247,7 @@ var LatticeEvalSuite = class {
 };
 
 // src/eval_lattice/LatticeEvalProject.ts
-import { AgentType as AgentType7 } from "@axiom-lattice/protocols";
+import { AgentType as AgentType8 } from "@axiom-lattice/protocols";
 import { HumanMessage as HumanMessage6 } from "@langchain/core/messages";
 import { v4 as uuidv47 } from "uuid";
 var DEFAULT_CALIBRATION_PROBES = [
@@ -34223,7 +34303,7 @@ var LatticeEvalProject = class {
       key: this.judgeAgentKey,
       name: `Judge agent for ${this.project.projectName}`,
       description: "Judge agent for evaluating Lattice test cases",
-      type: AgentType7.REACT,
+      type: AgentType8.REACT,
       prompt: "",
       modelKey: judgeModelKey
     };
@@ -37578,6 +37658,33 @@ function createTaskRunBridge(deps) {
           transitioned: true
         };
       }
+      if (task.status === "interrupted" || task.status === "failed") {
+        if (task.ownerType !== "agent") {
+          return {
+            success: false,
+            code: "AGENT_TASK_REQUIRED",
+            error: "Lifecycle transitions only support agent tasks."
+          };
+        }
+        const result = task.status === "interrupted" ? await deps.lifecycle.resumeInterruption({ tenantId: tenantId2, taskId: task.id, actor, threadId }) : await deps.lifecycle.retryTask({ tenantId: tenantId2, taskId: task.id, actor, threadId });
+        if (!result.success) {
+          return {
+            success: false,
+            code: result.code,
+            error: result.error,
+            ...result.hint !== void 0 ? { hint: result.hint } : {},
+            ...result.retryable !== void 0 ? { retryable: result.retryable } : {},
+            ...result.warnings !== void 0 ? { warnings: result.warnings } : {}
+          };
+        }
+        return {
+          success: true,
+          task: result.task,
+          warnings: result.warnings ?? [],
+          mutated: true,
+          transitioned: true
+        };
+      }
       return { success: true, task, warnings, mutated: false, transitioned: false };
     },
     async settleRun(input) {
@@ -37731,48 +37838,18 @@ async function prepareTaskDispatch(deps, input) {
       }
     };
   }
-  if (task.status !== "pending") {
+  if (task.status !== "pending" && task.status !== "interrupted" && task.status !== "failed") {
     return {
       kind: "failure",
       failure: {
         success: false,
         code: "TASK_NOT_DISPATCHABLE",
-        error: "Only a `pending` task can be dispatched.",
-        hint: `This task is '${task.status}'. Only a \`pending\` task dispatches: resolve it (resume an interruption / cancel a stuck run) or create a new task.`,
+        error: "Only a `pending`, `interrupted`, or `failed` task can be dispatched.",
+        hint: `This task is '${task.status}'. A \`pending\` task starts, an \`interrupted\` task resumes, and a \`failed\` task retries. A task already \`in_progress\` is held by a live run; terminal tasks cannot be dispatched.`,
         taskId: task.id
       }
     };
   }
-  if (deps.resolveTaskCapability) {
-    let targetCapable;
-    try {
-      targetCapable = await deps.resolveTaskCapability(input.tenantId, input.agentId);
-    } catch (error) {
-      return {
-        kind: "failure",
-        failure: {
-          success: false,
-          code: "AGENT_RESOLUTION_FAILED",
-          error: errorMessage(error),
-          taskId: task.id,
-          agentId: input.agentId
-        }
-      };
-    }
-    if (!targetCapable) {
-      return {
-        kind: "failure",
-        failure: {
-          success: false,
-          code: "TASK_DELEGATE_TARGET_NOT_CAPABLE",
-          taskId: task.id,
-          agentId: input.agentId,
-          error: `Agent '${input.agentId}' cannot manage tasks, so a dispatched TaskItem could never be completed.`,
-          hint: "Delegate to an agent with the `task` middleware (exposes `manage_task`), or do the work inline and update the task with `manage_task set_status`."
-        }
-      };
-    }
-  }
   const managedAuthority = executionAuthorityRegistry.resolve(task);
   if (managedAuthority) {
     if (managedAuthority.onManagedStart) {
@@ -38184,6 +38261,7 @@ function toJsonSafeValue(value) {
 }
 
 // src/services/TaskExecutionService.ts
+import { GraphInterrupt as GraphInterrupt2 } from "@langchain/langgraph";
 function persistedExecutionObservation(item, attempted) {
   const detail = item.detail;
   const persistedObservation = toJsonSafeValue(detail?.observation);
@@ -38230,9 +38308,10 @@ function createTaskExecutionService(deps) {
   const run = async (plan) => {
     const { tenantId: tenantId2, agentId, actor, parent, completedDependencies } = plan;
     let task = plan.task;
+    const persistedThreadId = (task.status === "interrupted" || task.status === "failed") && typeof task.context?.thread_id === "string" && task.context.thread_id.trim() !== "" ? task.context.thread_id : void 0;
     let threadId;
     try {
-      threadId = (deps.createThreadId ?? randomUUID8)();
+      threadId = persistedThreadId ?? (deps.createThreadId ?? randomUUID8)();
     } catch (error) {
       return {
         success: false,
@@ -38271,12 +38350,12 @@ function createTaskExecutionService(deps) {
       task = transfer.task;
     }
     const warnings = [];
-    if (task.status === "pending") {
+    if (task.status === "pending" || task.status === "interrupted" || task.status === "failed") {
       const begun = await bridge.beginRun({
         tenantId: tenantId2,
         task,
         actor,
-        threadId: plan.callerThreadId
+        threadId
       });
       if (!begun.success) return { ...begun, taskId: task.id };
       if (!begun.mutated || !begun.transitioned) {
@@ -38305,6 +38384,19 @@ function createTaskExecutionService(deps) {
     try {
       observation = toJsonSafeValue(await deps.invokeAgent(invocation));
     } catch (error) {
+      if (error instanceof GraphInterrupt2) {
+        try {
+          await bridge.settleRun({
+            tenantId: tenantId2,
+            task,
+            actor,
+            threadId,
+            outcome: { kind: "interrupted", summary: "Awaiting user input" }
+          });
+        } catch {
+        }
+        throw error;
+      }
       const normalizationError = error instanceof JsonSafeValueError;
       const message = normalizationError ? `${error.code}: ${error.message}` : errorMessage(error);
       const failureCode = normalizationError ? "EXECUTION_RESULT_NORMALIZATION_FAILED" : "AGENT_INVOCATION_FAILED";
@@ -38435,6 +38527,76 @@ function createTaskExecutionService(deps) {
   };
 }
 
+// src/services/TaskRunRegistry.ts
+var TaskRunRegistry = class {
+  constructor() {
+    this.live = /* @__PURE__ */ new Set();
+  }
+  /** Marks a task as currently held by a live run. */
+  register(taskId) {
+    this.live.add(taskId);
+  }
+  /** Removes a task once its run has ended. */
+  unregister(taskId) {
+    this.live.delete(taskId);
+  }
+  /** Reports whether a task is currently held by a live run. */
+  isLive(taskId) {
+    return this.live.has(taskId);
+  }
+  /** Returns a snapshot of the live task ids (diagnostics/tests). */
+  snapshot() {
+    return [...this.live];
+  }
+  /** Clears all live entries (tests / process teardown). */
+  clear() {
+    this.live.clear();
+  }
+};
+var taskRunRegistry = new TaskRunRegistry();
+async function reconcileStaleTaskRuns(input) {
+  const registry4 = input.registry ?? taskRunRegistry;
+  const converged = [];
+  for (const task of input.tasks) {
+    if (task.status !== "in_progress" || registry4.isLive(task.id)) continue;
+    const result = await input.lifecycle.interruptTask({
+      tenantId: task.tenantId,
+      taskId: task.id,
+      actor: input.actor,
+      type: "missing_input",
+      summary: "Run is no longer executing this task (no_executor)"
+    });
+    if (result.success) converged.push(task.id);
+  }
+  return { converged };
+}
+async function reconcileTenantTaskRuns(input) {
+  const tasks = await input.taskStore.list({ tenantId: input.tenantId, status: "in_progress" });
+  const candidates = input.include ? tasks.filter(input.include) : tasks;
+  return reconcileStaleTaskRuns({
+    tasks: candidates,
+    actor: input.actor,
+    lifecycle: input.lifecycle,
+    ...input.registry ? { registry: input.registry } : {}
+  });
+}
+async function reconcileAllTenantTaskRuns(input) {
+  const tenants = await input.tenantStore.listTenants();
+  const converged = [];
+  for (const tenant of tenants) {
+    const result = await reconcileTenantTaskRuns({
+      tenantId: tenant.id,
+      actor: input.actor,
+      taskStore: input.taskStore,
+      lifecycle: input.lifecycle,
+      ...input.registry ? { registry: input.registry } : {},
+      ...input.include ? { include: input.include } : {}
+    });
+    converged.push(...result.converged);
+  }
+  return { converged };
+}
+
 // src/index.ts
 import * as Protocols from "@axiom-lattice/protocols";
 
@@ -39799,7 +39961,7 @@ function createMetricsRuntimeTool(params) {
 // src/middlewares/semanticMetricsModelingSkill.ts
 var CONTENT = `---
 name: semantic-metrics-modeling
-description: Builder policy for turning a granted datasource into published semantic tables and metrics. Governs goal agreement, FEP verification, persistent-task tracking, belief-state updates, and continuous refinement until acceptance evidence is met.
+description: Builder policy for turning a granted datasource into published semantic tables and metrics. Defines the orchestrator/worker contract \u2014 the orchestrator agrees goals, proposes the model, plans persistent tasks, and delegates execution to general-purpose workers with self-contained briefs; workers execute one bound brief each. Governs goal agreement, delegation, FEP verification, belief-state reconciliation, and continuous refinement until acceptance evidence is met.
 ---
 
 # Semantic Metrics Modeling
@@ -39808,6 +39970,15 @@ You are the Semantic Metrics Builder. You turn physical datasource tables into r
 **semantic tables** and **business metrics** on a Metrics Server (\`/api/v1\`). Work is
 governed, observable, and continuously refined \u2014 never a one-shot guess.
 
+You always operate in exactly ONE of two roles:
+
+- **Orchestrator** (default; no \`## Bound Task\` section in your context): you face the
+  user. You agree the Goal Model, propose the model, plan persistent tasks, dispatch
+  execution to workers, reconcile belief, and own every user interaction.
+- **Worker** (your context contains a \`## Bound Task\` section naming you executor of one
+  task): you execute that task's brief only. See **Worker mode** \u2014 its rules override the
+  orchestrator policy.
+
 ## Goal Model
 
 Before any exploration or publishing, agree with the user on:
@@ -39816,16 +39987,17 @@ Before any exploration or publishing, agree with the user on:
 - **Usable state**: observable conditions that make the published meta useful.
 - **Scope**: which datasource/tables, and what is explicitly out of scope.
 - **Acceptance evidence**: objective criteria (e.g. "metric \`sell_in_nes\` returns sane monthly
-  totals for 2024") used to decide success.
+  totals for 2024") used to decide success. Verbatim acceptance evidence is required later by
+  the Verify dispatch \u2014 record it exactly.
 Do not guess material goals, consumers, or acceptance evidence.
 
 **Vague requests** (e.g. "build the metric layer") \u2014 do not act and do not ask blind questions.
-First run cheap read-only observations (\`list_datasources\`, \`get_grants\`, \`list_tables\`,
-\`list_metrics\`) to see what is authorized and already published, then ask focused questions that
-carry that context and offer concrete options (which datasource/tables, which business questions,
-extend existing metrics or build new). Every clarification question must include enough context and
-options for the user to answer in one step. Only after the user picks a direction does the Goal
-Model become confirmable \u2014 record it, create the task, and proceed to the workflow.
+First run cheap read-only observations (\`list_datasources\`, \`get_grants\`, \`list_metrics\`) to
+see what is authorized and already published, then ask focused questions that carry that
+context and offer concrete options (which datasource/tables, which business questions, extend
+existing metrics or build new). Every clarification question must include enough context and
+options for the user to answer in one step. Only after the user picks a direction does the
+Goal Model become confirmable \u2014 record it, create the task, and proceed to the workflow.
 
 ## Target model and quality bar
 
@@ -39863,19 +40035,152 @@ Apply this loop to every step (explore, publish table, publish metric, verify):
 - **Decide**: classify as **RETAIN** (confirmed), **REVERT** (rejected), or **INCONCLUSIVE**.
 - **Reconcile**: update the belief state and plan, then repeat while decision-relevant action remains.
 
-Renew user approval when a foundational assumption or the goal changes.
-
-## Task Policy
+The orchestrator applies the loop **between dispatches** (each observation updates the plan
+before the next brief is written). A worker applies it **inside its brief**.
 
-Use persistent TaskItems as your planning surface. Do not use \`write_todos\`. Create a child task
-only for an independently verifiable outcome (e.g. "publish table meta for \`hankel_distr_sell_in\`").
-Exploration queries and tool calls are activities inside the active task. See the
-\`task-definition\` skill for \`manage_task\` operation details.
-
-## Belief State
+Renew user approval when a foundational assumption or the goal changes.
 
-Record your modeling beliefs in the active task's description under a \`## Belief State\` section as
-a Markdown table:
+## Orchestrator: Task Policy
+
+You are an orchestrator, not the hands. Exactly five duties:
+
+1. **Goal Model agreement** \u2014 including cheap read-only observation for vague requests
+   (\`list_datasources\`, \`get_grants\`, \`list_metrics\`). This is your ONLY inline datasource
+   access; do not use \`write_todos\`.
+2. **Propose the model** and get user approval.
+3. **Task tree** \u2014 parent task = contract + \`## Belief State\`; child tasks = independently
+   verifiable outcomes (explore / publish-table / publish-metric / verify), one per dispatch.
+   See the \`task-definition\` skill for \`manage_task\` operation details.
+4. **Dispatch and collect** \u2014 \`task { taskId, agentId: "general-purpose" }\`; read the
+   observation; record the \`executionResultId\` on the child task with \`manage_task update\` or
+   \`add_activity\`; reconcile \`## Belief State\`.
+5. **HITL** \u2014 every \`ask_user_to_clarify\` is yours. Workers never ask the user.
+
+Hard rules:
+- Never run exploration SQL inline. Never build or publish payloads inline (sole exception:
+  the Publish/Verify inline fallback below).
+- **Belief State: you are the sole writer.** Workers return findings in their results; you
+  update \`## Belief State\` via \`manage_task update\` on the parent task. Workers never touch it.
+- **Dispatch serially** \u2014 one worker at a time; reconcile belief before writing the next brief.
+- **Distinguish dispatch failure from worker outcome**: a dispatch failure is a tool-level
+  error where the worker never ran. A worker returning INCONCLUSIVE or failed is a normal FEP
+  input \u2014 reconcile it, never treat it as a dispatch failure.
+
+Dispatch failure handling (worker never ran, tool error):
+1. Retry the dispatch once (recreate the child task if the store reports it unusable).
+2. **Explore: never execute inline.** If the retry fails, stop and ask the user via
+   \`ask_user_to_clarify\` (report what is blocked and why).
+3. **Publish/Verify: after a failed retry you MAY execute inline** to preserve delivery \u2014
+   the payload decisions are already in your context. Follow the same gate self-check as a
+   worker would.
+
+## Delegation Protocol
+
+Mechanics every brief must be designed around:
+
+- A worker sees ONLY: its task title + description, the parent task's description, and the
+  results of completed dependency tasks. It does NOT see this conversation.
+- Therefore **every brief is self-contained**: all decisions, boundaries, and evidence travel
+  inside the task description.
+- Dispatch is synchronous: \`task { taskId, agentId: "general-purpose" }\` returns an
+  observation (the worker's final message, truncated at ~8k chars) and an
+  \`executionResultId\`. Record the id on the child task (\`manage_task update\`/\`add_activity\`).
+- The worker settles its own task (\`set_status\` with \`result\`/\`failureReason\`). Read both the
+  observation and the task result before reconciling.
+
+Write briefs as field checklists adapted to the situation \u2014 decisions and evidence, not prose.
+The worker assembles payloads from the reference sections of this skill; the brief carries the
+approved decisions, never full payload JSON.
+
+### Explore brief (\`Explore <schema>.<table> for <goal>\`)
+
+Required fields:
+1. Datasource: serverKey/connectionKey + datasourceId (and \`runConfig.metricsDataSource\` preset if present).
+2. Grant boundary: the allowed schema + table pattern from \`get_grants\`, verbatim; never probe outside it.
+3. Target table(s): schema-qualified names; one brief per table.
+4. Question list: per column (or column group) \u2014 business meaning candidates, expected role
+   (dimension | measure | time), net/gross, grain.
+5. Method: read-only SELECT/WITH only; use the \`references/metadata-sql.md\` templates
+   (columns, sample rows, value distribution); cap sample size (e.g. \u22641000 rows, \u226450 groups).
+   Prefer targeted queries over bulk catalog dumps. A large single read (e.g. full
+   \`read_semantic_catalog\` detail) is allowed \u2014 your isolation protects the orchestrator's
+   context \u2014 but findings must be compressed to conclusion level.
+6. Output contract: structured findings \u2014 per column: observed type, sample values,
+   distribution highlights, role candidate + evidence, \`INCONCLUSIVE\` marking for unresolved
+   semantics.
+7. Invariants: read-only only; grant boundary absolute; never guess \u2014 \`INCONCLUSIVE\` instead.
+8. Closing: settle the task (\`set_status completed\`, result = findings summary); final message
+   = the structured findings (it becomes the observation).
+
+### Publish-table brief (\`Publish table meta <objectKey>\`)
+
+Required fields:
+1. Approved decisions: full column list (name/type/role/label/description), grain,
+   displayName/docType/shortDesc/sourceSystem/sourceTables.
+2. Identity: \`objectKey\` (stable, unique per datasource) + \`schemaName.tableName\`.
+3. Assembly instruction: full \`table_view_detail\` payload per **Publish table meta** below,
+   plus the identity twin (\`table_catalog\`, same \`objectKey\`), plus an EXACT \`accessGrant\`
+   matching the tenant grant.
+4. Gate self-check: publish gate items 1\u20133 \u2014 do not publish if any fails.
+5. Publish via \`metrics_meta_tool\` \`create_table\`; then \`get_meta\` to confirm visibility.
+6. Mistakes: fix with \`update_table\`; never leave a partial publish.
+7. Invariants: EXACT patternType; every column tagged and labeled.
+8. Closing: settle the task; final message = receipts (objectKeys + get_meta confirmation).
+
+### Publish-metric brief (\`Publish metric <objectKey>\`)
+
+Required fields (per metric):
+1. Identity: \`objectKey\` = \`metric_name\`, display_name, domain, description, data_type, format.
+2. Source: schema-qualified \`source.table_view\` (must match the published table meta).
+3. Calculation: aggregate (\`aggregation\` + \`measure\`, with the confirmed business meaning) or
+   derived (ratio references / formula) \u2014 exactly as approved in Propose the model.
+4. \`supported_dimensions\`: array of objects \`{dim_id, field_name, label, data_type}\`,
+   including the time dimension.
+5. \`default_time_context\`: time_dimension + granularity + supported_grains (+ window if requested).
+6. \`ai_agent_context\`: polarity, synonyms, human_readable_explanation.
+7. Assembly instruction: \`metric_index\` then \`metric_detail\` in the FULL runtime style per
+   **Publish metric meta** below; publish via \`metrics_meta_tool\` \`create_metric\`.
+8. Gate self-check + smoke \`query\` (one grouping by the default time grain) + \`get_meta\`
+   receipts; closing = settle the task, final message = receipts.
+
+### Verify brief (\`Verify <metric> against acceptance evidence\`)
+
+Required fields:
+1. Acceptance evidence verbatim (from the Goal Model).
+2. Queries to run (semantic \`query\` via \`metrics_runtime_tool\`) and the expected shape/values.
+3. Report contract: PASS/FAIL verdict + actual vs expected; on FAIL include the differences
+   and a suspicion list \u2014 do NOT modify meta (fixes are new Publish tasks).
+4. Invariants: read-only only.
+5. Closing: settle the task; final message = the verdict summary.
+
+### Brief closing (all types)
+
+- Invariants line: grant boundary + read-only SQL + publish gate before any create.
+- Result structure: the structured summary the orchestrator expects back.
+- Finish by settling the task (\`set_status completed\` with result, or \`failed\` with
+  failureReason) and making the final message that structured summary.
+
+## Worker mode
+
+Trigger: your context contains \`## Bound Task\`. You are a worker; these rules override the
+orchestrator policy (Safety and the reference sections still apply):
+
+- Execute the bound task's brief only. Read the contract with \`manage_task get\`; the task
+  description is authoritative. Load this skill if the bootstrap asks \u2014 you need its payload
+  reference sections.
+- Do NOT: re-agree the Goal Model, create sibling or child tasks, dispatch \`task\`, call
+  \`ask_user_to_clarify\`, or update the parent task's \`## Belief State\`.
+- Apply the FEP loop inside the brief; obey the grant boundary and read-only SQL; run the
+  publish gate before any create.
+- Unclear semantics: mark \`INCONCLUSIVE\` with candidates + evidence in your findings. Never
+  guess, never publish on a guess.
+- Finish: \`set_status completed\` with a structured result (or \`failed\` with failureReason),
+  and make your final message the structured summary \u2014 it is the observation your
+  orchestrator reads.
+
+## Belief State (orchestrator-owned)
+
+The parent task's description carries a \`## Belief State\` section as a Markdown table:
 
 \`\`\`
 | Belief Key | Probability | Target | Basis |
@@ -39884,31 +40189,35 @@ a Markdown table:
 \`\`\`
 
 Rules: belief keys are lowercase kebab-case; probability/target are percentages 0\u2013100% that
-represent evidence support, not calibrated probability. Update this section each FEP reconcile so
-the task always reflects the current evidence.
+represent evidence support, not calibrated probability. Only the orchestrator writes this
+section \u2014 after each dispatch it folds the worker's findings into the table so the parent
+task always reflects the current evidence.
 
 ## Workflow
 
-1. **Pick the datasource.** \`metrics_datasource_tool\` action \`list_datasources\`, or the preset
-   \`runConfig.metricsDataSource\` (\`serverKey\`\u2192connectionKey, \`datasourceId\`).
-2. **Read the boundary.** \`get_grants\` \u2192 note the allowed schema + table pattern. Never probe outside it.
-3. **Explore within the grant.** \`query\` with read-only SQL. Use the templates in
-   \`references/metadata-sql.md\`; if the user supplied schema docs or sample files, read them first
-   via filesystem to reduce querying.
-4. **Propose the model.** Present the table columns (with \`role: dimension | measure\`) and the
-   metrics (aggregate/derived) for approval before publishing.
-5. **Publish the semantic table.** \`metrics_meta_tool\` \`create_table\`.
-6. **Publish the metric.** \`metrics_meta_tool\` \`create_metric\` \u2014 \`metric_index\` then \`metric_detail\`
-   using the SQL-free \`calculation\` DSL.
-7. **Verify.** \`metrics_runtime_tool\` \`get_meta\`, then \`query\` the metric against acceptance evidence.
-
-## 1. Explore
+1. **Pick the datasource + cheap observation.** \`metrics_datasource_tool\` action
+   \`list_datasources\`, or the preset \`runConfig.metricsDataSource\` (\`serverKey\`\u2192connectionKey,
+   \`datasourceId\`). Inline, read-only.
+2. **Agree the Goal Model.** (HITL)
+3. **Create the parent task** \u2014 contract + \`## Belief State\` (seeded from the Goal Model).
+4. **Explore by dispatch** \u2014 one Explore brief per table, serial; collect findings; reconcile
+   \`## Belief State\`; collect \`INCONCLUSIVE\` columns.
+5. **Propose the model** (HITL) \u2014 present table columns (with \`role: dimension | measure\`)
+   and the metrics (aggregate/derived) for approval; include clarify questions for
+   \`INCONCLUSIVE\` columns in the same ask.
+6. **Publish tables by dispatch** \u2014 one Publish-table brief per table; check receipts.
+7. **Publish metrics by dispatch** \u2014 one Publish-metric brief per metric; receipts + smoke query.
+8. **Verify by dispatch** \u2014 Verify brief against acceptance evidence. FAIL \u2192 reconcile
+   belief \u2192 fix decisions \u2192 new Publish task (\`update_table\`/\`update_metric\`) \u2192 re-Verify.
+   PASS \u2192 complete the parent task (result = acceptance evidence met).
+
+## Explore (reference)
 
 Read \`table-grants\`, then probe with \`query\`. SQL is validated read-only by the client and the
 server enforces the grant; un-granted tables return \`TABLE_NOT_GRANTED\`. Prefer the
 \`references/metadata-sql.md\` templates because dialect varies (PostgreSQL / SQL Server / HANA).
-If the user provides a data dictionary or sample data file, read it with filesystem and reconcile it
-against the probed columns.
+If the user provides a data dictionary or sample data file, read it with filesystem and
+reconcile it against the probed columns.
 
 ## Unclear field semantics
 
@@ -39917,7 +40226,7 @@ sum, a rate to average, or an enum to filter). Publishing meta on a misunderstoo
 the runtime and every downstream metric that depends on it, and delete is not available. Treat this
 as FEP **INCONCLUSIVE** \u2014 never guess, and never publish on an unverified guess.
 
-Resolve in order of increasing cost:
+Resolve in order of increasing cost (inside the Explore brief):
 1. **Probe sample values and distribution** (\`query\`, templates in \`references/metadata-sql.md\`):
    - numbers in (0,1) or clustered near 100 \u2192 likely a ratio/percentage \u2192 dimension or \`avg\`, rarely \`sum\`;
    - large additive amounts (currency, counts) \u2192 measure with \`sum\`;
@@ -39929,14 +40238,16 @@ Resolve in order of increasing cost:
 
 If evidence is still INCONCLUSIVE:
 - Do **not** publish meta that depends on the unclear field.
-- List the field with its candidate interpretations in the **Propose the model** step and ask the
-  user to confirm its semantics (role, value meaning, net/gross) via ask_user_to_clarify. The user
-  does not need to see the table \u2014 your probed schema, samples, and candidates are enough.
-- Record a low-probability belief entry (e.g.
-  \`| sales-nes-semantics | 40% | 100% | user must confirm role / net amount |\`) so verify/refine can
-  revisit it later instead of assuming it is settled.
+- The worker marks the column \`INCONCLUSIVE\` (candidates + evidence) in its findings; the
+  **orchestrator** lists it with candidate interpretations in the **Propose the model** step
+  and asks the user to confirm its semantics (role, value meaning, net/gross) via
+  \`ask_user_to_clarify\`. The user does not need to see the table \u2014 probed schema, samples, and
+  candidates are enough.
+- The orchestrator records a low-probability belief entry (e.g.
+  \`| sales-nes-semantics | 40% | 100% | user must confirm role / net amount |\`) so verify/refine
+  can revisit it later instead of assuming it is settled.
 
-## 2. Publish table meta (\`create_table\`)
+## Publish table meta (\`create_table\`)
 
 Publish the authoritative shape below (objectType \`table_view_detail\`, with an EXACT accessGrant):
 
@@ -39979,7 +40290,7 @@ Design rules:
 - Runtime table publication uses \`patternType: "EXACT"\` (\`PREFIX\` is only for datasource-level exploration scopes).
 - For each semantic table also publish the identity twin: the same body with \`objectType: "table_catalog"\` and the same \`objectKey\` (same or richer payload).
 
-## 3. Publish metric meta (\`create_metric\`)
+## Publish metric meta (\`create_metric\`)
 
 Two steps for the same \`objectKey\`.
 
@@ -40087,11 +40398,13 @@ Design rules:
 - Do not inline raw SQL for new DB-backed metrics (complex logic belongs in a view).
 - Use \`update_metric\` / \`update_table\` to correct mistakes; no removal actions are exposed.
 
-## 4. Verify and refine
+## Verify and refine
 
-- \`get_meta\` \u2192 confirm the table and metric are visible.
-- \`query\` the metric against the acceptance evidence. On failure, apply the FEP reconcile: update the
-  \`## Belief State\`, fix the meta, and retry \u2014 until acceptance evidence is met.
+- Verify is **dispatched** (Verify brief). The worker runs \`get_meta\` \u2192 confirms the table and
+  metric are visible, then \`query\`es the metric against acceptance evidence.
+- On FAIL the worker reports differences; the **orchestrator** applies the FEP reconcile:
+  update \`## Belief State\`, fix the decisions, and dispatch a new Publish task
+  (\`update_table\`/\`update_metric\`) \u2014 then re-Verify \u2014 until acceptance evidence is met.
 
 ## Troubleshooting
 
@@ -40103,6 +40416,8 @@ Design rules:
 | derived metric create fails | numerator/denominator metrics don't exist yet \u2014 publish them first |
 | datasource \`query\` rejected | SQL was not read-only (SELECT/WITH only) or multi-statement |
 | \`403 Metric is not authorized\` on query_metrics | the metric meta is not in the queryable runtime schema (e.g. missing \`source.table_view\` / \`supported_dimensions\` / \`default_time_context\`) or genuinely unauthorized \u2014 re-publish with the full runtime payload and verify; never retry blindly |
+| worker observation truncated | findings exceeded ~8k chars; worker must keep the final message a compact structured summary |
+| dispatch failed (tool error) | retry once; Explore never goes inline \u2014 ask the user; Publish/Verify may go inline after the failed retry |
 
 ## Safety
 
@@ -40159,15 +40474,35 @@ the SQL is validated read-only.
   "examples/metric-aggregate.json": {
     content: `{
   "objectType": "metric_detail",
-  "objectKey": "hankel_sell_in_nes",
+  "objectKey": "sell_in_nes",
   "status": 1,
   "payload": {
-    "name": "hankel_sell_in_nes",
-    "displayName": "Sell-in NES",
+    "metric_name": "sell_in_nes",
+    "display_name": "Sell-in NES",
+    "domain": "sales",
     "description": "Net external sales amount from distributor sell-in rows.",
-    "sourceTable": "hankel_distr_sell_in",
+    "data_type": "numeric",
+    "format": "currency",
+    "source_type": "cdp_postgres",
+    "source": { "table_view": "public.hankel_distr_sell_in", "base_filters": [] },
     "calculation": { "type": "aggregate", "aggregation": "sum", "measure": "nes" },
-    "dimensions": ["posting_year", "posting_month", "sales_team", "region"]
+    "supported_dimensions": [
+      { "dim_id": "posting_year", "field_name": "posting_year", "label": "Posting Year", "data_type": "number" },
+      { "dim_id": "sales_team", "field_name": "sales_team", "label": "Sales Team", "data_type": "string" },
+      { "dim_id": "posting_date", "field_name": "posting_date", "label": "Posting Date", "data_type": "string" }
+    ],
+    "default_time_context": {
+      "time_dimension": "posting_date",
+      "label": "Posting date",
+      "granularity": "month",
+      "window": "YTD",
+      "supported_grains": ["month", "year"]
+    },
+    "ai_agent_context": {
+      "polarity": "positive",
+      "synonyms": ["sell in", "nes", "net external sales"],
+      "human_readable_explanation": "Higher sell-in NES means more goods purchased from the distributor."
+    }
   }
 }
 `
@@ -40175,27 +40510,40 @@ the SQL is validated read-only.
   "examples/metric-derived.json": {
     content: `{
   "objectType": "metric_detail",
-  "objectKey": "hankel_gross_margin_rate",
+  "objectKey": "gross_margin_rate",
   "status": 1,
   "payload": {
-    "name": "hankel_gross_margin_rate",
-    "displayName": "Gross Margin Rate",
+    "metric_name": "gross_margin_rate",
+    "display_name": "Gross Margin Rate",
+    "domain": "sales",
     "description": "Gross margin divided by sell-in NES.",
-    "sourceTable": "hankel_distr_sell_in",
-    "calculation": {
-      "type": "derived",
-      "operator": "ratio",
-      "numerator": "hankel_gross_margin",
-      "denominator": "hankel_sell_in_nes"
+    "data_type": "numeric",
+    "format": "percent",
+    "source_type": "cdp_postgres",
+    "source": { "table_view": "public.hankel_distr_sell_in", "base_filters": [] },
+    "calculation": { "type": "derived", "operator": "ratio", "numerator": "gross_margin", "denominator": "sell_in_nes" },
+    "supported_dimensions": [
+      { "dim_id": "posting_year", "field_name": "posting_year", "label": "Posting Year", "data_type": "number" },
+      { "dim_id": "posting_date", "field_name": "posting_date", "label": "Posting Date", "data_type": "string" }
+    ],
+    "default_time_context": {
+      "time_dimension": "posting_date",
+      "label": "Posting date",
+      "granularity": "month",
+      "supported_grains": ["month", "year"]
     },
-    "dimensions": ["posting_year", "sales_team", "region"]
+    "ai_agent_context": {
+      "polarity": "positive",
+      "synonyms": ["gross margin rate", "margin rate"],
+      "human_readable_explanation": "Gross margin rate divides gross margin by sell-in NES; higher means more margin retained on sold-in goods."
+    }
   }
 }
 `
   }
 };
 var SEMANTIC_METRICS_MODELING_SKILL = {
-  version: "1.0.0",
+  version: "1.1.2",
   content: CONTENT,
   resources
 };
@@ -40209,7 +40557,7 @@ Never announce the skill load. If it fails, retry once, then stop and explicitly
 report that the required Semantic Metrics Builder skill could not be loaded.`;
 
 // src/middlewares/semanticMetricsMiddleware.ts
-import { AgentType as AgentType8 } from "@axiom-lattice/protocols";
+import { AgentType as AgentType9 } from "@axiom-lattice/protocols";
 function createSemanticMetricsMiddleware(config) {
   const connections = config.connections ?? [];
   const connectAll = config.connectAll === true;
@@ -40361,7 +40709,7 @@ var semanticMetricsPlugin = {
       key: "semantic-metrics-builder",
       name: "Semantic Metrics Builder",
       description: "Explore a granted datasource and build semantic tables and metrics interactively, tracking the work as persistent tasks with belief state and verifying each step.",
-      type: AgentType8.DEEP_AGENT,
+      type: AgentType9.DEEP_AGENT,
       prompt: SEMANTIC_METRICS_BUILDER_PROMPT,
       middleware: [
         {
@@ -41947,7 +42295,65 @@ var widgetPlugin = {
 // src/middlewares/taskMiddleware.ts
 import { createMiddleware as createMiddleware24, tool as tool67 } from "langchain";
 import { z as z73 } from "zod";
-import { GraphInterrupt as GraphInterrupt2, interrupt as interrupt4 } from "@langchain/langgraph";
+import { GraphInterrupt as GraphInterrupt3, interrupt as interrupt4 } from "@langchain/langgraph";
+
+// src/util/truncateForJson.ts
+var TRUNCATION_MARKER = "...[truncated]";
+function truncateString(value, cap) {
+  if (value.length <= cap) return value;
+  const budget = Math.max(0, cap - TRUNCATION_MARKER.length);
+  return value.slice(0, budget) + TRUNCATION_MARKER;
+}
+function truncateValue(value, depth, maxDepth, maxEntries, maxStringLength, seen) {
+  if (typeof value === "string") return truncateString(value, maxStringLength);
+  if (value === null || typeof value !== "object") return value;
+  if (depth >= maxDepth) return "[truncated:max-depth]";
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  try {
+    if (value instanceof Date) return value.toISOString();
+    if (Array.isArray(value)) {
+      const limit2 = Math.min(value.length, maxEntries);
+      const output2 = [];
+      for (let index = 0; index < limit2; index += 1) {
+        output2.push(truncateValue(value[index], depth + 1, maxDepth, maxEntries, maxStringLength, seen));
+      }
+      if (value.length > limit2) output2.push("[truncated:entries]");
+      return output2;
+    }
+    const record = value;
+    const output = {};
+    const keys = Object.keys(record);
+    const limit = Math.min(keys.length, maxEntries);
+    for (let index = 0; index < limit; index += 1) {
+      const key5 = keys[index];
+      output[truncateString(key5, maxStringLength)] = truncateValue(
+        record[key5],
+        depth + 1,
+        maxDepth,
+        maxEntries,
+        maxStringLength,
+        seen
+      );
+    }
+    if (keys.length > limit) output["[truncated]"] = true;
+    return output;
+  } finally {
+    seen.delete(value);
+  }
+}
+function truncateForJson(value, options = {}) {
+  return truncateValue(
+    value,
+    0,
+    options.maxDepth ?? JSON_SAFE_MAX_DEPTH,
+    options.maxEntries ?? JSON_SAFE_MAX_COLLECTION_ENTRIES,
+    options.maxStringLength ?? JSON_SAFE_MAX_STRING_LENGTH,
+    /* @__PURE__ */ new WeakSet()
+  );
+}
+
+// src/middlewares/taskMiddleware.ts
 import {
   isExecutionResultEventKey as isExecutionResultEventKey3,
   parseTaskBeliefState as parseTaskBeliefState2,
@@ -42277,6 +42683,132 @@ function getRuntimeActor2(runConfig) {
   if (runConfig.user_id) return `user:${String(runConfig.user_id)}`;
   return void 0;
 }
+function readRuntimeRunConfig(source) {
+  const s = source;
+  const rc = s?.context?.runConfig ?? s?.configurable?.runConfig;
+  return rc && typeof rc === "object" && !Array.isArray(rc) ? rc : {};
+}
+function readExecutionTaskId(runConfig) {
+  const execution = runConfig.execution;
+  if (!execution || typeof execution !== "object" || Array.isArray(execution)) return void 0;
+  const value = execution.taskId;
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function renderTaskBinding(taskId) {
+  return `
+
+## Bound Task
+
+You are executing task \`${taskId}\`. Read its contract with \`manage_task get\`, update it as you work, and complete it when done.
+`;
+}
+function createBoundTaskLifecycle() {
+  return createTaskLifecycleService({ taskStore: getTaskStore(), workItemStore: getTaskWorkItemStore() });
+}
+function createBoundTaskBridge() {
+  return createTaskRunBridge({ lifecycle: createBoundTaskLifecycle() });
+}
+function isResumableInterruption(interruption) {
+  if (!interruption || typeof interruption !== "object" || Array.isArray(interruption)) return false;
+  const type = interruption.type;
+  return type === "missing_input" || type === "user_decision";
+}
+var TASK_WORKER_OBSERVATION_MAX_CHARS = 8192;
+function snapshotMessages(state) {
+  if (!state || typeof state !== "object") return [];
+  const values = state.values;
+  if (!values || typeof values !== "object") return [];
+  const messages = values.messages;
+  return Array.isArray(messages) ? messages : [];
+}
+function messageText(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return void 0;
+  return value.flatMap((part) => {
+    if (typeof part === "string") return [part];
+    if (part && typeof part === "object" && typeof part.text === "string") {
+      return [part.text];
+    }
+    return [];
+  }).join("");
+}
+function lastAssistantText(source) {
+  const messages = Array.isArray(source) ? source : source && typeof source === "object" && Array.isArray(source.messages) ? source.messages : snapshotMessages(source);
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!message || typeof message !== "object") continue;
+    const role = message.role ?? message.type;
+    if (role !== "ai" && role !== "assistant") continue;
+    const text = messageText(message.content);
+    if (text !== void 0) return text;
+  }
+  return void 0;
+}
+function boundedWorkerObservation(result, state) {
+  const text = lastAssistantText(state) ?? lastAssistantText(result) ?? "";
+  return {
+    status: "completed",
+    output: truncateForJson(text, { maxStringLength: TASK_WORKER_OBSERVATION_MAX_CHARS })
+  };
+}
+var EXECUTOR_CACHE_TTL_MS = 3e4;
+var executorCache = /* @__PURE__ */ new Map();
+function executorString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+async function renderAvailableExecutors(rc, tenantId2) {
+  const authority = classifyTaskAuthority(rc);
+  const governed = authority.kind === "projectRoom" || authority.kind === "projectTask";
+  const projectId = governed ? (authority.trusted.projectTask ?? authority.trusted.projectRoom)?.projectId : void 0;
+  const cacheKey = `${tenantId2}:${governed ? `project:${projectId ?? ""}` : "ordinary"}`;
+  const cached = executorCache.get(cacheKey);
+  const now = Date.now();
+  if (cached && now - cached.at < EXECUTOR_CACHE_TTL_MS) return cached.text;
+  const lines = [];
+  try {
+    if (governed && projectId) {
+      const store = getStoreLattice("default", "projectBotMembership").store;
+      if (typeof store.list === "function") {
+        const bots = await store.list(tenantId2, projectId);
+        for (const bot of (Array.isArray(bots) ? bots : []).slice(0, 40)) {
+          const row = bot;
+          if (row.status !== "active") continue;
+          const id = executorString(row.assistantId);
+          if (!id) continue;
+          const title = executorString(row.title);
+          const responsibility = executorString(row.responsibility);
+          lines.push(`- ${id}${title ? ` \u2014 ${title}` : ""}${responsibility ? ` (${responsibility})` : ""}`);
+        }
+      }
+    } else {
+      const configs = await agentLatticeManager.getAllAgentConfigsByTenant(tenantId2);
+      for (const config of configs.slice(0, 40)) {
+        const row = config;
+        const id = executorString(row.key);
+        if (!id) continue;
+        const name = executorString(row.name);
+        const description = executorString(row.description);
+        lines.push(`- ${id}${name ? ` \u2014 ${name}` : ""}${description ? ` (${description.slice(0, 120)})` : ""}`);
+      }
+    }
+  } catch {
+  }
+  if (lines.length === 0) {
+    executorCache.set(cacheKey, { at: now, text: "" });
+    return "";
+  }
+  const header = governed ? "## Available task executors (Project roster)" : "## Available task executors";
+  const text = `
+
+${header}
+
+Dispatch \`task\` only to an executor that has the tools the work needs (for example \`update_agent\`/\`create_agent\` for materialization). Never dispatch to the subject agent you are building. Use \`general-purpose\` to run your own capabilities.
+
+${lines.join("\n")}
+`;
+  executorCache.set(cacheKey, { at: now, text });
+  return text;
+}
 function delegatedTaskScopeError(taskId) {
   return JSON.stringify({
     success: false,
@@ -42646,11 +43178,11 @@ function buildReviewMarkdown(task) {
 }
 var manageTaskSchema = z73.object({
   action: z73.enum(["create", "get", "list", "update", "set_status", "add_activity", "delete"]).describe("Action to perform. Available: create, get, list, update, set_status, add_activity, delete. To change status, use set_status. To change content fields, use update."),
-  id: z73.string().optional().describe("Task ID (required for get, update, add_activity, and delete)"),
+  id: z73.string().optional().describe("Task ID (required for get, update, add_activity; required for delete unless ids is given)"),
   title: z73.string().optional().describe("Task title (required for create)"),
   description: z73.string().optional().describe("Task description in Markdown"),
   priority: z73.enum(["low", "medium", "high"]).optional().describe("Priority level"),
-  status: z73.enum(["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"]).optional().describe("Task status. For status-only changes, prefer set_status action. Agent summary-only interrupted updates default to missing_input"),
+  status: z73.enum(["pending", "in_progress", "review", "failed", "interrupted", "completed", "cancelled"]).optional().describe("Task status. For status-only changes, prefer set_status action. Set 'in_progress' when you start processing a task you hold; 'completed'/'failed' require the task to be 'in_progress'. Agent summary-only interrupted updates default to missing_input"),
   dueDate: z73.string().optional().describe("Due date (ISO 8601 format)"),
   metadata: z73.record(z73.unknown()).optional().describe("Structured metadata (e.g. projectId, module)"),
   metadataFilter: z73.record(
@@ -42683,7 +43215,8 @@ var manageTaskSchema = z73.object({
     message: "executionResultId must be the execution-result:<threadId> event key returned by task()"
   }).optional().describe(
     "Canonical ASCII `execution-result:<suffix>` event key returned by task(); the nonempty suffix allows only A-Z, a-z, 0-9, period, underscore, colon, and hyphen, and is not a database row ID"
-  )
+  ),
+  ids: z73.array(z73.string().trim().min(1)).optional().describe("Task IDs to delete in one batch (delete action only). Use with or instead of id.")
 }).superRefine((input, context) => {
   if (input.executionResultId && input.action !== "update" && input.action !== "set_status" && input.action !== "add_activity") {
     context.addIssue({
@@ -42699,10 +43232,19 @@ var manageTaskSchema = z73.object({
       message: "metadataFilter is valid only for list"
     });
   }
+  if (input.ids && input.action !== "delete") {
+    context.addIssue({
+      code: z73.ZodIssueCode.custom,
+      path: ["ids"],
+      message: "ids is valid only for delete"
+    });
+  }
 });
 var startTaskSchema = z73.object({
   taskId: z73.string().trim().min(1).describe("ID of the persisted TaskItem to start"),
-  agentId: z73.string().trim().min(1).describe("ID of the Agent that should execute the task")
+  agentId: z73.string().trim().min(1).describe(
+    `ID of the Agent that should execute the task. Use "general-purpose" to run the caller's own capabilities as an isolated worker.`
+  )
 });
 function mergeTaskUpdateWarnings(existing, added) {
   const warnings = [...existing ?? [], ...added ?? []];
@@ -42839,6 +43381,49 @@ function createTaskMiddleware(options = {}) {
     }
     const ownerId = input.ownerId || trustedScope?.assistantId || (input.ownerType === "agent" ? rc.assistant_id : null) || rc.user_id;
     const store = getTaskStore();
+    const deleteOneTask = async (id) => {
+      if (delegatedTaskId && id !== delegatedTaskId) {
+        return delegatedTaskScopeError(delegatedTaskId);
+      }
+      const existing = await store.getById(tenantId2, id);
+      if (!existing) {
+        return JSON.stringify({
+          success: false,
+          code: "TASK_NOT_FOUND",
+          error: `Task '${id}' was not found.`,
+          hint: "Use manage_task list to see available tasks and their correct IDs."
+        });
+      }
+      if (!taskMatchesRuntimeScope3(existing, workspaceId, projectId)) {
+        return taskScopeAccessError(id);
+      }
+      if (trustedProject?.projectTask) {
+        const trustedFailure = trustedTaskContextFailure(existing, trustedProject.projectTask);
+        if (trustedFailure) return trustedFailure;
+      }
+      let deleted;
+      if (trustedProject) {
+        const snapshot = taskMutationSnapshot(existing);
+        if (!snapshot) return trustedContextError();
+        try {
+          await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
+        } catch (error) {
+          return projectPolicyError(error);
+        }
+        deleted = await store.deleteIfSnapshot(tenantId2, id, snapshot);
+      } else {
+        deleted = await store.delete(tenantId2, id);
+      }
+      if (!deleted) {
+        return JSON.stringify({
+          success: false,
+          code: "TASK_DELETE_FAILED",
+          error: `Task '${id}' was not found or could not be deleted.`,
+          hint: "Use manage_task list to verify the task exists and you have access to it."
+        });
+      }
+      return JSON.stringify({ success: true, message: `Task '${id}' deleted` });
+    };
     switch (input.action) {
       case "create": {
         if (delegatedTaskId && input.parentId !== delegatedTaskId) {
@@ -42994,9 +43579,6 @@ function createTaskMiddleware(options = {}) {
             hint: "Pass the task ID you want to retrieve"
           });
         }
-        if (delegatedTaskId && input.id !== delegatedTaskId) {
-          return delegatedTaskScopeError(delegatedTaskId);
-        }
         const task = await store.getById(tenantId2, input.id);
         if (!task) {
           return JSON.stringify({
@@ -43042,25 +43624,6 @@ function createTaskMiddleware(options = {}) {
         });
       }
       case "list": {
-        if (delegatedTaskId) {
-          const delegatedTask = await store.getById(tenantId2, delegatedTaskId);
-          if (!delegatedTask || !taskMatchesRuntimeScope3(delegatedTask, workspaceId, projectId)) {
-            return serializeTaskReadResponse({ success: true, data: [], count: 0 });
-          }
-          const children = await store.list({
-            tenantId: tenantId2,
-            workspaceId,
-            projectId,
-            parentId: delegatedTaskId,
-            metadata: input.metadataFilter
-          });
-          const scopedChildren = children.filter((child) => child.id !== delegatedTaskId && child.parentId === delegatedTaskId && exactScopeMatch(child, delegatedTask));
-          return serializeTaskReadResponse({
-            success: true,
-            data: [delegatedTask, ...scopedChildren],
-            count: scopedChildren.length + 1
-          });
-        }
         const filter2 = {
           tenantId: tenantId2,
           ownerType: input.ownerType,
@@ -43655,41 +44218,31 @@ function createTaskMiddleware(options = {}) {
           });
           return lifecycleMutationResponse(interrupted);
         }
-        if (lifecycle && input.status === "in_progress" && existing.status === "interrupted") {
-          await validateExecutionResult();
+        if (lifecycle && input.status === "in_progress") {
           const callerError = await revalidateCaller();
           if (callerError) return callerError;
-          const resumed = await lifecycle.resumeInterruption({
-            tenantId: tenantId2,
-            taskId: input.id,
-            actor,
-            threadId: statusThreadId
-          });
-          return lifecycleMutationResponse(resumed);
-        }
-        if (lifecycle && input.status === "in_progress" && existing.status === "pending") {
-          await validateExecutionResult();
-          const callerError = await revalidateCaller();
-          if (callerError) return callerError;
-          const started = await lifecycle.startTask({
-            tenantId: tenantId2,
-            taskId: input.id,
-            actor,
-            threadId: statusThreadId
-          });
-          return lifecycleMutationResponse(started);
-        }
-        if (lifecycle && input.status === "in_progress" && existing.status === "failed") {
-          await validateExecutionResult();
-          const callerError = await revalidateCaller();
-          if (callerError) return callerError;
-          const retried = await lifecycle.retryTask({
+          if (existing.status === "interrupted") {
+            return lifecycleMutationResponse(await lifecycle.resumeInterruption({
+              tenantId: tenantId2,
+              taskId: input.id,
+              actor,
+              threadId: statusThreadId
+            }));
+          }
+          if (existing.status === "failed") {
+            return lifecycleMutationResponse(await lifecycle.retryTask({
+              tenantId: tenantId2,
+              taskId: input.id,
+              actor,
+              threadId: statusThreadId
+            }));
+          }
+          return lifecycleMutationResponse(await lifecycle.startTask({
             tenantId: tenantId2,
             taskId: input.id,
             actor,
             threadId: statusThreadId
-          });
-          return lifecycleMutationResponse(retried);
+          }));
         }
         const effectiveRequireReview = existing.requireReview === true || input.requireReview === true;
         const candidateReviewInterruption = input.status === "interrupted" && input.context?.interruption && typeof input.context.interruption === "object" && input.context.interruption.type === "review_required" && !!input.result?.trim();
@@ -43758,7 +44311,7 @@ function createTaskMiddleware(options = {}) {
           try {
             response = await interrupt4(buildReviewMarkdown(submitted.task));
           } catch (error) {
-            if (error instanceof GraphInterrupt2) throw error;
+            if (error instanceof GraphInterrupt3) throw error;
             return lifecycleMutationResponse(submitted, { code: "REVIEW_REQUIRED" });
           }
           if (response?.action === "approve") {
@@ -43870,54 +44423,49 @@ function createTaskMiddleware(options = {}) {
         return successfulTaskResponse(input.id, updatedStatus, true);
       }
       case "delete": {
-        if (!input.id) {
-          return JSON.stringify({
-            success: false,
-            error: "id is required for delete action",
-            hint: "Pass the task ID you want to delete"
-          });
-        }
-        if (delegatedTaskId && input.id !== delegatedTaskId) {
-          return delegatedTaskScopeError(delegatedTaskId);
-        }
-        const existing = await store.getById(tenantId2, input.id);
-        if (!existing) {
-          return JSON.stringify({
-            success: false,
-            code: "TASK_NOT_FOUND",
-            error: `Task '${input.id}' was not found.`,
-            hint: "Use manage_task list to see available tasks and their correct IDs."
-          });
-        }
-        if (!taskMatchesRuntimeScope3(existing, workspaceId, projectId)) {
-          return taskScopeAccessError(input.id);
-        }
-        if (trustedProject?.projectTask) {
-          const trustedFailure = trustedTaskContextFailure(existing, trustedProject.projectTask);
-          if (trustedFailure) return trustedFailure;
+        const missingTargetError = JSON.stringify({
+          success: false,
+          error: "id or ids is required for delete action",
+          hint: "Pass the task ID(s) you want to delete"
+        });
+        const requestedIds = input.ids && input.ids.length > 0 ? [.../* @__PURE__ */ new Set([...input.id ? [input.id] : [], ...input.ids])] : void 0;
+        if (requestedIds === void 0) {
+          if (!input.id) {
+            return missingTargetError;
+          }
+          return deleteOneTask(input.id);
         }
-        let deleted;
-        if (trustedProject) {
-          const snapshot = taskMutationSnapshot(existing);
-          if (!snapshot) return trustedContextError();
+        const deletedIds = [];
+        const failed = [];
+        for (const id of requestedIds) {
+          let raw;
           try {
-            await createProjectTaskOwnerPolicy().requireCaller(trustedRosterScope(trustedProject));
+            raw = await deleteOneTask(id);
           } catch (error) {
-            return projectPolicyError(error);
+            failed.push({
+              id,
+              code: "TASK_DELETE_FAILED",
+              error: error instanceof Error ? error.message : String(error)
+            });
+            continue;
+          }
+          const result = JSON.parse(raw);
+          if (result.success) {
+            deletedIds.push(id);
+          } else {
+            failed.push({
+              id,
+              ...result.code ? { code: result.code } : {},
+              error: result.error ?? `Task '${id}' could not be deleted.`
+            });
           }
-          deleted = await store.deleteIfSnapshot(tenantId2, input.id, snapshot);
-        } else {
-          deleted = await store.delete(tenantId2, input.id);
-        }
-        if (!deleted) {
-          return JSON.stringify({
-            success: false,
-            code: "TASK_DELETE_FAILED",
-            error: `Task '${input.id}' was not found or could not be deleted.`,
-            hint: "Use manage_task list to verify the task exists and you have access to it."
-          });
         }
-        return JSON.stringify({ success: true, message: `Task '${input.id}' deleted` });
+        return JSON.stringify({
+          success: failed.length === 0,
+          deleted: deletedIds,
+          failed,
+          summary: `${deletedIds.length} of ${requestedIds.length} deleted`
+        });
       }
       default:
         return JSON.stringify({
@@ -44032,23 +44580,29 @@ function createTaskMiddleware(options = {}) {
         error: "Runtime actor identity is required for persistent task execution"
       });
     }
+    const callerAssistantId = rc.assistant_id;
+    const agentId = input.agentId === "general-purpose" && callerAssistantId ? `${callerAssistantId}-general-purpose` : input.agentId;
     const service2 = createTaskExecutionService({
       taskStore: getTaskStore(),
       workItemStore: getTaskWorkItemStore(),
-      resolveAgent: async (targetTenantId, agentId) => !!await agentLatticeManager.getOrLoadWithTenant(targetTenantId, agentId),
-      resolveTaskCapability: async (targetTenantId, agentId) => agentHasManagedTaskCapability(
-        (await agentLatticeManager.getOrLoadWithTenant(targetTenantId, agentId))?.config
-      ),
+      resolveAgent: async (targetTenantId, agentId2) => !!await agentLatticeManager.getOrLoadWithTenant(targetTenantId, agentId2),
       invokeAgent: async (invocation) => {
-        const worker = new Agent({
-          tenant_id: invocation.tenantId,
+        const workerResult = await agentWorkerGraph.invoke({
           assistant_id: invocation.agentId,
           thread_id: invocation.threadId,
-          workspace_id: invocation.workspaceId,
-          project_id: invocation.projectId,
-          custom_run_config: createDelegatedWorkerRunConfig(invocation.taskId)
+          input: { message: invocation.message },
+          runConfig: {
+            ...rc,
+            assistant_id: invocation.agentId,
+            thread_id: invocation.threadId,
+            taskId: invocation.taskId,
+            tenantId: invocation.tenantId,
+            workspaceId: invocation.workspaceId,
+            projectId: invocation.projectId
+          }
         });
-        return worker.invoke({ input: { message: invocation.message } });
+        const finalState = workerResult?.finalState;
+        return boundedWorkerObservation(finalState, void 0);
       }
     });
     const trustedCaller = authority.kind === "projectTask" || authority.kind === "projectRoom" ? authority.trusted.projectTask ?? authority.trusted.projectRoom : void 0;
@@ -44057,7 +44611,7 @@ function createTaskMiddleware(options = {}) {
       workspaceId: rc.workspaceId,
       projectId: rc.projectId,
       taskId: input.taskId,
-      agentId: input.agentId,
+      agentId,
       actor,
       callerThreadId: rc.thread_id,
       ...trustedCaller ? { callerMembershipId: trustedCaller.membershipId, callerAssistantId: trustedCaller.assistantId } : {}
@@ -44066,6 +44620,66 @@ function createTaskMiddleware(options = {}) {
   return createMiddleware24({
     name: "TaskMiddleware",
     contextSchema,
+    // Persisted between invocations (ADRs: the run↔task binding survives turns).
+    stateSchema: z73.object({
+      taskId: z73.string().default("")
+    }),
+    // CLAIM: a run that holds a task moves it to in_progress (idempotent).
+    beforeAgent: async (state, runtime) => {
+      const rc = readRuntimeRunConfig(runtime);
+      const bound = typeof state?.taskId === "string" ? state.taskId : "";
+      const taskId = bound || readExecutionTaskId(rc) || "";
+      if (!taskId) return {};
+      if (!taskId) return {};
+      const tenantId2 = rc.tenantId || "default";
+      const threadId = runtime?.configurable?.thread_id;
+      const task = await getTaskStore().getById(tenantId2, taskId);
+      if (!task) return {};
+      const runWorkspaceId = typeof rc.workspaceId === "string" ? rc.workspaceId : void 0;
+      const runProjectId = typeof rc.projectId === "string" ? rc.projectId : void 0;
+      if (task.workspaceId && task.workspaceId !== runWorkspaceId) return {};
+      if (task.projectId && task.projectId !== runProjectId) return {};
+      if (task.status === "completed" || task.status === "failed" || task.status === "cancelled") {
+        return bound ? {} : { taskId };
+      }
+      taskRunRegistry.register(taskId);
+      if (task.status === "pending") {
+        await createBoundTaskBridge().beginRun({
+          tenantId: tenantId2,
+          task,
+          actor: getRuntimeActor2(rc) ?? "system",
+          ...threadId ? { threadId } : {}
+        });
+      } else if (task.status === "interrupted" && isResumableInterruption(task.context?.interruption)) {
+        await createBoundTaskLifecycle().resumeInterruption({
+          tenantId: tenantId2,
+          taskId: task.id,
+          actor: getRuntimeActor2(rc) ?? "system",
+          ...threadId ? { threadId } : {}
+        });
+      }
+      return bound ? {} : { taskId };
+    },
+    // SETTLE: a run that ends without a lifecycle transition converges the task.
+    afterAgent: async (state, runtime) => {
+      const taskId = typeof state?.taskId === "string" ? state.taskId : "";
+      if (!taskId) return {};
+      const rc = readRuntimeRunConfig(runtime);
+      const tenantId2 = rc.tenantId || "default";
+      const threadId = runtime?.configurable?.thread_id;
+      const task = await getTaskStore().getById(tenantId2, taskId);
+      if (task?.status === "in_progress" && task.context?.thread_id === threadId) {
+        await createBoundTaskBridge().settleRun({
+          tenantId: tenantId2,
+          task,
+          actor: getRuntimeActor2(rc) ?? "system",
+          ...threadId ? { threadId } : {},
+          outcome: { kind: "interrupted", summary: "Run ended without a task lifecycle transition" }
+        });
+      }
+      taskRunRegistry.unregister(taskId);
+      return {};
+    },
     wrapModelCall: async (request, handler) => {
       const taskPrompt = `## Task Management
 
@@ -44074,8 +44688,11 @@ ongoing record of a GOAL and its ACCEPTANCE CRITERIA.
 
 ### When to create a task
 - Agent-owned work is multi-step and needs a persistent contract and plan ->
-  create the parent task FIRST (a \`pending\` record), then either execute it
-  inline and keep the status truthful, or dispatch it with \`task\`.
+  create the parent task FIRST (a \`pending\` record), then process it in this run;
+  mark it \`in_progress\` with \`manage_task set_status\` when you start, and
+  \`completed\` when the acceptance criteria are met. To bring in an
+  expert, create a subtask and dispatch it with \`task { taskId, agentId }\` \u2014 never
+  re-dispatch the task you are processing.
 - Persistence is useful for resumption, review, or visibility across the
   independently verifiable business results.
 
@@ -44105,9 +44722,13 @@ ${TASK_CONVERGENCE_GUIDANCE}
 - No params: ownerType defaults to "user" with current user's ID
 - ownerType="agent": auto-fills ownerId from current agent (subtask for yourself)
 - Explicit ownerId: assign to a specific agent or user`;
+      const boundTaskId = request.state?.taskId;
+      const binding = typeof boundTaskId === "string" && boundTaskId ? renderTaskBinding(boundTaskId) : "";
+      const rc = readRuntimeRunConfig(request.runtime);
+      const executors = await renderAvailableExecutors(rc, rc.tenantId || "default");
       return handler({
         ...request,
-        systemPrompt: taskPrompt + "\n\n" + (request.systemPrompt ?? "")
+        systemPrompt: taskPrompt + binding + executors + "\n\n" + (request.systemPrompt ?? "")
       });
     },
     tools: [
@@ -44132,15 +44753,14 @@ ${TASK_CONVERGENCE_GUIDANCE}
 - update: Update a task's content fields (title/description/priority/dueDate/metadata/parentId/sourceId/context/ownerId/result/failureReason/requireReview/dependencies/files)
   Status changes can also be done here, but use set_status for a simpler dedicated status update.
 - set_status: Change a task's status (id and status required). Use this when you only need to change the status.
-  Valid status values: pending, in_progress, review, failed, interrupted, completed, cancelled
-  Companion fields: result (for completed), failureReason (for failed), summary (for any status)
-  To mark complete: set_status with status='completed', result='...'
+  Start processing a task you hold: set_status with status='in_progress' (the engine binds it to this run's thread).
+  To mark complete: set_status with status='completed', result='...' (the task must be in_progress)
   To mark failed: set_status with status='failed', failureReason='...'
   To pause for input: set_status with status='interrupted', summary='what is needed'
-  Status can be freely changed to any valid value \u2014 no restrictions on transitions.
+  Valid status values: pending, in_progress, review, failed, interrupted, completed, cancelled.
   set_status only changes the record; it never dispatches execution (only the \`task\` tool does).
 - add_activity: Add a Markdown activity without changing task fields or status (id and content required)
-- delete: Delete a task (id required)
+- delete: Delete one task by id, or a batch with ids (best-effort per id; returns deleted/failed lists). At least one of id/ids is required.
 
 ## Agent completion beliefs
 Completing an agent-owned task MAY include a beliefImpact array reporting which
@@ -44151,14 +44771,16 @@ Report existing keys directly; set 'isNew: true' to add a key the owner does not
 track yet. Belief is evidence metadata: it never blocks a completion, and an
 unmatched or malformed entry is recorded without changing the owner's table.
 Create always persists a pending record \u2014 a supplied status is coerced and no
-execution is dispatched. Only dispatching runs a task through the queue; an
-agent may also work inline and update status.`,
+execution is dispatched. When you start processing a task you hold, set it
+\`in_progress\` with \`manage_task set_status\`; a dispatched task is claimed
+automatically by the engine. Use \`task { taskId, agentId }\` to delegate a subtask
+to an expert \u2014 never re-dispatch the task you are processing.`,
           schema: manageTaskSchema
         }
       ),
       tool67(handleStartTask, {
         name: "task",
-        description: "Start a persisted TaskItem with any Agent in a fresh isolated thread. An ordinary task returns an observation plus executionResultId that the caller passes to the manage_task update or add_activity that interprets it; a project task returns a managed result (success:true, managed:true) because the project-lifecycle queue owns execution.",
+        description: `Start a persisted TaskItem with any existing Agent in a fresh isolated thread. Use this to delegate work \u2014 dispatch a subtask you created to the agent that should execute it; never re-dispatch the task you are currently processing (give the expert a child task instead). Pass agentId "general-purpose" for the general-purpose worker \u2014 ${DEFAULT_GENERAL_PURPOSE_DESCRIPTION} It has access to all the caller's tools, model, and middleware, so use it for general-purpose subtasks, to isolate context and token usage, and whenever no specialized agent fits. The target does NOT need task-management tools: it runs and returns an observation plus an executionResultId, and the caller passes that executionResultId to the manage_task update or add_activity that interprets and records it. A project task instead returns a managed result (success:true, managed:true) because the project-lifecycle queue owns execution.`,
         schema: startTaskSchema
       })
     ]
@@ -44300,7 +44922,7 @@ canonical Belief State:
 };
 
 // src/middlewares/documentLearningMiddleware.ts
-import { AgentType as AgentType9 } from "@axiom-lattice/protocols";
+import { AgentType as AgentType10 } from "@axiom-lattice/protocols";
 import { createMiddleware as createMiddleware25 } from "langchain";
 
 // src/middlewares/documentLearningSkills.ts
@@ -44567,7 +45189,7 @@ var documentLearningPlugin = {
       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,
+      type: AgentType10.DEEP_AGENT,
       prompt: DOCUMENT_LEARNER_SYSTEM_PROMPT,
       subAgents: ["document-parser-benchmark"],
       tools: [
@@ -44876,7 +45498,7 @@ function createParseDocumentTool({
 }
 
 // src/middlewares/documentParserMiddleware.ts
-import { AgentType as AgentType10 } from "@axiom-lattice/protocols";
+import { AgentType as AgentType11 } from "@axiom-lattice/protocols";
 
 // src/middlewares/documentBenchmarkWorkflow.ts
 var DOCUMENT_PARSER_BENCHMARK_YAML = `name: document-parser-benchmark
@@ -45401,7 +46023,7 @@ var documentParserPlugin = {
   agents: {
     "document-parser-benchmark": {
       key: "document-parser-benchmark",
-      type: AgentType10.WORKFLOW,
+      type: AgentType11.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.",
@@ -45613,7 +46235,7 @@ var projectRoomPlugin = {
 // src/middlewares/sandboxPluginsMiddleware.ts
 import { createMiddleware as createMiddleware28, tool as tool70 } from "langchain";
 import { z as z76 } from "zod";
-import { AgentType as AgentType11 } from "@axiom-lattice/protocols";
+import { AgentType as AgentType12 } from "@axiom-lattice/protocols";
 
 // src/middlewares/sandboxPluginsSkills.ts
 var PLUGIN_JSON_TEMPLATE = `{
@@ -46363,7 +46985,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: AgentType12.DEEP_AGENT,
       prompt: PLUGIN_BUILDER_PROMPT,
       middleware: [
         {
@@ -47129,6 +47751,7 @@ export {
   TaskLifecycleNotifier,
   TaskLifecycleService,
   TaskRunBridgeStoresRequiredError,
+  TaskRunRegistry,
   TaskStatus,
   TeamAgentGraphBuilder,
   TenantPluginCatalog,
@@ -47140,7 +47763,6 @@ export {
   VectorStoreProviderManager,
   VolumeFilesystem,
   abortWorkflowRun,
-  agentHasManagedTaskCapability,
   agentInstanceManager,
   agentLatticeManager,
   appendReconciliationWarning,
@@ -47315,6 +47937,9 @@ export {
   projectTaskAdmissionNotifier,
   queueLatticeManager,
   readLoopBreakerConfig,
+  reconcileAllTenantTaskRuns,
+  reconcileStaleTaskRuns,
+  reconcileTenantTaskRuns,
   registerAgentLattice,
   registerAgentLatticeWithTenant,
   registerAgentLattices,
@@ -47363,6 +47988,7 @@ export {
   storeLatticeManager,
   sttModelLatticeManager,
   taskLifecycleNotifier,
+  taskRunRegistry,
   toJsonSchema,
   toSafeStateExpr,
   toolLatticeManager,