@axiom-lattice/core 4.3.0 → 5.0.0

package/dist/index.mjs

@@ -445,11 +445,11 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key Lattice键名
    * @param tool 已有的StructuredTool实例
    */
-  registerExistingTool(key5, tool71) {
+  registerExistingTool(key5, tool68) {
     const config = {
-      name: tool71.name,
-      description: tool71.description,
-      schema: tool71.schema,
+      name: tool68.name,
+      description: tool68.description,
+      schema: tool68.schema,
       // StructuredTool的schema已经是Zod兼容的
       needUserApprove: false
       // MCP工具默认不需要用户批准
@@ -457,7 +457,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
     const toolLattice = {
       key: key5,
       config,
-      client: tool71
+      client: tool68
     };
     this.register(key5, toolLattice);
   }
@@ -468,14 +468,14 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key - tool lattice key (no tenant prefix)
    * @param tool - the StructuredTool client
    */
-  registerExistingToolWithTenant(tenantId2, key5, tool71) {
+  registerExistingToolWithTenant(tenantId2, key5, tool68) {
     const config = {
-      name: tool71.name,
-      description: tool71.description,
-      schema: tool71.schema,
+      name: tool68.name,
+      description: tool68.description,
+      schema: tool68.schema,
       needUserApprove: false
     };
-    const toolLattice = { key: key5, config, client: tool71 };
+    const toolLattice = { key: key5, config, client: tool68 };
     this.registerWithTenant(tenantId2, key5, toolLattice);
   }
   /**
@@ -525,8 +525,8 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
 };
 var toolLatticeManager = ToolLatticeManager.getInstance();
 var registerToolLattice = (key5, config, executor) => toolLatticeManager.registerLattice(key5, config, executor);
-var registerExistingTool = (key5, tool71) => toolLatticeManager.registerExistingTool(key5, tool71);
-var registerExistingToolWithTenant = (tenantId2, key5, tool71) => toolLatticeManager.registerExistingToolWithTenant(tenantId2, key5, tool71);
+var registerExistingTool = (key5, tool68) => toolLatticeManager.registerExistingTool(key5, tool68);
+var registerExistingToolWithTenant = (tenantId2, key5, tool68) => toolLatticeManager.registerExistingToolWithTenant(tenantId2, key5, tool68);
 var getToolLattice = (key5) => toolLatticeManager.getToolLattice(key5);
 var getToolClientWithTenant = (tenantId2, key5) => toolLatticeManager.getToolClientWithTenant(tenantId2, key5);
 var getToolDefinition = (key5) => toolLatticeManager.getToolDefinition(key5);
@@ -1363,15 +1363,15 @@ ${body}` : `${frontmatter}
     const resourcesDir = path.join(skillDir, "resources");
     try {
       const entries = await fs.readdir(resourcesDir, { withFileTypes: true, recursive: true });
-      const resources3 = [];
+      const resources2 = [];
       for (const entry of entries) {
         if (!entry.isDirectory()) {
           const fullPath = path.join(entry.path, entry.name);
           const relativePath = path.relative(resourcesDir, fullPath);
-          resources3.push(relativePath.replace(/\\/g, "/"));
+          resources2.push(relativePath.replace(/\\/g, "/"));
         }
       }
-      return resources3.sort();
+      return resources2.sort();
     } catch (error) {
       if (error.code === "ENOENT") {
         return [];
@@ -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)
   };
 }
@@ -11661,11 +11661,11 @@ var PluginRegistry = class {
         if (!isRecord2(rawDefinition) || typeof rawDefinition.version !== "string" || rawDefinition.version.trim().length === 0 || typeof rawDefinition.content !== "string") {
           throw new Error(`Plugin "${key5}": skill "${name}" version and content must be a string`);
         }
-        const resources3 = rawDefinition.resources;
-        if (resources3 !== void 0 && !isRecord2(resources3)) {
+        const resources2 = rawDefinition.resources;
+        if (resources2 !== void 0 && !isRecord2(resources2)) {
           throw new Error(`Plugin "${key5}": skill "${name}" resources must be an object`);
         }
-        for (const [path8, resource] of Object.entries(resources3 ?? {})) {
+        for (const [path8, resource] of Object.entries(resources2 ?? {})) {
           try {
             validateRelativePath(path8, "resource");
           } catch {
@@ -12818,7 +12818,7 @@ function isSafeUiPath(path8) {
 }
 function validateSandboxPluginManifest(args) {
   const diagnostics = [];
-  const error = (code, message, pluginType, tool71) => diagnostics.push({ level: "error", code, message, pluginType, tool: tool71 });
+  const error = (code, message, pluginType, tool68) => diagnostics.push({ level: "error", code, message, pluginType, tool: tool68 });
   const raw = args.raw;
   if (!isRecord5(raw)) {
     error("MANIFEST_NOT_OBJECT", "manifest must be a JSON object", args.dirName);
@@ -13826,9 +13826,9 @@ function freezeMetadata(metadata) {
     ...resourceSelector ? { resourceSelector } : {}
   });
 }
-function toolName(tool71) {
-  if (typeof tool71 !== "object" || tool71 === null || !("name" in tool71)) return void 0;
-  return typeof tool71.name === "string" ? tool71.name : void 0;
+function toolName(tool68) {
+  if (typeof tool68 !== "object" || tool68 === null || !("name" in tool68)) return void 0;
+  return typeof tool68.name === "string" ? tool68.name : void 0;
 }
 function schemaHasConnectionKey(schema6) {
   const definition = isRecord7(schema6._def) ? schema6._def : void 0;
@@ -13836,10 +13836,10 @@ function schemaHasConnectionKey(schema6) {
   const fields = typeof shape === "function" ? shape() : shape;
   return isRecord7(fields) && Object.prototype.hasOwnProperty.call(fields, "connectionKey");
 }
-function hasConnectionKeySchema(tool71) {
-  if (!isRecord7(tool71) || !isRecord7(tool71.schema)) return false;
-  if (schemaHasConnectionKey(tool71.schema)) return true;
-  const definition = isRecord7(tool71.schema._def) ? tool71.schema._def : void 0;
+function hasConnectionKeySchema(tool68) {
+  if (!isRecord7(tool68) || !isRecord7(tool68.schema)) return false;
+  if (schemaHasConnectionKey(tool68.schema)) return true;
+  const definition = isRecord7(tool68.schema._def) ? tool68.schema._def : void 0;
   if (Array.isArray(definition?.options) && definition.options.length > 0) {
     return definition.options.every(
       (option) => isRecord7(option) && schemaHasConnectionKey(option)
@@ -13894,8 +13894,8 @@ var CapabilityToolRegistry = class {
    * @remarks Standard connection authorization is captured only for tools whose
    * schema declares `connectionKey`; legacy selectors remain explicit metadata.
    */
-  register(name, metadata, tool71) {
-    this.registerInternal(name, metadata, hasConnectionKeySchema(tool71));
+  register(name, metadata, tool68) {
+    this.registerInternal(name, metadata, hasConnectionKeySchema(tool68));
   }
   /**
    * Registers all tools actually exposed by a middleware instance.
@@ -13906,13 +13906,13 @@ var CapabilityToolRegistry = class {
    * @returns Nothing.
    */
   registerMiddleware(capabilityType, middleware, resourceSelectors = {}) {
-    for (const tool71 of middleware.tools ?? []) {
-      const name = toolName(tool71);
+    for (const tool68 of middleware.tools ?? []) {
+      const name = toolName(tool68);
       if (name) {
         this.registerInternal(name, {
           capabilityType,
           resourceSelector: resourceSelectors[name]
-        }, hasConnectionKeySchema(tool71));
+        }, hasConnectionKeySchema(tool68));
       }
     }
   }
@@ -14604,9 +14604,9 @@ var ReActAgentGraphBuilder = class {
    */
   async build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool71 = getToolClientWithTenant(params.tenantId ?? "default", t.key);
-      return tool71;
-    }).filter((tool71) => tool71 !== void 0);
+      const tool68 = getToolClientWithTenant(params.tenantId ?? "default", t.key);
+      return tool68;
+    }).filter((tool68) => tool68 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
@@ -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,
@@ -15736,8 +15779,8 @@ function validateCapability(value, index) {
         fieldPath: `/capabilities/${index}/allowedTools`
       });
     }
-    for (const [toolIndex, tool71] of capability.allowedTools.entries()) {
-      if (typeof tool71 !== "string") {
+    for (const [toolIndex, tool68] of capability.allowedTools.entries()) {
+      if (typeof tool68 !== "string") {
         throw new CapabilityBundleValidationError(
           "CAPABILITY_BUNDLE_INVALID_CAPABILITY",
           "allowedTools entries must be strings",
@@ -15751,10 +15794,10 @@ function validateCapability(value, index) {
         fieldPath: `/capabilities/${index}/allowedTools`
       });
     }
-    const toolNames = new Set(plugin.meta.tools.map((tool71) => tool71.name));
-    for (const [toolIndex, tool71] of capability.allowedTools.entries()) {
-      if (typeof tool71 !== "string" || !toolNames.has(tool71)) {
-        throw new CapabilityBundleValidationError("CAPABILITY_BUNDLE_UNKNOWN_TOOL", `Unknown tool '${String(tool71)}'`, {
+    const toolNames = new Set(plugin.meta.tools.map((tool68) => tool68.name));
+    for (const [toolIndex, tool68] of capability.allowedTools.entries()) {
+      if (typeof tool68 !== "string" || !toolNames.has(tool68)) {
+        throw new CapabilityBundleValidationError("CAPABILITY_BUNDLE_UNKNOWN_TOOL", `Unknown tool '${String(tool68)}'`, {
           capabilityType,
           fieldPath: `/capabilities/${index}/allowedTools/${toolIndex}`
         });
@@ -16237,7 +16280,7 @@ function applyStaticCeiling(capabilities, staticMiddleware) {
     const projectTools = capability.allowedTools;
     const staticTools = ceiling.allowedTools;
     const effectiveStaticTools = staticTools?.length === 0 ? void 0 : staticTools;
-    const allowedTools = projectTools === void 0 ? effectiveStaticTools : effectiveStaticTools === void 0 ? projectTools : projectTools.filter((tool71) => effectiveStaticTools.includes(tool71));
+    const allowedTools = projectTools === void 0 ? effectiveStaticTools : effectiveStaticTools === void 0 ? projectTools : projectTools.filter((tool68) => effectiveStaticTools.includes(tool68));
     runtime[capability.type] = structuredClone({
       ...capability,
       config: applyStaticResourceCeiling(capability, ceiling),
@@ -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
@@ -21999,7 +22040,7 @@ var DeepAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClientWithTenant(params.tenantId ?? "default", t.key);
       return toolClient;
-    }).filter((tool71) => tool71 !== void 0);
+    }).filter((tool68) => tool68 !== void 0);
     const subagents = await Promise.all(params.subAgents.map(async (sa) => {
       if (sa.client) {
         return {
@@ -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;
   }
 };
@@ -23625,7 +23688,7 @@ var TeamAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClientWithTenant(params.tenantId ?? "default", t.key);
       return toolClient;
-    }).filter((tool71) => tool71 !== void 0);
+    }).filter((tool68) => tool68 !== void 0);
     const teammates = params.subAgents.map((sa) => {
       const baseConfig = sa.config;
       return {
@@ -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) {
@@ -27995,7 +28080,7 @@ function requireSkillDeclaration(skillLoaded) {
   return void 0;
 }
 async function validateAgentReferences(input, tenantId2) {
-  const availableTools = getAvailableTools(tenantId2).map((tool71) => tool71.key);
+  const availableTools = getAvailableTools(tenantId2).map((tool68) => tool68.key);
   const availableMiddlewareTypes = getAvailableMiddlewareTypes();
   const availableCustomMiddlewareKeys = CustomMiddlewareRegistry.list().filter(
     (key5) => CustomMiddlewareRegistry.get(key5) !== void 0
@@ -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 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.
 
-## 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: 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 {
   /**
@@ -30985,15 +31065,15 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     const metaByName = new Map(metaList.map((m) => [m.name, m.meta]));
     this.unregisterServerTools(tenantId2, serverKey);
     const keys = [];
-    for (const tool71 of tools) {
-      if (rt.selectedTools && !rt.selectedTools.includes(tool71.name)) continue;
-      const meta = metaByName.get(tool71.name);
+    for (const tool68 of tools) {
+      if (rt.selectedTools && !rt.selectedTools.includes(tool68.name)) continue;
+      const meta = metaByName.get(tool68.name);
       const rawVisibility = meta?.ui?.visibility;
       const visibility = Array.isArray(rawVisibility) ? rawVisibility : typeof rawVisibility === "string" ? [rawVisibility] : void 0;
       if (visibility && !visibility.includes("model")) continue;
       const ref = extractAppsRef(meta, serverKey);
-      const registered = ref ? wrapMcpToolWithUi(tool71, ref) : tool71;
-      const toolKey = _McpLatticeManager.buildToolKey(serverKey, tool71.name);
+      const registered = ref ? wrapMcpToolWithUi(tool68, ref) : tool68;
+      const toolKey = _McpLatticeManager.buildToolKey(serverKey, tool68.name);
       try {
         toolLatticeManager.registerExistingToolWithTenant(tenantId2, toolKey, registered);
         keys.push(toolKey);
@@ -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";
 
@@ -38700,10 +38862,10 @@ var createLoadSkillContentTool = (pluginSkills, pluginSkillOwnersOrStaticSelecti
             lockIdentity
           );
           let result2 = pluginSkill.definition.content;
-          const resources3 = Object.entries(pluginSkill.definition.resources ?? {});
-          if (resources3.length > 0) {
+          const resources2 = Object.entries(pluginSkill.definition.resources ?? {});
+          if (resources2.length > 0) {
             result2 += "\n\n---\n\n**Resources** (synced to the sandbox; use `read_file` to access):\n";
-            for (const [resourcePath, resource] of resources3) {
+            for (const [resourcePath, resource] of resources2) {
               result2 += `- ${resourcePath} (mime type: ${resource.mimeType ?? "not specified"})
 `;
             }
@@ -38730,10 +38892,10 @@ var createLoadSkillContentTool = (pluginSkills, pluginSkillOwnersOrStaticSelecti
             `/root/.agents/skills/${input.skill_name}/resources`,
             { recursive: false }
           );
-          const resources3 = resourcesResult.files.map((f) => f.path.split("/").pop()).filter(Boolean);
-          if (resources3.length > 0) {
+          const resources2 = resourcesResult.files.map((f) => f.path.split("/").pop()).filter(Boolean);
+          if (resources2.length > 0) {
             result += "\n\n---\n\n**Resources** (use `read_file` tool to access):\n";
-            resources3.forEach((r) => {
+            resources2.forEach((r) => {
               result += `- ${r}
 `;
             });
@@ -39055,1368 +39217,13 @@ var skillPlugin = {
   })
 };
 
-// src/middlewares/semanticMetricsMiddleware.ts
+// src/middlewares/collectionMiddleware.ts
 import { createMiddleware as createMiddleware20 } from "langchain";
 
-// src/tool_lattice/semantic_metrics/metrics_datasource_tool.ts
+// src/tool_lattice/collection/list_collections.ts
 import z57 from "zod";
 import { tool as tool51 } from "langchain";
 
-// src/tool_lattice/semantic_metrics/types.ts
-function readToolRunConfig(exeConfig) {
-  return exeConfig?.configurable?.runConfig;
-}
-function resolveDatasourceId(input, exeConfig) {
-  const id = input.datasourceId ?? readToolRunConfig(exeConfig)?.metricsDataSource?.datasourceId;
-  if (id === void 0 || id === null || id === "") {
-    throw new Error("datasourceId is required (provide it or set runConfig.metricsDataSource.datasourceId)");
-  }
-  return Number(id);
-}
-function assertDatasourceSelected(scope, datasourceId) {
-  if (scope.unrestricted) return;
-  if (!scope.ids.includes(datasourceId)) {
-    throw new Error(
-      `DATASOURCE_NOT_SELECTED: datasource ${datasourceId} is not in the effective scope [${scope.ids.join(", ")}]`
-    );
-  }
-}
-function effectiveDatasourceScope(connectionScope) {
-  return connectionScope.length > 0 ? { unrestricted: false, ids: [...connectionScope] } : { unrestricted: true, ids: [] };
-}
-var DDL_DML_KEYWORDS = [
-  "insert",
-  "update",
-  "delete",
-  "drop",
-  "alter",
-  "create",
-  "truncate",
-  "grant",
-  "revoke",
-  "merge",
-  "replace",
-  "upsert"
-];
-var DDL_DML_RE = new RegExp(`\\b(?:${DDL_DML_KEYWORDS.join("|")})\\b`, "i");
-var SELECT_INTO_RE = /\bselect\b[\s\S]*?\binto\b/i;
-function validateSql(sql) {
-  const trimmed = sql.trim();
-  if (!trimmed) {
-    return { ok: false, reason: "SQL is empty" };
-  }
-  const withoutComments = trimmed.replace(/--[^\n]*/g, " ").replace(/\/\*[\s\S]*?\*\//g, " ");
-  const statements = withoutComments.split(";").map((s) => s.trim()).filter(Boolean);
-  if (statements.length > 1) {
-    return { ok: false, reason: "Multiple statements are not allowed" };
-  }
-  const firstKeyword = withoutComments.trim().split(/\s+/)[0].toLowerCase();
-  if (firstKeyword !== "select" && firstKeyword !== "with") {
-    return { ok: false, reason: `Only SELECT or WITH queries are allowed (got "${firstKeyword}")` };
-  }
-  if (SELECT_INTO_RE.test(withoutComments)) {
-    return { ok: false, reason: "SELECT INTO is not allowed (creates a table)" };
-  }
-  if (DDL_DML_RE.test(withoutComments)) {
-    return { ok: false, reason: "Only read-only queries are allowed (DML/DDL detected)" };
-  }
-  return { ok: true };
-}
-
-// src/tool_lattice/semantic_metrics/SemanticMetricsV2Client.ts
-var NO_CONNECTION_HINT = "No semantic-metrics connection is configured for this tenant. Add a connection of type 'semantic-metrics' for the tenant, then select it (connections) or enable connectAll in the agent's middleware config.";
-async function resolveMetricsClientFromSelector(selector, scope, connectionKey) {
-  let resolved;
-  try {
-    resolved = await resolvePluginConnections(selector.connectionType, selector, scope);
-  } catch (error) {
-    if (error instanceof Error && error.message === "ConnectionStore not configured") {
-      throw new Error(NO_CONNECTION_HINT);
-    }
-    throw error;
-  }
-  const available = resolved.map((c) => c.key).join(", ");
-  if (resolved.length === 0) {
-    throw new Error(NO_CONNECTION_HINT);
-  }
-  const key5 = connectionKey?.trim() || (resolved.length === 1 ? resolved[0].key : "");
-  if (!key5) {
-    throw new Error(
-      `connectionKey is required. Available connections: ${available}`
-    );
-  }
-  const entry = resolved.find((c) => c.key === key5);
-  if (!entry) {
-    throw new Error(`Connection "${key5}" not found. Available connections: ${available}`);
-  }
-  const config = entry.config;
-  return new SemanticMetricsV2Client(config);
-}
-var SemanticMetricsV2Client = class {
-  /**
-   * @param config - Connection configuration (server URL, optional API key and headers).
-   */
-  constructor(config) {
-    this.config = config;
-    this.baseUrl = config.serverUrl.replace(/\/$/, "");
-  }
-  /**
-   * Build default request headers: `Accept: application/json`, custom headers,
-   * and a Bearer `Authorization` header when an API key is configured.
-   *
-   * @returns Merged headers.
-   */
-  getHeaders() {
-    const headers = {
-      Accept: "application/json",
-      ...this.config.headers ?? {}
-    };
-    if (this.config.apiKey) {
-      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
-    }
-    return headers;
-  }
-  /**
-   * Numeric selected resource ids of this connection (normalized).
-   *
-   * Reads `selectedEntities` — the standard connection resource-selection
-   * field written by the connection UI (`connection.discover` + selection).
-   *
-   * @returns The selected resource ids; empty when unrestricted.
-   */
-  getSelectedEntities() {
-    const raw = this.config.selectedEntities;
-    if (!Array.isArray(raw)) return [];
-    return raw.map((v) => Number(v)).filter((n) => Number.isFinite(n));
-  }
-  /**
-   * Perform a JSON request against the base URL.
-   *
-   * The Metrics Server wraps every response as `{ code, message, data }`. A
-   * `code` of 200 resolves to `data`; any other `code` throws a business error
-   * carrying the server message (regardless of HTTP status). Non-envelope
-   * bodies are returned as-is.
-   *
-   * @param path - Path appended to the base URL (must start with `/`).
-   * @param init - Optional `fetch` init overrides (method, body, per-call headers).
-   * @returns The unwrapped `data` payload of the response envelope.
-   * @throws When the server returns a non-200 `code`, or the HTTP response is not OK.
-   */
-  async request(path8, init = {}) {
-    const response = await fetch(`${this.baseUrl}${path8}`, {
-      ...init,
-      method: init.method ?? "GET",
-      headers: { ...this.getHeaders(), ...init.headers ?? {} }
-    });
-    const text = await response.text().catch(() => "");
-    const parsed = this.parseBody(text);
-    if (parsed?.envelope === true) {
-      if (parsed.code !== 200) {
-        throw new Error(`API ${parsed.code}: ${parsed.message || "Unknown error"}`);
-      }
-      return parsed.data;
-    }
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${text || response.statusText}`);
-    }
-    return parsed?.value ?? void 0;
-  }
-  /**
-   * Parse a response body text. Detects the server envelope `{ code, message, data }`.
-   *
-   * @param text - Raw response body text.
-   * @returns `{ envelope: true, code, message, data }` for an envelope body,
-   *   `{ envelope: false, value }` for anything else (or `{ envelope: false }` when empty/invalid).
-   */
-  parseBody(text) {
-    if (!text.trim()) return { envelope: false };
-    try {
-      const value = JSON.parse(text);
-      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-        const record = value;
-        if (typeof record.code === "number") {
-          return {
-            envelope: true,
-            code: record.code,
-            message: typeof record.message === "string" ? record.message : void 0,
-            data: record.data
-          };
-        }
-      }
-      return { envelope: false, value };
-    } catch {
-      return { envelope: false, value: text };
-    }
-  }
-  /**
-   * POST a JSON body to a path.
-   *
-   * @param path - Path appended to the base URL.
-   * @param body - Payload serialized as JSON.
-   * @returns Parsed JSON response body.
-   */
-  post(path8, body) {
-    return this.request(path8, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-  }
-  /**
-   * PUT a JSON body to a path.
-   *
-   * @param path - Path appended to the base URL.
-   * @param body - Payload serialized as JSON.
-   * @returns Parsed JSON response body.
-   */
-  put(path8, body) {
-    return this.request(path8, {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-  }
-  /**
-   * List all datasources.
-   *
-   * @returns Parsed JSON response body.
-   */
-  listDatasources() {
-    return this.request("/datasources");
-  }
-  /**
-   * Get table grants for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns Parsed JSON response body.
-   */
-  getTableGrants(datasourceId) {
-    return this.request(`/datasources/${encodeURIComponent(datasourceId)}/table-grants`);
-  }
-  /**
-   * Run a read-only SQL query against a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param input - Query input: `sql` (SELECT/WITH only), optional `params`, `maxRows`, `debug`.
-   * @returns Parsed JSON response body.
-   * @throws When `sql` fails read-only validation (rejected before any fetch).
-   */
-  async queryDatasource(datasourceId, input) {
-    const validation = validateSql(input.sql);
-    if (!validation.ok) throw new Error(`SQL_NOT_ALLOWED: ${validation.reason}`);
-    return this.post(`/datasources/${encodeURIComponent(datasourceId)}/query`, input);
-  }
-  /**
-   * Test a datasource connection.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns Parsed JSON response body.
-   */
-  testDatasource(datasourceId) {
-    return this.post(`/datasources/${encodeURIComponent(datasourceId)}/test`, {});
-  }
-  /**
-   * Get connection-pool status for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns Parsed JSON response body.
-   */
-  getPoolStatus(datasourceId) {
-    return this.request(`/datasources/${encodeURIComponent(datasourceId)}/pool`);
-  }
-  /**
-   * List table metadata for a datasource, auto-paginating.
-   *
-   * The server pages this collection (`page`/`pageSize`, default page size 20),
-   * so requests aggregate every page into one `{ items, total }` result.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns `{ items: [...], total }` covering all pages.
-   */
-  async listTables(datasourceId) {
-    return this.listMetaPage(`/datasources/${encodeURIComponent(datasourceId)}/meta/tables`);
-  }
-  /**
-   * Shared pagination walk for the paged meta collections (`{items,total,page,pageSize}`).
-   *
-   * @param basePath - Collection path (tables or metrics).
-   * @returns `{ items, total }` aggregated across all pages.
-   */
-  async listMetaPage(basePath) {
-    const pageSize = 100;
-    const items = [];
-    let total = Number.POSITIVE_INFINITY;
-    for (let page = 1; items.length < total; page += 1) {
-      const body = await this.request(`${basePath}?page=${page}&pageSize=${pageSize}`);
-      const record = body !== null && typeof body === "object" ? body : {};
-      const batch = Array.isArray(record.items) ? record.items : [];
-      items.push(...batch);
-      total = typeof record.total === "number" ? record.total : items.length;
-      if (batch.length === 0) break;
-    }
-    return { items, total: items.length };
-  }
-  /**
-   * Get metadata for a single table.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param tableKey - Table key.
-   * @returns Parsed JSON response body.
-   */
-  getTable(datasourceId, tableKey) {
-    return this.request(
-      `/datasources/${encodeURIComponent(datasourceId)}/meta/tables/${encodeURIComponent(tableKey)}`
-    );
-  }
-  /**
-   * Create a table definition for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param payload - Table definition payload.
-   * @returns Parsed JSON response body.
-   */
-  createTable(datasourceId, payload) {
-    return this.post(`/datasources/${encodeURIComponent(datasourceId)}/meta/tables`, payload);
-  }
-  /**
-   * Update a table definition for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param tableKey - Table key.
-   * @param payload - Table definition payload.
-   * @returns Parsed JSON response body.
-   */
-  /**
-   * Update a published table meta via read-modify-write.
-   *
-   * The server's PUT replaces the whole payload, so the current payload is
-   * fetched first and the incoming fields are merged on top; fields not
-   * mentioned are preserved.
-   */
-  async updateTable(datasourceId, tableKey, payload) {
-    const existing = await this.readMetaPayload(`${this.baseUrl}/datasources/${encodeURIComponent(datasourceId)}/meta/tables/${encodeURIComponent(tableKey)}`);
-    return this.put(
-      `/datasources/${encodeURIComponent(datasourceId)}/meta/tables/${encodeURIComponent(tableKey)}`,
-      { payload: { ...existing, ...payload } }
-    );
-  }
-  /**
-   * List metric definitions for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns Parsed JSON response body.
-   */
-  /**
-   * List metric metadata for a datasource, auto-paginating.
-   *
-   * The server pages this collection (`page`/`pageSize`, default page size 20),
-   * so requests aggregate every page into one `{ items, total }` result.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns `{ items: [...], total }` covering all pages.
-   */
-  async listMetrics(datasourceId) {
-    return this.listMetaPage(`/datasources/${encodeURIComponent(datasourceId)}/meta/metrics`);
-  }
-  /**
-   * Get a single metric definition.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param metricKey - Metric key.
-   * @returns Parsed JSON response body.
-   */
-  getMetric(datasourceId, metricKey) {
-    return this.request(
-      `/datasources/${encodeURIComponent(datasourceId)}/meta/metrics/${encodeURIComponent(metricKey)}`
-    );
-  }
-  /**
-   * Create a metric definition for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param payload - Metric definition payload.
-   * @returns Parsed JSON response body.
-   */
-  createMetric(datasourceId, payload) {
-    return this.post(`/datasources/${encodeURIComponent(datasourceId)}/meta/metrics`, payload);
-  }
-  /**
-   * Update a metric definition for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @param metricKey - Metric key.
-   * @param payload - Metric definition payload.
-   * @returns Parsed JSON response body.
-   */
-  /**
-   * Update a published metric meta via read-modify-write.
-   *
-   * The server's PUT replaces the whole payload, so the current payload is
-   * fetched first and the incoming fields are merged on top; fields not
-   * mentioned are preserved.
-   */
-  async updateMetric(datasourceId, metricKey, payload) {
-    const existing = await this.readMetaPayload(`${this.baseUrl}/datasources/${encodeURIComponent(datasourceId)}/meta/metrics/${encodeURIComponent(metricKey)}`);
-    return this.put(
-      `/datasources/${encodeURIComponent(datasourceId)}/meta/metrics/${encodeURIComponent(metricKey)}`,
-      { payload: { ...existing, ...payload } }
-    );
-  }
-  /**
-   * Fetch the current `payload` object of a published meta entry.
-   *
-   * The single-entry read returns `{ code, data: [entry] }` (already unwrapped
-   * to the array by {@link request}); the payload lives on the first entry.
-   *
-   * @param absoluteUrl - Full URL of the single-entry meta read.
-   * @returns The stored payload object (empty when none exists).
-   */
-  async readMetaPayload(absoluteUrl) {
-    const response = await fetch(absoluteUrl, { headers: this.getHeaders() });
-    const text = await response.text().catch(() => "");
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${text || response.statusText}`);
-    }
-    const parsed = this.parseBody(text);
-    const data = parsed?.envelope === true ? parsed.data : parsed?.value;
-    const entry = Array.isArray(data) ? data[0] : data;
-    const payload = entry?.payload;
-    return payload !== null && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-  }
-  /**
-   * Get runtime metadata for a datasource.
-   *
-   * @param datasourceId - Datasource identifier.
-   * @returns Parsed JSON response body.
-   */
-  getRuntimeMeta(datasourceId) {
-    return this.request(`/datasources/${encodeURIComponent(datasourceId)}/meta`);
-  }
-  /**
-   * Run a metrics query.
-   *
-   * @param request - Metrics query request payload.
-   * @returns Parsed JSON response body.
-   */
-  queryMetrics(request) {
-    return this.post("/metrics/query", request);
-  }
-  /**
-   * Run an ad-hoc custom SQL query, validated as read-only before sending.
-   *
-   * @param request - Request with `datasourceId`, `customSql` (SELECT/WITH only),
-   * and optional `limit` / `debug`.
-   * @returns Parsed JSON response body.
-   * @throws When `customSql` fails read-only validation (rejected before any fetch).
-   */
-  async customSql(request) {
-    const validation = validateSql(request.customSql);
-    if (!validation.ok) throw new Error(`SQL_NOT_ALLOWED: ${validation.reason}`);
-    return this.post("/metrics/query", request);
-  }
-};
-
-// src/tool_lattice/semantic_metrics/metrics_datasource_tool.ts
-var DESCRIPTION = `PHYSICAL LAYER EXPLORATION \u2014 the only tool for probing raw datasource structure (Builder/Admin only; business agents do not need it).
-
-OWNS: discovering datasources, reading table-grants (the exploration boundary for this tenant), and running read-only SQL (SELECT/WITH only) to inspect physical tables, columns, sample rows, and value distributions. Also: per-datasource connection test and pool status.
-
-DOES NOT OWN:
-- Published semantic assets (table meta / metric meta) \u2192 use metrics_meta_tool.
-- Runtime meta and business metric queries \u2192 use metrics_runtime_tool.
-
-USE WHEN: starting a modeling task \u2014 \`list_datasources\` is always the FIRST step: it returns the datasource ids that every other action and tool requires (get_grants, query_sql here; read_semantic_catalog, query_metrics in metrics_runtime_tool; the meta actions in metrics_meta_tool). Read grants next, then probe tables, columns, samples, and distributions within the grant. If a field's business meaning is unclear, probe sample values and distributions here before publishing anything.
-
-COMMON MISTAKES (do not):
-- Do not answer business metric questions here (e.g. "monthly sales by region") \u2014 that is metrics_runtime_tool \`query\` against published metrics, NOT this tool's \`query_sql\` (physical-table SQL).
-- Do not read or publish semantic meta through this tool \u2014 metrics_meta_tool owns the semantic layer.
-- Do not probe tables outside the tenant's table-grants; un-granted probes are rejected and break the exploration boundary.
-- Do not attempt writes \u2014 SQL is validated read-only and rejected before sending.`;
-function createMetricsDatasourceTool(params) {
-  const { connectionType, connections, connectAll } = params;
-  return tool51(
-    async (input, exeConfig) => {
-      try {
-        const client = await resolveMetricsClientFromSelector(
-          { connectionType, connections, connectAll },
-          readToolRunConfig(exeConfig) ?? {},
-          input.connectionKey
-        );
-        const scope = effectiveDatasourceScope(client.getSelectedEntities());
-        switch (input.action) {
-          case "list_datasources": {
-            const result = await client.listDatasources();
-            const filtered = scope.unrestricted ? result : result.filter((d) => scope.ids.includes(Number(d.id)));
-            const safe = filtered.map((d) => ({
-              id: d.id,
-              name: d.name,
-              sourceType: d.sourceType,
-              description: d.description,
-              statusLabel: d.statusLabel
-            }));
-            return JSON.stringify(safe, null, 2);
-          }
-          case "get_grants": {
-            const ds = resolveDatasourceId(input, exeConfig);
-            assertDatasourceSelected(scope, ds);
-            const result = await client.getTableGrants(ds);
-            return JSON.stringify(result, null, 2);
-          }
-          case "query_sql": {
-            const ds = resolveDatasourceId(input, exeConfig);
-            assertDatasourceSelected(scope, ds);
-            if (!input.sql) throw new Error("sql is required for the 'query_sql' action");
-            const result = await client.queryDatasource(ds, {
-              sql: input.sql,
-              params: input.params,
-              maxRows: input.maxRows
-            });
-            return JSON.stringify(result, null, 2);
-          }
-          case "test_connection": {
-            const ds = resolveDatasourceId(input, exeConfig);
-            assertDatasourceSelected(scope, ds);
-            const result = await client.testDatasource(ds);
-            return JSON.stringify(result, null, 2);
-          }
-          case "pool_status": {
-            const ds = resolveDatasourceId(input, exeConfig);
-            assertDatasourceSelected(scope, ds);
-            const result = await client.getPoolStatus(ds);
-            return JSON.stringify(result, null, 2);
-          }
-        }
-      } catch (error) {
-        return `Error: ${error instanceof Error ? error.message : String(error)}`;
-      }
-    },
-    {
-      name: "metrics_datasource_tool",
-      description: DESCRIPTION,
-      schema: z57.object({
-        action: z57.enum(["list_datasources", "get_grants", "query_sql", "test_connection", "pool_status"]).describe(
-          "list_datasources: list datasources \u2014 ALWAYS call this first to obtain the datasource id used by every other action and tool; get_grants: read table-grants; query_sql: run read-only SQL against PHYSICAL tables (note: this is query_sql, NOT the semantic 'query' action of metrics_runtime_tool); test_connection: test the datasource; pool_status: connection-pool status"
-        ),
-        connectionKey: z57.string().optional().describe("Connection key. Omit when only one semantic-metrics connection exists"),
-        datasourceId: z57.coerce.number().optional().describe("Numeric datasource id, e.g. 15 (required for all actions except list_datasources; optional if set in runConfig.metricsDataSource)"),
-        sql: z57.string().optional().describe("Read-only SQL (SELECT/WITH only). Required for the query action. Metadata templates \u2014 PostgreSQL/SQL Server columns: select column_name, data_type from information_schema.columns where table_schema = :schemaName and table_name = :tableName order by ordinal_position; HANA columns: select column_name, data_type_name from table_columns where schema_name = :schemaName and table_name = :tableName order by position; distributions: select <dim>, count(*) as row_count from <table> group by <dim> order by row_count desc limit :maxRows"),
-        params: z57.record(z57.union([z57.string(), z57.number(), z57.boolean()])).optional().describe("Named :param values for the SQL"),
-        maxRows: z57.number().optional().describe("Max rows to return")
-      })
-    }
-  );
-}
-
-// src/tool_lattice/semantic_metrics/metrics_meta_tool.ts
-import z58 from "zod";
-import { tool as tool52 } from "langchain";
-var DESCRIPTION2 = `SEMANTIC ASSET REGISTRY (Builder/Admin only) \u2014 the only tool for reading and publishing the runtime's semantic layer: table meta (meta/tables) and metric meta (meta/metrics).
-
-OWNS: listing published tables and metrics, reading one by objectKey, publishing a semantic table (create_table: columns tagged with role dimension|measure), publishing a metric (create_metric: a metric_index payload then a metric_detail payload using the SQL-free calculation DSL), and correcting published assets (update_table / update_metric).
-
-DOES NOT OWN:
-- Running queries or reading the aggregated runtime view \u2192 metrics_runtime_tool (get_meta / query / custom_sql).
-- Probing physical tables, columns, grants, or samples \u2192 metrics_datasource_tool.
-
-USE WHEN: physical exploration is done and the model has been proposed and confirmed by the user \u2014 to publish the semantic table and metrics, or to correct published assets afterwards.
-
-COMMON MISTAKES (do not):
-- Do not call get_meta here \u2014 that action belongs to metrics_runtime_tool, not this tool.
-- Do not try to "query numbers" through this tool \u2014 list/read actions return definitions only; use metrics_runtime_tool query for data.
-- Do not publish a metric whose sourceTable has no published table meta, or whose dimensions are not published columns with role dimension \u2014 the server will reject it.
-- The builder assistant must load the semantic-metrics-modeling skill and pass modelingSkillLoaded: true on write actions; no removal actions are exposed on purpose.`;
-var MODELING_SKILL_NAME = "semantic-metrics-modeling";
-var BUILDER_ASSISTANT_ID = "semantic-metrics-builder";
-function requireModelingSkillLoaded(action, input, exeConfig) {
-  const isWriteAction = action === "create_table" || action === "update_table" || action === "create_metric" || action === "update_metric";
-  if (!isWriteAction) return void 0;
-  const runConfig = readToolRunConfig(exeConfig);
-  const assistantId = runConfig?.assistant_id;
-  if (assistantId === BUILDER_ASSISTANT_ID && input.modelingSkillLoaded !== true) {
-    return JSON.stringify({
-      success: false,
-      error: `Load the '${MODELING_SKILL_NAME}' skill before publishing meta.`
-    });
-  }
-  return void 0;
-}
-function actionRequiresPayload(action) {
-  return action === "create_table" || action === "update_table" || action === "create_metric" || action === "update_metric";
-}
-function createMetricsMetaTool(params) {
-  const { connectionType, connections, connectAll } = params;
-  return tool52(
-    async (input, exeConfig) => {
-      try {
-        const guardError = requireModelingSkillLoaded(input.action, input, exeConfig);
-        if (guardError !== void 0) return guardError;
-        const client = await resolveMetricsClientFromSelector(
-          { connectionType, connections, connectAll },
-          readToolRunConfig(exeConfig) ?? {},
-          input.connectionKey
-        );
-        const ds = resolveDatasourceId(input, exeConfig);
-        assertDatasourceSelected(effectiveDatasourceScope(client.getSelectedEntities()), ds);
-        if (actionRequiresPayload(input.action) && input.payload === void 0) {
-          throw new Error(`payload is required for ${input.action}`);
-        }
-        const payload = input.payload ?? {};
-        switch (input.action) {
-          case "list_tables": {
-            return JSON.stringify(await client.listTables(ds), null, 2);
-          }
-          case "read_table_meta": {
-            if (!input.objectKey) throw new Error("objectKey is required for read_table_meta");
-            return JSON.stringify(await client.getTable(ds, input.objectKey), null, 2);
-          }
-          case "create_table": {
-            return JSON.stringify(await client.createTable(ds, payload), null, 2);
-          }
-          case "update_table": {
-            if (!input.objectKey) throw new Error("objectKey is required for update_table");
-            return JSON.stringify(await client.updateTable(ds, input.objectKey, payload), null, 2);
-          }
-          case "list_metrics": {
-            return JSON.stringify(await client.listMetrics(ds), null, 2);
-          }
-          case "read_metric_meta": {
-            if (!input.objectKey) throw new Error("objectKey is required for read_metric_meta");
-            return JSON.stringify(await client.getMetric(ds, input.objectKey), null, 2);
-          }
-          case "create_metric": {
-            return JSON.stringify(await client.createMetric(ds, payload), null, 2);
-          }
-          case "update_metric": {
-            if (!input.objectKey) throw new Error("objectKey is required for update_metric");
-            return JSON.stringify(await client.updateMetric(ds, input.objectKey, payload), null, 2);
-          }
-        }
-      } catch (error) {
-        return `Error: ${error instanceof Error ? error.message : String(error)}`;
-      }
-    },
-    {
-      name: "metrics_meta_tool",
-      description: DESCRIPTION2,
-      schema: z58.object({
-        action: z58.enum([
-          "list_tables",
-          "read_table_meta",
-          "create_table",
-          "update_table",
-          "list_metrics",
-          "read_metric_meta",
-          "create_metric",
-          "update_metric"
-        ]).describe(
-          "Actions ONLY in this meta tool (runtime query actions like get_meta/query belong to metrics_runtime_tool): list_tables/list_metrics (browse published assets), read_table_meta/read_metric_meta (details by objectKey), create_table/create_metric (publish), update_table/update_metric (correct)"
-        ),
-        connectionKey: z58.string().optional().describe("Connection key. Omit when only one semantic-metrics connection exists"),
-        datasourceId: z58.coerce.number().optional().describe("Numeric datasource id, e.g. 15 (optional if set in runConfig.metricsDataSource)"),
-        objectKey: z58.string().optional().describe("Semantic table/metric key (required for read_table_meta/update_table/read_metric_meta/update_metric)"),
-        payload: z58.record(z58.unknown()).optional().describe("Meta payload (required for create/update actions; objectType/objectKey/status/payload/accessGrant)"),
-        modelingSkillLoaded: z58.literal(true).optional().describe("Set true after loading the semantic-metrics-modeling skill (required for the builder assistant on write actions)")
-      })
-    }
-  );
-}
-
-// src/tool_lattice/semantic_metrics/metrics_runtime_tool.ts
-import z59 from "zod";
-import { tool as tool53 } from "langchain";
-var DESCRIPTION3 = `RUNTIME QUERY SURFACE \u2014 read what is published and answer business questions with numbers. Business agents use ONLY this tool; Builder agents also use it to verify freshly published metrics.
-
-OWNS: list_datasources (self-contained datasource discovery \u2014 redacted output, the first step before anything else), read_semantic_catalog (the published semantic model for a datasource: tables, metrics, dimensions, filters) and query_metrics (the semantic metric query: metrics / groupBy / filters / orderBy / limit \u2014 the server generates the SQL, so there is no free-form SQL here).
-
-DOES NOT OWN:
-- Publishing or correcting semantic tables/metrics \u2192 metrics_meta_tool (create_table/update_table/create_metric/update_metric/list_tables/read_table_meta/list_metrics/read_metric_meta).
-- Physical exploration of raw tables, grants, or samples \u2192 metrics_datasource_tool (query_sql).
-- Free-form custom SQL \u2014 intentionally not provided; use query against published metrics.
-
-USE WHEN: read_semantic_catalog to see what is published before asking numbers; query_metrics to answer a business question from already-published metrics (Business) or to verify a just-published metric against its acceptance evidence (Builder).
-
-COMMON MISTAKES (do not):
-- Do not call meta-tool actions here (create_table / update_table / create_metric / update_metric / list_tables / read_table_meta / list_metrics / read_metric_meta) \u2014 they live in metrics_meta_tool and will fail schema validation here.
-- Do not look for a custom-SQL action \u2014 there is none; explore physical data with metrics_datasource_tool query_sql, and query business numbers with the semantic query action.
-- Metrics and dimensions in query_metrics must already be published; querying an unpublished metric fails with "not found in catalog".`;
-function createMetricsRuntimeTool(params) {
-  const { connectionType, connections, connectAll } = params;
-  return tool53(
-    async (input, exeConfig) => {
-      try {
-        const client = await resolveMetricsClientFromSelector(
-          { connectionType, connections, connectAll },
-          readToolRunConfig(exeConfig) ?? {},
-          input.connectionKey
-        );
-        const scope = effectiveDatasourceScope(client.getSelectedEntities());
-        switch (input.action) {
-          case "list_datasources": {
-            const result = await client.listDatasources();
-            const filtered = scope.unrestricted ? result : result.filter((d) => scope.ids.includes(Number(d.id)));
-            const safe = filtered.map((d) => ({
-              id: d.id,
-              name: d.name,
-              sourceType: d.sourceType,
-              description: d.description,
-              statusLabel: d.statusLabel
-            }));
-            return JSON.stringify(safe, null, 2);
-          }
-          case "read_semantic_catalog": {
-            const ds = resolveDatasourceId(input, exeConfig);
-            assertDatasourceSelected(scope, ds);
-            return JSON.stringify(await client.getRuntimeMeta(ds), null, 2);
-          }
-          case "query_metrics": {
-            if (!input.query) throw new Error("query is required for the 'query_metrics' action");
-            const bodyDatasourceId = input.query.datasourceId;
-            if (bodyDatasourceId !== void 0) {
-              assertDatasourceSelected(scope, Number(bodyDatasourceId));
-            }
-            return JSON.stringify(await client.queryMetrics(input.query), null, 2);
-          }
-        }
-      } catch (error) {
-        return `Error: ${error instanceof Error ? error.message : String(error)}`;
-      }
-    },
-    {
-      name: "metrics_runtime_tool",
-      description: DESCRIPTION3,
-      schema: z59.object({
-        action: z59.enum(["list_datasources", "read_semantic_catalog", "query_metrics"]).describe(
-          "Actions ONLY in this runtime tool: list_datasources (list available datasources \u2014 ALWAYS call this first to obtain the datasourceId; output is redacted to non-sensitive fields), read_semantic_catalog (read the published semantic model: tables, metrics, dimensions), query_metrics (run a semantic metric query \u2014 the only way to get business numbers). Do NOT put meta-tool actions (list_tables/read_table_meta/create_table/update_table/list_metrics/read_metric_meta/create_metric/update_metric) here"
-        ),
-        connectionKey: z59.string().optional().describe("Connection key. Omit when only one semantic-metrics connection exists"),
-        datasourceId: z59.coerce.number().optional().describe("Numeric datasource id, e.g. 15 (required for read_semantic_catalog; optional if set in runConfig.metricsDataSource)"),
-        query: z59.record(z59.unknown()).optional().describe('Semantic metric query request. Required for the query_metrics action, e.g. { datasourceId: 15, metrics: ["sell_in_nes"], groupBy: ["sales_team"], filters: [{ dimension: "posting_year", operator: "GTE", values: [2024] }], limit: 10 }')
-      })
-    }
-  );
-}
-
-// 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.
----
-
-# Semantic Metrics Modeling
-
-You are the Semantic Metrics Builder. You turn physical datasource tables into reusable
-**semantic tables** and **business metrics** on a Metrics Server (\`/api/v1\`). Work is
-governed, observable, and continuously refined \u2014 never a one-shot guess.
-
-## Goal Model
-
-Before any exploration or publishing, agree with the user on:
-- **Real goal**: the business outcome (which metrics, for what decision), not just "make a table".
-- **Consumer**: who reads the result and how.
-- **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.
-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.
-
-## Target model and quality bar
-
-Your goal is a specific, verifiable artifact, not "some tables and metrics".
-
-**Target shape** \u2014 one delivery is:
-- a published \`table_view_detail\` meta per logical table, with every column tagged
-  \`role\` (dimension | measure) and a business-readable \`label\`;
-- a \`metric_index\` + \`metric_detail\` pair per metric, using the SQL-free \`calculation\` DSL;
-- the set, taken together, answers the user's concrete business question.
-
-**Publish gate (self-check every metric before create)** \u2014 if any fails, do **not** publish; go
-explore or ask the user:
-1. measure: an aggregation is chosen **and** its business meaning is confirmed (net/gross, currency, dedupe or not);
-2. dimension: has a business meaning and a grain (day/month/year/\u2026);
-3. \`displayName\`/\`label\` are business-readable;
-4. the metric answers one concrete question from the user's stated goal;
-5. a runtime \`query\` returns numbers consistent with the confirmed meaning.
-
-**Intent gaps first** \u2014 before diving into exploration, list the inputs you still need to meet the
-quality bar (business meaning, grain, target metric list, table scope, consumer) and ask for them
-explicitly. Exploration and user questions are both driven by this target shape and quality bar:
-missing business meaning \u2192 ask; unclear field semantics \u2192 probe or ask; right shape but it does not
-answer the business question \u2192 do not publish.
-
-## FEP Loop
-
-Apply this loop to every step (explore, publish table, publish metric, verify):
-**OBSERVE \u2192 HYPOTHESIZE \u2192 ACT \u2192 VERIFY \u2192 DECIDE \u2192 RECONCILE**
-
-- **Observe**: current state, grants, published meta, and decision-relevant uncertainty.
-- **Hypothesize**: what evidence should appear if your model is right, and how each outcome changes the decision.
-- **Act**: one proportional action \u2014 no more than necessary.
-- **Verify**: compare the observed result (e.g. a runtime \`query\`) against the prediction.
-- **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
-
-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
-
-Record your modeling beliefs in the active task's description under a \`## Belief State\` section as
-a Markdown table:
-
-\`\`\`
-| Belief Key | Probability | Target | Basis |
-|---|---|---|---|
-| sell-in-nes-source-table | 70% | 100% | column \`nes\` probed as numeric measure in grant |
-\`\`\`
-
-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.
-
-## 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
-
-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.
-
-## Unclear field semantics
-
-A probed column name may not reveal its business meaning (e.g. whether \`nes\` is a net amount to
-sum, a rate to average, or an enum to filter). Publishing meta on a misunderstood field pollutes
-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:
-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\`;
-   - small enumerations (year 2023/2024, 0/1 flags, codes) \u2192 dimension.
-   The share of zeros/negatives and the value scale usually disambiguate semantics.
-2. **Read user-provided docs**: if the user supplied a data dictionary or sample file, read it via
-   filesystem and reconcile it against the probed columns.
-3. **Cross-field correlation**: compare the unclear field with fields whose semantics are confirmed.
-
-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.
-
-## 2. Publish table meta (\`create_table\`)
-
-Publish the authoritative shape below (objectType \`table_view_detail\`, with an EXACT accessGrant):
-
-\`\`\`json
-{
-  "objectType": "table_view_detail",
-  "objectKey": "hankel_view_sales_summary",
-  "status": 1,
-  "payload": {
-    "schemaName": "public",
-    "tableName": "hankel_view_sales_summary",
-    "displayName": "Hankel Sales Summary",
-    "docType": "Sales Summary",
-    "docTypeEn": "Sales Summary",
-    "shortDesc": "Sales-level progress summary.",
-    "grain": "canonical_sales_name",
-    "sourceSystem": "Hankel Run for Gold",
-    "sourceTables": ["hankel_project_opportunity_lines", "hankel_new_order_lines"],
-    "columns": [
-      { "name": "canonical_sales_name", "label": "Canonical Sales Name", "type": "string", "role": "dimension", "description": "Standardized sales name used for grouping." },
-      { "name": "nes", "label": "NES", "type": "number", "role": "measure", "description": "Net external sales amount." },
-      { "name": "report_cutoff_date", "label": "Report Cutoff Date", "type": "date", "role": "time", "description": "Cutoff date of the report snapshot." }
-    ]
-  },
-  "accessGrant": {
-    "schemaName": "public",
-    "tablePattern": "hankel_view_sales_summary",
-    "patternType": "EXACT",
-    "caseSensitive": false,
-    "status": 1
-  }
-}
-\`\`\`
-
-Design rules:
-- \`objectKey\` is stable and unique per datasource (the view/table key).
-- \`columns[].role\` has THREE values: \`dimension\` (grouping/filtering), \`measure\` (aggregated numbers), \`time\` (the report cutoff/snapshot date used by default_time_context).
-- Give every column a business \`description\`.
-- Lineage fields (\`docType\`, \`shortDesc\`, \`grain\`, \`sourceSystem\`, \`sourceTables\`) make the asset findable and trustworthy \u2014 fill them from exploration evidence.
-- 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\`)
-
-Two steps for the same \`objectKey\`.
-
-### 3a. Metric index (for lists/search)
-
-\`\`\`json
-{
-  "objectType": "metric_index",
-  "objectKey": "sell_in_nes",
-  "status": 1,
-  "payload": {
-    "metric_name": "sell_in_nes",
-    "display_name": "Sell-in NES",
-    "domain": "sales",
-    "short_desc": "Net external sales amount from distributor sell-in rows.",
-    "search_keywords": ["sell in", "nes", "net external sales"],
-    "source_type": "cdp_postgres",
-    "source": { "table_view": "public.hankel_distr_sell_in" }
-  }
-}
-\`\`\`
-
-\`search_keywords\` drive metric retrieval for natural-language questions \u2014 include business synonyms.
-
-### 3b. Metric detail (the calculation)
-
-IMPORTANT \u2014 runtime schema requirement: the Metrics Server query runtime only recognizes metrics
-published in the FULL runtime style below (the same shape as existing working metrics, with
-snake_case fields like \`metric_name\`, \`source.table_view\`, \`supported_dimensions\` objects, and
-\`default_time_context\`). A minimal \`{name, sourceTable, calculation, dimensions}\` payload is
-accepted by the publish API but is NOT queryable \u2014 querying it returns 403 "not authorized".
-
-Aggregate metric (full runtime style):
-
-\`\`\`json
-{
-  "objectType": "metric_detail",
-  "objectKey": "sell_in_nes",
-  "status": 1,
-  "payload": {
-    "metric_name": "sell_in_nes",
-    "display_name": "Sell-in NES",
-    "domain": "sales",
-    "description": "Net external sales amount from distributor sell-in rows.",
-    "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" },
-    "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" }
-    ],
-    "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."
-    }
-  }
-}
-\`\`\`
-
-Derived ratio metric (references two aggregate metrics):
-
-\`\`\`json
-{
-  "objectType": "metric_detail",
-  "objectKey": "gross_margin_rate",
-  "status": 1,
-  "payload": {
-    "metric_name": "gross_margin_rate",
-    "display_name": "Gross Margin Rate",
-    "description": "Gross margin divided by sell-in NES.",
-    "domain": "sales",
-    "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" }
-    ],
-    "default_time_context": { "time_dimension": "posting_date", "granularity": "month", "supported_grains": ["month", "year"] }
-  }
-}
-\`\`\`
-
-Design rules:
-- \`objectKey\` unique per datasource (index and detail share it).
-- \`payload.metric_name\` must equal \`objectKey\`.
-- \`source.table_view\` must be schema-qualified and match the published table meta's physical table.
-- \`supported_dimensions\` is an array of OBJECTS ({dim_id, field_name, label, data_type}); include the time dimension too; each must be a published column of that table meta.
-- \`calculation.type: "aggregate"\` = one measure + aggregation (sum/avg/count/min/max/count_distinct).
-- \`calculation.type: "derived"\` operator \`ratio\` references existing metric objectKeys (numerator/denominator); a \`formula\` variant takes an expression of metric names, numbers, parentheses, and + - * / \u2014 referenced metrics must share the same source.table_view.
-- \`default_time_context\` (\`time_dimension\` + \`granularity\` + \`supported_grains\`, optionally \`window\`) is required by the query runtime; its \`time_dimension\` must appear in supported_dimensions.
-- \`ai_agent_context\` (\`polarity\`, \`synonyms\`, \`human_readable_explanation\`) improves natural-language metric retrieval \u2014 always provide it.
-- One semantic query can only combine metrics sharing the same source.table_view; groupBy values must be dim_ids or time-grain expressions like \`posting_date__month\`.
-- 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
-
-- \`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.
-
-## Troubleshooting
-
-| Symptom | Cause / fix |
-|---|---|
-| \`TABLE_NOT_GRANTED\` | SQL referenced a table outside the tenant grant; pick an in-grant table |
-| metric create fails: sourceTable missing | publish the table meta first |
-| metric create fails: unknown dimension | publish the dimension column with \`role: dimension\` |
-| 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 |
-
-## Safety
-
-- Only query tables that match the tenant's \`table-grants\`.
-- Never return a full physical-table inventory or reveal whether an un-granted table exists.
-- SQL is validated read-only; let the server reject anything outside that.
-`;
-var resources = {
-  "references/metadata-sql.md": {
-    content: `# Datasource exploration SQL templates (read-only)
-
-Pick the block matching the server's database. These run through the datasource \`query\` action;
-the SQL is validated read-only.
-
-## PostgreSQL
-- Tables: \`select table_schema, table_name from information_schema.tables where table_schema not in ('pg_catalog','information_schema') order by table_schema, table_name\`
-- Columns: \`select column_name, data_type from information_schema.columns where table_schema = :schemaName and table_name = :tableName order by ordinal_position\`
-- Sample: \`select * from :schemaName.:tableName limit :maxRows\` \u2014 pass a concrete table, not a bound param, if the server does not support binding identifiers.
-
-## SQL Server
-- Tables: \`select table_schema, table_name from information_schema.tables order by table_schema, table_name\`
-- Columns: \`select column_name, data_type from information_schema.columns where table_schema = :schemaName and table_name = :tableName order by ordinal_position\`
-
-## HANA
-- Tables: \`select schema_name, table_name from sys.tables where schema_name = :schemaName order by table_name\`
-- Columns: \`select column_name, data_type_name from table_columns where schema_name = :schemaName and table_name = :tableName order by position\`
-
-## Value distribution (any dialect)
-\`select <dim>, count(*) as row_count from <table> group by <dim> order by row_count desc limit :maxRows\`
-`
-  },
-  "examples/table-meta.json": {
-    content: `{
-  "objectType": "table_view_detail",
-  "objectKey": "hankel_distr_sell_in",
-  "status": 1,
-  "payload": {
-    "schemaName": "public",
-    "tableName": "hankel_distr_sell_in",
-    "displayName": "Hankel Distributor Sell In",
-    "description": "Distributor sell-in transaction rows for the Hankel tenant.",
-    "columns": [
-      { "name": "posting_year", "label": "Posting Year", "type": "number", "role": "dimension" },
-      { "name": "posting_month", "label": "Posting Month", "type": "number", "role": "dimension" },
-      { "name": "sales_team", "label": "Sales Team", "type": "string", "role": "dimension" },
-      { "name": "region", "label": "Region", "type": "string", "role": "dimension" },
-      { "name": "nes", "label": "Net External Sales", "type": "number", "role": "measure" },
-      { "name": "gross_margin", "label": "Gross Margin", "type": "number", "role": "measure" }
-    ]
-  }
-}
-`
-  },
-  "examples/metric-aggregate.json": {
-    content: `{
-  "objectType": "metric_detail",
-  "objectKey": "hankel_sell_in_nes",
-  "status": 1,
-  "payload": {
-    "name": "hankel_sell_in_nes",
-    "displayName": "Sell-in NES",
-    "description": "Net external sales amount from distributor sell-in rows.",
-    "sourceTable": "hankel_distr_sell_in",
-    "calculation": { "type": "aggregate", "aggregation": "sum", "measure": "nes" },
-    "dimensions": ["posting_year", "posting_month", "sales_team", "region"]
-  }
-}
-`
-  },
-  "examples/metric-derived.json": {
-    content: `{
-  "objectType": "metric_detail",
-  "objectKey": "hankel_gross_margin_rate",
-  "status": 1,
-  "payload": {
-    "name": "hankel_gross_margin_rate",
-    "displayName": "Gross Margin Rate",
-    "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"
-    },
-    "dimensions": ["posting_year", "sales_team", "region"]
-  }
-}
-`
-  }
-};
-var SEMANTIC_METRICS_MODELING_SKILL = {
-  version: "1.0.0",
-  content: CONTENT,
-  resources
-};
-
-// src/middlewares/semanticMetricsBuilderPrompt.ts
-var SEMANTIC_METRICS_BUILDER_PROMPT = `You are the Semantic Metrics Builder.
-
-CRITICAL FIRST ACTION: Before any response or other action, call the \`skill\`
-tool with skill_name: "semantic-metrics-modeling" to load semantic-metrics-modeling and follow it.
-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";
-function createSemanticMetricsMiddleware(config) {
-  const connections = config.connections ?? [];
-  const connectAll = config.connectAll === true;
-  const selector = { connectionType: "semantic-metrics", connections, connectAll };
-  return createMiddleware20({
-    name: "SemanticMetrics",
-    contextSchema,
-    tools: [
-      createMetricsDatasourceTool(selector),
-      createMetricsMetaTool(selector),
-      createMetricsRuntimeTool(selector)
-    ]
-  });
-}
-function buildConnectionHeaders(config) {
-  const headers = {
-    Accept: "application/json",
-    ...config.headers !== void 0 && config.headers !== null ? config.headers : {}
-  };
-  if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
-  return headers;
-}
-function resolveBaseUrl(config) {
-  const serverUrl = config.serverUrl;
-  if (!serverUrl) {
-    throw new Error("serverUrl is required");
-  }
-  return serverUrl.replace(/\/$/, "");
-}
-var semanticMetricsPlugin = {
-  meta: {
-    type: "semantic-metrics",
-    category: "data",
-    capabilityBundleEligible: true,
-    openExpose: [
-      // Query-only surface: no writes reach either tool (SQL is read-only).
-      { name: "metrics_datasource_tool", readOnly: true },
-      { name: "metrics_runtime_tool", readOnly: true }
-    ],
-    name: "Semantic Metrics",
-    description: "Semantic metrics datasource exploration, meta publishing, and runtime querying. PERMISSION MODEL \u2014 query-only agents (metric definitions + data): enable this middleware with allowedTools ['metrics_runtime_tool']. Metric designers (Builder): keep all three tools (metrics_datasource_tool, metrics_meta_tool, metrics_runtime_tool) for exploration, publishing, and verification, or use the built-in 'semantic-metrics-builder' agent.",
-    version: "1.0.0",
-    tools: [
-      { name: "metrics_datasource_tool", description: "Explore datasource structure within the tenant's granted scope" },
-      { name: "metrics_meta_tool", description: "Publish and maintain runtime semantic tables and metrics" },
-      { name: "metrics_runtime_tool", description: "Read runtime meta and execute semantic metric queries" }
-    ],
-    configSchema: {
-      type: "object",
-      title: "Semantic Metrics Configuration",
-      description: "First select connections (connections or connectAll). Then scope tools by role via allowedTools: QUERY-ONLY agents (metric definitions + data) set allowedTools to ['metrics_runtime_tool'] \u2014 it is self-contained (list_datasources, read_semantic_catalog, query_metrics); metric DESIGNERS keep all three tools (datasource exploration, meta publishing, runtime verification).",
-      properties: {
-        connections: {
-          type: "array",
-          title: "Connections",
-          items: { type: "string" },
-          widget: "connectionSelect"
-        },
-        connectAll: {
-          type: "boolean",
-          title: "Connect All",
-          default: false,
-          widget: "switch"
-        }
-      }
-    },
-    defaultConfig: { connections: [], connectAll: false }
-  },
-  connection: {
-    // PluginConnectionFieldSchema.type supports only string/number/boolean/password,
-    // so headers is NOT a form field; the V2 client still reads config.headers at runtime.
-    fields: [
-      { key: "serverUrl", type: "string", title: "Metrics Server Base URL (include /api/v1)", required: true },
-      { key: "apiKey", type: "password", title: "API Key (optional)" }
-    ],
-    test: async (config) => {
-      try {
-        const baseUrl = resolveBaseUrl(config);
-        const res = await fetch(`${baseUrl}/datasources`, {
-          headers: buildConnectionHeaders(config)
-        });
-        const text = await res.text().catch(() => "");
-        let ok = res.ok;
-        let detail = "";
-        try {
-          const parsed = JSON.parse(text);
-          if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-            const code = parsed.code;
-            if (typeof code === "number") {
-              ok = res.ok && code === 200;
-              if (!ok) detail = ` (${parsed.message ?? code})`;
-            }
-          }
-        } catch {
-        }
-        return {
-          ok,
-          message: ok ? `Reachable at ${baseUrl}` : `HTTP ${res.status}${detail}`
-        };
-      } catch (err) {
-        return {
-          ok: false,
-          message: `Cannot connect: ${err instanceof Error ? err.message : String(err)}`
-        };
-      }
-    },
-    discover: async (config) => {
-      try {
-        const baseUrl = resolveBaseUrl(config);
-        const res = await fetch(`${baseUrl}/datasources`, {
-          headers: buildConnectionHeaders(config)
-        });
-        const text = await res.text();
-        if (!res.ok) {
-          throw new Error(`HTTP ${res.status}${text ? `: ${text.slice(0, 200)}` : ""}`);
-        }
-        const parsed = JSON.parse(text);
-        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-          throw new Error("Metrics server returned an unexpected payload (expected a JSON envelope)");
-        }
-        const envelope = parsed;
-        if (typeof envelope.code === "number" && envelope.code !== 200) {
-          throw new Error(envelope.message || `API ${envelope.code}`);
-        }
-        const data = envelope.data;
-        if (!Array.isArray(data)) {
-          throw new Error("Metrics server returned an unexpected payload (expected a datasource array)");
-        }
-        return data.filter((d) => {
-          if (d === null || typeof d !== "object") return false;
-          const id = d.id;
-          return id !== void 0 && id !== null && id !== "";
-        }).map((item) => ({
-          id: String(item.id),
-          name: item.name ?? String(item.id)
-        }));
-      } catch (err) {
-        throw new Error(
-          `Cannot discover datasources: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-  },
-  skills: {
-    "semantic-metrics-modeling": SEMANTIC_METRICS_MODELING_SKILL
-  },
-  agents: {
-    "semantic-metrics-builder": {
-      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,
-      prompt: SEMANTIC_METRICS_BUILDER_PROMPT,
-      middleware: [
-        {
-          id: "semantic-metrics",
-          type: "semantic-metrics",
-          name: "Semantic Metrics",
-          description: "Explore datasources, publish table/meta metrics, query runtime",
-          enabled: true,
-          config: { connections: [], connectAll: true }
-        },
-        {
-          id: "skill",
-          type: "skill",
-          name: "Skill",
-          description: "Load the semantic-metrics-modeling policy and task-definition reference",
-          enabled: true,
-          config: { readAll: false, skills: ["semantic-metrics-modeling", "task-definition"] }
-        },
-        {
-          id: "task",
-          type: "task",
-          name: "Task",
-          description: "Persistent TaskItems as the planning surface; update Belief State in task descriptions",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "ask_user_to_clarify",
-          type: "ask_user_to_clarify",
-          name: "Ask User",
-          description: "Wait for user input at modeling approval gates",
-          enabled: true,
-          config: {}
-        },
-        {
-          id: "filesystem",
-          type: "filesystem",
-          name: "Filesystem",
-          description: "Read user-provided schema docs, data dictionaries, or sample data files",
-          enabled: true,
-          config: {}
-        }
-      ]
-    }
-  },
-  middleware: (config) => createSemanticMetricsMiddleware(config)
-};
-
-// src/middlewares/collectionMiddleware.ts
-import { createMiddleware as createMiddleware21 } from "langchain";
-
-// src/tool_lattice/collection/list_collections.ts
-import z60 from "zod";
-import { tool as tool54 } from "langchain";
-
 // src/tool_lattice/collection/utils.ts
 function getEffectiveCollectionScope(exeConfig, staticScope) {
   const runtimeConfig = getRuntimeCapabilityConfig(exeConfig, "collection");
@@ -40438,7 +39245,7 @@ var createListCollectionsTool = ({
   collectionKeys,
   connectAll
 }) => {
-  return tool54(
+  return tool51(
     async (_input, _exeConfig) => {
       try {
         const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -40473,23 +39280,23 @@ var createListCollectionsTool = ({
     {
       name: "list_collections",
       description: LIST_COLLECTIONS_DESCRIPTION,
-      schema: z60.object({})
+      schema: z57.object({})
     }
   );
 };
 
 // src/tool_lattice/collection/search_collection.ts
-import z61 from "zod";
-import { tool as tool55 } from "langchain";
+import z58 from "zod";
+import { tool as tool52 } from "langchain";
 var SEARCH_COLLECTION_DESCRIPTION = `Search for content within a specific collection using semantic (vector) similarity. Use the 'filter' parameter to narrow results by metadata fields (e.g., {"category": "cardiovascular"}). Returns the most relevant content entries with similarity scores.`;
-var searchSchema = z61.object({
-  collection: z61.string().describe("The collection name to search in"),
-  query: z61.string().describe("The search query text"),
-  filter: z61.record(z61.unknown()).optional().describe("Metadata filter conditions"),
-  top_k: z61.number().optional().default(5).describe("Number of results to return")
+var searchSchema = z58.object({
+  collection: z58.string().describe("The collection name to search in"),
+  query: z58.string().describe("The search query text"),
+  filter: z58.record(z58.unknown()).optional().describe("Metadata filter conditions"),
+  top_k: z58.number().optional().default(5).describe("Number of results to return")
 });
 var createSearchCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => {
-  return tool55(
+  return tool52(
     async (input, _exeConfig) => {
       try {
         const { collection, query, filter: filter2, top_k } = input;
@@ -40555,10 +39362,10 @@ var createSearchCollectionTool = (scope = { collectionKeys: [], connectAll: true
 };
 
 // src/tool_lattice/collection/get_collection.ts
-import z62 from "zod";
-import { tool as tool56 } from "langchain";
+import z59 from "zod";
+import { tool as tool53 } from "langchain";
 var GET_COLLECTION_DESCRIPTION = `Get a collection's full definition including its custom fields schema. Use this to discover what metadata fields are available before adding entries.`;
-var createGetCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool56(
+var createGetCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool53(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.name, _exeConfig, scope);
@@ -40583,24 +39390,24 @@ Embedding: ${c.embeddingKey}${fieldsDesc}`;
       return `Error: ${error.message}`;
     }
   },
-  { name: "get_collection", description: GET_COLLECTION_DESCRIPTION, schema: z62.object({ name: z62.string().describe("Collection name") }) }
+  { name: "get_collection", description: GET_COLLECTION_DESCRIPTION, schema: z59.object({ name: z59.string().describe("Collection name") }) }
 );
 
 // src/tool_lattice/collection/create_collection.ts
-import z63 from "zod";
-import { tool as tool57 } from "langchain";
-var createSchema = z63.object({
-  name: z63.string().describe("Collection name (lowercase, underscores only)"),
-  label: z63.string().describe("Display name"),
-  embeddingKey: z63.string().describe("Embedding model key"),
-  fields: z63.array(z63.object({
-    key: z63.string().describe("Field key name"),
-    type: z63.enum(["string", "number", "enum"]).describe("Field data type"),
-    enumValues: z63.array(z63.string()).optional().describe("Valid values for enum type"),
-    required: z63.boolean().optional().default(false).describe("Whether field is required")
+import z60 from "zod";
+import { tool as tool54 } from "langchain";
+var createSchema = z60.object({
+  name: z60.string().describe("Collection name (lowercase, underscores only)"),
+  label: z60.string().describe("Display name"),
+  embeddingKey: z60.string().describe("Embedding model key"),
+  fields: z60.array(z60.object({
+    key: z60.string().describe("Field key name"),
+    type: z60.enum(["string", "number", "enum"]).describe("Field data type"),
+    enumValues: z60.array(z60.string()).optional().describe("Valid values for enum type"),
+    required: z60.boolean().optional().default(false).describe("Whether field is required")
   })).optional().describe("Custom field definitions for entries in this collection")
 });
-var createCreateCollectionTool = (scope = {}) => tool57(
+var createCreateCollectionTool = (scope = {}) => tool54(
   async (input, _exeConfig) => {
     try {
       const tenantId2 = _exeConfig?.configurable?.runConfig?.tenantId || "default";
@@ -40626,20 +39433,20 @@ var createCreateCollectionTool = (scope = {}) => tool57(
 );
 
 // src/tool_lattice/collection/update_collection.ts
-import z64 from "zod";
-import { tool as tool58 } from "langchain";
-var schema = z64.object({
-  name: z64.string().describe("Collection name"),
-  label: z64.string().optional().describe("New display name"),
-  embeddingKey: z64.string().optional().describe("New embedding model key"),
-  fields: z64.array(z64.object({
-    key: z64.string().describe("Field key name"),
-    type: z64.enum(["string", "number", "enum"]).describe("Field data type"),
-    enumValues: z64.array(z64.string()).optional().describe("Valid values for enum type"),
-    required: z64.boolean().optional().default(false).describe("Whether field is required")
+import z61 from "zod";
+import { tool as tool55 } from "langchain";
+var schema = z61.object({
+  name: z61.string().describe("Collection name"),
+  label: z61.string().optional().describe("New display name"),
+  embeddingKey: z61.string().optional().describe("New embedding model key"),
+  fields: z61.array(z61.object({
+    key: z61.string().describe("Field key name"),
+    type: z61.enum(["string", "number", "enum"]).describe("Field data type"),
+    enumValues: z61.array(z61.string()).optional().describe("Valid values for enum type"),
+    required: z61.boolean().optional().default(false).describe("Whether field is required")
   })).optional().describe("Custom field definitions for entries (replaces existing schema)")
 });
-var createUpdateCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool58(
+var createUpdateCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool55(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.name, _exeConfig, scope);
@@ -40660,9 +39467,9 @@ var createUpdateCollectionTool = (scope = { collectionKeys: [], connectAll: true
 );
 
 // src/tool_lattice/collection/delete_collection.ts
-import z65 from "zod";
-import { tool as tool59 } from "langchain";
-var createDeleteCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool59(
+import z62 from "zod";
+import { tool as tool56 } from "langchain";
+var createDeleteCollectionTool = (scope = { collectionKeys: [], connectAll: true }) => tool56(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.name, _exeConfig, scope);
@@ -40674,19 +39481,19 @@ var createDeleteCollectionTool = (scope = { collectionKeys: [], connectAll: true
       return `Error: ${e.message}`;
     }
   },
-  { name: "delete_collection", description: `Delete a collection and all its entries. This cannot be undone.`, schema: z65.object({ name: z65.string().describe("Collection name") }) }
+  { name: "delete_collection", description: `Delete a collection and all its entries. This cannot be undone.`, schema: z62.object({ name: z62.string().describe("Collection name") }) }
 );
 
 // src/tool_lattice/collection/list_entries.ts
-import z66 from "zod";
-import { tool as tool60 } from "langchain";
-var schema2 = z66.object({
-  collection: z66.string().describe("Collection name")
+import z63 from "zod";
+import { tool as tool57 } from "langchain";
+var schema2 = z63.object({
+  collection: z63.string().describe("Collection name")
 });
 function buildKey2(tenantId2, name) {
   return `${tenantId2}:${name}`;
 }
-var createListEntriesTool = (scope = { collectionKeys: [], connectAll: true }) => tool60(
+var createListEntriesTool = (scope = { collectionKeys: [], connectAll: true }) => tool57(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.collection, _exeConfig, scope);
@@ -40715,19 +39522,19 @@ var createListEntriesTool = (scope = { collectionKeys: [], connectAll: true }) =
 );
 
 // src/tool_lattice/collection/add_entry.ts
-import z67 from "zod";
-import { tool as tool61 } from "langchain";
+import z64 from "zod";
+import { tool as tool58 } from "langchain";
 import { Document } from "@langchain/core/documents";
 import { v4 as uuidv48 } from "uuid";
-var schema3 = z67.object({
-  collection: z67.string().describe("Collection name"),
-  content: z67.string().describe("Entry content text"),
-  metadata: z67.record(z67.unknown()).optional().describe("Metadata fields matching the collection schema")
+var schema3 = z64.object({
+  collection: z64.string().describe("Collection name"),
+  content: z64.string().describe("Entry content text"),
+  metadata: z64.record(z64.unknown()).optional().describe("Metadata fields matching the collection schema")
 });
 function key2(t, n) {
   return `${t}:${n}`;
 }
-var createAddEntryTool = (scope = { collectionKeys: [], connectAll: true }) => tool61(
+var createAddEntryTool = (scope = { collectionKeys: [], connectAll: true }) => tool58(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.collection, _exeConfig, scope);
@@ -40759,18 +39566,18 @@ var createAddEntryTool = (scope = { collectionKeys: [], connectAll: true }) => t
 );
 
 // src/tool_lattice/collection/update_entry.ts
-import z68 from "zod";
-import { tool as tool62 } from "langchain";
-var schema4 = z68.object({
-  collection: z68.string().describe("Collection name"),
-  entryId: z68.string().describe("Entry ID to update"),
-  content: z68.string().optional().describe("New content"),
-  metadata: z68.record(z68.unknown()).optional().describe("New metadata")
+import z65 from "zod";
+import { tool as tool59 } from "langchain";
+var schema4 = z65.object({
+  collection: z65.string().describe("Collection name"),
+  entryId: z65.string().describe("Entry ID to update"),
+  content: z65.string().optional().describe("New content"),
+  metadata: z65.record(z65.unknown()).optional().describe("New metadata")
 });
 function key3(t, n) {
   return `${t}:${n}`;
 }
-var createUpdateEntryTool = (scope = { collectionKeys: [], connectAll: true }) => tool62(
+var createUpdateEntryTool = (scope = { collectionKeys: [], connectAll: true }) => tool59(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.collection, _exeConfig, scope);
@@ -40791,16 +39598,16 @@ var createUpdateEntryTool = (scope = { collectionKeys: [], connectAll: true }) =
 );
 
 // src/tool_lattice/collection/delete_entry.ts
-import z69 from "zod";
-import { tool as tool63 } from "langchain";
-var schema5 = z69.object({
-  collection: z69.string().describe("Collection name"),
-  entryId: z69.string().describe("Entry ID to delete")
+import z66 from "zod";
+import { tool as tool60 } from "langchain";
+var schema5 = z66.object({
+  collection: z66.string().describe("Collection name"),
+  entryId: z66.string().describe("Entry ID to delete")
 });
 function key4(t, n) {
   return `${t}:${n}`;
 }
-var createDeleteEntryTool = (scope = { collectionKeys: [], connectAll: true }) => tool63(
+var createDeleteEntryTool = (scope = { collectionKeys: [], connectAll: true }) => tool60(
   async (input, _exeConfig) => {
     try {
       const scopeError = validateCollectionScope(input.collection, _exeConfig, scope);
@@ -40820,7 +39627,7 @@ var createDeleteEntryTool = (scope = { collectionKeys: [], connectAll: true }) =
 function createCollectionMiddleware(params) {
   const { collectionKeys, connectAll, compileStableCandidateTools = false } = params;
   if (!compileStableCandidateTools && !connectAll && (!collectionKeys || collectionKeys.length === 0)) {
-    return createMiddleware21({
+    return createMiddleware20({
       name: "collectionMiddleware",
       contextSchema,
       tools: [
@@ -40830,7 +39637,7 @@ function createCollectionMiddleware(params) {
     });
   }
   const toolParams = { collectionKeys, connectAll };
-  return createMiddleware21({
+  return createMiddleware20({
     name: "collectionMiddleware",
     contextSchema,
     tools: [
@@ -40893,24 +39700,24 @@ var collectionPlugin = {
 };
 
 // src/middlewares/askUserClarifyMiddleware.ts
-import { createMiddleware as createMiddleware22, ToolMessage as ToolMessage11 } from "langchain";
+import { createMiddleware as createMiddleware21, ToolMessage as ToolMessage11 } from "langchain";
 import { interrupt as interrupt3 } from "@langchain/langgraph";
 
 // src/tool_lattice/ask_user_to_clarify/index.ts
-import { tool as tool64 } from "langchain";
-import z70 from "zod";
-var questionSchema = z70.object({
-  question: z70.string().describe("The question text to ask the user. MUST include the specific context, options, or details being clarified \u2014 never use a bare generic label. Good: 'Confirm the plan: use Redis cache + PostgreSQL primary, split microservices as needed?' Bad: 'Confirm the plan?'"),
-  options: z70.array(z70.string()).optional().default([]).describe("List of EXACT, selectable values. Maximum 3 options allowed. DO NOT include placeholder values like 'Other' or 'Enter manually'. For free-text with predefined choices, use allowOther=true (works with 'single' and 'multiple'). For pure free-text without choices, use type='input' instead. For file_upload and input, pass an empty array."),
-  type: z70.enum(["single", "multiple", "file_upload", "input"]).describe("The question format. 'single' = pick one from options (default, see tool description for guidance). 'multiple' = pick several from options. 'input' = free-text field (only when options cannot express the answer). 'file_upload' = file picker."),
-  required: z70.boolean().optional().default(false).describe("Whether this question must be answered"),
-  allowOther: z70.boolean().optional().default(true).describe("Set to true to append an 'Other' checkbox with a free-text input field. Works with 'single' and 'multiple' types. Use for open-ended answers or when the options cannot cover all possibilities. Not applicable for 'input' or 'file_upload' types.")
+import { tool as tool61 } from "langchain";
+import z67 from "zod";
+var questionSchema = z67.object({
+  question: z67.string().describe("The question text to ask the user. MUST include the specific context, options, or details being clarified \u2014 never use a bare generic label. Good: 'Confirm the plan: use Redis cache + PostgreSQL primary, split microservices as needed?' Bad: 'Confirm the plan?'"),
+  options: z67.array(z67.string()).optional().default([]).describe("List of EXACT, selectable values. Maximum 3 options allowed. DO NOT include placeholder values like 'Other' or 'Enter manually'. For free-text with predefined choices, use allowOther=true (works with 'single' and 'multiple'). For pure free-text without choices, use type='input' instead. For file_upload and input, pass an empty array."),
+  type: z67.enum(["single", "multiple", "file_upload", "input"]).describe("The question format. 'single' = pick one from options (default, see tool description for guidance). 'multiple' = pick several from options. 'input' = free-text field (only when options cannot express the answer). 'file_upload' = file picker."),
+  required: z67.boolean().optional().default(false).describe("Whether this question must be answered"),
+  allowOther: z67.boolean().optional().default(true).describe("Set to true to append an 'Other' checkbox with a free-text input field. Works with 'single' and 'multiple' types. Use for open-ended answers or when the options cannot cover all possibilities. Not applicable for 'input' or 'file_upload' types.")
 });
-var inputSchema = z70.object({
-  questions: z70.array(questionSchema).min(1, "At least one question is required").describe("A structured sequence of clarification questions. Use these to gather missing parameters or disambiguate user intent before proceeding.")
+var inputSchema = z67.object({
+  questions: z67.array(questionSchema).min(1, "At least one question is required").describe("A structured sequence of clarification questions. Use these to gather missing parameters or disambiguate user intent before proceeding.")
 });
 function createAskUserToClarifyTool() {
-  return tool64(
+  return tool61(
     async (input) => {
       return JSON.stringify(input);
     },
@@ -40935,7 +39742,7 @@ function isProjectRoomRun(request) {
   return isRecord9(runConfig?.projectRoom);
 }
 function createAskUserClarifyMiddleware() {
-  return createMiddleware22({
+  return createMiddleware21({
     name: "AskUserClarifyMiddleware",
     tools: [createAskUserToClarifyTool()],
     wrapToolCall: async (request, handler) => {
@@ -41039,11 +39846,11 @@ var askUserClarifyPlugin = {
 };
 
 // src/middlewares/widgetMiddleware.ts
-import { createMiddleware as createMiddleware23 } from "langchain";
+import { createMiddleware as createMiddleware22 } from "langchain";
 
 // src/tool_lattice/widget/loadGuidelines.ts
-import { tool as tool65 } from "langchain";
-import { z as z71 } from "zod";
+import { tool as tool62 } from "langchain";
+import { z as z68 } from "zod";
 
 // src/middlewares/guidelines/index.ts
 var CORE = `# Imagine \u2014 Visual Creation Suite
@@ -41834,13 +40641,13 @@ function getGuidelines(modules) {
 var AVAILABLE_MODULES = Object.keys(MODULE_SECTIONS);
 
 // src/tool_lattice/widget/loadGuidelines.ts
-var LoadGuidelinesInputSchema = z71.object({
-  modules: z71.array(z71.string()).describe(
+var LoadGuidelinesInputSchema = z68.object({
+  modules: z68.array(z68.string()).describe(
     "Which design modules to load. Choose all that apply. Available modules: [" + AVAILABLE_MODULES.join(",") + "]"
   )
 });
 function createLoadGuidelinesTool() {
-  return tool65(
+  return tool62(
     async (input) => {
       const result = getGuidelines(input.modules);
       return result;
@@ -41854,8 +40661,8 @@ function createLoadGuidelinesTool() {
 }
 
 // src/tool_lattice/widget/showWidget.ts
-import { tool as tool66 } from "langchain";
-import { z as z72 } from "zod";
+import { tool as tool63 } from "langchain";
+import { z as z69 } from "zod";
 function containsForbiddenTags(code) {
   const forbiddenPatterns = [
     /<!DOCTYPE/i,
@@ -41877,20 +40684,20 @@ function validateWidgetCode(code) {
   }
   return { valid: true };
 }
-var ShowWidgetInputSchema = z72.object({
-  i_have_seen_guidelines: z72.boolean().describe(
+var ShowWidgetInputSchema = z69.object({
+  i_have_seen_guidelines: z69.boolean().describe(
     "Must be true. Confirm you have called load_guidelines first."
   ),
-  title: z72.string().describe("Title displayed above the widget"),
-  loading_messages: z72.array(z72.string()).optional().describe(
+  title: z69.string().describe("Title displayed above the widget"),
+  loading_messages: z69.array(z69.string()).optional().describe(
     "1-4 short strings shown while the widget renders"
   ),
-  widget_code: z72.string().describe(
+  widget_code: z69.string().describe(
     "HTML fragment to render. Rules: 1. No DOCTYPE, <html>, <head>, or <body> tags. 2. Order: <style> block first, then HTML content, then <script> last. 3. Use only CSS variables for colors (e.g. var(--color-accent)). 4. No gradients, shadows, or blur effects. For SVG: start directly with <svg> tag."
   )
 });
 function createShowWidgetTool() {
-  return tool66(
+  return tool63(
     async (input) => {
       if (!input.i_have_seen_guidelines) {
         return "Error: You must call load_guidelines before using show_widget. Set i_have_seen_guidelines to true only after loading guidelines.";
@@ -41921,7 +40728,7 @@ function createWidgetMiddleware() {
     createLoadGuidelinesTool(),
     createShowWidgetTool()
   ];
-  return createMiddleware23({
+  return createMiddleware22({
     name: "widgetMiddleware",
     contextSchema,
     tools
@@ -41945,9 +40752,67 @@ 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 { createMiddleware as createMiddleware23, tool as tool64 } from "langchain";
+import { z as z70 } from "zod";
+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 +41142,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,
@@ -42644,65 +41635,75 @@ function buildReviewMarkdown(task) {
     result: task.result
   });
 }
-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)"),
-  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"),
-  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(
-    z73.union([z73.string(), z73.number(), z73.boolean()])
+var manageTaskSchema = z70.object({
+  action: z70.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: z70.string().optional().describe("Task ID (required for get, update, add_activity; required for delete unless ids is given)"),
+  title: z70.string().optional().describe("Task title (required for create)"),
+  description: z70.string().optional().describe("Task description in Markdown"),
+  priority: z70.enum(["low", "medium", "high"]).optional().describe("Priority level"),
+  status: z70.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: z70.string().optional().describe("Due date (ISO 8601 format)"),
+  metadata: z70.record(z70.unknown()).optional().describe("Structured metadata (e.g. projectId, module)"),
+  metadataFilter: z70.record(
+    z70.union([z70.string(), z70.number(), z70.boolean()])
   ).optional().describe("List-only filter. Every key must equal the task metadata value, e.g. {projectId:'p1', retries:2}. Multiple keys AND together."),
-  parentId: z73.string().optional().describe("Parent task ID for grouping subtasks"),
-  sourceId: z73.string().optional().describe("Source session/thread ID"),
-  context: z73.record(z73.unknown()).optional().describe("Additional context data"),
-  ownerType: z73.enum(["user", "agent"]).optional().describe("Owner type. Defaults to 'user' if omitted"),
-  ownerId: z73.string().optional().describe("Owner ID. Auto-filled from current user/agent if omitted"),
-  requireReview: z73.boolean().optional().describe("If true, agent completion pauses as interrupted(review_required) for HITL approval"),
-  dependencies: z73.array(z73.string()).optional().describe("List of task IDs that must be completed before this task can start"),
-  dependencyTaskIds: z73.array(z73.string().trim().min(1)).optional().describe("Exact blocking task IDs required for an external_dependency interruption"),
-  result: z73.string().optional().describe("Result summary. Used with set_status status='completed' or update status='completed'"),
-  failureReason: z73.string().optional().describe("Failure reason. Used with set_status status='failed' or update status='failed'"),
-  files: z73.array(z73.object({
-    uri: z73.string().describe("Uniquely locates the resource: http(s):// URL, /s/:token share, or sandbox path"),
-    name: z73.string().optional().describe("Display name"),
-    addedBy: z73.enum(["user", "agent"]).optional().describe("Who attached the file")
+  parentId: z70.string().optional().describe("Parent task ID for grouping subtasks"),
+  sourceId: z70.string().optional().describe("Source session/thread ID"),
+  context: z70.record(z70.unknown()).optional().describe("Additional context data"),
+  ownerType: z70.enum(["user", "agent"]).optional().describe("Owner type. Defaults to 'user' if omitted"),
+  ownerId: z70.string().optional().describe("Owner ID. Auto-filled from current user/agent if omitted"),
+  requireReview: z70.boolean().optional().describe("If true, agent completion pauses as interrupted(review_required) for HITL approval"),
+  dependencies: z70.array(z70.string()).optional().describe("List of task IDs that must be completed before this task can start"),
+  dependencyTaskIds: z70.array(z70.string().trim().min(1)).optional().describe("Exact blocking task IDs required for an external_dependency interruption"),
+  result: z70.string().optional().describe("Result summary. Used with set_status status='completed' or update status='completed'"),
+  failureReason: z70.string().optional().describe("Failure reason. Used with set_status status='failed' or update status='failed'"),
+  files: z70.array(z70.object({
+    uri: z70.string().describe("Uniquely locates the resource: http(s):// URL, /s/:token share, or sandbox path"),
+    name: z70.string().optional().describe("Display name"),
+    addedBy: z70.enum(["user", "agent"]).optional().describe("Who attached the file")
   })).optional().describe("File references attached to this task"),
-  beliefImpact: z73.array(z73.object({
-    key: z73.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-    after: z73.number().int().min(0).max(100),
-    basis: z73.string().trim().min(1).max(1e3),
-    isNew: z73.boolean().optional().describe("Set true only to add a belief key that is absent from the belief owner's Belief State; omit for keys that already exist")
+  beliefImpact: z70.array(z70.object({
+    key: z70.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+    after: z70.number().int().min(0).max(100),
+    basis: z70.string().trim().min(1).max(1e3),
+    isNew: z70.boolean().optional().describe("Set true only to add a belief key that is absent from the belief owner's Belief State; omit for keys that already exist")
   })).optional().describe("Structured belief reports required when an agent-owned task completes; existing keys update the belief owner's table, and a brand-new key must be declared with isNew: true"),
-  content: z73.string().optional().describe("Markdown content required for add_activity"),
-  summary: z73.string().optional().describe("Brief summary of the operation"),
-  executionResultId: z73.string().refine(isExecutionResultEventKey3, {
+  content: z70.string().optional().describe("Markdown content required for add_activity"),
+  summary: z70.string().optional().describe("Brief summary of the operation"),
+  executionResultId: z70.string().refine(isExecutionResultEventKey3, {
     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: z70.array(z70.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({
-      code: z73.ZodIssueCode.custom,
+      code: z70.ZodIssueCode.custom,
       path: ["executionResultId"],
       message: "executionResultId is valid only for update, set_status, or add_activity"
     });
   }
   if (input.metadataFilter && input.action !== "list") {
     context.addIssue({
-      code: z73.ZodIssueCode.custom,
+      code: z70.ZodIssueCode.custom,
       path: ["metadataFilter"],
       message: "metadataFilter is valid only for list"
     });
   }
+  if (input.ids && input.action !== "delete") {
+    context.addIssue({
+      code: z70.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")
+var startTaskSchema = z70.object({
+  taskId: z70.string().trim().min(1).describe("ID of the persisted TaskItem to start"),
+  agentId: z70.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 +41840,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 +42038,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 +42083,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 +42677,31 @@ function createTaskMiddleware(options = {}) {
           });
           return lifecycleMutationResponse(interrupted);
         }
-        if (lifecycle && input.status === "in_progress" && existing.status === "interrupted") {
-          await validateExecutionResult();
-          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();
+        if (lifecycle && input.status === "in_progress") {
           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 +42770,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 +42882,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 +43039,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,15 +43070,75 @@ 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 } : {}
     }));
   };
-  return createMiddleware24({
+  return createMiddleware23({
     name: "TaskMiddleware",
     contextSchema,
+    // Persisted between invocations (ADRs: the run↔task binding survives turns).
+    stateSchema: z70.object({
+      taskId: z70.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 +43147,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,13 +43181,17 @@ ${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: [
-      tool67(
+      tool64(
         handleManageTask,
         {
           name: "manage_task",
@@ -44132,15 +43212,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 +43230,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, {
+      tool64(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
       })
     ]
@@ -44301,7 +43382,7 @@ canonical Belief State:
 
 // src/middlewares/documentLearningMiddleware.ts
 import { AgentType as AgentType9 } from "@axiom-lattice/protocols";
-import { createMiddleware as createMiddleware25 } from "langchain";
+import { createMiddleware as createMiddleware24 } from "langchain";
 
 // src/middlewares/documentLearningSkills.ts
 var LEARN_CAPABILITY_SKILL = `---
@@ -44540,7 +43621,7 @@ patterns discovered, recommendations. Include validation coverage: user-sample N
 `;
 
 // src/middlewares/documentLearningMiddleware.ts
-var createDocumentLearningMiddleware = () => createMiddleware25({
+var createDocumentLearningMiddleware = () => createMiddleware24({
   name: "DocumentLearningMiddleware",
   contextSchema,
   tools: []
@@ -44658,12 +43739,12 @@ var documentLearningPlugin = {
 };
 
 // src/middlewares/documentParserMiddleware.ts
-import { createMiddleware as createMiddleware26 } from "langchain";
+import { createMiddleware as createMiddleware25 } from "langchain";
 
 // src/tool_lattice/document_parser/index.ts
 import * as path7 from "path";
-import z74 from "zod";
-import { tool as tool68 } from "langchain";
+import z71 from "zod";
+import { tool as tool65 } from "langchain";
 var PARSE_DOCUMENT_DESCRIPTION = `Parse a document file (docx, pdf) into structured Markdown using a remote document parsing service.
 This tool handles the full pipeline internally: file upload \u2192 document parsing \u2192 polling until complete \u2192 download result \u2192 save to filesystem.
 
@@ -44786,7 +43867,7 @@ function createParseDocumentTool({
   baseUrl = "",
   apiKey = ""
 }) {
-  return tool68(
+  return tool65(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config?.configurable?.runConfig ?? { assistant_id: "", thread_id: "" };
@@ -44857,17 +43938,17 @@ function createParseDocumentTool({
     {
       name: "parse_document",
       description: PARSE_DOCUMENT_DESCRIPTION,
-      schema: z74.object({
-        file_path: z74.string().describe(
+      schema: z71.object({
+        file_path: z71.string().describe(
           'Absolute path to the document file. Must point to an existing .docx or .pdf file. Example: "/project/reports/contract.docx". The file must be accessible from the current workspace.'
         ),
-        engine: z74.string().describe(
+        engine: z71.string().describe(
           'Parsing engine to use. Available options: "textin" (recommended, works with local files, supports docx/pdf), "datalab" (alternative engine for docx/pdf), "mineru" (requires public URL, use only if textin/datalab fail), "paddleocr_remote" (PaddleOCR, good for scanned documents), "qwen_ocr" (OCR-focused, best for image-heavy PDFs).'
         ),
-        output_path: z74.string().optional().describe(
+        output_path: z71.string().optional().describe(
           'Path to save the parsed result. If not specified, the input extension is replaced with .md. Example: "/project/report.docx" becomes "/project/report.md". Parent directories are created automatically.'
         ),
-        output_format: z74.enum(["markdown", "json"]).optional().default("markdown").describe(
+        output_format: z71.enum(["markdown", "json"]).optional().default("markdown").describe(
           'Output format. "markdown": structured Markdown with tables, headers, formatting preserved (recommended). "json": raw JSON output from the parsing engine (for programmatic use).'
         )
       })
@@ -45285,7 +44366,7 @@ def main() -> None:
 if __name__ == "__main__":
     main()
 `;
-var resources2 = {
+var resources = {
   "references/api_reference.md": { mimeType: "text/markdown", content: `# API reference
 
 The supported command-line form is 'markitdown input -o output.md'. The Python API uses 'MarkItDown().convert(path)' upstream, but this runtime prefers the installed CLI and does not provide direct Python SDK LLM calls. Use local conversion for local files and keep output as Markdown.` },
@@ -45314,7 +44395,7 @@ Single file: 'markitdown input -o output.md'. Ordinary directory: 'scripts/batch
 var DOCUMENT_PARSER_MARKITDOWN_SKILL = {
   version: "1.1.0",
   content: MARKITDOWN_SKILL_CONTENT,
-  resources: resources2
+  resources
 };
 
 // src/middlewares/documentParserMiddleware.ts
@@ -45323,7 +44404,7 @@ function createDocumentParserMiddleware(config) {
   const baseUrl = config.baseUrl || "";
   const apiKey = config.apiKey || "";
   const connections = Array.isArray(config.connections) ? config.connections.filter((key5) => typeof key5 === "string") : [];
-  return createMiddleware26({
+  return createMiddleware25({
     name: "DocumentParser",
     contextSchema,
     tools: [createParseDocumentTool({ connectAll, connections, baseUrl, apiKey })]
@@ -45444,8 +44525,8 @@ import {
   snapshotExactArray as snapshotExactArray3,
   snapshotExactRecord as snapshotExactRecord8
 } from "@axiom-lattice/protocols";
-import { createMiddleware as createMiddleware27, tool as tool69 } from "langchain";
-import { z as z75 } from "zod";
+import { createMiddleware as createMiddleware26, tool as tool66 } from "langchain";
+import { z as z72 } from "zod";
 var PROJECT_ROOM_CONTEXT_REQUIRED = "PROJECT_ROOM_CONTEXT_REQUIRED";
 var PROJECT_ROOM_POST_FAILED = "PROJECT_ROOM_POST_FAILED";
 var PROJECT_ROOM_ROSTER_FAILED = "PROJECT_ROOM_ROSTER_FAILED";
@@ -45465,10 +44546,10 @@ var ROSTER_FAILED = JSON.stringify({
   error: PROJECT_ROOM_ROSTER_FAILED,
   message: PROJECT_ROOM_ROSTER_FAILED_MESSAGE
 });
-var postSchema = z75.object({
-  text: z75.string().trim().min(1).max(2e4)
+var postSchema = z72.object({
+  text: z72.string().trim().min(1).max(2e4)
 }).strict();
-var listSchema = z75.object({}).strict();
+var listSchema = z72.object({}).strict();
 function ownDataValue2(record, key5) {
   if (typeof record !== "object" || record === null || Array.isArray(record)) return void 0;
   try {
@@ -45535,10 +44616,10 @@ async function hasActiveCurrentMembership(scope) {
   return true;
 }
 function createProjectRoomMiddleware() {
-  return createMiddleware27({
+  return createMiddleware26({
     name: "ProjectRoomMiddleware",
     tools: [
-      tool69(async (input, config) => {
+      tool66(async (input, config) => {
         const { text } = input;
         const scope = readTrustedRoomScope(config);
         if (!scope) return CONTEXT_REQUIRED;
@@ -45569,7 +44650,7 @@ function createProjectRoomMiddleware() {
         description: "Post a text reply to the current trusted Project Room message",
         schema: postSchema
       }),
-      tool69(async (_input, config) => {
+      tool66(async (_input, config) => {
         const scope = readTrustedRoomScope(config);
         if (!scope) return CONTEXT_REQUIRED;
         try {
@@ -45611,8 +44692,8 @@ var projectRoomPlugin = {
 };
 
 // src/middlewares/sandboxPluginsMiddleware.ts
-import { createMiddleware as createMiddleware28, tool as tool70 } from "langchain";
-import { z as z76 } from "zod";
+import { createMiddleware as createMiddleware27, tool as tool67 } from "langchain";
+import { z as z73 } from "zod";
 import { AgentType as AgentType11 } from "@axiom-lattice/protocols";
 
 // src/middlewares/sandboxPluginsSkills.ts
@@ -46334,16 +45415,16 @@ function tenantIdFrom(exeConfig) {
   const c = exeConfig;
   return c?.configurable?.runConfig?.tenantId ?? "default";
 }
-var managePluginSchema = z76.object({
-  action: z76.enum(["list", "get", "validate", "create", "update", "delete", "reload", "test"]),
-  type: z76.string().optional(),
-  manifest: z76.record(z76.unknown()).optional(),
-  handlers: z76.record(z76.string()).optional(),
-  target: z76.object({
-    kind: z76.enum(["tool", "connection-test", "connection-discover"]),
-    name: z76.string().optional(),
-    input: z76.unknown().optional(),
-    connectionKey: z76.string().optional()
+var managePluginSchema = z73.object({
+  action: z73.enum(["list", "get", "validate", "create", "update", "delete", "reload", "test"]),
+  type: z73.string().optional(),
+  manifest: z73.record(z73.unknown()).optional(),
+  handlers: z73.record(z73.string()).optional(),
+  target: z73.object({
+    kind: z73.enum(["tool", "connection-test", "connection-discover"]),
+    name: z73.string().optional(),
+    input: z73.unknown().optional(),
+    connectionKey: z73.string().optional()
   }).optional()
 });
 var sandboxPluginsPlugin = {
@@ -46417,10 +45498,10 @@ var sandboxPluginsPlugin = {
       ]
     }
   },
-  middleware: () => createMiddleware28({
+  middleware: () => createMiddleware27({
     name: "SandboxPluginsMiddleware",
     tools: [
-      tool70(
+      tool67(
         async (input, exeConfig) => {
           const tenantId2 = tenantIdFrom(exeConfig);
           const catalog2 = getSandboxPluginCatalog();
@@ -46561,7 +45642,6 @@ var BUILTIN_PLUGINS = [
   sqlPlugin,
   skillPlugin,
   metricsPlugin,
-  semanticMetricsPlugin,
   askUserClarifyPlugin,
   widgetPlugin,
   clawPlugin,
@@ -47129,6 +46209,7 @@ export {
   TaskLifecycleNotifier,
   TaskLifecycleService,
   TaskRunBridgeStoresRequiredError,
+  TaskRunRegistry,
   TaskStatus,
   TeamAgentGraphBuilder,
   TenantPluginCatalog,
@@ -47140,7 +46221,6 @@ export {
   VectorStoreProviderManager,
   VolumeFilesystem,
   abortWorkflowRun,
-  agentHasManagedTaskCapability,
   agentInstanceManager,
   agentLatticeManager,
   appendReconciliationWarning,
@@ -47193,7 +46273,6 @@ export {
   createSandboxProvider,
   createSandboxResolver,
   createSchedulerMiddleware,
-  createSemanticMetricsMiddleware,
   createSharePayload,
   createTaskExecutionService,
   createTaskLifecycleService,
@@ -47315,6 +46394,9 @@ export {
   projectTaskAdmissionNotifier,
   queueLatticeManager,
   readLoopBreakerConfig,
+  reconcileAllTenantTaskRuns,
+  reconcileStaleTaskRuns,
+  reconcileTenantTaskRuns,
   registerAgentLattice,
   registerAgentLatticeWithTenant,
   registerAgentLattices,
@@ -47349,7 +46431,6 @@ export {
   sandboxLatticeManager,
   sanitizeToolCallId,
   scheduleLatticeManager,
-  semanticMetricsPlugin,
   serializePluginMeta,
   serializeTaskMutationSuccess,
   serializeTaskNormalizationFallback,
@@ -47363,6 +46444,7 @@ export {
   storeLatticeManager,
   sttModelLatticeManager,
   taskLifecycleNotifier,
+  taskRunRegistry,
   toJsonSchema,
   toSafeStateExpr,
   toolLatticeManager,