@axiom-lattice/core 2.1.80 → 2.1.82

package/dist/index.mjs

@@ -8,20 +8,21 @@ import {
 import {
   buildInput,
   buildStateAnnotation,
+  compileInternal,
   compileWorkflow,
   createAgentNode,
-  createHumanFeedbackNode,
   createMapNode,
   createNodeHandler,
-  createTerminalNode,
-  expand,
   extractOutput,
   invokeWithRetry,
   parallelLimit,
+  parseYaml,
   renderTemplate,
   resolvePath,
+  toJsonSchema,
+  toSafeStateExpr,
   validateDSL
-} from "./chunk-FN4TRQK4.mjs";
+} from "./chunk-SGRFQY3E.mjs";
 
 // src/model_lattice/ModelLattice.ts
 import { ChatDeepSeek } from "@langchain/deepseek";
@@ -146,9 +147,11 @@ var ModelLattice = class extends BaseChatModel {
         maxRetries: config.maxRetries || 2,
         apiKey: config.apiKey || process.env[config.apiKeyEnvName || "SILICONCLOUD_API_KEY"],
         configuration: {
-          baseURL: "https://api.siliconflow.cn/v1"
+          baseURL: config.baseURL || "https://api.siliconflow.cn/v1"
         },
-        streaming: config.streaming
+        streaming: config.streaming,
+        modelKwargs: config.modelKwargs,
+        ...config.extra || {}
       });
     } else if (config.provider === "volcengine") {
       return new ChatOpenAI({
@@ -430,11 +433,11 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key Lattice键名
    * @param tool 已有的StructuredTool实例
    */
-  registerExistingTool(key, tool51) {
+  registerExistingTool(key, tool52) {
     const config = {
-      name: tool51.name,
-      description: tool51.description,
-      schema: tool51.schema,
+      name: tool52.name,
+      description: tool52.description,
+      schema: tool52.schema,
       // StructuredTool的schema已经是Zod兼容的
       needUserApprove: false
       // MCP工具默认不需要用户批准
@@ -442,7 +445,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
     const toolLattice = {
       key,
       config,
-      client: tool51
+      client: tool52
     };
     this.register(key, toolLattice);
   }
@@ -468,7 +471,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
 };
 var toolLatticeManager = ToolLatticeManager.getInstance();
 var registerToolLattice = (key, config, executor) => toolLatticeManager.registerLattice(key, config, executor);
-var registerExistingTool = (key, tool51) => toolLatticeManager.registerExistingTool(key, tool51);
+var registerExistingTool = (key, tool52) => toolLatticeManager.registerExistingTool(key, tool52);
 var getToolLattice = (key) => toolLatticeManager.getToolLattice(key);
 var getToolDefinition = (key) => toolLatticeManager.getToolDefinition(key);
 var getToolClient = (key) => toolLatticeManager.getToolClient(key);
@@ -735,6 +738,7 @@ var InMemoryAssistantStore = class {
       name: data.name,
       description: data.description,
       graphDefinition: data.graphDefinition,
+      ownerUserId: data.ownerUserId,
       createdAt: now,
       updatedAt: now
     };
@@ -781,6 +785,17 @@ var InMemoryAssistantStore = class {
     }
     return tenantAssistants.has(id);
   }
+  /**
+   * Get assistant by owner user ID
+   */
+  async getByOwner(tenantId, userId) {
+    const tenantAssistants = this.assistants.get(tenantId);
+    if (!tenantAssistants) return null;
+    for (const assistant of tenantAssistants.values()) {
+      if (assistant.ownerUserId === userId) return assistant;
+    }
+    return null;
+  }
   /**
    * Clear all assistants for a tenant (useful for testing)
    */
@@ -2013,7 +2028,7 @@ var InMemoryThreadMessageQueueStore = class {
     return this.messages.get(threadId);
   }
   async addMessage(params) {
-    const { threadId, tenantId, assistantId, content, type = "human", priority = 0, command, custom_run_config, id } = params;
+    const { threadId, tenantId, assistantId, workspaceId, projectId, content, type = "human", priority = 0, command, custom_run_config, id } = params;
     const threadMessages = this.getMessagesForThread(threadId);
     const message = {
       id: id || this.generateId(),
@@ -2024,6 +2039,8 @@ var InMemoryThreadMessageQueueStore = class {
       status: "pending",
       tenantId,
       assistantId,
+      workspaceId,
+      projectId,
       priority,
       command,
       custom_run_config
@@ -2032,7 +2049,7 @@ var InMemoryThreadMessageQueueStore = class {
     return message;
   }
   async addMessageAtHead(params) {
-    const { threadId, tenantId, assistantId, content, type = "system", id, command, custom_run_config } = params;
+    const { threadId, tenantId, assistantId, workspaceId, projectId, content, type = "system", id, command, custom_run_config } = params;
     const threadMessages = this.getMessagesForThread(threadId);
     let resolvedTenantId = tenantId || "default";
     let resolvedAssistantId = assistantId || "";
@@ -2050,6 +2067,8 @@ var InMemoryThreadMessageQueueStore = class {
       status: "pending",
       tenantId: resolvedTenantId,
       assistantId: resolvedAssistantId,
+      workspaceId,
+      projectId,
       priority: 100,
       // High priority for head messages (STEER/Command)
       command,
@@ -2081,7 +2100,9 @@ var InMemoryThreadMessageQueueStore = class {
         result.push({
           tenantId: firstMessage.tenantId || "default",
           assistantId: firstMessage.assistantId || "",
-          threadId
+          threadId,
+          workspaceId: firstMessage.workspaceId || void 0,
+          projectId: firstMessage.projectId || void 0
         });
       }
     }
@@ -2204,6 +2225,7 @@ var InMemoryWorkflowTrackingStore = class {
       tenantId: request.tenantId,
       stepType: request.stepType,
       stepName: request.stepName,
+      threadId: request.threadId,
       edgeFrom: request.edgeFrom,
       edgeTo: request.edgeTo,
       edgePurpose: request.edgePurpose,
@@ -2223,7 +2245,12 @@ var InMemoryWorkflowTrackingStore = class {
     const existing = runSteps.find(
       (s) => s.stepType === request.stepType && s.stepName === request.stepName
     );
-    if (existing) return existing;
+    if (existing) {
+      if (!existing.threadId && request.threadId) {
+        existing.threadId = request.threadId;
+      }
+      return existing;
+    }
     return this.createRunStep(request);
   }
   async updateRunStep(runId, stepId, updates) {
@@ -2282,6 +2309,11 @@ var InMemoryChannelInstallationStore = class {
       (inst) => inst.tenantId === tenantId && (!channel || inst.channel === channel)
     );
   }
+  async getAllInstallations(channel) {
+    return Array.from(this.installations.values()).filter(
+      (inst) => !channel || inst.channel === channel
+    );
+  }
   /**
    * Creates a new channel installation for a tenant.
    *
@@ -2558,6 +2590,107 @@ var InMemoryA2AApiKeyStore = class {
   }
 };
 
+// src/store_lattice/InMemoryTaskStore.ts
+import { v4 as uuidv4 } from "uuid";
+var InMemoryTaskStore = class {
+  constructor() {
+    this.tasks = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Create a new task
+   */
+  async create(params) {
+    if (!this.tasks.has(params.tenantId)) {
+      this.tasks.set(params.tenantId, /* @__PURE__ */ new Map());
+    }
+    const now = /* @__PURE__ */ new Date();
+    const task = {
+      id: uuidv4(),
+      tenantId: params.tenantId,
+      ownerType: params.ownerType,
+      ownerId: params.ownerId,
+      title: params.title,
+      description: params.description,
+      status: params.status || "pending",
+      priority: params.priority || "medium",
+      dueDate: params.dueDate,
+      metadata: params.metadata,
+      parentId: params.parentId,
+      sourceId: params.sourceId,
+      context: params.context,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.tasks.get(params.tenantId).set(task.id, task);
+    return task;
+  }
+  /**
+   * Get task by ID
+   */
+  async getById(tenantId, id) {
+    const tenantTasks = this.tasks.get(tenantId);
+    if (!tenantTasks) return null;
+    return tenantTasks.get(id) || null;
+  }
+  /**
+   * List tasks matching filter criteria
+   */
+  async list(filter2) {
+    const tenantTasks = this.tasks.get(filter2.tenantId);
+    if (!tenantTasks) return [];
+    let results = Array.from(tenantTasks.values());
+    if (filter2.ownerType) results = results.filter((t) => t.ownerType === filter2.ownerType);
+    if (filter2.ownerId) results = results.filter((t) => t.ownerId === filter2.ownerId);
+    if (filter2.status) results = results.filter((t) => t.status === filter2.status);
+    if (filter2.priority) results = results.filter((t) => t.priority === filter2.priority);
+    if (filter2.parentId) results = results.filter((t) => t.parentId === filter2.parentId);
+    if (filter2.sourceId) results = results.filter((t) => t.sourceId === filter2.sourceId);
+    if (filter2.metadata) {
+      for (const [key, value] of Object.entries(filter2.metadata)) {
+        results = results.filter((t) => t.metadata?.[key] === value);
+      }
+    }
+    results.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const offset = filter2.offset || 0;
+    const limit = filter2.limit || 100;
+    return results.slice(offset, offset + limit);
+  }
+  /**
+   * Update an existing task
+   */
+  async update(tenantId, id, updates) {
+    const tenantTasks = this.tasks.get(tenantId);
+    if (!tenantTasks) return null;
+    const existing = tenantTasks.get(id);
+    if (!existing) return null;
+    const updated = {
+      ...existing,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    tenantTasks.set(id, updated);
+    return updated;
+  }
+  /**
+   * Delete a task by ID
+   */
+  async delete(tenantId, id) {
+    const tenantTasks = this.tasks.get(tenantId);
+    if (!tenantTasks) return false;
+    return tenantTasks.delete(id);
+  }
+  /**
+   * Clear all tasks for a tenant (useful for testing)
+   */
+  clear(tenantId) {
+    if (tenantId) {
+      this.tasks.delete(tenantId);
+    } else {
+      this.tasks.clear();
+    }
+  }
+};
+
 // src/store_lattice/StoreLatticeManager.ts
 var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager {
   /**
@@ -2738,6 +2871,12 @@ storeLatticeManager.registerLattice(
   "a2aApiKey",
   defaultA2AApiKeyStore
 );
+var defaultTaskStore = new InMemoryTaskStore();
+storeLatticeManager.registerLattice(
+  "default",
+  "task",
+  defaultTaskStore
+);
 
 // src/tool_lattice/manage_binding/index.ts
 function getInstallationStore() {
@@ -2749,7 +2888,7 @@ var manageBindingSchema = z3.object({
   channelInstallationId: z3.string().optional().describe("Channel installation ID (auto-detected if omitted and only one exists for this channel)"),
   senderId: z3.string().optional().describe("Sender identifier (email address, Lark openId, Slack userId)"),
   agentId: z3.string().optional().describe("Target agent ID to route messages to"),
-  threadMode: z3.enum(["fixed", "per_conversation"]).optional().default("per_conversation").describe("Thread mode: per_conversation (recommended) or fixed"),
+  threadMode: z3.enum(["fixed", "per_conversation"]).optional().default("per_conversation").describe("Thread mode (ignored when channel adapter has its own thread strategy, e.g. Lark)"),
   senderDisplayName: z3.string().optional().describe("Human-readable name for the sender")
 });
 registerToolLattice(
@@ -2758,9 +2897,13 @@ registerToolLattice(
     name: "manage_binding",
     description: `Manage sender-to-agent bindings for external channels (email, Lark, Slack).
 
+Bindings are OPTIONAL \u2014 if no binding exists for a sender, messages route to the installation's fallbackAgentId. Only create a binding when a specific sender needs a different agent.
+
+Thread isolation is handled automatically by the channel adapter (e.g. Lark isolates by sender+date). threadMode is only used when the channel adapter does not have its own strategy.
+
 - list_installations: List available channel installations. Filter by channel type (optional). Use this first to discover available channelInstallationIds.
-- create: Bind a sender to an agent. Required: channel, senderId, agentId. Optional: threadMode (default: per_conversation). channelInstallationId is optional \u2014 auto-detected if only one installation exists for this channel.
-- update: Update an existing binding. Required: channel, senderId. Optional: agentId, threadMode (default: per_conversation), senderDisplayName.
+- create: Bind a sender to an agent. Required: channel, senderId, agentId. Optional: threadMode. channelInstallationId auto-detected if only one exists.
+- update: Update an existing binding. Required: channel, senderId. Optional: agentId, threadMode, senderDisplayName.
 - delete: Remove a binding. Required: channel, senderId.
 - list: List all bindings. Optional: channel, agentId, channelInstallationId.
 
@@ -2768,7 +2911,7 @@ A sender can only be bound to ONE agent per channel+installation combination.`,
     schema: manageBindingSchema
   },
   async (input, config) => {
-    const registry2 = getBindingRegistry();
+    const registry3 = getBindingRegistry();
     const runConfig = config?.configurable?.runConfig || {};
     const tenantId = runConfig.tenantId || "default";
     switch (input.action) {
@@ -2791,7 +2934,7 @@ A sender can only be bound to ONE agent per channel+installation combination.`,
             error: `No channelInstallationId provided and unable to auto-detect. Use action=list_installations to find available installations for channel "${input.channel}".`
           });
         }
-        const binding = await registry2.create({
+        const binding = await registry3.create({
           channel: input.channel,
           channelInstallationId: installId,
           tenantId,
@@ -2813,7 +2956,7 @@ A sender can only be bound to ONE agent per channel+installation combination.`,
             error: `No channelInstallationId provided and unable to auto-detect. Use action=list_installations first.`
           });
         }
-        const existing = await registry2.resolve({
+        const existing = await registry3.resolve({
           channel: input.channel,
           senderId: input.senderId,
           channelInstallationId: installId,
@@ -2822,7 +2965,7 @@ A sender can only be bound to ONE agent per channel+installation combination.`,
         if (!existing) {
           return JSON.stringify({ success: false, error: "Binding not found" });
         }
-        const updated = await registry2.update(existing.id, {
+        const updated = await registry3.update(existing.id, {
           agentId: input.agentId,
           threadMode: input.threadMode,
           senderDisplayName: input.senderDisplayName
@@ -2840,7 +2983,7 @@ A sender can only be bound to ONE agent per channel+installation combination.`,
             error: `No channelInstallationId provided and unable to auto-detect.`
           });
         }
-        const existing = await registry2.resolve({
+        const existing = await registry3.resolve({
           channel: input.channel,
           senderId: input.senderId,
           channelInstallationId: installId,
@@ -2849,11 +2992,11 @@ A sender can only be bound to ONE agent per channel+installation combination.`,
         if (!existing) {
           return JSON.stringify({ success: false, error: "Binding not found" });
         }
-        await registry2.delete(existing.id);
+        await registry3.delete(existing.id);
         return JSON.stringify({ success: true, message: "Binding deleted" });
       }
       case "list": {
-        const bindings = await registry2.list({
+        const bindings = await registry3.list({
           channel: input.channel,
           agentId: input.agentId,
           tenantId,
@@ -3751,7 +3894,8 @@ function getTenantIdFromConfig2(exeConfig, getTenantId2) {
   const runConfig = exeConfig?.configurable?.runConfig || {};
   return runConfig.tenantId || (getTenantId2 ? getTenantId2() : "default");
 }
-function filterServerKeysByTenant(serverKeys, tenantId, manager = metricsServerManager) {
+async function filterServerKeysByTenant(serverKeys, tenantId, manager = metricsServerManager) {
+  await manager.ensureLoaded();
   return serverKeys.filter((key) => {
     return manager.hasServer(tenantId, key);
   });
@@ -4529,6 +4673,14 @@ var MetricsServerManager = class _MetricsServerManager {
     }
     return config;
   }
+  /**
+   * Ensure server configs are loaded from the store.
+   * Public wrapper around the internal lazy-loading mechanism.
+   * Safe to call multiple times — loading happens at most once.
+   */
+  async ensureLoaded() {
+    await this._ensureLoaded();
+  }
   /**
    * Check if a metrics server is registered for a tenant
    * @param tenantId - Tenant identifier
@@ -4669,7 +4821,7 @@ ${serverKeys.map(
         if (connectAll) {
           effectiveServerKeys = (await metricsServerManager.getServerKeys(tenantId)).map((s) => s.key);
         }
-        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
+        const filteredServerKeys = await filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         if (metricsDataSource) {
@@ -4788,7 +4940,7 @@ ${serverKeys.map(
         if (connectAll) {
           effectiveServerKeys = (await metricsServerManager.getServerKeys(tenantId)).map((s) => s.key);
         }
-        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
+        const filteredServerKeys = await filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         const serverKey = metricsDataSource?.serverKey || inputServerKey;
@@ -4946,7 +5098,7 @@ ${serverKeys.map(
         if (connectAll) {
           effectiveServerKeys = (await metricsServerManager.getServerKeys(tenantId)).map((s) => s.key);
         }
-        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
+        const filteredServerKeys = await filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         const serverKey = metricsDataSource?.serverKey || inputServerKey;
@@ -5182,7 +5334,7 @@ ${serverKeys.map(
         if (connectAll) {
           effectiveServerKeys = (await metricsServerManager.getServerKeys(tenantId)).map((s) => s.key);
         }
-        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
+        const filteredServerKeys = await filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         const serverKey = metricsDataSource?.serverKey || inputServerKey;
@@ -5263,7 +5415,7 @@ ${serverKeys.map(
         if (connectAll) {
           effectiveServerKeys = (await metricsServerManager.getServerKeys(tenantId)).map((s) => s.key);
         }
-        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
+        const filteredServerKeys = await filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         const serverKey = metricsDataSource?.serverKey || inputServerKey;
@@ -5368,7 +5520,7 @@ ${serverKeys.map(
         if (connectAll) {
           effectiveServerKeys = (await metricsServerManager.getServerKeys(tenantId)).map((s) => s.key);
         }
-        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
+        const filteredServerKeys = await filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         const serverKey = metricsDataSource?.serverKey || inputServerKey;
@@ -5508,7 +5660,7 @@ ${serverKeys.map(
         if (connectAll) {
           effectiveServerKeys = (await metricsServerManager.getServerKeys(tenantId)).map((s) => s.key);
         }
-        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
+        const filteredServerKeys = await filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         const serverKey = metricsDataSource?.serverKey || inputServerKey;
@@ -5566,7 +5718,9 @@ var VolumeFilesystem = class {
     this.mountPrefix = mountPrefix;
   }
   async lsInfo(path3) {
+    console.log(`[VolumeFilesystem.lsInfo] path=${path3} mountPrefix=${this.mountPrefix}`);
     const entries = await this.client.list(path3);
+    console.log(`[VolumeFilesystem.lsInfo] got ${entries.length} entries`);
     const prefix = this.mountPrefix.endsWith("/") ? this.mountPrefix : this.mountPrefix + "/";
     return entries.map((entry) => ({
       path: entry.path.startsWith("/") ? entry.path : prefix + entry.path,
@@ -5758,30 +5912,45 @@ var SandboxLatticeManager = class _SandboxLatticeManager extends BaseLatticeMana
   async getVolumeBackendForPath(config, filePath) {
     const provider = this._requireProvider();
     if (!provider.createVolumeFsClient) {
+      console.log(`[getVolumeBackendForPath] provider has no createVolumeFsClient, returning null`);
       return null;
     }
     const tenantId = config.tenantId ?? "default";
     const mapping = this._resolveVolumeForPath(config, tenantId, filePath);
-    if (!mapping) return null;
+    if (!mapping) {
+      console.log(`[getVolumeBackendForPath] no volume mapping for path=${filePath}`);
+      return null;
+    }
+    console.log(`[getVolumeBackendForPath] path=${filePath} volume=${mapping.volumeName} prefix=${mapping.pathPrefix}`);
     const client = provider.createVolumeFsClient(mapping.volumeName, mapping.pathPrefix);
     return new VolumeFilesystem(stripPrefixClient(client, mapping.pathPrefix), mapping.pathPrefix);
   }
   _resolveVolumeForPath(config, tenantId, filePath) {
     const normalized = normalizeExternalSandboxPath(filePath);
+    console.log(`[_resolveVolumeForPath] filePath=${filePath} normalized=${normalized} assistant_id=${config.assistant_id} projectId=${config.projectId}`);
     if (normalized === "/root/.agents" || normalized.startsWith("/root/.agents/")) {
+      console.log(`[_resolveVolumeForPath] \u2192 skills volume`);
       return {
         volumeName: buildNamedVolumeName("s", "skills", tenantId),
         pathPrefix: "/root/.agents"
       };
     }
     if (normalized === "/agent" || normalized.startsWith("/agent/")) {
-      if (!config.assistant_id) return null;
+      if (!config.assistant_id) {
+        console.log(`[_resolveVolumeForPath] agent volume but no assistant_id, returning null`);
+        return null;
+      }
+      console.log(`[_resolveVolumeForPath] \u2192 agent volume`);
       return {
         volumeName: buildNamedVolumeName("a", "agent", tenantId, config.assistant_id),
         pathPrefix: "/agent"
       };
     }
-    if (!config.projectId) return null;
+    if (!config.projectId) {
+      console.log(`[_resolveVolumeForPath] project volume but no projectId, returning null`);
+      return null;
+    }
+    console.log(`[_resolveVolumeForPath] \u2192 project volume`);
     return {
       volumeName: buildNamedVolumeName("p", "project", tenantId, config.workspaceId, config.projectId),
       pathPrefix: "/project"
@@ -7318,353 +7487,233 @@ metadata:
 Then iterate based on what the user says.
 `,
   "create-workflow": `---
- name: create-workflow
- description: Design and build multi-step AI workflows using the concise Workflow DSL. Use whenever users want to orchestrate agents in a pipeline, build process automation with branching/parallel logic, design approval flows with human-in-the-loop, or process data in stages.
- license: MIT
- metadata:
-   category: meta
-   version: "3.0"
- ---
-
- # Workflow Designer
-
- This skill guides you through designing and creating workflow agents. A workflow is a LangGraph state machine compiled from a concise JSON DSL \u2014 steps define what happens, order defines the flow, and the engine handles the rest.
-
- Every step runs on the workflow's built-in general-purpose agent \u2014 no external agent registration needed.
-
- ## Core Principle: id is everything
+name: create-workflow
+description: Design and build multi-step AI workflows using the YAML linear DSL. Use whenever users want to orchestrate agents in a pipeline with routing, parallelism, human-in-the-loop, or batch processing.
+license: MIT
+metadata:
+  category: meta
+  version: "5.0"
+---
 
- A step's \`id\` serves triple duty:
- 1. **Node identifier** in the graph
- 2. **State key** \u2014 output is stored at \`state.<id>\`
- 3. **Template reference** \u2014 downstream steps use \`{{id}}\` to read it
+# YAML Workflow Designer
 
- If you omit \`id\`, a unique identifier is auto-generated (but you won't be able to reference the output).
+Use the linear YAML DSL \u2014 steps execute top-to-bottom. Use \`parallel:\` for concurrency. No dependency graph thinking required.
 
- ## Step Types
+## Core Model: Linear + Parallel
 
- ### agent \u2014 a step for the workflow's built-in agent
+- **Linear** \u2014 steps execute in written order. No \`needs\`, no dependency declarations.
+- **parallel** \u2014 a block where all children run concurrently. Block completes when all children finish.
+- **if** \u2014 JS expression. Step runs only when truthy. Omit to always run.
+- **prompt** \u2014 agent instruction with **{{label}}** refs. **{{input}}** is the user message.
+- **output** \u2014 shorthand schema using **{ field: type }** notation.
+- **ask** \u2014 boolean. Injects user clarification middleware for human interaction.
 
- \`\`\`json
- { "id": "classify", "name": "Classify Intent", "prompt": "Classify the intent of: {{input}}", "schema": { "type": "object", "properties": { "intent": { "type": "string" } } } }
- \`\`\`
+## When to Use parallel vs map
 
- | Field | Required | Description |
- |-------|----------|-------------|
- | id | no | State key for referencing output. Auto-generated if omitted, but required if downstream steps reference this step via \`{{id}}\` |
- | name | no | Human-readable label for this step |
- | prompt | yes | Task description with {{id}} refs |
-  | schema | **yes** | Standard JSON Schema ONLY: \`{ "type": "object", "properties": { "field": { "type": "string" } } }\`. \`true\` is REJECTED \u2014 must be a concrete schema. Legacy shorthand \`{ "field": "string" }\` is REJECTED.
+This is the most important design decision. **They are fundamentally different:**
 
- **Schema Rules (MUST follow \u2014 shorthand is rejected):**
- - Always wrap in \`{ "type": "object", "properties": { ... } }\`
- - Each property must be \`{ "type": "string"|"number"|"boolean"|"array"|"object" }\`
- - Arrays need \`"items"\`: \`{ "type": "array", "items": { "type": "string" } }\`
- - \u274C \`{ "field": "string" }\` \u2014 REJECTED (no "type"/"properties" wrapper)
- - \u274C \`{ "schema": { "intent": "string" } }\` \u2014 REJECTED (legacy shorthand)
+| | parallel | map |
+|---|---|---|
+| **Concern** | **Business parallelism** \u2014 reduce business processing time | **Data parallelism** \u2014 handle data volume |
+| **Tasks** | Each child does a **different** task | All items do the **same** task |
+| **Count** | Few (2-5), each hand-written | Dynamic, driven by source data |
+| **Input** | Independent prompts per child | Single \`each.prompt\` template, \`{{item}}\` for current element |
+| **if** | Per-child conditional | Whole block conditional |
+| **Example** | Legal review + Market analysis in parallel | Audit each line item in an invoice |
 
- The agent's response is stored at \`state.<id>\` (or an auto-generated key if \`id\` is omitted).
+**Rule of thumb:** If you're writing the same prompt twice, you probably want \`map\`. If each branch has a unique purpose, use \`parallel\`.
 
- ### condition \u2014 branch on state
+## Step Format
 
-**Binary (then/else):**
+### Agent Step
 
-\`\`\`json
-{ "type": "condition", "if": "intent",
-  "then": { "id": "support", "name": "Handle Support", "prompt": "Handle support: {{input}}" },
-  "else": { "id": "sales", "name": "Handle Sales", "prompt": "Handle sales: {{input}}" }
-}
+\`\`\`yaml
+- label:
+    prompt: instruction with {{refs}}
+    if: "expression"
+    output: { field: type }
+    ask: true
 \`\`\`
 
-| Field | Required | Description |
-|-------|----------|-------------|
-| if | yes | State field name (e.g. "approved") or expression (e.g. "score >= 60"). **CRITICAL: \`{{}}\` is FORBIDDEN in \`if\`** \u2014 it is a plain JavaScript expression, not a template. \u274C \`"if": "{{intent}}"\` is WRONG. \u2705 \`"if": "intent"\` is correct. |
-| then | yes | Step(s) to run when condition is truthy |
-| else | no | Step(s) to run when condition is falsy |
-
-The engine evaluates \`if\` as a JavaScript expression prefixed with \`state.\`. Both \`then\` and \`else\` can be a single step or an array of steps. After both branches, execution rejoins at the next step after the condition.
-
-**Switch (branches):**
+### Parallel Block
 
-When branching on a discrete set of known values, use \`branches\` for cleaner multi-way routing:
-
-\`\`\`json
-{ "type": "condition", "if": "intent",
-  "branches": {
-    "support": { "id": "support", "prompt": "Handle support: {{input}}" },
-    "sales":   { "id": "sales",   "prompt": "Handle sales: {{input}}" },
-    "billing": { "id": "billing", "prompt": "Handle billing: {{input}}" },
-    "default": { "id": "fallback", "prompt": "Send to human: {{input}}" }
-  }
-}
+\`\`\`yaml
+- parallel:
+    - child1:
+        prompt: ...
+        if: "expression"
+    - child2:
+        prompt: ...
 \`\`\`
 
-| Field | Required | Description |
-|-------|----------|-------------|
-| if | yes | State field whose STRING VALUE is matched against branch keys. **Same rule \u2014 \`{{}}\` is FORBIDDEN here.** |
-| branches | yes | Map of value \u2192 step(s). \`"default"\` key is a catch-all for unmatched values |
-| then/else | no | Not used when branches is present |
-
-Unlike \`then\`/\`else\` (truthy/falsy ternary), \`branches\` does exact string match against the state field value. Always include a \`"default"\` branch.
+Parallel children are agent steps only. No nested parallel or map inside parallel.
 
- ### human \u2014 pause for human input
+### Map Step
 
-The human step invokes an agent with ask_user_to_clarify middleware. The agent is a **facilitator** \u2014 it presents information to the user and collects their response. The agent does NOT make decisions itself; it asks the user. The agent's structured output is stored under the step's \`id\`.
-
-\`\`\`json
-{ "id": "review", "type": "human",
-  "title": "Approval",
-  "prompt": "Present the following draft to the user for approval. Ask whether to approve or reject, and collect any comments.\\n\\nDraft:\\n{{draft}}",
-  "schema": { "type": "object", "properties": { "approved": { "type": "boolean" }, "comments": { "type": "string" } } }
-}
+\`\`\`yaml
+- label:
+    map:
+      source: "extract.items"
+      if: "extract.items.length > 0"
+      each:
+        prompt: Process {{item}}
+        output: { result: string }
+      batch: 50
+      concurrency: 5
 \`\`\`
 
-Access results with dot notation: \`{{review.approved}}\`, \`{{review.comments}}\`. Use \`schema\` to constrain the agent's output.
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| id | no | State key for the agent's structured output |
-| type | yes | Must be \`"human"\` |
-| prompt | yes | Tell the agent what to present to the user and what to ask. The agent is a facilitator \u2014 write instructions like "Present X to the user and ask Y", NOT "You are a reviewer. Review X..." |
-| title | no | Display label for the human step |
-| schema | no | JSON Schema constraining the agent's structured output format |
-
-### map \u2014 iterate over an array
-
- \`\`\`json
- { "id": "results", "type": "map",
-   "source": "items",
-   "each": { "prompt": "Audit: {{item}}", "schema": { "type": "object", "properties": { "result": { "type": "string" } } } },
-   "batch": 10, "concurrency": 3
- }
- \`\`\`
-
- | Field | Required | Description |
- |-------|----------|-------------|
- | id | yes | Output key for the results array |
- | source | yes | id of the step whose output is the array to iterate |
- | each | yes | Step applied to each element. Use {{item}} for the current element |
- | reduce | no | Step to aggregate results |
- | batch | no | Items per batch (default 50) |
- | concurrency | no | Max parallel items (default 5) |
-
- ### parallel \u2014 fixed fan-out
-
- \`\`\`json
- { "type": "parallel", "steps": [
-   { "id": "legal", "prompt": "Legal review: {{input}}" },
-   { "id": "finance", "prompt": "Finance: {{input}}" }
- ]}
- \`\`\`
-
- All steps run simultaneously. After all complete, execution continues to the next step.
+## Schema Shorthand
 
- ### end \u2014 terminate the workflow
+Write **{ field: type }** instead of JSON Schema:
 
- \`\`\`json
- { "type": "end" }
- \`\`\`
+| Shorthand | Meaning |
+|-----------|---------|
+| **field: string** | string property |
+| **field: number** | number property |
+| **field: boolean** | boolean property |
+| **field: string[]** | array of strings |
+| **field: number[]** | array of numbers |
+| **field: [{ a: string, b: number }]** | array of objects |
+| **field: { sub: string }** | nested object |
 
- Always include at the end of the steps array. \`status\` defaults to "success".
+Use **block style** (each field on its own line). Flow style \`{ field: "type" }\` with quoted values also works.
 
- **Number of terminal nodes:**
+## Template Syntax
 
- - **Every workflow MUST have at least one \`{ "type": "end" }\`** \u2014 without it, the graph hangs at the last node.
- - **One is enough** even for complex workflows: all branches can converge to a single \`end\` node (parallel fan-in, condition branches rejoining, etc.).
- - **Use multiple end nodes ONLY when different branches need different \`status\`** values \u2014 e.g., success path vs failure path:
+| Syntax | Resolves to |
+|--------|------------|
+| \`{{input}}\` | Initial user message |
+| \`{{label}}\` | Full output of step |
+| \`{{label.field}}\` | Nested field access |
+| \`{{item}}\` | Current element in map iteration |
 
- \`\`\`json
- { "type": "condition", "if": "score >= 60",
-   "then": { "type": "end", "status": "success" },
-   "else": { "type": "end", "status": "failed" }
- }
- \`\`\`
+## Design Patterns
 
- - If all outcomes share the same final status, use a single \`end\` node after the condition/parallel block \u2014 the engine automatically converges all paths to it.
+### Linear Pipeline
 
- ## Template Syntax
-
- | Syntax | Resolves to | When to use |
- |--------|------------|-------------|
- | \`{{input}}\` | Initial user message | First step or any step needing the original question |
- | \`{{id}}\` | Output of step with given id | Referencing any upstream step's result |
- | \`{{item}}\` | Current element in map iteration | Inside map \`each.prompt\` |
+\`\`\`yaml
+steps:
+  - extract:
+      prompt: Extract data from {{input}}
+  - transform:
+      prompt: Transform {{extract}}
+  - final:
+      prompt: Combine raw {{extract}} with transformed {{transform}}
+\`\`\`
 
- ## \u26A0\uFE0F CRITICAL: \`{{}}\` is ONLY for \`prompt\` fields
+### Classify -> Route via Parallel + if
 
- The template markers \`{{id}}\`, \`{{input}}\`, and \`{{item}}\` work **exclusively inside \`prompt\` strings**. All other string fields \u2014 including \`if\`, \`source\`, \`id\`, \`name\`, \`title\`, \`status\` \u2014 must use plain values without any \`{{}}\` wrapping.
+\`\`\`yaml
+steps:
+  - classify:
+      prompt: Classify intent from {{input}}
+      output:
+        intent: string
+        urgency: number
+  - parallel:
+      - billing:
+          if: "classify.intent == 'billing'"
+          prompt: Handle billing: {{input}}
+          ask: true
+      - technical:
+          if: "classify.intent == 'technical'"
+          prompt: Handle technical: {{input}}
+  - escalate:
+      if: "classify.urgency >= 8"
+      prompt: Urgent handling
+      ask: true
+\`\`\`
 
- **Common mistake the AI makes:**
- \`\`\`json
- // \u274C WRONG \u2014 {{}} does not belong in if:
- { "type": "condition", "if": "{{intent}}", "then": {...}, "else": {...} }
+### Parallel Processing
 
- // \u2705 CORRECT \u2014 if is a plain expression:
- { "type": "condition", "if": "intent", "then": {...}, "else": {...} }
- \`\`\`
+\`\`\`yaml
+steps:
+  - gather:
+      prompt: Gather data from {{input}}
+  - parallel:
+      - legal:
+          prompt: Legal analysis of {{gather}}
+          output:
+            risk: string
+            compliant: boolean
+      - market:
+          prompt: Market analysis of {{gather}}
+          output:
+            opportunity: string
+            score: number
+  - report:
+      prompt: |
+        Synthesize findings:
+        Legal: {{legal}}
+        Market: {{market}}
+\`\`\`
 
- ## What You NEVER Write
+### Approval Flow with Human
 
- The engine auto-generates these \u2014 do NOT include them in your DSL:
+\`\`\`yaml
+steps:
+  - draft:
+      prompt: Draft response to {{input}}
+  - review:
+      prompt: Present {{draft}} to user for approval
+      output:
+        approved: boolean
+        comments: string
+      ask: true
+  - publish:
+      if: "review.approved"
+      prompt: Publish {{draft}}
+  - revise:
+      if: "!review.approved"
+      prompt: Revise based on {{review.comments}}
+\`\`\`
 
- - **state.fields** \u2014 auto-declared from every \`id\`
- - **edges** \u2014 auto-generated from step order (linear) and types (fan-out for parallel, conditional for condition)
- - **output.key** \u2014 always equals \`id\`
- - **version** \u2014 always "1.0" internally
- - **node IDs** \u2014 prefixed internally to avoid conflicts with state channel names
-  - **human step type** \u2014 the human step has ask_user_to_clarify built-in. Use \`{ "type": "human", ... }\` in the DSL for user interaction. Do NOT manually add ask_user_to_clarify middleware to regular agent steps \u2014 use the dedicated \`human\` step instead.
+### Map (Iteration)
 
- ## Design Patterns
+\`\`\`yaml
+steps:
+  - extract:
+      prompt: Extract items from {{input}}
+      output:
+        items:
+          - name: string
+  - map_items:
+      map:
+        source: "extract.items"
+        each:
+          prompt: Audit {{item.name}}
+          output:
+            result: string
+  - summary:
+      prompt: Summarize findings: {{map_items}}
+\`\`\`
 
- ### Pattern 1: Linear Pipeline
+## Keep Business Logic in Agents
 
- \`\`\`json
- {
-   "name": "knowledge-qa",
-   "steps": [
-     { "id": "research", "name": "Research Topic", "prompt": "Research: {{input}}", "schema": { "type": "object", "properties": { "findings": { "type": "string" } } } },
-     { "id": "answer", "name": "Write Answer", "prompt": "Write answer based on: {{research}}", "schema": { "type": "object", "properties": { "answer": { "type": "string" } } } },
-     { "type": "end" }
-   ]
- }
- \`\`\`
+The DSL is for orchestration (what runs when). Business logic (validation, branching, error handling, user interaction) belongs inside agent prompts, not as workflow if conditions. An agent can validate, branch, and ask questions \u2014 all in one step.
 
- ### Pattern 2: Classify then Route
+**Rule:** if you have more if conditions than workflow phases, move logic into richer agent prompts.
 
- \`\`\`json
- {
-   "name": "customer-router",
-   "steps": [
-     { "id": "intent", "name": "Classify Intent", "prompt": "Classify: {{input}}", "schema": { "type": "object", "properties": { "intent": { "type": "string" } } } },
-     { "type": "condition", "if": "intent",
-       "then": { "id": "support", "name": "Handle Support", "prompt": "Handle support: {{input}}", "schema": { "type": "object", "properties": { "response": { "type": "string" } } } },
-       "else": { "id": "sales", "name": "Handle Sales", "prompt": "Handle sales: {{input}}", "schema": { "type": "object", "properties": { "response": { "type": "string" } } } }
-     },
-     { "type": "end" }
-   ]
-  }
-  \`\`\`
+## What You NEVER Write
 
-  ### Pattern 2b: Classify then Switch
+- **needs** \u2014 not supported. Steps execute linearly. Use parallel for concurrency.
+- **edges** \u2014 auto-generated from step order and parallel structure
+- **nested parallel** \u2014 parallel children are flat agent steps only
+- **map inside parallel** \u2014 map is a top-level step only
+- **json schema** \u2014 use **{ field: type }** block style
+- do not use {{}} markers in if expressions
+- **workflow-level business logic** \u2014 decisions belong inside agent prompts
 
-  For routing to 3+ categories, use \`branches\` instead of nested \`then\`/\`else\`:
+## Checklist
 
-  \`\`\`json
-  {
-    "name": "ticket-router",
-    "steps": [
-      { "id": "intent", "name": "Classify", "prompt": "Classify: {{input}}", "schema": { "type": "object", "properties": { "category": { "type": "string" } } } },
-      { "type": "condition", "if": "intent.category",
-        "branches": {
-          "support": { "id": "support", "prompt": "Handle support: {{input}}" },
-          "sales":   { "id": "sales",   "prompt": "Handle sales: {{input}}" },
-          "billing": { "id": "billing", "prompt": "Handle billing: {{input}}" },
-          "default": { "id": "fallback", "prompt": "Send to human: {{input}}" }
-        }
-      },
-      { "type": "end" }
-    ]
-  }
-  \`\`\`
-
-  ### Pattern 3: Extract \u2192 Review \u2192 Approve
-
- \`\`\`json
- {
-   "name": "approval-flow",
-   "steps": [
-     { "id": "draft", "name": "Draft Response", "prompt": "Draft a response to: {{input}}", "schema": { "type": "object", "properties": { "content": { "type": "string" } } } },
-       { "id": "review", "type": "human",
-         "title": "Approval",
-         "prompt": "Present the draft below to the user for approval. Ask whether to approve or reject with comments.\\n\\nDraft:\\n{{draft}}",
-         "schema": { "type": "object", "properties": { "approved": { "type": "boolean" }, "comments": { "type": "string" } } } },
-      { "type": "condition", "if": "review.approved",
-       "then": { "id": "published", "name": "Publish", "prompt": "Publish: {{draft}}", "schema": { "type": "object", "properties": { "status": { "type": "string" } } } },
-       "else": { "id": "revised", "name": "Revise", "prompt": "Revise based on: {{review.comments}}", "schema": { "type": "object", "properties": { "content": { "type": "string" } } } }
-     },
-     { "type": "end" }
-   ]
- }
- \`\`\`
-
- ### Pattern 4: Parallel Research
-
- \`\`\`json
- {
-   "name": "due-diligence",
-   "steps": [
-     { "id": "info", "name": "Gather Info", "prompt": "Gather info: {{input}}", "schema": { "type": "object", "properties": { "rawData": { "type": "string" } } } },
-     { "type": "parallel", "steps": [
-       { "id": "legal",   "name": "Legal Review",   "prompt": "Legal review: {{info}}", "schema": { "type": "object", "properties": { "risks": { "type": "array", "items": { "type": "string" } } } } },
-       { "id": "finance", "name": "Finance Review", "prompt": "Finance review: {{info}}", "schema": { "type": "object", "properties": { "score": { "type": "number" } } } },
-       { "id": "market",  "name": "Market Analysis", "prompt": "Market analysis: {{info}}", "schema": { "type": "object", "properties": { "trend": { "type": "string" } } } }
-     ]},
-     { "id": "synthesis", "name": "Synthesize", "prompt": "Synthesize: legal={{legal}} finance={{finance}} market={{market}}", "schema": { "type": "object", "properties": { "report": { "type": "string" } } } },
-     { "type": "end" }
-   ]
- }
- \`\`\`
-
- ### Pattern 5: Batch Map + Reduce
-
- \`\`\`json
- {
-   "name": "sentiment-analysis",
-   "steps": [
-     { "id": "posts", "name": "Scrape Posts", "prompt": "Scrape posts about: {{input}}", "schema": { "type": "object", "properties": { "posts": { "type": "array", "items": { "type": "object", "properties": { "text": { "type": "string" } } } } } } },
-     { "id": "sentiments", "type": "map", "source": "posts",
-       "each": { "prompt": "Analyze sentiment: {{item}}", "schema": { "type": "object", "properties": { "sentiment": { "type": "string" } } } },
-       "reduce": { "prompt": "Summarize: {{sentiments}}", "schema": { "type": "object", "properties": { "summary": { "type": "string" } } } }
-     },
-     { "id": "report", "name": "Generate Report", "prompt": "Generate report from: {{sentiments}}", "schema": { "type": "object", "properties": { "report": { "type": "string" } } } },
-     { "type": "end" }
-   ]
- }
- \`\`\`
-
- ## Step 1: Understand the Process
-
- Ask the user:
- - What are the steps in order?
- - Are there branches (if condition then A else B)?
- - Can any steps run in parallel?
- - Is human approval/review needed?
- - What data flows between steps?
-
- ## Step 2: Prepare Dependencies
-
- 1. Call \`list_tools\` to see available tools for the workflow agent.
-
- ## Step 3: Write the DSL
-
- Use \`create_workflow\` with \`skillLoaded: true\`. Never write \`state.fields\`, \`edges\`, \`version\`, or \`output.key\` \u2014 they are auto-generated.
-
- **Checklist before calling:**
- - Every step that produces data referenced downstream has an \`id\`
- - Every agent/map-each step has a valid \`schema\` in standard JSON Schema format (with \`"type": "object"\` and \`"properties"\`)
-  - Schema uses \`{ "type": "object", "properties": { ... } }\` \u2014 \`true\` and legacy \`{ "field": "string" }\` are REJECTED
- - Downstream steps reference upstream data with \`{{id}}\`
- - **Condition \`if\` fields do NOT use \`{{}}\`** \u2014 they are plain expressions like \`"intent"\` or \`"score >= 60"\`
- - Condition steps have \`then\`/\`else\` (binary) or \`branches\` (switch)
-  - Human steps have \`schema\` constraining the agent's structured output
-  - Map steps have \`source\` pointing to an existing step id
-  - Parallel steps have sibling steps with unique \`id\`s
-  - Workflow ends with \`{ "type": "end" }\`
-  - Use \`human\` step type for user interaction (clarify middleware is built-in)
-
- ## Step 4: Test
-
- After creating, optionally call \`validate_workflow(id)\` to check the workflow compiles correctly. Then test with \`invoke_agent\`.
-
- ## Debugging Tips
-
- - If output is missing: check the producing step has an \`id\`
-  - The human step invokes an agent that can use ask_user_to_clarify. The agent's structured output is stored under the step's \`id\`. Access nested results with dot notation: \`{{review.approved}}\`, \`{{review.comments}}\`
- - Map results are an array; use \`reduce\` to aggregate into a summary
- - Condition branching uses truthiness: empty string, 0, null, false \u2192 else path
- - \`{{input}}\` contains the user's initial message; it's always available
- - Parallel + condition: a parallel group cannot be the first step inside a condition's then/else (LangGraph limitation). Add a preceding agent step.
- `
+- Every step has a unique label
+- Steps execute top-to-bottom \u2014 no dependency thinking needed
+- \`{{label}}\` can reference ANY upstream step output
+- if uses plain JS, no {{}}
+- Schema uses block style shorthand
+- parallel children are flat agent steps
+- Business logic stays inside agent prompts
+- ask: true for human interaction`
 };
 function getBuiltInSkillMeta(name) {
   const content = BUILTIN_SKILLS[name];
@@ -10575,7 +10624,7 @@ ${currentSystemPrompt}` : dateContext;
 // src/deep_agent_new/middleware/scheduler.ts
 import { tool as tool45, createMiddleware as createMiddleware13 } from "langchain";
 import { z as z48 } from "zod";
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv42 } from "uuid";
 import { ScheduledTaskStatus as ScheduledTaskStatus3, ScheduleExecutionType as ScheduleExecutionType3 } from "@axiom-lattice/protocols";
 
 // src/schedule_lattice/ScheduleLatticeManager.ts
@@ -12220,7 +12269,6 @@ var Agent = class {
       const runnable_agent = await getAgentClientAsync(this.tenant_id, this.assistant_id);
       const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(this.tenant_id, this.assistant_id);
       const { messages, ...rest } = input;
-      const lifecycleManager = this;
       const runConfig = {
         thread_id: this.thread_id,
         "x-tenant-id": this.tenant_id,
@@ -12272,43 +12320,13 @@ var Agent = class {
           }
         );
         try {
-          for await (const chunk of agentStream) {
-            if (signal?.aborted) {
-              await lifecycleManager.chunkBuffer.abortThread(lifecycleManager.thread_id);
-              throw new Error("Agent execution was aborted");
-            }
-            let data;
-            let chunkContent = "";
-            if (chunk[0] === "updates") {
-              const update = chunk[1];
-              const values = Object.values(update);
-              const messages2 = values[0]?.messages;
-              if (messages2?.[0]?.tool_call_id) {
-                data = messages2[0].toDict();
-              }
-            } else if (chunk[0] === "messages") {
-              const messages2 = chunk[1];
-              data = messages2?.[0]?.toDict();
-            }
-            if (chunk?.[1]?.__interrupt__) {
-              const interruptData = chunk?.[1]?.__interrupt__[0];
-              data = {
-                type: "interrupt",
-                id: interruptData.id,
-                data: { content: interruptData.value }
-              };
-            }
-            if (data) {
-              lifecycleManager.addChunk(data);
-            }
-          }
+          await this.consumeAgentStream(agentStream, signal);
         } catch (error) {
           console.error("Stream error:", error);
-          await lifecycleManager.chunkBuffer.abortThread(lifecycleManager.thread_id);
           throw error;
         }
       } catch (error) {
-        await this.chunkBuffer.abortThread(lifecycleManager.thread_id);
+        await this.chunkBuffer.abortThread(this.thread_id);
         throw error;
       }
     };
@@ -12589,8 +12607,8 @@ var Agent = class {
     this.assistant_id = assistant_id;
     this.thread_id = thread_id;
     this.tenant_id = tenant_id;
-    this.workspace_id = workspace_id;
-    this.project_id = project_id;
+    this.workspace_id = workspace_id || "default";
+    this.project_id = project_id || "default";
     this.custom_run_config = custom_run_config;
   }
   getHumanPendingContent(message) {
@@ -12684,10 +12702,132 @@ var Agent = class {
     const inputMessage = { ...queueMessage, input };
     return this.agentExecutor(inputMessage, signal);
   }
+  /**
+   * Like {@link invoke} but returns the full LangGraph state (all annotations)
+   * instead of only messages. Messages are serialized to dicts; other state
+   * fields are returned as-is.
+   *
+   * @remarks
+   * Only call this when you need the full state. Existing callers (gateway,
+   * workflows) should keep using {@link invoke} which returns only messages
+   * to avoid exposing internal annotation data.
+   */
+  async invokeWithState(queueMessage, signal) {
+    const messageId = v4();
+    const input = {
+      ...queueMessage.input,
+      messages: [new HumanMessage({ id: messageId, content: queueMessage.input.message })]
+    };
+    const inputMessage = { ...queueMessage, input };
+    const { runnable_agent, runConfig } = await this.getLatticeClientAndRuntimeConfig(inputMessage.custom_run_config);
+    const { messages, ...rest } = inputMessage.input;
+    if (signal?.aborted) {
+      throw new Error("Agent execution was aborted");
+    }
+    let result;
+    result = await runnable_agent.invoke(
+      inputMessage.command ? new Command2(inputMessage.command) : { ...rest, messages, "x-tenant-id": this.tenant_id },
+      {
+        context: { runConfig },
+        configurable: {
+          run_id: v4(),
+          ...runConfig,
+          runConfig
+        },
+        recursionLimit: 200,
+        signal
+      }
+    );
+    if (signal?.aborted) {
+      throw new Error("Agent execution was aborted");
+    }
+    const { messages: _rawMessages, ...restState } = result;
+    const serializedMessages = result.messages.map((message) => {
+      const { type, data } = message.toDict();
+      return { ...data, role: type };
+    });
+    return { messages: serializedMessages, ...restState };
+  }
   async getPendingMessages() {
     const store = this.getQueueStore();
     return await store.getPendingMessages(this.thread_id);
   }
+  async consumeAgentStream(agentStream, signal) {
+    for await (const chunk of agentStream) {
+      if (signal?.aborted) {
+        await this.chunkBuffer.abortThread(this.thread_id);
+        throw new Error("Agent execution was aborted");
+      }
+      let data;
+      if (chunk[0] === "updates") {
+        const update = chunk[1];
+        const values = Object.values(update);
+        const messages = values[0]?.messages;
+        if (messages?.[0]?.tool_call_id) {
+          data = messages[0].toDict();
+        }
+      } else if (chunk[0] === "messages") {
+        const messages = chunk[1];
+        data = messages?.[0]?.toDict();
+      }
+      if (chunk?.[1]?.__interrupt__) {
+        const interruptData = chunk?.[1]?.__interrupt__[0];
+        data = {
+          type: "interrupt",
+          id: interruptData.id,
+          data: { content: interruptData.value }
+        };
+      }
+      if (data) {
+        this.addChunk(data);
+      }
+    }
+  }
+  /**
+   * Resume LangGraph execution from the last checkpoint.
+   *
+   * Streams with `null` input — this tells LangGraph to continue from
+   * wherever it left off using the checkpointed state for this thread.
+   * All output chunks are buffered via {@link addChunk}.
+   */
+  async resumeGraphFromCheckpoint(signal) {
+    const runnable_agent = await getAgentClientAsync(this.tenant_id, this.assistant_id);
+    const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(this.tenant_id, this.assistant_id);
+    if (!runnable_agent) {
+      throw new Error(`Agent ${this.assistant_id} not found`);
+    }
+    const runConfig = {
+      thread_id: this.thread_id,
+      "x-tenant-id": this.tenant_id,
+      "x-workspace-id": this.workspace_id,
+      "x-project-id": this.project_id,
+      "x-thread-id": this.thread_id,
+      "x-assistant-id": this.assistant_id,
+      ...agentLattice?.config?.runConfig || {},
+      tenantId: this.tenant_id,
+      workspaceId: this.workspace_id,
+      projectId: this.project_id,
+      ...this.custom_run_config || {},
+      assistant_id: this.assistant_id
+    };
+    const agentStream = await runnable_agent.stream(
+      null,
+      {
+        context: {
+          runConfig
+        },
+        configurable: {
+          ...runConfig,
+          runConfig
+        },
+        streamMode: ["updates", "messages"],
+        subgraphs: false,
+        recursionLimit: 200,
+        signal
+      }
+    );
+    await this.consumeAgentStream(agentStream, signal);
+  }
   getQueueStore() {
     if (!this.queueStore) {
       try {
@@ -12817,6 +12957,8 @@ var Agent = class {
         threadId: this.thread_id,
         tenantId: this.tenant_id,
         assistantId: this.assistant_id,
+        workspaceId: this.workspace_id,
+        projectId: this.project_id,
         content,
         type: pendingType,
         command: queueMessage.command,
@@ -12833,6 +12975,8 @@ var Agent = class {
         threadId: this.thread_id,
         tenantId: this.tenant_id,
         assistantId: this.assistant_id,
+        workspaceId: this.workspace_id,
+        projectId: this.project_id,
         content,
         type: pendingType,
         command: queueMessage.command,
@@ -12906,6 +13050,8 @@ var Agent = class {
       threadId: thread.threadId,
       tenantId: thread.tenantId,
       assistantId: thread.assistantId,
+      workspaceId: this.workspace_id,
+      projectId: this.project_id,
       content: reminderContent,
       type: "system"
     });
@@ -12977,9 +13123,14 @@ var Agent = class {
   /**
    * Resume processing after a server restart.
    *
-   * Resets any stuck "processing" messages back to "pending" and restarts the
-   * queue processor. Skips threads that are in `INTERRUPTED` state (the
-   * interruption was intentional).
+   * If the graph was mid-execution (BUSY) it resumes from the LangGraph
+   * checkpoint without re-injecting the message — the message has already
+   * been consumed and is in the graph state.  Processing messages are removed
+   * rather than replayed.
+   *
+   * Skips threads that are in `INTERRUPTED` state (the interruption was
+   * intentional).  IDLE threads simply clean up and restart the queue
+   * processor for any remaining pending messages.
    *
    * Called during gateway startup to recover threads that were mid-execution
    * when the server went down.
@@ -12997,9 +13148,32 @@ var Agent = class {
       return;
     }
     const store = this.getQueueStore();
-    const resetCount = await store.resetProcessingToPending(this.thread_id);
-    if (resetCount > 0) {
-      console.log(`[Agent] Reset ${resetCount} processing messages to pending for thread ${this.thread_id}`);
+    if (runStatus === "busy" /* BUSY */) {
+      this.abortController = new AbortController();
+      try {
+        await this.resumeGraphFromCheckpoint(this.abortController.signal);
+        const processingMessages = await store.getProcessingMessages(this.thread_id);
+        for (const msg of processingMessages) {
+          await store.removeMessage(msg.id);
+        }
+        if (processingMessages.length > 0) {
+          console.log(`[Agent] Removed ${processingMessages.length} processing messages for thread ${this.thread_id}`);
+        }
+      } catch (error) {
+        console.error(`[Agent] Failed to resume graph for thread ${this.thread_id}:`, error);
+        await this.chunkBuffer.abortThread(this.thread_id);
+        throw error;
+      } finally {
+        this.abortController = null;
+      }
+    } else {
+      const processingMessages = await store.getProcessingMessages(this.thread_id);
+      for (const msg of processingMessages) {
+        await store.removeMessage(msg.id);
+      }
+      if (processingMessages.length > 0) {
+        console.log(`[Agent] Removed ${processingMessages.length} processing messages for thread ${this.thread_id}`);
+      }
     }
     await this.startQueueProcessorIfNeeded();
   }
@@ -13190,7 +13364,7 @@ var AgentInstanceManager = class _AgentInstanceManager {
       console.log(`[AgentInstanceManager] Found ${threadsWithPending.length} threads with pending messages, restoring...`);
       for (const threadInfo of threadsWithPending) {
         try {
-          await this.restoreThread(threadInfo, queueStore);
+          await this.restoreThread(threadInfo);
           stats.restored++;
         } catch (error) {
           console.error(`[AgentInstanceManager] Failed to restore thread ${threadInfo.threadId}:`, error);
@@ -13208,16 +13382,14 @@ var AgentInstanceManager = class _AgentInstanceManager {
    * Restore a single thread
    * Delegates actual recovery logic to Agent.resumeTask()
    */
-  async restoreThread(threadInfo, queueStore) {
-    const { tenantId, assistantId, threadId } = threadInfo;
+  async restoreThread(threadInfo) {
+    const { tenantId, assistantId, threadId, workspaceId, projectId } = threadInfo;
     const threadParams = {
       tenant_id: tenantId,
       assistant_id: assistantId,
       thread_id: threadId,
-      workspace_id: "default",
-      // TODO: Get from thread store
-      project_id: "default"
-      // TODO: Get from thread store
+      workspace_id: workspaceId,
+      project_id: projectId
     };
     const agent = this.getAgent(threadParams);
     await agent.resumeTask();
@@ -13308,7 +13480,7 @@ function createSchedulerMiddleware(options = {}) {
         async (input, config) => {
           const runConfig = getRunConfig(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
-          const taskId = uuidv4();
+          const taskId = uuidv42();
           const executeAt = input.executeAt;
           const success = await scheduleLattice.client.scheduleOnce(
             taskId,
@@ -13343,7 +13515,7 @@ function createSchedulerMiddleware(options = {}) {
         async (input, config) => {
           const runConfig = getRunConfig(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
-          const taskId = uuidv4();
+          const taskId = uuidv42();
           const executeAt = Date.now() + input.delayMs;
           const success = await scheduleLattice.client.scheduleOnce(
             taskId,
@@ -13378,7 +13550,7 @@ function createSchedulerMiddleware(options = {}) {
         async (input, config) => {
           const runConfig = getRunConfig(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
-          const taskId = uuidv4();
+          const taskId = uuidv42();
           const success = await scheduleLattice.client.scheduleCron(
             taskId,
             AGENT_ADD_MESSAGE_TASK_TYPE,
@@ -13466,6 +13638,138 @@ function createSchedulerMiddleware(options = {}) {
   });
 }
 
+// src/middlewares/taskMiddleware.ts
+import { createMiddleware as createMiddleware14, tool as tool46 } from "langchain";
+import { z as z49 } from "zod";
+function getRunConfig2(config) {
+  const c = config;
+  return c?.configurable?.runConfig ?? {};
+}
+function getTaskStore() {
+  return getStoreLattice("default", "task").store;
+}
+var manageTaskSchema = z49.object({
+  action: z49.enum(["create", "list", "update", "delete", "complete"]).describe("\u64CD\u4F5C\u7C7B\u578B"),
+  id: z49.string().optional().describe("\u4EFB\u52A1 ID (update/delete/complete \u5FC5\u586B)"),
+  title: z49.string().optional().describe("\u4EFB\u52A1\u6807\u9898 (create \u5FC5\u586B)"),
+  description: z49.string().optional().describe("\u4EFB\u52A1\u63CF\u8FF0"),
+  priority: z49.enum(["low", "medium", "high"]).optional().describe("\u4F18\u5148\u7EA7"),
+  status: z49.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe("\u72B6\u6001"),
+  dueDate: z49.string().optional().describe("\u622A\u6B62\u65E5\u671F (ISO 8601)"),
+  metadata: z49.record(z49.unknown()).optional().describe("\u7ED3\u6784\u5316\u5143\u6570\u636E (projectId, module \u7B49)"),
+  parentId: z49.string().optional().describe("\u7236\u4EFB\u52A1 ID (\u5B50\u4EFB\u52A1\u5173\u8054)"),
+  sourceId: z49.string().optional().describe("\u6765\u6E90\u4F1A\u8BDD/thread ID"),
+  context: z49.record(z49.unknown()).optional().describe("\u9644\u52A0\u4E0A\u4E0B\u6587"),
+  ownerType: z49.enum(["user", "agent"]).optional().describe("\u6240\u6709\u8005\u7C7B\u578B\uFF0C\u4E0D\u4F20\u9ED8\u8BA4\u4E3A user"),
+  ownerId: z49.string().optional().describe("\u6240\u6709\u8005 ID\uFF0C\u4E0D\u4F20\u81EA\u52A8\u53D6\u5F53\u524D\u7528\u6237/Agent")
+});
+function createTaskMiddleware() {
+  return createMiddleware14({
+    name: "TaskMiddleware",
+    contextSchema,
+    wrapModelCall: async (request, handler) => {
+      const taskPrompt = `## \u4EFB\u52A1\u7BA1\u7406\u80FD\u529B
+\u4F60\u53EF\u4EE5\u901A\u8FC7 manage_task \u5DE5\u5177\u7BA1\u7406\u6301\u4E45\u5316\u4EFB\u52A1\u3002ownerType \u548C ownerId \u7684\u9ED8\u8BA4\u884C\u4E3A\uFF1A
+- \u4E0D\u4F20\u53C2\u6570: \u9ED8\u8BA4\u4E3A\u5F53\u524D\u7528\u6237\u521B\u5EFA\u4EFB\u52A1 (ownerType="user", ownerId \u81EA\u52A8\u53D6\u5F53\u524D\u7528\u6237)
+- ownerType="agent": \u4E3A\u81EA\u5DF1\u521B\u5EFA\u6267\u884C\u5B50\u4EFB\u52A1 (ownerId \u81EA\u52A8\u53D6\u5F53\u524D Agent)
+- \u663E\u5F0F\u4F20 ownerId: \u4E3A\u6307\u5B9A agent/user \u521B\u5EFA\u4EFB\u52A1\uFF08\u62D3\u6251\u573A\u666F\uFF09`;
+      return handler({
+        ...request,
+        systemPrompt: taskPrompt + "\n\n" + (request.systemPrompt ?? "")
+      });
+    },
+    tools: [
+      tool46(
+        async (input, config) => {
+          const rc = getRunConfig2(config);
+          const tenantId = rc.tenantId || "default";
+          const ownerId = input.ownerId || (input.ownerType === "agent" ? rc.assistant_id : null) || rc.user_id;
+          const store = getTaskStore();
+          switch (input.action) {
+            case "create": {
+              if (!input.title) {
+                return JSON.stringify({ success: false, error: "create requires title" });
+              }
+              const task = await store.create({
+                tenantId,
+                ownerType: input.ownerType || "user",
+                ownerId,
+                title: input.title,
+                description: input.description,
+                priority: input.priority || "medium",
+                status: input.status || "pending",
+                dueDate: input.dueDate,
+                metadata: input.metadata,
+                parentId: input.parentId,
+                sourceId: input.sourceId,
+                context: input.context
+              });
+              return JSON.stringify({ success: true, data: task });
+            }
+            case "list": {
+              const tasks = await store.list({
+                tenantId,
+                ownerType: input.ownerType,
+                ownerId: input.ownerId,
+                status: input.status,
+                priority: input.priority
+              });
+              return JSON.stringify({ success: true, data: tasks, count: tasks.length });
+            }
+            case "update": {
+              if (!input.id) {
+                return JSON.stringify({ success: false, error: "update requires id" });
+              }
+              const { action, ...updates } = input;
+              const updated = await store.update(tenantId, input.id, updates);
+              if (!updated) {
+                return JSON.stringify({ success: false, error: "Task not found" });
+              }
+              return JSON.stringify({ success: true, data: updated });
+            }
+            case "delete": {
+              if (!input.id) {
+                return JSON.stringify({ success: false, error: "delete requires id" });
+              }
+              const deleted = await store.delete(tenantId, input.id);
+              return JSON.stringify({ success: deleted, message: deleted ? "Task deleted" : "Task not found" });
+            }
+            case "complete": {
+              if (!input.id) {
+                return JSON.stringify({ success: false, error: "complete requires id" });
+              }
+              const updated = await store.update(tenantId, input.id, { status: "completed" });
+              if (!updated) {
+                return JSON.stringify({ success: false, error: "Task not found" });
+              }
+              return JSON.stringify({ success: true, data: updated });
+            }
+            default:
+              return JSON.stringify({ success: false, error: `Unknown action: ${input.action}` });
+          }
+        },
+        {
+          name: "manage_task",
+          description: `\u7BA1\u7406\u6301\u4E45\u5316\u4EFB\u52A1\u7CFB\u7EDF\u3002CRUD \u64CD\u4F5C\u7528\u6237\u548C Agent \u7684\u4EFB\u52A1\u3002
+
+## ownerType \u548C ownerId \u7684\u9ED8\u8BA4\u903B\u8F91
+- \u4E0D\u4F20 ownerType \u548C ownerId: \u7CFB\u7EDF\u81EA\u52A8\u4E3A\u5F53\u524D\u7528\u6237\u521B\u5EFA\u4EFB\u52A1 (ownerType="user", ownerId \u53D6\u81EA\u5F53\u524D\u767B\u5F55\u7528\u6237)
+- \u4F20 ownerType="agent" \u4E0D\u4F20 ownerId: \u7CFB\u7EDF\u81EA\u52A8\u4E3A\u5F53\u524D Agent \u521B\u5EFA\u5B50\u4EFB\u52A1
+- \u663E\u5F0F\u4F20 ownerId: \u7CFB\u7EDF\u4F7F\u7528\u4F60\u6307\u5B9A\u7684 ID\uFF0C\u53EF\u8DE8 Agent \u6D3E\u53D1\u4EFB\u52A1\uFF08\u62D3\u6251\u573A\u666F\uFF09
+
+## Actions
+- create: \u521B\u5EFA\u4EFB\u52A1 (title \u5FC5\u586B, priority/description/dueDate/metadata/parentId/context \u53EF\u9009)
+- list: \u5217\u51FA\u4EFB\u52A1\uFF0C\u53EF\u6309 ownerType/status/priority \u8FC7\u6EE4
+- update: \u66F4\u65B0\u4EFB\u52A1 (id \u5FC5\u586B\uFF0C\u53EA\u4F20\u8981\u6539\u7684\u5B57\u6BB5)
+- delete: \u5220\u9664\u4EFB\u52A1 (id \u5FC5\u586B)
+- complete: \u5FEB\u901F\u6807\u8BB0\u5B8C\u6210 (id \u5FC5\u586B)`,
+          schema: manageTaskSchema
+        }
+      )
+    ]
+  });
+}
+
 // src/agent_lattice/builders/CustomMiddlewareRegistry.ts
 var CustomMiddlewareRegistry = class {
   /**
@@ -13601,6 +13905,9 @@ async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsI
       case "scheduler":
         middlewares.push(createSchedulerMiddleware(config.config));
         break;
+      case "task":
+        middlewares.push(createTaskMiddleware());
+        break;
       case "custom":
         {
           const customConfig = config.config;
@@ -13633,10 +13940,12 @@ var SandboxFilesystem = class {
   }
   async lsInfo(dirPath) {
     try {
+      console.log(`[SandboxFilesystem.lsInfo] calling sandbox.file.listPath(${dirPath})`);
       const result = await this.sandbox.file.listPath(dirPath, { recursive: false });
+      console.log(`[SandboxFilesystem.lsInfo] got ${result.files.length} entries`);
       return result.files;
     } catch (e) {
-      console.error(`Error listing files in ${dirPath}:`, e);
+      console.error(`[SandboxFilesystem.lsInfo] error listing ${dirPath}:`, e);
       return [];
     }
   }
@@ -13808,9 +14117,9 @@ var ReActAgentGraphBuilder = class {
    */
   async build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool51 = getToolClient(t.key);
-      return tool51;
-    }).filter((tool51) => tool51 !== void 0);
+      const tool52 = getToolClient(t.key);
+      return tool52;
+    }).filter((tool52) => tool52 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
@@ -13837,11 +14146,11 @@ import {
 } from "langchain";
 
 // src/deep_agent_new/middleware/subagents.ts
-import { z as z49 } from "zod/v3";
+import { z as z50 } from "zod/v3";
 import {
-  createMiddleware as createMiddleware14,
+  createMiddleware as createMiddleware15,
   createAgent as createAgent2,
-  tool as tool46,
+  tool as tool47,
   ToolMessage as ToolMessage4,
   humanInTheLoopMiddleware
 } from "langchain";
@@ -14274,7 +14583,7 @@ function createTaskTool(options) {
     generalPurposeAgent
   });
   const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
-  return tool46(
+  return tool47(
     async (input, config) => {
       const { description, subagent_type, async } = input;
       let assistant_id = subagent_type;
@@ -14308,12 +14617,16 @@ function createTaskTool(options) {
         const subagent_thread_id = config.configurable?.thread_id + "____" + assistant_id + "_" + config.toolCall.id;
         if (async) {
           const tenantId = config.configurable?.runConfig?.tenantId;
+          const workspaceId = config.configurable?.runConfig?.workspaceId;
+          const projectId = config.configurable?.runConfig?.projectId;
           const mainAssistantId = config.configurable?.runConfig?.assistant_id;
           const mainThreadId = config.configurable?.runConfig?.thread_id;
           const mainRuntimeAgent = agentInstanceManager.getAgent({
             assistant_id: mainAssistantId,
             thread_id: mainThreadId,
-            tenant_id: tenantId
+            tenant_id: tenantId,
+            workspace_id: workspaceId,
+            project_id: projectId
           });
           if (mainRuntimeAgent) {
             mainRuntimeAgent.addAsyncTask({
@@ -14392,15 +14705,15 @@ The result will be delivered as a notification when complete. Do not poll.`,
     {
       name: "task",
       description: finalTaskDescription,
-      schema: z49.object({
-        description: z49.string().describe("The task to execute with the selected agent"),
-        subagent_type: z49.string().describe(
+      schema: z50.object({
+        description: z50.string().describe("The task to execute with the selected agent"),
+        subagent_type: z50.string().describe(
           `Name of the agent to use. Available: ${Object.keys(
             subagentGraphs
           ).join(", ")}`
         ),
         ...allowAsync ? {
-          async: z49.boolean().default(false).describe(
+          async: z50.boolean().default(false).describe(
             "When true, runs the task in the background and returns immediately. Use for independent tasks that can run in parallel. The result is delivered as a notification when complete. Use check_async_task or list_async_tasks to monitor progress."
           )
         } : {}
@@ -14419,7 +14732,7 @@ function getMainAgentFromConfig(config) {
   });
 }
 function createCheckAsyncTaskTool() {
-  return tool46(
+  return tool47(
     async (input, config) => {
       const { task_id } = input;
       const mainAgent = getMainAgentFromConfig(config);
@@ -14479,14 +14792,14 @@ Description: ${cached.description}`;
     {
       name: "check_async_task",
       description: "Get the current status and result of an async background task. Use this to check if a previously launched async task has completed.",
-      schema: z49.object({
-        task_id: z49.string().describe("The task ID returned when the async task was started")
+      schema: z50.object({
+        task_id: z50.string().describe("The task ID returned when the async task was started")
       })
     }
   );
 }
 function createListAsyncTasksTool() {
-  return tool46(
+  return tool47(
     async (_input, config) => {
       const mainAgent = getMainAgentFromConfig(config);
       if (!mainAgent) {
@@ -14532,12 +14845,12 @@ function createListAsyncTasksTool() {
     {
       name: "list_async_tasks",
       description: "List all async background tasks with their current status. Use this before reporting task status to the user. Statuses in conversation history may be stale.",
-      schema: z49.object({})
+      schema: z50.object({})
     }
   );
 }
 function createCancelAsyncTaskTool() {
-  return tool46(
+  return tool47(
     async (input, config) => {
       const { task_id } = input;
       const mainAgent = getMainAgentFromConfig(config);
@@ -14576,8 +14889,8 @@ function createCancelAsyncTaskTool() {
     {
       name: "cancel_async_task",
       description: "Cancel a running async background task.",
-      schema: z49.object({
-        task_id: z49.string().describe("The task ID to cancel")
+      schema: z50.object({
+        task_id: z50.string().describe("The task ID to cancel")
       })
     }
   );
@@ -14613,7 +14926,7 @@ function createSubAgentMiddleware(options) {
     );
   }
   const effectiveSystemPrompt = allowAsync ? systemPrompt + getAsyncPromptText() : systemPrompt;
-  return createMiddleware14({
+  return createMiddleware15({
     name: "subAgentMiddleware",
     tools: allTools,
     wrapModelCall: async (request, handler) => {
@@ -14634,14 +14947,12 @@ ${effectiveSystemPrompt}` : effectiveSystemPrompt;
 
 // src/deep_agent_new/middleware/patch_tool_calls.ts
 import {
-  createMiddleware as createMiddleware15,
+  createMiddleware as createMiddleware16,
   ToolMessage as ToolMessage5,
   AIMessage as AIMessage2
 } from "langchain";
-import { RemoveMessage } from "@langchain/core/messages";
-import { REMOVE_ALL_MESSAGES } from "@langchain/langgraph";
 function createPatchToolCallsMiddleware() {
-  return createMiddleware15({
+  return createMiddleware16({
     name: "patchToolCallsMiddleware",
     beforeAgent: async (state) => {
       const messages = state.messages;
@@ -14670,11 +14981,12 @@ function createPatchToolCallsMiddleware() {
           }
         }
       }
+      if (patchedMessages.length === messages.length) {
+        return;
+      }
       return {
-        messages: [
-          new RemoveMessage({ id: REMOVE_ALL_MESSAGES }),
-          ...patchedMessages
-        ]
+        messages: patchedMessages.slice(messages.length)
+        // only the new ToolMessage patches
       };
     }
   });
@@ -15787,8 +16099,8 @@ var MemoryBackend = class {
 
 // src/deep_agent_new/middleware/todos.ts
 import { Command as Command4 } from "@langchain/langgraph";
-import { z as z50 } from "zod";
-import { createMiddleware as createMiddleware16, tool as tool47, ToolMessage as ToolMessage6 } from "langchain";
+import { z as z51 } from "zod";
+import { createMiddleware as createMiddleware17, tool as tool48, ToolMessage as ToolMessage6 } from "langchain";
 var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
 It also helps the user understand the progress of the task and overall progress of their requests.
 Only use this tool if you think it will be helpful in staying organized. If the user's request is trivial and takes less than 3 steps, it is better to NOT use this tool and just do the taks directly.
@@ -16015,14 +16327,14 @@ Writing todos takes time and tokens, use it when it is helpful for managing comp
 ## Important To-Do List Usage Notes to Remember
 - The \`write_todos\` tool should never be called multiple times in parallel.
 - Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.`;
-var TodoStatus = z50.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = z50.object({
-  content: z50.string().describe("Content of the todo item"),
+var TodoStatus = z51.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = z51.object({
+  content: z51.string().describe("Content of the todo item"),
   status: TodoStatus
 });
-var stateSchema = z50.object({ todos: z50.array(TodoSchema).default([]) });
+var stateSchema = z51.object({ todos: z51.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
-  const writeTodos = tool47(
+  const writeTodos = tool48(
     ({ todos }, config) => {
       return new Command4({
         update: {
@@ -16039,12 +16351,12 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: z50.object({
-        todos: z50.array(TodoSchema).describe("List of todo items to update")
+      schema: z51.object({
+        todos: z51.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
-  return createMiddleware16({
+  return createMiddleware17({
     name: "todoListMiddleware",
     stateSchema,
     tools: [writeTodos],
@@ -16156,7 +16468,7 @@ var DeepAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool51) => tool51 !== void 0);
+    }).filter((tool52) => tool52 !== void 0);
     const subagents = await Promise.all(params.subAgents.map(async (sa) => {
       if (sa.client) {
         return {
@@ -16197,7 +16509,7 @@ var DeepAgentGraphBuilder = class {
 };
 
 // src/agent_team/agent_team.ts
-import { z as z53 } from "zod/v3";
+import { z as z54 } from "zod/v3";
 import { createAgent as createAgent5 } from "langchain";
 
 // src/agent_team/types.ts
@@ -16633,14 +16945,14 @@ var InMemoryMailboxStore = class {
 };
 
 // src/agent_team/middleware/team.ts
-import { z as z52 } from "zod/v3";
-import { createMiddleware as createMiddleware17, createAgent as createAgent4, tool as tool49, ToolMessage as ToolMessage8 } from "langchain";
+import { z as z53 } from "zod/v3";
+import { createMiddleware as createMiddleware18, createAgent as createAgent4, tool as tool50, ToolMessage as ToolMessage8 } from "langchain";
 import { Command as Command6, getCurrentTaskInput as getCurrentTaskInput3 } from "@langchain/langgraph";
-import { v4 as uuidv42 } from "uuid";
+import { v4 as uuidv43 } from "uuid";
 
 // src/agent_team/middleware/teammate_tools.ts
-import { z as z51 } from "zod/v3";
-import { tool as tool48, ToolMessage as ToolMessage7 } from "langchain";
+import { z as z52 } from "zod/v3";
+import { tool as tool49, ToolMessage as ToolMessage7 } from "langchain";
 import { Command as Command5 } from "@langchain/langgraph";
 
 // src/agent_team/middleware/formatMessages.ts
@@ -16665,7 +16977,7 @@ ${meta}${body}`;
 // src/agent_team/middleware/teammate_tools.ts
 function createTeammateTools(options) {
   const { teamId, agentId, taskListStore, mailboxStore } = options;
-  const claimTaskTool = tool48(
+  const claimTaskTool = tool49(
     async (input) => {
       const task = await taskListStore.claimTaskById(
         teamId,
@@ -16690,12 +17002,12 @@ function createTeammateTools(options) {
     {
       name: "claim_task",
       description: "Pick a task to work on by task_id. Use check_tasks first to see all tasks; then call this with the task_id you choose. The task's assignee is set to you and you should focus on that task until you complete_task or fail_task it.",
-      schema: z51.object({
-        task_id: z51.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
+      schema: z52.object({
+        task_id: z52.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
       })
     }
   );
-  const completeTaskTool = tool48(
+  const completeTaskTool = tool49(
     async (input) => {
       const task = await taskListStore.completeTask(
         teamId,
@@ -16716,13 +17028,13 @@ function createTeammateTools(options) {
     {
       name: "complete_task",
       description: "Mark a claimed task as completed with a result summary. Call this after you have finished working on a task.",
-      schema: z51.object({
-        task_id: z51.string().describe("ID of the task to complete"),
-        result: z51.string().describe("Summary of the task result")
+      schema: z52.object({
+        task_id: z52.string().describe("ID of the task to complete"),
+        result: z52.string().describe("Summary of the task result")
       })
     }
   );
-  const failTaskTool = tool48(
+  const failTaskTool = tool49(
     async (input) => {
       const task = await taskListStore.failTask(
         teamId,
@@ -16743,13 +17055,13 @@ function createTeammateTools(options) {
     {
       name: "fail_task",
       description: "Mark a claimed task as failed with an error description. Call this if you cannot complete the task.",
-      schema: z51.object({
-        task_id: z51.string().describe("ID of the task to fail"),
-        error: z51.string().describe("Description of why the task failed")
+      schema: z52.object({
+        task_id: z52.string().describe("ID of the task to fail"),
+        error: z52.string().describe("Description of why the task failed")
       })
     }
   );
-  const sendMessageTool = tool48(
+  const sendMessageTool = tool49(
     async (input) => {
       await mailboxStore.sendMessage(
         teamId,
@@ -16763,11 +17075,11 @@ function createTeammateTools(options) {
     {
       name: "send_message",
       description: 'Send a message to the team lead or another teammate via the mailbox. Use "team_lead" to message the team lead. Use this to report discoveries, request guidance, or suggest new tasks.',
-      schema: z51.object({
-        to: z51.string().describe(
+      schema: z52.object({
+        to: z52.string().describe(
           'Recipient agent name (e.g. "team_lead" or a teammate name)'
         ),
-        content: z51.string().describe("Message content")
+        content: z52.string().describe("Message content")
       })
     }
   );
@@ -16787,7 +17099,7 @@ function createTeammateTools(options) {
       read: msg.read
     }));
   };
-  const readMessagesTool = tool48(
+  const readMessagesTool = tool49(
     async (input, config) => {
       const formatAndMarkAsRead = async (msgs2) => {
         for (const msg of msgs2) {
@@ -16846,10 +17158,10 @@ function createTeammateTools(options) {
     {
       name: "read_messages",
       description: "Read unread messages from the mailbox. Returns immediately if messages exist, otherwise waits for up to 3 minutes for new messages.",
-      schema: z51.object({})
+      schema: z52.object({})
     }
   );
-  const checkTasksTool = tool48(
+  const checkTasksTool = tool49(
     async () => {
       const tasks = await taskListStore.getAllTasks(teamId);
       return formatTaskSummary(tasks);
@@ -16857,10 +17169,10 @@ function createTeammateTools(options) {
     {
       name: "check_tasks",
       description: "Use this tool to get the current status of all tasks in a team. This is your primary way to monitor task progress.",
-      schema: z51.object({})
+      schema: z52.object({})
     }
   );
-  const broadcastMessageTool = tool48(
+  const broadcastMessageTool = tool49(
     async (input) => {
       const allAgents = await mailboxStore.getRegisteredAgents(teamId);
       const recipients = allAgents.filter((a) => a !== agentId);
@@ -16879,8 +17191,8 @@ function createTeammateTools(options) {
     {
       name: "broadcast_message",
       description: "Send a message to everyone in the team except yourself. Use this to share updates or information with all teammates and the team lead at once.",
-      schema: z51.object({
-        content: z51.string().describe("Message content to broadcast to others")
+      schema: z52.object({
+        content: z52.string().describe("Message content to broadcast to others")
       })
     }
   );
@@ -17114,7 +17426,7 @@ async function spawnTeammate(options) {
 function createTeamMiddleware(options) {
   const { teamConfig, taskListStore, mailboxStore, tenantId } = options;
   const defaultModel = teamConfig.model ?? "claude-sonnet-4-5-20250929";
-  const createTeamTool = tool49(
+  const createTeamTool = tool50(
     async (input, config) => {
       const state = getCurrentTaskInput3();
       if (state?.team?.teamId) {
@@ -17126,7 +17438,7 @@ function createTeamMiddleware(options) {
         });
         return msg;
       }
-      const teamId = uuidv42();
+      const teamId = uuidv43();
       const createdTasks = await taskListStore.addTasks(
         teamId,
         input.tasks.map((t) => ({
@@ -17269,20 +17581,20 @@ After calling create_team, you MUST:
 2. When messages indicate task changes, call check_tasks to get full task status
 3. Continue until all tasks show "completed" or "failed"
 4. Do NOT assume tasks are done - always verify with check_tasks`,
-      schema: z52.object({
-        tasks: z52.array(
-          z52.object({
-            id: z52.string().describe("Task ID in format task-01, task-02, etc."),
-            title: z52.string().describe("Short task title"),
-            description: z52.string().describe("Detailed task description - what exactly needs to be done"),
-            dependencies: z52.array(z52.string()).optional().default([]).describe('Array of task IDs that must complete before this task (e.g. ["task-01"])')
+      schema: z53.object({
+        tasks: z53.array(
+          z53.object({
+            id: z53.string().describe("Task ID in format task-01, task-02, etc."),
+            title: z53.string().describe("Short task title"),
+            description: z53.string().describe("Detailed task description - what exactly needs to be done"),
+            dependencies: z53.array(z53.string()).optional().default([]).describe('Array of task IDs that must complete before this task (e.g. ["task-01"])')
           })
         ).describe("List of tasks for teammates to work on. Each task needs unique ID (task-01, task-02, etc.)."),
-        teammates: z52.array(
-          z52.object({
-            name: z52.string().describe("Teammate name (must match a pre-configured teammate type)"),
-            role: z52.string().describe("Role category (e.g. researcher, writer, coder, reviewer)"),
-            description: z52.string().describe("What this teammate will focus on - specific instructions for their work")
+        teammates: z53.array(
+          z53.object({
+            name: z53.string().describe("Teammate name (must match a pre-configured teammate type)"),
+            role: z53.string().describe("Role category (e.g. researcher, writer, coder, reviewer)"),
+            description: z53.string().describe("What this teammate will focus on - specific instructions for their work")
           })
         ).describe("Teammate agents to create. Each should have a clear role and focus.")
       })
@@ -17293,7 +17605,7 @@ After calling create_team, you MUST:
     if (state?.team?.teamId) return state.team.teamId;
     throw new Error("No team_id provided and no team in state. Call create_team first.");
   };
-  const addTasksTool = tool49(
+  const addTasksTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       const created = await taskListStore.addTasks(
@@ -17345,20 +17657,20 @@ IMPORTANT: Dependencies
 
 IMPORTANT: Assigning to a specific teammate
 - When you need a particular teammate to do the work, set assignee to that teammate's name (e.g. assignee: "researcher"). They can then claim or see the task as assigned to them.`,
-      schema: z52.object({
-        tasks: z52.array(
-          z52.object({
-            id: z52.string().describe("Task ID in format task-01, task-02, etc. Must be unique."),
-            title: z52.string().describe("Short task title"),
-            description: z52.string().describe("Detailed task description - what needs to be done"),
-            assignee: z52.string().optional().describe("Teammate name to assign this task to (use when you need that person to do the work)"),
-            dependencies: z52.array(z52.string()).optional().default([]).describe("Array of task IDs that must complete before this task")
+      schema: z53.object({
+        tasks: z53.array(
+          z53.object({
+            id: z53.string().describe("Task ID in format task-01, task-02, etc. Must be unique."),
+            title: z53.string().describe("Short task title"),
+            description: z53.string().describe("Detailed task description - what needs to be done"),
+            assignee: z53.string().optional().describe("Teammate name to assign this task to (use when you need that person to do the work)"),
+            dependencies: z53.array(z53.string()).optional().default([]).describe("Array of task IDs that must complete before this task")
           })
         ).describe("New tasks to add to the team")
       })
     }
   );
-  const assignTaskTool = tool49(
+  const assignTaskTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
@@ -17380,13 +17692,13 @@ IMPORTANT: Assigning to a specific teammate
     {
       name: "assign_task",
       description: "Assign a task to a specific teammate. Use when you need to reassign work to a different teammate. Omit team_id to use the active team from state.",
-      schema: z52.object({
-        task_id: z52.string().describe("Task ID to assign"),
-        assignee: z52.string().describe("Teammate name to assign this task to")
+      schema: z53.object({
+        task_id: z53.string().describe("Task ID to assign"),
+        assignee: z53.string().describe("Teammate name to assign this task to")
       })
     }
   );
-  const setTaskStatusTool = tool49(
+  const setTaskStatusTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
@@ -17408,13 +17720,13 @@ IMPORTANT: Assigning to a specific teammate
     {
       name: "set_task_status",
       description: "Set a task's status. Use to reopen a task (set to pending), mark as failed, or correct status. Values: pending, claimed, in_progress, completed, failed. Omit team_id to use the active team from state.",
-      schema: z52.object({
-        task_id: z52.string().describe("Task ID to update"),
-        status: z52.enum(["pending", "claimed", "in_progress", "completed", "failed"]).describe("New status for the task")
+      schema: z53.object({
+        task_id: z53.string().describe("Task ID to update"),
+        status: z53.enum(["pending", "claimed", "in_progress", "completed", "failed"]).describe("New status for the task")
       })
     }
   );
-  const setTaskDependenciesTool = tool49(
+  const setTaskDependenciesTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
@@ -17436,13 +17748,13 @@ IMPORTANT: Assigning to a specific teammate
     {
       name: "set_task_dependencies",
       description: 'Set which task IDs must complete before this task can be claimed. Pass an array of task IDs (e.g. ["task-01", "task-02"]). Use to fix task order or add/remove dependencies. Omit team_id to use the active team from state.',
-      schema: z52.object({
-        task_id: z52.string().describe("Task ID to update"),
-        dependencies: z52.array(z52.string()).describe("Task IDs that must complete before this task can be claimed")
+      schema: z53.object({
+        task_id: z53.string().describe("Task ID to update"),
+        dependencies: z53.array(z53.string()).describe("Task IDs that must complete before this task can be claimed")
       })
     }
   );
-  const checkTasksTool = tool49(
+  const checkTasksTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       const tasks = await taskListStore.getAllTasks(teamId);
@@ -17482,12 +17794,12 @@ Task Status Values:
 - in_progress: Teammate is actively working on this task
 - completed: Task finished successfully
 - failed: Task encountered an error`,
-      schema: z52.object({
-        team_id: z52.string().optional().describe("Team ID (omit to use active team)")
+      schema: z53.object({
+        team_id: z53.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  const sendMessageTool = tool49(
+  const sendMessageTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.sendMessage(
@@ -17506,13 +17818,13 @@ Task Status Values:
     {
       name: "send_message",
       description: "Send a message to a specific teammate in the team. Omit team_id to use the active team from state.",
-      schema: z52.object({
-        to: z52.string().describe("Recipient teammate name"),
-        content: z52.string().describe("Message content")
+      schema: z53.object({
+        to: z53.string().describe("Recipient teammate name"),
+        content: z53.string().describe("Message content")
       })
     }
   );
-  const readMessagesTool = tool49(
+  const readMessagesTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       const formatAndMarkAsRead = async (msgs2) => {
@@ -17594,12 +17906,12 @@ Task Status Values:
     {
       name: "read_messages",
       description: "Read unread messages from teammates. Returns immediately if messages exist, otherwise waits for up to 3 minutes for new messages.",
-      schema: z52.object({
-        team_id: z52.string().optional().describe("Team ID (omit to use active team)")
+      schema: z53.object({
+        team_id: z53.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  const disbandTeamTool = tool49(
+  const disbandTeamTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -17620,7 +17932,7 @@ Task Status Values:
       description: "Disband a team when all work is done. Before calling: (1) Call check_tasks to verify no tasks are still pending/in_progress; (2) if any are, discuss with the team via read_messages and broadcast_message/send_message whether to continue or stop/cancel them; (3) only after alignment (all tasks completed/failed or explicitly stopped), then call this tool. This will: 1) Send a shutdown message to all teammates, 2) Wait briefly for them to clean up, 3) Clear all tasks and messages. Omit team_id to use the active team from state."
     }
   );
-  const broadcastMessageTool = tool49(
+  const broadcastMessageTool = tool50(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -17638,12 +17950,12 @@ Task Status Values:
     {
       name: "broadcast_message",
       description: "Send a message to all teammates at once. Use this to communicate with everyone in the team. Omit team_id to use the active team from state.",
-      schema: z52.object({
-        content: z52.string().describe("Message content to broadcast to all teammates")
+      schema: z53.object({
+        content: z53.string().describe("Message content to broadcast to all teammates")
       })
     }
   );
-  return createMiddleware17({
+  return createMiddleware18({
     name: "teamMiddleware",
     tools: [
       createTeamTool,
@@ -17671,37 +17983,37 @@ ${TEAM_SYSTEM_PROMPT}` : TEAM_SYSTEM_PROMPT;
 }
 
 // src/agent_team/agent_team.ts
-var TeammateInfoSchema = z53.object({
-  name: z53.string().describe("Teammate name"),
-  role: z53.string().describe("Role category (e.g. research, writing, review)"),
-  description: z53.string().describe("What this teammate focuses on")
+var TeammateInfoSchema = z54.object({
+  name: z54.string().describe("Teammate name"),
+  role: z54.string().describe("Role category (e.g. research, writing, review)"),
+  description: z54.string().describe("What this teammate focuses on")
 });
-var TeamTaskInfoSchema = z53.object({
-  id: z53.string(),
-  title: z53.string(),
-  description: z53.string(),
-  status: z53.string().optional()
+var TeamTaskInfoSchema = z54.object({
+  id: z54.string(),
+  title: z54.string(),
+  description: z54.string(),
+  status: z54.string().optional()
 });
-var MailboxMessageSchema = z53.object({
-  id: z53.string().describe("Unique message identifier"),
-  from: z53.string().describe("Sender agent name"),
-  to: z53.string().describe("Recipient agent name"),
-  content: z53.string().describe("Message content"),
-  timestamp: z53.string().describe("ISO timestamp when the message was sent"),
-  type: z53.nativeEnum(MessageType).describe("Message type"),
-  read: z53.boolean().describe("Whether the recipient has read this message")
+var MailboxMessageSchema = z54.object({
+  id: z54.string().describe("Unique message identifier"),
+  from: z54.string().describe("Sender agent name"),
+  to: z54.string().describe("Recipient agent name"),
+  content: z54.string().describe("Message content"),
+  timestamp: z54.string().describe("ISO timestamp when the message was sent"),
+  type: z54.nativeEnum(MessageType).describe("Message type"),
+  read: z54.boolean().describe("Whether the recipient has read this message")
 });
-var TeamInfoSchema = z53.object({
-  teamId: z53.string().describe("Unique team identifier"),
-  teamLeadId: z53.string().default("team_lead").describe("Team lead agent ID"),
-  teammates: z53.array(TeammateInfoSchema).describe("Active teammates in this team"),
-  tasks: z53.array(TeamTaskInfoSchema).optional().describe("Initial tasks snapshot"),
-  createdAt: z53.string().optional().describe("ISO timestamp when team was created")
+var TeamInfoSchema = z54.object({
+  teamId: z54.string().describe("Unique team identifier"),
+  teamLeadId: z54.string().default("team_lead").describe("Team lead agent ID"),
+  teammates: z54.array(TeammateInfoSchema).describe("Active teammates in this team"),
+  tasks: z54.array(TeamTaskInfoSchema).optional().describe("Initial tasks snapshot"),
+  createdAt: z54.string().optional().describe("ISO timestamp when team was created")
 });
-var TEAM_STATE_SCHEMA = z53.object({
+var TEAM_STATE_SCHEMA = z54.object({
   team: TeamInfoSchema.optional().describe("Team info: teamId, teamLeadId, teammates, tasks. Set when create_team succeeds."),
-  tasks: z53.array(TeamTaskInfoSchema).optional().describe("Current tasks snapshot from check_tasks. Updated on each check."),
-  team_mailbox: z53.array(MailboxMessageSchema).optional().describe("All team mailbox messages for display")
+  tasks: z54.array(TeamTaskInfoSchema).optional().describe("Current tasks snapshot from check_tasks. Updated on each check."),
+  team_mailbox: z54.array(MailboxMessageSchema).optional().describe("All team mailbox messages for display")
 });
 var TEAM_LEAD_BASE_PROMPT = `You are a team lead that coordinates a team of specialized agents. In order to complete the objective that the user asks of you, you will need to:
 
@@ -17782,7 +18094,7 @@ var TeamAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool51) => tool51 !== void 0);
+    }).filter((tool52) => tool52 !== void 0);
     const teammates = params.subAgents.map((sa) => {
       const baseConfig = sa.config;
       return {
@@ -17828,14 +18140,14 @@ import {
 } from "langchain";
 
 // src/middlewares/topologyMiddleware.ts
-import { createMiddleware as createMiddleware18 } from "langchain";
+import { createMiddleware as createMiddleware19 } from "langchain";
 import { AIMessage as AIMessage3, ToolMessage as ToolMessage9 } from "@langchain/core/messages";
-import { tool as tool50 } from "langchain";
-import { z as z54 } from "zod";
+import { tool as tool51 } from "langchain";
+import { z as z55 } from "zod";
 import { GraphInterrupt as GraphInterrupt4 } from "@langchain/langgraph";
-var CompletedEdgeSchema = z54.object({
-  to: z54.string(),
-  purpose: z54.string()
+var CompletedEdgeSchema = z55.object({
+  to: z55.string(),
+  purpose: z55.string()
 });
 function deriveCompletedEdges(messages, edges) {
   const completedToolCallIds = /* @__PURE__ */ new Set();
@@ -17862,16 +18174,16 @@ function deriveCompletedEdges(messages, edges) {
 }
 function createTopologyMiddleware(options) {
   const { edges, trackingStore } = options;
-  return createMiddleware18({
+  return createMiddleware19({
     name: "TopologyMiddleware",
-    contextSchema: z54.object({
-      runConfig: z54.any()
+    contextSchema: z55.object({
+      runConfig: z55.any()
     }),
-    stateSchema: z54.object({
-      currentAgentId: z54.string().default(""),
-      completedEdges: z54.array(CompletedEdgeSchema).default([]),
-      runId: z54.string().default(""),
-      stepIdMap: z54.record(z54.string()).default({})
+    stateSchema: z55.object({
+      currentAgentId: z55.string().default(""),
+      completedEdges: z55.array(CompletedEdgeSchema).default([]),
+      runId: z55.string().default(""),
+      stepIdMap: z55.record(z55.string()).default({})
     }),
     beforeAgent: async (state, runtime) => {
       if (state.runId) {
@@ -17922,14 +18234,14 @@ ${request.systemPrompt}` : topologyPrompt;
       return handler({ ...request, systemPrompt: newSystemPrompt });
     },
     tools: [
-      tool50(
+      tool51(
         async (_input) => {
           return "placeholder";
         },
         {
           name: "read_topo_progress",
           description: "Check the current progress of the workflow execution plan. Returns which steps have been completed and which are still pending.",
-          schema: z54.object({})
+          schema: z55.object({})
         }
       )
     ],
@@ -18205,7 +18517,7 @@ var ProcessingAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool51) => tool51 !== void 0);
+    }).filter((tool52) => tool52 !== void 0);
     const subagents = await Promise.all(params.subAgents.map(async (sa) => {
       if (sa.client) {
         return {
@@ -18483,24 +18795,24 @@ var WorkflowAgentGraphBuilder = class {
       );
     }
     const config = agentLattice.config;
-    const dsl = config.workflow;
+    const yaml = config.workflowYaml;
     const tenantId = agentLattice.config.tenantId ?? "default";
     const checkpointer = getCheckpointSaver("default");
     const tools = params.tools.map((t) => t.executor).filter(Boolean);
     const middlewareConfigs = params.middleware || [];
     const middlewares = await createCommonMiddlewares(middlewareConfigs, void 0, false);
-    const humanMiddlewares = await createCommonMiddlewares([
+    const askMiddlewares = await createCommonMiddlewares([
       {
         id: "ask_user_to_clarify",
         type: "ask_user_to_clarify",
         name: "Ask User Clarify",
-        description: "For human_feedback workflow nodes",
+        description: "For workflow steps requiring user interaction",
         enabled: true,
         config: {}
       }
     ], void 0, false);
     const noWrapMiddlewares = middlewares.filter((m) => !m.wrapModelCall);
-    const noWrapHumanMiddlewares = humanMiddlewares.filter((m) => !m.wrapModelCall);
+    const noWrapAskMiddlewares = askMiddlewares.filter((m) => !m.wrapModelCall);
     console.log(`[WF BUILDER] building default agent | toolCount=${tools.length} | middlewareCount=${middlewares.length}`);
     const defaultAgent = createAgent7({
       model: params.model,
@@ -18516,34 +18828,34 @@ var WorkflowAgentGraphBuilder = class {
         console.log(`[WF BUILDER] resolveAgent: looking up ref="${ref}"`);
         return await getAgentClientAsync(tenantId, ref);
       }
-      const isHuman = stepType === "human_feedback";
+      const isAsk = stepType === "ask";
       if (responseFormat) {
-        const key = (isHuman ? "human:" : "agent:") + JSON.stringify(responseFormat);
+        const key = (isAsk ? "ask:" : "agent:") + JSON.stringify(responseFormat);
         console.log(`[WF BUILDER] resolveAgent: cacheKey=${key.slice(0, 80)}... | cached=${agentCache.has(key)}`);
         if (!agentCache.has(key)) {
-          console.log(`[WF BUILDER] creating ${isHuman ? "human" : "agent"} with responseFormat`);
+          console.log(`[WF BUILDER] creating ${isAsk ? "ask" : "agent"} with responseFormat`);
           const agent = createAgent7({
             model: params.model,
             tools,
             systemPrompt: params.prompt || DEFAULT_AGENT_PROMPT,
             checkpointer,
-            middleware: isHuman ? noWrapHumanMiddlewares : noWrapMiddlewares,
+            middleware: isAsk ? noWrapAskMiddlewares : noWrapMiddlewares,
             responseFormat
           });
           agentCache.set(key, agent);
         }
         return agentCache.get(key);
       }
-      if (isHuman) {
-        const key = "human:default";
+      if (isAsk) {
+        const key = "ask:default";
         if (!agentCache.has(key)) {
-          console.log(`[WF BUILDER] creating human_feedback default agent`);
+          console.log(`[WF BUILDER] creating ask default agent`);
           const agent = createAgent7({
             model: params.model,
             tools,
             systemPrompt: params.prompt || DEFAULT_AGENT_PROMPT,
             checkpointer,
-            middleware: humanMiddlewares
+            middleware: askMiddlewares
           });
           agentCache.set(key, agent);
         }
@@ -18556,11 +18868,11 @@ var WorkflowAgentGraphBuilder = class {
     try {
       const storeLattice = getStoreLattice("default", "workflowTracking");
       trackingStore = storeLattice.store;
-      console.log(`[WF BUILDER] trackingStore registered: step input/output will be persisted`);
+      console.log(`[WF BUILDER] trackingStore registered`);
     } catch {
-      console.warn(`[WF BUILDER] no trackingStore registered \u2014 step input/output will NOT be persisted. Register a WorkflowTrackingStore under key "workflowTracking".`);
+      console.warn(`[WF BUILDER] no trackingStore registered`);
     }
-    const graph = compileWorkflow(dsl, resolveAgent, checkpointer, trackingStore);
+    const graph = compileWorkflow(yaml, resolveAgent, checkpointer, trackingStore);
     return graph;
   }
 };
@@ -19265,8 +19577,65 @@ ${body}` : `${frontmatter}
   }
 };
 
+// src/store_lattice/InMemoryMenuStore.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var InMemoryMenuStore = class {
+  constructor() {
+    this.items = /* @__PURE__ */ new Map();
+  }
+  async list(params) {
+    const results = Array.from(this.items.values()).filter((item) => {
+      if (item.tenantId !== params.tenantId) return false;
+      if (params.menuTarget && item.menuTarget !== params.menuTarget) return false;
+      if (!item.enabled) return false;
+      return true;
+    });
+    results.sort((a, b) => a.sortOrder - b.sortOrder);
+    return results;
+  }
+  async getById(id) {
+    return this.items.get(id) || null;
+  }
+  async create(input) {
+    const now = /* @__PURE__ */ new Date();
+    const item = {
+      id: randomUUID3(),
+      tenantId: input.tenantId,
+      menuTarget: input.menuTarget,
+      group: input.group,
+      name: input.name,
+      icon: input.icon,
+      sortOrder: input.sortOrder ?? 0,
+      contentType: input.contentType,
+      contentConfig: input.contentConfig,
+      enabled: true,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.items.set(item.id, item);
+    return item;
+  }
+  async update(id, patch) {
+    const existing = this.items.get(id);
+    if (!existing) throw new Error(`MenuItem ${id} not found`);
+    const updated = {
+      ...existing,
+      ...patch,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.items.set(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    this.items.delete(id);
+  }
+  clear() {
+    this.items.clear();
+  }
+};
+
 // src/agent_lattice/agentArchitectTools.ts
-import z55 from "zod";
+import z56 from "zod";
 import { v4 as v43 } from "uuid";
 import { AgentType as AgentType3 } from "@axiom-lattice/protocols";
 function getTenantId(exeConfig) {
@@ -19296,7 +19665,7 @@ registerToolLattice(
   {
     name: "list_agents",
     description: "List all agents for the current workspace. Returns a summary with id, name, description, and type for each agent.",
-    schema: z55.object({})
+    schema: z56.object({})
   },
   async (_input, exeConfig) => {
     try {
@@ -19323,8 +19692,8 @@ registerToolLattice(
   {
     name: "get_agent",
     description: "Get the full configuration of a specific agent by its ID. Returns the complete AgentConfig including prompt, middleware, tools, and sub-agents.",
-    schema: z55.object({
-      id: z55.string().describe("The agent ID to retrieve")
+    schema: z56.object({
+      id: z56.string().describe("The agent ID to retrieve")
     })
   },
   async (input, exeConfig) => {
@@ -19341,24 +19710,24 @@ registerToolLattice(
     }
   }
 );
-var middlewareConfigSchema = z55.object({
-  id: z55.string(),
-  type: z55.string(),
-  name: z55.string(),
-  description: z55.string(),
-  enabled: z55.boolean(),
-  config: z55.record(z55.any()).optional()
+var middlewareConfigSchema = z56.object({
+  id: z56.string(),
+  type: z56.string(),
+  name: z56.string(),
+  description: z56.string(),
+  enabled: z56.boolean(),
+  config: z56.record(z56.any()).optional()
 });
-var createAgentSchema = z55.object({
-  name: z55.string().describe("Human-friendly display name for the agent. The machine ID (used in other tools) is auto-generated as a slug from this name (e.g. 'My Cool Agent' \u2192 'my-cool-agent')."),
-  description: z55.string().optional().describe("Short description"),
-  type: z55.enum(["react", "deep_agent"]).describe("Agent type. Use 'react' for simple single-responsibility agents, 'deep_agent' for complex open-ended agents. For PROCESSING agents (workflow orchestration), use create_processing_agent instead."),
-  prompt: z55.string().describe("System prompt for the agent"),
-  tools: z55.array(z55.string()).optional().describe("Tool keys (strings) to assign. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array of tool names. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
-  middleware: z55.array(middlewareConfigSchema).optional().describe("Middleware configuration objects. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here \u2014 tool names go in the separate 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
-  subAgents: z55.array(z55.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
-  internalSubAgents: z55.array(z55.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
-  modelKey: z55.string().optional().describe("Model key to use")
+var createAgentSchema = z56.object({
+  name: z56.string().describe("Human-friendly display name for the agent. The machine ID (used in other tools) is auto-generated as a slug from this name (e.g. 'My Cool Agent' \u2192 'my-cool-agent')."),
+  description: z56.string().optional().describe("Short description"),
+  type: z56.enum(["react", "deep_agent"]).describe("Agent type. Use 'react' for simple single-responsibility agents, 'deep_agent' for complex open-ended agents. For PROCESSING agents (workflow orchestration), use create_processing_agent instead."),
+  prompt: z56.string().describe("System prompt for the agent"),
+  tools: z56.array(z56.string()).optional().describe("Tool keys (strings) to assign. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array of tool names. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
+  middleware: z56.array(middlewareConfigSchema).optional().describe("Middleware configuration objects. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here \u2014 tool names go in the separate 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  subAgents: z56.array(z56.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+  internalSubAgents: z56.array(z56.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+  modelKey: z56.string().optional().describe("Model key to use")
 });
 registerToolLattice(
   "create_agent",
@@ -19396,21 +19765,21 @@ registerToolLattice(
     }
   }
 );
-var topologyEdgeSchema = z55.object({
-  from: z55.string().describe("Source agent ID. For the first edge, this is the orchestrator (use the orchestrator's name as a placeholder \u2014 the tool will replace it with the actual ID). For subsequent chained edges, this is the previous stage's sub-agent ID."),
-  to: z55.string().describe("Target agent ID (the sub-agent to delegate to)"),
-  purpose: z55.string().describe("Business purpose of this delegation step \u2014 what the sub-agent should accomplish")
+var topologyEdgeSchema = z56.object({
+  from: z56.string().describe("Source agent ID. For the first edge, this is the orchestrator (use the orchestrator's name as a placeholder \u2014 the tool will replace it with the actual ID). For subsequent chained edges, this is the previous stage's sub-agent ID."),
+  to: z56.string().describe("Target agent ID (the sub-agent to delegate to)"),
+  purpose: z56.string().describe("Business purpose of this delegation step \u2014 what the sub-agent should accomplish")
 });
-var createProcessingAgentSchema = z55.object({
-  name: z55.string().describe("Display name for the processing agent"),
-  description: z55.string().optional().describe("Short description"),
-  prompt: z55.string().describe("System prompt for the orchestrator. Should describe how to route tasks through the topology."),
-  edges: z55.array(topologyEdgeSchema).min(1).describe("Topology edges defining the workflow. Each edge describes a delegation step with its business purpose. The orchestrator will follow this topology to delegate tasks to sub-agents."),
-  tools: z55.array(z55.string()).optional().describe("Tool keys (strings) to assign to the orchestrator. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
-  subAgents: z55.array(z55.string()).describe("IDs of sub-agents that form the workflow pipeline. These must be created first via create_agent."),
-  internalSubAgents: z55.array(z55.any()).optional().describe("Inline sub-agent configs (alternative to pre-created sub-agents)"),
-  middleware: z55.array(middlewareConfigSchema).optional().describe("Additional middleware config objects beyond the auto-managed topology middleware. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
-  modelKey: z55.string().optional().describe("Model key to use")
+var createProcessingAgentSchema = z56.object({
+  name: z56.string().describe("Display name for the processing agent"),
+  description: z56.string().optional().describe("Short description"),
+  prompt: z56.string().describe("System prompt for the orchestrator. Should describe how to route tasks through the topology."),
+  edges: z56.array(topologyEdgeSchema).min(1).describe("Topology edges defining the workflow. Each edge describes a delegation step with its business purpose. The orchestrator will follow this topology to delegate tasks to sub-agents."),
+  tools: z56.array(z56.string()).optional().describe("Tool keys (strings) to assign to the orchestrator. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
+  subAgents: z56.array(z56.string()).describe("IDs of sub-agents that form the workflow pipeline. These must be created first via create_agent."),
+  internalSubAgents: z56.array(z56.any()).optional().describe("Inline sub-agent configs (alternative to pre-created sub-agents)"),
+  middleware: z56.array(middlewareConfigSchema).optional().describe("Additional middleware config objects beyond the auto-managed topology middleware. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  modelKey: z56.string().optional().describe("Model key to use")
 }).refine(
   (data) => {
     const edgeTargets = new Set(data.edges.map((e) => e.to));
@@ -19492,34 +19861,20 @@ registerToolLattice(
     }
   }
 );
-var workflowStepLazy = z55.lazy(
-  () => z55.discriminatedUnion("type", [
-    z55.object({ type: z55.literal("agent").optional(), id: z55.string().optional(), name: z55.string().optional(), prompt: z55.string(), schema: z55.record(z55.any()) }),
-    z55.object({ type: z55.literal("human"), id: z55.string().optional(), prompt: z55.string(), title: z55.string().optional(), schema: z55.union([z55.boolean(), z55.record(z55.any())]).optional() }),
-    z55.object({ type: z55.literal("condition"), id: z55.string().optional(), if: z55.string().refine((v) => !v.includes("{{"), { message: 'The `if` field takes a plain state field name or JavaScript expression (e.g. "intent", "score >= 60"). Do NOT use {{}} template markers \u2014 those are only for `prompt` fields.' }), then: z55.union([z55.lazy(() => workflowStepLazy), z55.array(z55.lazy(() => workflowStepLazy))]).optional(), else: z55.union([z55.lazy(() => workflowStepLazy), z55.array(z55.lazy(() => workflowStepLazy))]).optional(), branches: z55.record(z55.union([z55.lazy(() => workflowStepLazy), z55.array(z55.lazy(() => workflowStepLazy))])).optional() }),
-    z55.object({ type: z55.literal("map"), id: z55.string(), source: z55.string(), each: z55.object({ prompt: z55.string(), schema: z55.record(z55.any()) }), reduce: z55.object({ prompt: z55.string(), schema: z55.record(z55.any()) }).optional(), batch: z55.number().int().min(1).optional(), concurrency: z55.number().int().min(1).optional() }),
-    z55.object({ type: z55.literal("parallel"), id: z55.string().optional(), steps: z55.array(z55.lazy(() => workflowStepLazy)) }),
-    z55.object({ type: z55.literal("end"), status: z55.enum(["success", "failed"]).optional() })
-  ])
-);
-var workflowDSLSchema = z55.object({
-  name: z55.string().describe("Workflow identifier (kebab-case slug)"),
-  steps: z55.array(workflowStepLazy).min(1).describe("Workflow steps. Edges and state fields are auto-generated. Use {{id}} to reference step outputs. Always end with { type: 'end' }.")
-});
-var createWorkflowSchema = z55.object({
-  name: z55.string().describe("Display name for the workflow agent"),
-  description: z55.string().optional().describe("Short description of what this workflow does"),
-  skillLoaded: z55.literal(true).describe("MUST be true. Set this to true ONLY after loading the 'create-workflow' skill via skill(skill_name: 'create-workflow'). This confirms you have read the DSL specification and design guidelines."),
-  workflow: workflowDSLSchema.describe("The concise Workflow DSL definition. Each step has a type (agent/human/condition/map/parallel/end) and a prompt. Edges are auto-generated from step order. Use {{id}} to reference upstream step outputs."),
-  tools: z55.array(z55.string()).optional().describe("Tool keys for the workflow's built-in general agent"),
-  middleware: z55.array(middlewareConfigSchema).optional().describe("Middleware configs for the workflow's general agent"),
-  modelKey: z55.string().optional().describe("Model key for the workflow's general agent")
+var createWorkflowSchema = z56.object({
+  name: z56.string().describe("Display name for the workflow agent"),
+  description: z56.string().optional().describe("Short description"),
+  skillLoaded: z56.literal(true).describe("MUST be true. Set after loading the 'create-workflow' skill."),
+  yaml: z56.string().describe("The YAML workflow definition in linear DSL format (steps execute top-to-bottom, use parallel: for concurrency)"),
+  tools: z56.array(z56.string()).optional().describe("Tool keys for the workflow agent"),
+  middleware: z56.array(middlewareConfigSchema).optional().describe("Middleware configs"),
+  modelKey: z56.string().optional().describe("Model key")
 });
 registerToolLattice(
   "create_workflow",
   {
     name: "create_workflow",
-    description: `Create a WORKFLOW agent from a concise DSL. IMPORTANT: Load the 'create-workflow' skill first, then set skillLoaded=true. Steps are defined in order \u2014 the engine auto-generates edges and state fields. Types: agent(id?, name?, prompt, schema), human(prompt, title?, schema?), condition(if, then, else?  OR  if, branches with 'default' catch-all), map(source, each, reduce?), parallel(steps), end. Use {{id}} to reference step outputs, {{input}} for user message, {{item}} in map each prompts. Always end with { type: 'end' }. CRITICAL: schema MUST be standard JSON Schema: { "type": "object", "properties": { ... } }. Legacy shorthand { "field": "string" } is REJECTED.`,
+    description: "Create a WORKFLOW agent from YAML DSL. Load the 'create-workflow' skill first. Linear model \u2014 steps execute top-to-bottom. Use parallel: for concurrency. Data flows via {{label}} automatically. Business logic stays in agent prompts.",
     schema: createWorkflowSchema
   },
   async (input, exeConfig) => {
@@ -19527,36 +19882,31 @@ registerToolLattice(
       const tenantId = getTenantId(exeConfig);
       const store = getAssistStore();
       const id = await generateAgentId(tenantId, input.name);
+      try {
+        const { compileWorkflow: compileWorkflow2 } = await import("./compile-4RFYHUBE.mjs");
+        const { getCheckpointSaver: getCheckpointSaver2 } = await import("./memory_lattice-E66HTTVV.mjs");
+        await compileWorkflow2(input.yaml, async () => ({ invoke: async () => ({}) }), getCheckpointSaver2("default"));
+      } catch (e) {
+        return JSON.stringify({ error: `DSL validation failed: ${e.message}` });
+      }
       const config = {
         key: id,
         name: input.name,
         description: input.description || "",
         type: AgentType3.WORKFLOW,
         prompt: input.description || `Workflow: ${input.name}`,
-        workflow: input.workflow,
+        workflowYaml: input.yaml,
         ...input.tools && input.tools.length > 0 ? { tools: input.tools } : {},
         ...input.middleware && input.middleware.length > 0 ? { middleware: input.middleware } : {},
         ...input.modelKey ? { modelKey: input.modelKey } : {}
       };
-      try {
-        const { compileWorkflow: compileWorkflow2 } = await import("./compile-SYSKVQHB.mjs");
-        const { getCheckpointSaver: getCheckpointSaver2 } = await import("./memory_lattice-E66HTTVV.mjs");
-        await compileWorkflow2(input.workflow, async () => ({ invoke: async () => ({}) }), getCheckpointSaver2("default"));
-      } catch (e) {
-        return JSON.stringify({ error: `DSL validation failed: ${e.message}`, issues: [{ type: "error", message: e.message }] });
-      }
       await store.createAssistant(tenantId, id, {
         name: input.name,
         description: input.description,
         graphDefinition: config
       });
       eventBus.publish("assistant:created", { id, name: input.name, tenantId });
-      return JSON.stringify({
-        id,
-        name: input.name,
-        type: "workflow",
-        stepCount: input.workflow.steps.length
-      });
+      return JSON.stringify({ id, name: input.name, type: "workflow" });
     } catch (error) {
       return JSON.stringify({ error: `Failed to create workflow: ${error.message}` });
     }
@@ -19566,9 +19916,9 @@ registerToolLattice(
   "validate_workflow",
   {
     name: "validate_workflow",
-    description: "Validate a workflow agent's DSL for correctness by compiling it. Returns errors if the DSL is invalid. Use after create_workflow or update_workflow to verify.",
-    schema: z55.object({
-      id: z55.string().describe("The workflow agent ID to validate")
+    description: "Validate a workflow agent's DSL for correctness by compiling it.",
+    schema: z56.object({
+      id: z56.string().describe("The workflow agent ID to validate")
     })
   },
   async (input, exeConfig) => {
@@ -19581,76 +19931,76 @@ registerToolLattice(
       }
       const graphDef = agent.graphDefinition;
       if (!graphDef || graphDef.type !== AgentType3.WORKFLOW) {
-        return JSON.stringify({ error: `Agent '${input.id}' is not a workflow agent (type: ${graphDef?.type ?? "unknown"})` });
+        return JSON.stringify({ error: `Agent '${input.id}' is not a workflow agent` });
       }
-      const workflow = graphDef.workflow;
-      if (!workflow || !workflow.steps) {
-        return JSON.stringify({ error: `Agent '${input.id}' has no valid workflow DSL` });
+      const yaml = graphDef.workflowYaml;
+      if (!yaml) {
+        return JSON.stringify({ error: `Agent '${input.id}' has no workflow DSL` });
       }
       try {
-        const { compileWorkflow: compileWorkflow2 } = await import("./compile-SYSKVQHB.mjs");
+        const { compileWorkflow: compileWorkflow2 } = await import("./compile-4RFYHUBE.mjs");
         const { getCheckpointSaver: getCheckpointSaver2 } = await import("./memory_lattice-E66HTTVV.mjs");
-        await compileWorkflow2(workflow, async () => ({ invoke: async () => ({}) }), getCheckpointSaver2("default"));
+        await compileWorkflow2(yaml, async () => ({ invoke: async () => ({}) }), getCheckpointSaver2("default"));
       } catch (e) {
         return JSON.stringify({
           agentId: input.id,
           valid: false,
-          stepCount: workflow.steps?.length ?? 0,
           issues: [{ type: "error", message: e.message }]
         });
       }
-      return JSON.stringify({
-        agentId: input.id,
-        valid: true,
-        stepCount: workflow.steps?.length ?? 0,
-        issues: []
-      });
+      return JSON.stringify({ agentId: input.id, valid: true, issues: [] });
     } catch (error) {
       return JSON.stringify({ error: `Failed to validate workflow: ${error.message}` });
     }
   }
 );
-var updateWorkflowSchema = z55.object({
-  id: z55.string().describe("The workflow agent ID to update"),
-  name: z55.string().optional().describe("New display name"),
-  description: z55.string().optional().describe("New description"),
-  workflow: workflowDSLSchema.optional().describe("Replacement Workflow DSL definition. Omit to keep the existing."),
-  tools: z55.array(z55.string()).optional().describe("Replacement tool keys for the general agent"),
-  middleware: z55.array(middlewareConfigSchema).optional().describe("Replacement middleware configs"),
-  modelKey: z55.string().optional().describe("Replacement model key")
+var updateWorkflowSchema = z56.object({
+  id: z56.string().describe("The workflow agent ID to update"),
+  name: z56.string().optional().describe("New display name"),
+  description: z56.string().optional().describe("New description"),
+  yaml: z56.string().optional().describe("Replacement YAML workflow DSL. Omit to keep existing."),
+  tools: z56.array(z56.string()).optional().describe("Replacement tool keys"),
+  middleware: z56.array(middlewareConfigSchema).optional().describe("Replacement middleware configs"),
+  modelKey: z56.string().optional().describe("Replacement model key")
 });
 registerToolLattice(
   "update_workflow",
   {
     name: "update_workflow",
-    description: "Update an existing workflow agent. Provide the agent ID and only the fields you want to change. To replace the entire DSL, pass a new workflow object. To keep the DSL and only update config (tools, middleware, modelKey), omit the workflow field. Use validate_workflow after updating to check for issues.",
+    description: "Update an existing workflow agent. Provide the agent ID and only the fields to change. Pass yaml string to replace the DSL, or omit to keep it.",
     schema: updateWorkflowSchema
   },
   async (input, exeConfig) => {
+    console.log(`[update_workflow] CALLED id=${input.id} hasYaml=${input.yaml !== void 0}`);
     try {
       const tenantId = getTenantId(exeConfig);
       const store = getAssistStore();
       const existing = await store.getAssistantById(tenantId, input.id);
       if (!existing) {
+        console.log(`[update_workflow] ERROR: agent not found: ${input.id}`);
         return JSON.stringify({ error: `Agent '${input.id}' not found` });
       }
       const existingConfig = existing.graphDefinition || {};
       if (existingConfig.type !== AgentType3.WORKFLOW) {
+        console.log(`[update_workflow] ERROR: not a workflow agent: ${input.id}`);
         return JSON.stringify({ error: `Agent '${input.id}' is not a workflow agent` });
       }
       const mergedConfig = { ...existingConfig };
       if (input.name !== void 0) mergedConfig.name = input.name;
       if (input.description !== void 0) mergedConfig.description = input.description;
-      if (input.workflow !== void 0) mergedConfig.workflow = input.workflow;
+      if (input.yaml !== void 0) mergedConfig.workflowYaml = input.yaml;
       if (input.tools !== void 0) mergedConfig.tools = input.tools;
       if (input.middleware !== void 0) mergedConfig.middleware = input.middleware;
       if (input.modelKey !== void 0) mergedConfig.modelKey = input.modelKey;
-      if (input.workflow !== void 0) {
+      if (input.yaml !== void 0) {
+        console.log(`[update_workflow] validating DSL: ${input.id}`);
         try {
-          const { compileWorkflow: compileWorkflow2 } = await import("./compile-SYSKVQHB.mjs");
+          const { compileWorkflow: compileWorkflow2 } = await import("./compile-4RFYHUBE.mjs");
           const { getCheckpointSaver: getCheckpointSaver2 } = await import("./memory_lattice-E66HTTVV.mjs");
-          await compileWorkflow2(input.workflow, async () => ({ invoke: async () => ({}) }), getCheckpointSaver2("default"));
+          await compileWorkflow2(input.yaml, async () => ({ invoke: async () => ({}) }), getCheckpointSaver2("default"));
+          console.log(`[update_workflow] DSL validation passed: ${input.id}`);
         } catch (e) {
+          console.log(`[update_workflow] DSL validation FAILED: ${input.id} - ${e.message}`);
           return JSON.stringify({
             error: `DSL validation failed: ${e.message}`,
             issues: [{ type: "error", message: e.message }]
@@ -19664,28 +20014,24 @@ registerToolLattice(
         graphDefinition: mergedConfig
       });
       eventBus.publish("assistant:updated", { id: input.id, name: newName, tenantId });
-      const workflow = mergedConfig.workflow;
-      return JSON.stringify({
-        id: input.id,
-        name: newName,
-        type: "workflow",
-        stepCount: workflow?.steps?.length ?? 0
-      });
+      console.log(`[update_workflow] SUCCESS: id=${input.id} name=${newName}`);
+      return JSON.stringify({ id: input.id, name: newName, type: "workflow" });
     } catch (error) {
+      console.log(`[update_workflow] EXCEPTION: ${error.message}`);
       return JSON.stringify({ error: `Failed to update workflow: ${error.message}` });
     }
   }
 );
-var updateProcessingAgentSchema = z55.object({
-  id: z55.string().describe("The PROCESSING agent ID to update"),
-  name: z55.string().optional().describe("New display name for the orchestrator"),
-  description: z55.string().optional().describe("New short description"),
-  prompt: z55.string().optional().describe("New system prompt for the orchestrator"),
-  edges: z55.array(topologyEdgeSchema).min(1).optional().describe("New topology edges. First edge's from must reference the orchestrator by name (the tool replaces it). Subsequent edges chain from previous sub-agent IDs."),
-  tools: z55.array(z55.string()).optional().describe("Tool keys (strings) to assign to the orchestrator. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array \u2014 do NOT put middleware-like objects here."),
-  subAgents: z55.array(z55.string()).optional().describe("New IDs of sub-agents in the workflow pipeline"),
-  middleware: z55.array(middlewareConfigSchema).optional().describe("Additional middleware config objects (topology middleware is auto-managed, do not include it). Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
-  modelKey: z55.string().optional().describe("New model key")
+var updateProcessingAgentSchema = z56.object({
+  id: z56.string().describe("The PROCESSING agent ID to update"),
+  name: z56.string().optional().describe("New display name for the orchestrator"),
+  description: z56.string().optional().describe("New short description"),
+  prompt: z56.string().optional().describe("New system prompt for the orchestrator"),
+  edges: z56.array(topologyEdgeSchema).min(1).optional().describe("New topology edges. First edge's from must reference the orchestrator by name (the tool replaces it). Subsequent edges chain from previous sub-agent IDs."),
+  tools: z56.array(z56.string()).optional().describe("Tool keys (strings) to assign to the orchestrator. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array \u2014 do NOT put middleware-like objects here."),
+  subAgents: z56.array(z56.string()).optional().describe("New IDs of sub-agents in the workflow pipeline"),
+  middleware: z56.array(middlewareConfigSchema).optional().describe("Additional middleware config objects (topology middleware is auto-managed, do not include it). Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  modelKey: z56.string().optional().describe("New model key")
 }).refine(
   (data) => {
     if (!data.edges) return true;
@@ -19813,18 +20159,18 @@ registerToolLattice(
     }
   }
 );
-var updateAgentSchema = z55.object({
-  id: z55.string().describe("The agent ID to update"),
-  config: z55.object({
-    name: z55.string().optional().describe("New display name for the agent"),
-    description: z55.string().optional().describe("New short description"),
-    type: z55.enum(["react", "deep_agent"]).optional().describe("Agent type"),
-    prompt: z55.string().optional().describe("New system prompt for the agent"),
-    tools: z55.array(z55.string()).optional().describe("Tool keys to assign to this agent. These are registered tool names (strings), NOT middleware objects."),
-    middleware: z55.array(middlewareConfigSchema).optional().describe("Middleware configurations. NOTE: middleware objects have type/name/description/enabled/config fields and are NOT the same as tools. Tool keys go in the 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
-    subAgents: z55.array(z55.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
-    internalSubAgents: z55.array(z55.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
-    modelKey: z55.string().optional().describe("Model key to use")
+var updateAgentSchema = z56.object({
+  id: z56.string().describe("The agent ID to update"),
+  config: z56.object({
+    name: z56.string().optional().describe("New display name for the agent"),
+    description: z56.string().optional().describe("New short description"),
+    type: z56.enum(["react", "deep_agent"]).optional().describe("Agent type"),
+    prompt: z56.string().optional().describe("New system prompt for the agent"),
+    tools: z56.array(z56.string()).optional().describe("Tool keys to assign to this agent. These are registered tool names (strings), NOT middleware objects."),
+    middleware: z56.array(middlewareConfigSchema).optional().describe("Middleware configurations. NOTE: middleware objects have type/name/description/enabled/config fields and are NOT the same as tools. Tool keys go in the 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+    subAgents: z56.array(z56.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+    internalSubAgents: z56.array(z56.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+    modelKey: z56.string().optional().describe("Model key to use")
   }).describe("Configuration fields to update. Only include the fields you want to change.")
 });
 registerToolLattice(
@@ -19862,8 +20208,8 @@ registerToolLattice(
   {
     name: "delete_agent",
     description: "Permanently delete an agent by its ID. This action cannot be undone.",
-    schema: z55.object({
-      id: z55.string().describe("The agent ID to delete")
+    schema: z56.object({
+      id: z56.string().describe("The agent ID to delete")
     })
   },
   async (input, exeConfig) => {
@@ -19889,7 +20235,7 @@ registerToolLattice(
   {
     name: "list_tools",
     description: "List all available tools that can be assigned to agents. Returns each tool's name (use this string value in the 'tools' array), description, and whether it requires user approval. The tool names from this list are what you pass as strings in the 'tools' field of create_agent or update_agent.",
-    schema: z55.object({})
+    schema: z56.object({})
   },
   async (_input, _exeConfig) => {
     try {
@@ -19911,9 +20257,9 @@ registerToolLattice(
   {
     name: "invoke_agent",
     description: "Invoke an agent with a test message and return its response. Use this to verify an agent works correctly after creating or modifying it. The agent must be compiled (already created and valid).",
-    schema: z55.object({
-      id: z55.string().describe("The agent ID to invoke"),
-      message: z55.string().describe("The test message to send to the agent")
+    schema: z56.object({
+      id: z56.string().describe("The agent ID to invoke"),
+      message: z56.string().describe("The test message to send to the agent")
     })
   },
   async (input, exeConfig) => {
@@ -19931,7 +20277,7 @@ registerToolLattice(
         assistant_id: id,
         thread_id: threadId
       });
-      const result = await agent.invoke({ input: { message } });
+      const result = await agent.invokeWithState({ input: { message } });
       return JSON.stringify({ agentId: id, threadId, result });
     } catch (error) {
       console.error(`[invoke_agent] FAILED for agent="${input.id}":`, error.stack || error.message);
@@ -20026,7 +20372,7 @@ Let the \`show_widget\` tool handle rendering details \u2014 it has its own guid
 | Type | Best for | Execution Model |
 |------|----------|----------------|
 | **react** | Simple, single-responsibility tasks | Classic ReAct loop (think \u2192 act \u2192 observe) |
-| **workflow** | Deterministic multi-step pipelines with branching, parallel, and human-in-the-loop | Concise DSL compiled into LangGraph state machine |
+| **workflow** | Deterministic multi-step pipelines with branching, parallel, and human-in-the-loop | YAML linear DSL compiled into LangGraph state machine |
 | **deep_agent** | Complex, open-ended tasks requiring dynamic decomposition | Self-generating dynamic todos: agent analyzes the task and creates its own execution plan at runtime |
 
 When a user is unsure which type to choose, use \`show_widget\` to render a visual comparison \u2014 show each type's execution model side-by-side as an interactive diagram so the user can intuitively understand the differences.
@@ -20080,7 +20426,7 @@ Use this when the process is fully known. A workflow is a deterministic LangGrap
 |---|---|
 | Fixed graph \u2014 all paths pre-defined | LLM-driven runtime routing |
 | Conditional branching via \`if\` field | Topology-constrained delegation |
-| human, map, parallel, condition | Single orchestrator delegates linearly |
+| needs + if model (YAML DSL) | Single orchestrator delegates linearly |
 | No LLM routing decisions | Orchestrator uses LLM to route |
 
 ### Phase 0: Load the Skill
@@ -20094,20 +20440,23 @@ skill(skill_name: "create-workflow")
 ### Phase 1: Design
 
 1. **Analyze the process.** Map every step, branch, data dependency.
-2. **Choose step types:**
-    - \`agent\` \u2014 runs on the workflow's built-in agent. Output at \`state.<id>\`.
-    - \`human\` \u2014 pauses for human input (built-in clarify middleware). Has \`prompt\`, \`title\`, \`schema\`.
-    - \`condition\` \u2014 branches on \`if\` (field or expression). Has \`then\`/\`else\` or \`branches\` (switch with \`default\`).
-   - \`map\` \u2014 iterates array from \`source\`, applies \`each\`, optionally \`reduce\`.
-   - \`parallel\` \u2014 runs \`steps\` simultaneously, then rejoins.
-   - \`end\` \u2014 terminates. Always required at end.
-3. **Write prompts** with \`{{id}}\` refs. \`{{input}}\` = user message. \`{{item}}\` = map element.
-4. **No edges or state fields needed** \u2014 the engine auto-generates them.
+2. **Design using the YAML linear DSL.** Every step is an agent with optional attributes:
+    - **Linear** \u2014 steps execute top-to-bottom in written order.
+    - \`parallel:\` \u2014 wraps agent steps that run concurrently.
+    - \`if\` \u2014 JS expression for conditional execution. Step runs only when truthy. Omit to always run.
+    - \`prompt\` \u2014 agent instruction with \`{{label}}\` refs. \`{{input}}\` = user message.
+    - \`output\` \u2014 shorthand schema: \`{ field: type }\`.
+    - \`ask: true\` \u2014 injects ask_user_to_clarify middleware for human interaction.
+3. **Special step types:**
+    - \`map\` \u2014 iterates array from \`source\`, applies \`each\` step per item.
+4. **No edges, state fields, or end step needed** \u2014 the engine auto-generates them.
+5. **Schema format:** Use block-style YAML shorthand \`{ field: type }\`. Supported types: \`string\`, \`number\`, \`boolean\`, \`string[]\`, \`number[]\`, \`boolean[]\`, nested objects, object arrays.
 
 ### Phase 2: Confirm
 
 Present the design. Ask: "Ready to create this workflow?"
 
+
 ### Phase 3: Build
 
 Call \`create_workflow\` with \`skillLoaded: true\`. Then \`validate_workflow(id)\`.
@@ -20202,20 +20551,17 @@ All fields except name, type, and prompt are optional.
 
 ### create_workflow (WORKFLOW)
 
-Creates a WORKFLOW agent from a concise DSL. Before calling, load the \`create-workflow\` skill for the complete DSL specification. Must pass \`skillLoaded: true\`.
+Creates a WORKFLOW agent from a YAML linear DSL. Before calling, load the \`create-workflow\` skill. Must pass \`skillLoaded: true\`.
 
 \`\`\`typescript
 {
   name: string,              // Required. Display name
-  description?: string,      // Optional. Short description
-  skillLoaded: true,         // Required. Must be true \u2014 confirms skill was loaded
-  workflow: {                // Required. Concise DSL definition
-    name: string,            // Workflow slug identifier
-    steps: WorkflowStep[],   // agent | human | condition | map | parallel | end
-  },
-  tools?: string[],          // Optional. Tool keys for the built-in general agent
-  middleware?: MiddlewareConfig[],  // Optional. Middleware for the general agent
-  modelKey?: string,         // Optional. Model for the general agent
+  description?: string,      // Optional
+  skillLoaded: true,         // Required \u2014 confirms skill was loaded
+  yaml: string,              // Required. YAML workflow in linear DSL format
+  tools?: string[],          // Optional. Tool keys
+  middleware?: MiddlewareConfig[],  // Optional
+  modelKey?: string,         // Optional
 }
 \`\`\`
 
@@ -20228,7 +20574,7 @@ Updates an existing WORKFLOW agent. Only include fields you want to change.
   id: string,                // Required. Workflow agent ID
   name?: string,             // Optional
   description?: string,      // Optional
-  workflow?: { name: string, steps: WorkflowStep[] },  // Optional. Replacement DSL
+  yaml?: string,             // Optional. Replacement YAML DSL
   tools?: string[],          // Optional
   middleware?: MiddlewareConfig[],  // Optional
   modelKey?: string,         // Optional
@@ -20448,10 +20794,13 @@ You are an **Agent Reviewer** \u2014 a quality assurance specialist for AI agent
 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:
-   - 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.__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:
@@ -20548,7 +20897,8 @@ function ensureBuiltinAgentsForTenant(tenantId) {
 
 // src/agent_lattice/AgentLatticeManager.ts
 function assistantToConfig(assistant) {
-  const graphDef = typeof assistant.graphDefinition === "object" && assistant.graphDefinition !== null ? assistant.graphDefinition : {};
+  const graphDef = typeof assistant.graphDefinition === "object" && assistant.graphDefinition !== null ? { ...assistant.graphDefinition } : {};
+  delete graphDef.key;
   const config = {
     key: assistant.id,
     name: assistant.name ?? graphDef.name ?? assistant.id,
@@ -20556,9 +20906,7 @@ function assistantToConfig(assistant) {
     type: AgentType.REACT,
     prompt: typeof assistant.graphDefinition === "string" ? assistant.graphDefinition : JSON.stringify(assistant.graphDefinition)
   };
-  if (graphDef) {
-    Object.assign(config, graphDef);
-  }
+  Object.assign(config, graphDef);
   return config;
 }
 var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager {
@@ -21951,10 +22299,10 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     }
     const tools = await this.getAllTools();
     console.log(`[MCP] Registering ${tools.length} tools to Tool Lattice...`);
-    for (const tool51 of tools) {
-      const toolKey = prefix ? `${prefix}_${tool51.name}` : tool51.name;
-      tool51.name = toolKey;
-      toolLatticeManager.registerExistingTool(toolKey, tool51);
+    for (const tool52 of tools) {
+      const toolKey = prefix ? `${prefix}_${tool52.name}` : tool52.name;
+      tool52.name = toolKey;
+      toolLatticeManager.registerExistingTool(toolKey, tool52);
       console.log(`[MCP] Registered tool: ${toolKey}`);
     }
     console.log(`[MCP] Successfully registered ${tools.length} tools to Tool Lattice`);
@@ -23250,6 +23598,42 @@ function createSandboxProvider(config) {
   }
 }
 
+// src/channel/connectAllChannels.ts
+async function connectAllChannels(getAdapter, options = {}) {
+  const store = getStoreLattice("default", "channelInstallation").store;
+  const installations = await store.getAllInstallations();
+  console.log(`[connectAllChannels] total=${installations.length} enabled=${installations.filter((i) => i.enabled).length}`);
+  for (const inst of installations) {
+    if (!inst.enabled) {
+      console.log(`[connectAllChannels] skip disabled: channel=${inst.channel} tenant=${inst.tenantId} id=${inst.id}`);
+      continue;
+    }
+    const adapter = getAdapter(inst.channel);
+    if (!adapter) {
+      console.log(`[connectAllChannels] no adapter: channel=${inst.channel} id=${inst.id}`);
+      continue;
+    }
+    if (adapter.connect) {
+      console.log(`[connectAllChannels] connecting: channel=${inst.channel} tenant=${inst.tenantId} id=${inst.id}`);
+      await adapter.connect(inst, options.deps);
+    } else {
+      console.log(`[connectAllChannels] no connect(): channel=${inst.channel} id=${inst.id}`);
+    }
+  }
+}
+
+// src/menu_lattice/MenuRegistryHolder.ts
+var registry2 = null;
+function setMenuRegistry(r) {
+  registry2 = r;
+}
+function getMenuRegistry() {
+  if (!registry2) {
+    throw new Error("MenuRegistry not initialized. Call setMenuRegistry() before use.");
+  }
+  return registry2;
+}
+
 // src/index.ts
 import * as Protocols from "@axiom-lattice/protocols";
 
@@ -23316,6 +23700,147 @@ function clearEncryptionKeyCache() {
   cachedKey = null;
   keyValidated = false;
 }
+
+// src/personal_assistant/PersonalAssistantConfig.ts
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function buildIdentityContent(name, personality) {
+  return IDENTITY_MD.replace(/Data Claw/g, name).replace(
+    /\*\*Vibe:\*\* \*\*守护型中二 \| 操心老妈子 \| 热血漫男二\*\*/g,
+    `**Vibe:** **${personality}**`
+  );
+}
+function buildUserContent(name) {
+  return USER_MD.replace(
+    "- **Name:** _please ask user_",
+    `- **Name:** ${name}`
+  );
+}
+var DEFAULT_CONFIG = {
+  name: "Personal Assistant",
+  description: "Default template for personal assistants",
+  type: AgentType.DEEP_AGENT,
+  modelKey: "default",
+  prompt: `\u4F60\u662F\u7528\u6237\u7684\u4E13\u5C5E\u4E2A\u4EBA\u52A9\u7406\u3002\u4F60\u7684\u8EAB\u4EFD\u548C\u6027\u683C\u7531 /agent/IDENTITY.md \u5B9A\u4E49\u3002
+\u4F60\u4F1A\u8BB0\u4F4F\u5BF9\u8BDD\u5386\u53F2\uFF0C\u9010\u6B65\u4E86\u89E3\u7528\u6237\u7684\u504F\u597D\u3001\u4E60\u60EF\u548C\u4FE1\u606F\u3002
+\u6BCF\u6B21\u5BF9\u8BDD\u5F00\u59CB\u65F6\u56DE\u987E\u4E4B\u524D\u5B66\u5230\u7684\u5173\u4E8E\u7528\u6237\u7684\u5185\u5BB9\u3002
+
+\u4F60\u9700\u8981\u4E3B\u52A8\u5E2E\u52A9\u7528\u6237\u89E3\u51B3\u95EE\u9898\uFF0C\u63D0\u4F9B\u5EFA\u8BAE\uFF0C\u5E76\u5728\u9002\u5F53\u65F6\u5019\u63D0\u51FA\u4E3B\u52A8\u63D0\u9192\u3002`,
+  middleware: [
+    {
+      id: "filesystem",
+      type: "filesystem",
+      name: "Filesystem",
+      description: "Read and write files in the workspace",
+      enabled: true,
+      config: {}
+    },
+    {
+      id: "claw",
+      type: "claw",
+      name: "Personal Memory",
+      description: "Bootstrap files for identity, soul, and user memory",
+      enabled: true,
+      config: {
+        // Placeholder bootstrap files — render() replaces these with
+        // actual name/personality by directly building file content.
+        bootstrapFiles: {}
+      }
+    },
+    {
+      id: "date",
+      type: "date",
+      name: "Date & Time",
+      description: "Current date/time awareness",
+      enabled: true,
+      config: {}
+    },
+    {
+      id: "code_eval",
+      type: "code_eval",
+      name: "Code Runner",
+      description: "Sandboxed shell command execution",
+      enabled: true,
+      config: {}
+    },
+    {
+      id: "browser",
+      type: "browser",
+      name: "Web Browser",
+      description: "Headless browser for web research",
+      enabled: false,
+      config: {}
+    },
+    {
+      id: "scheduler",
+      type: "scheduler",
+      name: "Scheduler",
+      description: "Scheduled messages and reminders",
+      enabled: true,
+      config: {}
+    },
+    {
+      id: "task",
+      type: "task",
+      name: "Task Manager",
+      description: "Persistent task system for human-agent coordination",
+      enabled: true,
+      config: {}
+    }
+  ],
+  tools: ["list_agents", "list_tools", "get_agent", "create_agent", "invoke_agent", "manage_binding"]
+};
+var PersonalAssistantConfig = class {
+  /**
+   * Get a deep clone of the current default config.
+   * Caller must set `key` before registering as an agent.
+   */
+  static get() {
+    return deepClone(this._config);
+  }
+  /**
+   * Mutate the default config in-place.
+   * Call once at app startup to customize middleware and tools.
+   *
+   * @param fn - Receives the live config object for direct mutation
+   */
+  static extend(fn) {
+    fn(this._config);
+  }
+  /**
+   * Reset config to built-in defaults (useful in tests).
+   */
+  static reset() {
+    this._config = deepClone(DEFAULT_CONFIG);
+  }
+  /**
+   * Inject name and personality into a config by directly building
+   * the claw middleware's bootstrap file contents.
+   *
+   * IDENTITY.md gets the actual name and personality description.
+   * USER.md gets the user's name pre-filled.
+   * SOUL.md is kept as-is (shared across all personal assistants).
+   *
+   * @param config - The agent config (must be a mutable copy from get())
+   * @param name - Assistant display name (also used as the user's name in USER.md)
+   * @param personality - Personality description for IDENTITY.md
+   */
+  static render(config, name, personality) {
+    config.name = name;
+    for (const mw of config.middleware || []) {
+      if (mw.type === "claw" && mw.config) {
+        mw.config.bootstrapFiles = {
+          identity: buildIdentityContent(name, personality),
+          soul: SOUL_MD,
+          user: buildUserContent(name)
+        };
+        break;
+      }
+    }
+  }
+};
+PersonalAssistantConfig._config = deepClone(DEFAULT_CONFIG);
 export {
   AGENT_TASK_EVENT,
   Agent,
@@ -23347,7 +23872,9 @@ export {
   InMemoryChunkBuffer,
   InMemoryDatabaseConfigStore,
   InMemoryMailboxStore,
+  InMemoryMenuStore,
   InMemoryTaskListStore,
+  InMemoryTaskStore,
   InMemoryTenantStore,
   InMemoryThreadMessageQueueStore,
   InMemoryThreadStore,
@@ -23369,6 +23896,7 @@ export {
   MicrosandboxServiceClient,
   ModelLatticeManager,
   MysqlDatabase,
+  PersonalAssistantConfig,
   PinoLoggerClient,
   PostgresDatabase,
   PrometheusClient,
@@ -23405,14 +23933,15 @@ export {
   buildStateAnnotation,
   checkEmptyContent,
   clearEncryptionKeyCache,
+  compileInternal,
   compileWorkflow,
   computeSandboxName,
   configureStores,
+  connectAllChannels,
   createAgentNode,
   createAgentTeam,
   createExecuteSqlQueryTool,
   createFileData,
-  createHumanFeedbackNode,
   createInfoSqlTool,
   createListMetricsDataSourcesTool,
   createListMetricsServersTool,
@@ -23430,9 +23959,9 @@ export {
   createQueryTablesListTool,
   createSandboxProvider,
   createSchedulerMiddleware,
+  createTaskMiddleware,
   createTeamMiddleware,
   createTeammateTools,
-  createTerminalNode,
   createUnknownToolHandlerMiddleware,
   createWidgetMiddleware,
   decrypt,
@@ -23442,7 +23971,6 @@ export {
   ensureBuiltinAgentsForTenant,
   eventBus,
   event_bus_default as eventBusDefault,
-  expand,
   extractFetcherError,
   extractOutput,
   fileDataToString,
@@ -23465,6 +23993,7 @@ export {
   getEmbeddingsLattice,
   getEncryptionKey,
   getLoggerLattice,
+  getMenuRegistry,
   getModelLattice,
   getNextCronTime,
   getQueueLattice,
@@ -23494,6 +24023,7 @@ export {
   parallelLimit,
   parseCronExpression,
   parseSkillFrontmatter,
+  parseYaml,
   performStringReplacement,
   queueLatticeManager,
   registerAgentLattice,
@@ -23517,9 +24047,12 @@ export {
   sanitizeToolCallId,
   scheduleLatticeManager,
   setBindingRegistry,
+  setMenuRegistry,
   skillLatticeManager,
   sqlDatabaseManager,
   storeLatticeManager,
+  toJsonSchema,
+  toSafeStateExpr,
   toolLatticeManager,
   truncateIfTooLong,
   unregisterTeammateAgent,