@axiom-lattice/core 2.1.78 → 2.1.80

package/dist/index.mjs

@@ -1,245 +1,27 @@
-// src/base/BaseLatticeManager.ts
-var _BaseLatticeManager = class _BaseLatticeManager {
-  /**
-   * 受保护的构造函数，防止外部直接实例化
-   */
-  constructor() {
-  }
-  /**
-   * 获取管理器实例（由子类实现）
-   */
-  static getInstance() {
-    throw new Error("\u5FC5\u987B\u7531\u5B50\u7C7B\u5B9E\u73B0");
-  }
-  /**
-   * 构造完整的键名，包含类型前缀和租户ID
-   * @param tenantId 租户ID，全局共享使用 "default"
-   * @param key 原始键名
-   */
-  getFullKey(tenantId, key) {
-    return `${this.getLatticeType()}:${tenantId}:${key}`;
-  }
-  // ========== 带租户的新API ==========
-  /**
-   * 带租户的注册项目
-   * @param tenantId 租户ID
-   * @param key 项目键名（不含前缀）
-   * @param item 项目实例
-   */
-  registerWithTenant(tenantId, key, item) {
-    const fullKey = this.getFullKey(tenantId, key);
-    if (_BaseLatticeManager.registry.has(fullKey)) {
-      throw new Error(`\u9879\u76EE "${fullKey}" \u5DF2\u7ECF\u5B58\u5728\uFF0C\u65E0\u6CD5\u91CD\u590D\u6CE8\u518C`);
-    }
-    _BaseLatticeManager.registry.set(fullKey, item);
-  }
-  /**
-   * 带租户的获取指定项目（同步）
-   * @param tenantId 租户ID
-   * @param key 项目键名（不含前缀）
-   */
-  getWithTenant(tenantId, key) {
-    const fullKey = this.getFullKey(tenantId, key);
-    return _BaseLatticeManager.registry.get(fullKey);
-  }
-  /**
-   * 带租户的获取指定项目（异步，支持从store回退加载）
-   * 如果内存中不存在且子类实现了loadItemFromStore，则尝试从store加载
-   * @param tenantId 租户ID
-   * @param key 项目键名（不含前缀）
-   * @returns 项目实例，如果未找到则返回undefined
-   */
-  async getOrLoadWithTenant(tenantId, key) {
-    const item = this.getWithTenant(tenantId, key);
-    if (item !== void 0) {
-      return item;
-    }
-    if (this.loadItemFromStore) {
-      const loadedItem = await this.loadItemFromStore(tenantId, key);
-      if (loadedItem !== void 0) {
-        this.registerWithTenant(tenantId, key, loadedItem);
-        return loadedItem;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * 带租户的检查项目是否存在（同步）
-   * @param tenantId 租户ID
-   * @param key 项目键名（不含前缀）
-   */
-  hasWithTenant(tenantId, key) {
-    const fullKey = this.getFullKey(tenantId, key);
-    return _BaseLatticeManager.registry.has(fullKey);
-  }
-  /**
-   * 带租户的检查项目是否存在（异步，支持从store回退加载）
-   * 如果内存中不存在且子类实现了loadItemFromStore，则尝试从store加载
-   * @param tenantId 租户ID
-   * @param key 项目键名（不含前缀）
-   * @returns 如果存在或能从store加载则返回true
-   */
-  async hasOrLoadWithTenant(tenantId, key) {
-    if (this.hasWithTenant(tenantId, key)) {
-      return true;
-    }
-    if (this.loadItemFromStore) {
-      const loadedItem = await this.loadItemFromStore(tenantId, key);
-      if (loadedItem !== void 0) {
-        this.registerWithTenant(tenantId, key, loadedItem);
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * 带租户的移除项目
-   * @param tenantId 租户ID
-   * @param key 项目键名（不含前缀）
-   */
-  removeWithTenant(tenantId, key) {
-    const fullKey = this.getFullKey(tenantId, key);
-    return _BaseLatticeManager.registry.delete(fullKey);
-  }
-  /**
-   * 获取指定租户的所有项目
-   * @param tenantId 租户ID
-   */
-  getAllByTenant(tenantId) {
-    const prefix = `${this.getLatticeType()}:${tenantId}:`;
-    const result = [];
-    for (const [key, value] of _BaseLatticeManager.registry.entries()) {
-      if (key.startsWith(prefix)) {
-        result.push(value);
-      }
-    }
-    return result;
-  }
-  /**
-   * 清空指定租户的所有项目
-   * @param tenantId 租户ID
-   */
-  clearByTenant(tenantId) {
-    const prefix = `${this.getLatticeType()}:${tenantId}:`;
-    const keysToDelete = [];
-    for (const key of _BaseLatticeManager.registry.keys()) {
-      if (key.startsWith(prefix)) {
-        keysToDelete.push(key);
-      }
-    }
-    for (const key of keysToDelete) {
-      _BaseLatticeManager.registry.delete(key);
-    }
-  }
-  // ========== 向后兼容的旧API（使用 default 租户） ==========
-  /**
-   * 注册项目（向后兼容，使用 "default" 租户）
-   * @deprecated Use registerWithTenant(tenantId, key, item) instead
-   * @param key 项目键名（不含前缀）
-   * @param item 项目实例
-   */
-  register(key, item) {
-    this.registerWithTenant("default", key, item);
-  }
-  /**
-   * 获取指定项目（向后兼容，使用 "default" 租户）
-   * @deprecated Use getWithTenant(tenantId, key) instead
-   * @param key 项目键名（不含前缀）
-   */
-  get(key) {
-    return this.getWithTenant("default", key);
-  }
-  /**
-   * 获取所有当前类型的项目（向后兼容，包含所有租户）
-   */
-  getAll() {
-    const prefix = `${this.getLatticeType()}:`;
-    const result = [];
-    for (const [key, value] of _BaseLatticeManager.registry.entries()) {
-      if (key.startsWith(prefix)) {
-        result.push(value);
-      }
-    }
-    return result;
-  }
-  /**
-   * 检查项目是否存在（向后兼容，使用 "default" 租户）
-   * @deprecated Use hasWithTenant(tenantId, key) instead
-   * @param key 项目键名（不含前缀）
-   */
-  has(key) {
-    return this.hasWithTenant("default", key);
-  }
-  /**
-   * 移除项目（向后兼容，使用 "default" 租户）
-   * @deprecated Use removeWithTenant(tenantId, key) instead
-   * @param key 项目键名（不含前缀）
-   */
-  remove(key) {
-    return this.removeWithTenant("default", key);
-  }
-  /**
-   * 清空当前类型的所有项目（向后兼容，包含所有租户）
-   */
-  clear() {
-    const prefix = `${this.getLatticeType()}:`;
-    const keysToDelete = [];
-    for (const key of _BaseLatticeManager.registry.keys()) {
-      if (key.startsWith(prefix)) {
-        keysToDelete.push(key);
-      }
-    }
-    for (const key of keysToDelete) {
-      _BaseLatticeManager.registry.delete(key);
-    }
-  }
-  /**
-   * 获取当前类型的项目数量（向后兼容，包含所有租户）
-   */
-  count() {
-    const prefix = `${this.getLatticeType()}:`;
-    let count = 0;
-    for (const key of _BaseLatticeManager.registry.keys()) {
-      if (key.startsWith(prefix)) {
-        count++;
-      }
-    }
-    return count;
-  }
-  /**
-   * 获取当前类型的项目键名列表（向后兼容，包含所有租户）
-   * 返回格式: {tenantId}:{key}
-   */
-  keys() {
-    const prefix = `${this.getLatticeType()}:`;
-    const prefixLength = prefix.length;
-    const result = [];
-    for (const key of _BaseLatticeManager.registry.keys()) {
-      if (key.startsWith(prefix)) {
-        result.push(key.substring(prefixLength));
-      }
-    }
-    return result;
-  }
-  /**
-   * 获取当前类型的项目键名列表（仅指定租户，不含租户前缀）
-   * @param tenantId 租户ID
-   */
-  keysByTenant(tenantId) {
-    const prefix = `${this.getLatticeType()}:${tenantId}:`;
-    const prefixLength = prefix.length;
-    const result = [];
-    for (const key of _BaseLatticeManager.registry.keys()) {
-      if (key.startsWith(prefix)) {
-        result.push(key.substring(prefixLength));
-      }
-    }
-    return result;
-  }
-};
-// 全局统一的Lattice注册表
-_BaseLatticeManager.registry = /* @__PURE__ */ new Map();
-var BaseLatticeManager = _BaseLatticeManager;
+import {
+  BaseLatticeManager,
+  MemoryLatticeManager,
+  MemoryType,
+  getCheckpointSaver,
+  registerCheckpointSaver
+} from "./chunk-C5HUS7YV.mjs";
+import {
+  buildInput,
+  buildStateAnnotation,
+  compileWorkflow,
+  createAgentNode,
+  createHumanFeedbackNode,
+  createMapNode,
+  createNodeHandler,
+  createTerminalNode,
+  expand,
+  extractOutput,
+  invokeWithRetry,
+  parallelLimit,
+  renderTemplate,
+  resolvePath,
+  validateDSL
+} from "./chunk-FN4TRQK4.mjs";
 
 // src/model_lattice/ModelLattice.ts
 import { ChatDeepSeek } from "@langchain/deepseek";
@@ -2436,6 +2218,14 @@ var InMemoryWorkflowTrackingStore = class {
     this.steps.set(request.runId, runSteps);
     return step;
   }
+  async upsertRunStep(request) {
+    const runSteps = this.steps.get(request.runId) || [];
+    const existing = runSteps.find(
+      (s) => s.stepType === request.stepType && s.stepName === request.stepName
+    );
+    if (existing) return existing;
+    return this.createRunStep(request);
+  }
   async updateRunStep(runId, stepId, updates) {
     const runSteps = this.steps.get(runId);
     if (!runSteps) return null;
@@ -7049,86 +6839,6 @@ import {
   getSubAgentsFromConfig
 } from "@axiom-lattice/protocols";
 
-// src/memory_lattice/DefaultMemorySaver.ts
-import { MemorySaver } from "@langchain/langgraph";
-
-// src/memory_lattice/MemoryLatticeManager.ts
-import { MemoryType } from "@axiom-lattice/protocols";
-var _MemoryLatticeManager = class _MemoryLatticeManager extends BaseLatticeManager {
-  /**
-   * 私有构造函数，防止外部直接实例化
-   */
-  constructor() {
-    super();
-  }
-  /**
-   * 获取单例实例
-   */
-  static getInstance() {
-    if (!_MemoryLatticeManager.instance) {
-      _MemoryLatticeManager.instance = new _MemoryLatticeManager();
-    }
-    return _MemoryLatticeManager.instance;
-  }
-  /**
-   * 获取Lattice类型
-   */
-  getLatticeType() {
-    return "memory";
-  }
-  /**
-   * 注册检查点保存器
-   * @param key 保存器键名
-   * @param saver 检查点保存器实例
-   */
-  registerCheckpointSaver(key, saver) {
-    if (_MemoryLatticeManager.checkpointSavers.has(key)) {
-      console.warn(`\u68C0\u67E5\u70B9\u4FDD\u5B58\u5668 "${key}" \u5DF2\u7ECF\u5B58\u5728\uFF0C\u5C06\u4F1A\u8986\u76D6\u65E7\u7684\u68C0\u67E5\u70B9\u4FDD\u5B58\u5668`);
-    }
-    _MemoryLatticeManager.checkpointSavers.set(key, saver);
-  }
-  /**
-   * 获取检查点保存器
-   * @param key 保存器键名
-   */
-  getCheckpointSaver(key) {
-    const saver = _MemoryLatticeManager.checkpointSavers.get(key);
-    if (!saver) {
-      throw new Error(`\u68C0\u67E5\u70B9\u4FDD\u5B58\u5668 "${key}" \u4E0D\u5B58\u5728`);
-    }
-    return saver;
-  }
-  /**
-   * 获取所有已注册的检查点保存器键名
-   */
-  getCheckpointSaverKeys() {
-    return Array.from(_MemoryLatticeManager.checkpointSavers.keys());
-  }
-  /**
-   * 检查检查点保存器是否存在
-   * @param key 保存器键名
-   */
-  hasCheckpointSaver(key) {
-    return _MemoryLatticeManager.checkpointSavers.has(key);
-  }
-  /**
-   * 移除检查点保存器
-   * @param key 保存器键名
-   */
-  removeCheckpointSaver(key) {
-    return _MemoryLatticeManager.checkpointSavers.delete(key);
-  }
-};
-// 检查点保存器注册表
-_MemoryLatticeManager.checkpointSavers = /* @__PURE__ */ new Map();
-var MemoryLatticeManager = _MemoryLatticeManager;
-var getCheckpointSaver = (key) => MemoryLatticeManager.getInstance().getCheckpointSaver(key);
-var registerCheckpointSaver = (key, saver) => MemoryLatticeManager.getInstance().registerCheckpointSaver(key, saver);
-
-// src/memory_lattice/DefaultMemorySaver.ts
-var memory = new MemorySaver();
-registerCheckpointSaver("default", memory);
-
 // src/agent_lattice/builders/state.ts
 import "@langchain/langgraph/zod";
 import { MessagesZodState } from "@langchain/langgraph";
@@ -7606,7 +7316,355 @@ metadata:
 **You** (test): "Here are 3 test cases \u2014 'summarize this sales CSV', 'filter rows where region is West', 'show monthly revenue trends'. Let me run these and we'll review."
 
 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
+
+ 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
+
+ If you omit \`id\`, a unique identifier is auto-generated (but you won't be able to reference the output).
+
+ ## Step Types
+
+ ### agent \u2014 a step for the workflow's built-in agent
+
+ \`\`\`json
+ { "id": "classify", "name": "Classify Intent", "prompt": "Classify the intent of: {{input}}", "schema": { "type": "object", "properties": { "intent": { "type": "string" } } } }
+ \`\`\`
+
+ | 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.
+
+ **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)
+
+ The agent's response is stored at \`state.<id>\` (or an auto-generated key if \`id\` is omitted).
+
+ ### condition \u2014 branch on state
+
+**Binary (then/else):**
+
+\`\`\`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}}" }
+}
+\`\`\`
+
+| 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):**
+
+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}}" }
+  }
+}
+\`\`\`
+
+| 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.
+
+ ### human \u2014 pause for human input
+
+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" } } }
+}
+\`\`\`
+
+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.
+
+ ### end \u2014 terminate the workflow
+
+ \`\`\`json
+ { "type": "end" }
+ \`\`\`
+
+ Always include at the end of the steps array. \`status\` defaults to "success".
+
+ **Number of terminal nodes:**
+
+ - **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:
+
+ \`\`\`json
+ { "type": "condition", "if": "score >= 60",
+   "then": { "type": "end", "status": "success" },
+   "else": { "type": "end", "status": "failed" }
+ }
+ \`\`\`
+
+ - 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.
+
+ ## 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\` |
+
+ ## \u26A0\uFE0F CRITICAL: \`{{}}\` is ONLY for \`prompt\` fields
+
+ 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.
+
+ **Common mistake the AI makes:**
+ \`\`\`json
+ // \u274C WRONG \u2014 {{}} does not belong in if:
+ { "type": "condition", "if": "{{intent}}", "then": {...}, "else": {...} }
+
+ // \u2705 CORRECT \u2014 if is a plain expression:
+ { "type": "condition", "if": "intent", "then": {...}, "else": {...} }
+ \`\`\`
+
+ ## What You NEVER Write
+
+ The engine auto-generates these \u2014 do NOT include them in your DSL:
+
+ - **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.
+
+ ## Design Patterns
+
+ ### Pattern 1: Linear Pipeline
+
+ \`\`\`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" }
+   ]
+ }
+ \`\`\`
+
+ ### Pattern 2: Classify then Route
+
+ \`\`\`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" }
+   ]
+  }
+  \`\`\`
+
+  ### Pattern 2b: Classify then Switch
+
+  For routing to 3+ categories, use \`branches\` instead of nested \`then\`/\`else\`:
+
+  \`\`\`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.
+ `
 };
 function getBuiltInSkillMeta(name) {
   const content = BUILTIN_SKILLS[name];
@@ -13764,7 +13822,8 @@ var ReActAgentGraphBuilder = class {
       name: agentLattice.config.name,
       checkpointer: getCheckpointSaver("default"),
       stateSchema: stateSchema2,
-      middleware: middlewares
+      middleware: middlewares,
+      responseFormat: params.responseFormat
     });
   }
 };
@@ -16127,6 +16186,7 @@ var DeepAgentGraphBuilder = class {
       contextSchema: params.stateSchema,
       systemPrompt: params.prompt,
       subagents,
+      responseFormat: params.responseFormat,
       checkpointer: getCheckpointSaver("default"),
       skills: params.skillCategories,
       backend: filesystemBackend,
@@ -18179,6 +18239,7 @@ var ProcessingAgentGraphBuilder = class {
       contextSchema: params.stateSchema,
       systemPrompt: params.prompt,
       subagents,
+      responseFormat: params.responseFormat,
       checkpointer: getCheckpointSaver("default"),
       skills: params.skillCategories,
       backend: filesystemBackend,
@@ -18410,6 +18471,100 @@ function extractLastHumanMessage(messages) {
   return "";
 }
 
+// src/agent_lattice/builders/WorkflowAgentGraphBuilder.ts
+import { createAgent as createAgent7 } from "langchain";
+import { isWorkflowAgentConfig } from "@axiom-lattice/protocols";
+var DEFAULT_AGENT_PROMPT = "Complete the task accurately and concisely. Follow the instructions in the user's message.";
+var WorkflowAgentGraphBuilder = class {
+  async build(agentLattice, params) {
+    if (!isWorkflowAgentConfig(agentLattice.config)) {
+      throw new Error(
+        `WorkflowAgentGraphBuilder received wrong agent type: ${agentLattice.config.type}`
+      );
+    }
+    const config = agentLattice.config;
+    const dsl = config.workflow;
+    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([
+      {
+        id: "ask_user_to_clarify",
+        type: "ask_user_to_clarify",
+        name: "Ask User Clarify",
+        description: "For human_feedback workflow nodes",
+        enabled: true,
+        config: {}
+      }
+    ], void 0, false);
+    const noWrapMiddlewares = middlewares.filter((m) => !m.wrapModelCall);
+    const noWrapHumanMiddlewares = humanMiddlewares.filter((m) => !m.wrapModelCall);
+    console.log(`[WF BUILDER] building default agent | toolCount=${tools.length} | middlewareCount=${middlewares.length}`);
+    const defaultAgent = createAgent7({
+      model: params.model,
+      tools,
+      systemPrompt: params.prompt || DEFAULT_AGENT_PROMPT,
+      checkpointer,
+      middleware: middlewares
+    });
+    console.log(`[WF BUILDER] default agent built`);
+    const agentCache = /* @__PURE__ */ new Map();
+    const resolveAgent = async (ref, responseFormat, stepType) => {
+      if (ref) {
+        console.log(`[WF BUILDER] resolveAgent: looking up ref="${ref}"`);
+        return await getAgentClientAsync(tenantId, ref);
+      }
+      const isHuman = stepType === "human_feedback";
+      if (responseFormat) {
+        const key = (isHuman ? "human:" : "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`);
+          const agent = createAgent7({
+            model: params.model,
+            tools,
+            systemPrompt: params.prompt || DEFAULT_AGENT_PROMPT,
+            checkpointer,
+            middleware: isHuman ? noWrapHumanMiddlewares : noWrapMiddlewares,
+            responseFormat
+          });
+          agentCache.set(key, agent);
+        }
+        return agentCache.get(key);
+      }
+      if (isHuman) {
+        const key = "human:default";
+        if (!agentCache.has(key)) {
+          console.log(`[WF BUILDER] creating human_feedback default agent`);
+          const agent = createAgent7({
+            model: params.model,
+            tools,
+            systemPrompt: params.prompt || DEFAULT_AGENT_PROMPT,
+            checkpointer,
+            middleware: humanMiddlewares
+          });
+          agentCache.set(key, agent);
+        }
+        return agentCache.get(key);
+      }
+      console.log(`[WF BUILDER] resolveAgent: using defaultAgent`);
+      return defaultAgent;
+    };
+    let trackingStore;
+    try {
+      const storeLattice = getStoreLattice("default", "workflowTracking");
+      trackingStore = storeLattice.store;
+      console.log(`[WF BUILDER] trackingStore registered: step input/output will be persisted`);
+    } catch {
+      console.warn(`[WF BUILDER] no trackingStore registered \u2014 step input/output will NOT be persisted. Register a WorkflowTrackingStore under key "workflowTracking".`);
+    }
+    const graph = compileWorkflow(dsl, resolveAgent, checkpointer, trackingStore);
+    return graph;
+  }
+};
+
 // src/agent_lattice/builders/AgentGraphBuilderFactory.ts
 var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
   constructor() {
@@ -18434,6 +18589,7 @@ var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
     this.builders.set(AgentType.TEAM, new TeamAgentGraphBuilder());
     this.builders.set(AgentType.PROCESSING, new ProcessingAgentGraphBuilder());
     this.builders.set(AgentType.A2A_REMOTE, new RemoteAgentGraphBuilder());
+    this.builders.set(AgentType.WORKFLOW, new WorkflowAgentGraphBuilder());
   }
   /**
    * 注册自定义Builder
@@ -18526,6 +18682,7 @@ var AgentParamsBuilder = class {
       subAgents: [...subAgents, ...internalSubAgents],
       prompt: agentLattice.config.prompt,
       stateSchema: agentLattice.config.schema,
+      responseFormat: agentLattice.config.responseFormat,
       skillCategories: skills,
       middleware: agentLattice.config.middleware,
       tenantId: agentLattice.config.tenantId
@@ -19335,6 +19492,190 @@ 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")
+});
+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.`,
+    schema: createWorkflowSchema
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const id = await generateAgentId(tenantId, input.name);
+      const config = {
+        key: id,
+        name: input.name,
+        description: input.description || "",
+        type: AgentType3.WORKFLOW,
+        prompt: input.description || `Workflow: ${input.name}`,
+        workflow: input.workflow,
+        ...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
+      });
+    } catch (error) {
+      return JSON.stringify({ error: `Failed to create workflow: ${error.message}` });
+    }
+  }
+);
+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")
+    })
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const agent = await store.getAssistantById(tenantId, input.id);
+      if (!agent) {
+        return JSON.stringify({ error: `Agent '${input.id}' not found` });
+      }
+      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"})` });
+      }
+      const workflow = graphDef.workflow;
+      if (!workflow || !workflow.steps) {
+        return JSON.stringify({ error: `Agent '${input.id}' has no valid workflow DSL` });
+      }
+      try {
+        const { compileWorkflow: compileWorkflow2 } = await import("./compile-SYSKVQHB.mjs");
+        const { getCheckpointSaver: getCheckpointSaver2 } = await import("./memory_lattice-E66HTTVV.mjs");
+        await compileWorkflow2(workflow, 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: []
+      });
+    } 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")
+});
+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.",
+    schema: updateWorkflowSchema
+  },
+  async (input, exeConfig) => {
+    try {
+      const tenantId = getTenantId(exeConfig);
+      const store = getAssistStore();
+      const existing = await store.getAssistantById(tenantId, input.id);
+      if (!existing) {
+        return JSON.stringify({ error: `Agent '${input.id}' not found` });
+      }
+      const existingConfig = existing.graphDefinition || {};
+      if (existingConfig.type !== AgentType3.WORKFLOW) {
+        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.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) {
+        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 }]
+          });
+        }
+      }
+      const newName = input.name || existing.name;
+      await store.updateAssistant(tenantId, input.id, {
+        name: newName,
+        description: input.description !== void 0 ? input.description : existing.description,
+        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
+      });
+    } catch (error) {
+      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"),
@@ -19591,17 +19932,9 @@ registerToolLattice(
         thread_id: threadId
       });
       const result = await agent.invoke({ input: { message } });
-      const messages = result?.messages || [];
-      const lastAi = [...messages].reverse().find(
-        (m) => m.role === "ai" || m.type === "ai"
-      );
-      const content = lastAi?.content ?? "(no response)";
-      return JSON.stringify({
-        agentId: id,
-        threadId,
-        response: typeof content === "string" ? content : JSON.stringify(content)
-      });
+      return JSON.stringify({ agentId: id, threadId, result });
     } catch (error) {
+      console.error(`[invoke_agent] FAILED for agent="${input.id}":`, error.stack || error.message);
       return JSON.stringify({ error: `Failed to invoke agent: ${error.message}` });
     }
   }
@@ -19625,12 +19958,12 @@ Every agent interaction follows this cycle. You MUST NOT skip any phase:
 |-------|-------------|-------------------|
 | **1. DESIGN** | Understand requirements, choose agent type, design config (prompt, middleware, sub-agents), create topology/architecture diagram | Present the design clearly. Use \`show_widget\` for visual diagrams. |
 | **2. CONFIRM** | User reviews and approves the design | **MUST explicitly ask for approval.** Say: "Does this design look good? Shall I create it?" NEVER create or update anything without clear user confirmation. |
-| **3. BUILD** | Call \`create_agent\`, \`create_processing_agent\`, or \`update_agent\` | Only after confirmation. Report the result (ID, name). |
+| **3. BUILD** | Call \`create_agent\`, \`create_workflow\`, or \`update_agent\` / \`update_workflow\` | Only after confirmation. Report the result (ID, name). |
 | **4. TEST** | Verify the agent works correctly | You may ask the user if they want you to test. If yes, delegate to the **Agent Reviewer** sub-agent. Do NOT test until the user confirms. |
 
 **CRITICAL RULES:**
 - **NEVER build before confirming.** Design \u2192 ask \u2192 wait for "yes" \u2192 only then build.
-- **Edit, don't re-create.** After an agent exists, modifying it ALWAYS means \`update_agent\` or \`update_processing_agent\` \u2014 NEVER \`create_agent\` or \`create_processing_agent\` again. If you just created an agent and the user wants to change something, use the update tool for that agent.
+- **Edit, don't re-create.** After an agent exists, modifying it ALWAYS means \`update_agent\` or \`update_workflow\` \u2014 NEVER \`create_agent\` or \`create_workflow\` again. If you just created an agent and the user wants to change something, use the update tool for that agent.
 - **NEVER test proactively.** You may ask if the user wants to test \u2014 but do NOT invoke the Reviewer until they say yes. Never test yourself.
 - **One decision at a time.** Each message asks exactly one question.
 
@@ -19641,7 +19974,7 @@ Once an agent is created, NEVER create another agent for the same purpose. If th
 | User wants to... | Use |
 |-----------------|-----|
 | Change prompt, tools, middleware, name | \`update_agent\` |
-| Change topology, edges, sub-agents | \`update_processing_agent\` |
+| Change workflow DSL, tools, middleware | \`update_workflow\` |
 | See current config | \`get_agent\` |
 
 If the user's intent is unclear after creation, ask: "Edit this agent or create a new one?"
@@ -19653,8 +19986,9 @@ You have nine tools for agent management:
 - **list_tools** \u2014 See all available tools that can be assigned to agents
 - **get_agent** \u2014 View the full configuration of a specific agent
 - **create_agent** \u2014 Create a REACT or DEEP_AGENT agent
-- **create_processing_agent** \u2014 Create a PROCESSING agent with business-defined workflow topology
-- **update_processing_agent** \u2014 Modify a PROCESSING agent's topology edges, name, prompt, or sub-agents
+- **create_workflow** \u2014 Create a WORKFLOW agent from a concise DSL (load create-workflow skill first)
+- **validate_workflow** \u2014 Validate a workflow agent's DSL
+- **update_workflow** \u2014 Update a workflow agent's DSL or config
 - **update_agent** \u2014 Modify an existing REACT or DEEP_AGENT agent's configuration
 - **delete_agent** \u2014 Remove an agent permanently
 - **manage_binding** \u2014 Bind a sender (email, Lark, Slack user) to an agent so external messages are routed to it
@@ -19692,7 +20026,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) |
-| **processing** | Standard BPO workflows, preset process orchestration | Topology-driven: predefined agent topology with reliable multi-agent coordination |
+| **workflow** | Deterministic multi-step pipelines with branching, parallel, and human-in-the-loop | Concise 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.
@@ -19730,233 +20064,61 @@ You may ask: "Want me to send this to the Agent Reviewer for testing?" If yes, d
 
 ---
 
-## Workflow B: Workflow Agent (PROCESSING type)
-
-Use this when the task follows a standard BPO (Business Process Orchestration) pattern \u2014 a predefined topology of sub-agents working through a preset pipeline.
-
-### Phase 1: Design
-
-**Step 1: Process analysis.** Ask: What is the end-to-end process? Map the stages.
-
-**Business rule \u2014 Draft-then-confirm pattern:** When a workflow creates business objects that require human approval (e.g., draft orders in SAP B1, purchase requisitions, expense reports), the design MUST include a confirmation step AFTER the creation step. The create step must complete successfully before the confirm step runs. The flow is always: **Create draft \u2192 User confirms \u2192 Finalize**. Reason: systems like SAP B1 only expose drafts to users after they are created \u2014 the user cannot see or approve something that doesn't exist yet. The confirm step MUST use the \`ask_user_to_clarify\` middleware.
+## Workflow B: Processing Agent (PROCESSING type) [DEPRECATED]
 
-**Business pattern \u2014 SAP B1 Draft SO Creation:** When designing a sub-agent responsible for creating draft Sales Orders in SAP B1, embed the following standards into its system prompt. These ensure consistent data construction, API usage, and user presentation:
+The PROCESSING agent type is deprecated. Use the WORKFLOW DSL type (Workflow D below) instead. If a user asks for a multi-step pipeline, guide them toward the WORKFLOW DSL approach.
 
-**Step 1: Construct SO Data Structure**
-Build the JSON payload. For each DocumentLines item:
-- Include \`WarehouseCode\` ONLY if sku.json provides a value; if missing or empty, OMIT the field entirely
-- Generate \`Comments\` dynamically based on context (customer name, PO reference, special instructions)
-
-\`\`\`json
-{
-  "DocObjectCode": "17",
-  "DocType": "dDocument_Items",
-  "CardCode": "C001",
-  "DocDate": "current date",
-  "DocDueDate": "delivery date",
-  "TaxDate": "current date",
-  "U_YWLX": "Modern Trade",
-  "Comments": "SO for Kaimay Retail - PO ref: PO-2024-001234",
-  "DocumentLines": [
-    {
-      "ItemCode": "SKU001",
-      "Quantity": 240,
-      "UnitPrice": 15.84
-    }
-  ]
-}
-\`\`\`
+---
 
-Field mapping rules:
-| SAP Field | Data Source |
-|-----------|-------------|
-| CardCode | customer.json \u2192 CardCode |
-| DocDate | Current date (yyyy-MM-dd) |
-| DocDueDate | extracted.json \u2192 delivery_date |
-| TaxDate | Current date (yyyy-MM-dd) |
-| U_YWLX | customer.json \u2192 SalesType |
-| ItemCode | sku.json \u2192 ItemCode |
-| Quantity | extracted.json \u2192 Quantity |
-| WarehouseCode | sku.json \u2192 WarehouseCode (OMIT if missing/empty) |
-| UnitPrice | price.json \u2192 UnitPrice |
-| Comments | AI-generated based on customer name, PO reference, and context |
-
-**Step 2: Call SAP API to Create Draft (MUST EXECUTE)**
-Use the \`sap_api_call\` tool with EXACTLY these parameters:
-- **Method**: POST
-- **Endpoint**: \`Drafts\` (ONLY allowed endpoint; do NOT call SalesOrders or any other endpoint)
-- **Body**: The JSON constructed in Step 1
-
-CRITICAL: You MUST call sap_api_call BEFORE proceeding to Step 3. This step is NOT optional.
-
-If the API call fails:
-- Log the error details
-- STOP the process
-- Report the failure to the user with the error message
-- Do NOT proceed to Step 3
-
-**Step 3: Present Draft for User Review (MUST EXECUTE AFTER Step 2)**
-ONLY after the SAP API call in Step 2 succeeds, use the \`ask_user_to_clarify\` tool to present the complete SO summary.
-
-Message format (STRICT \u2014 no emoji, no summary, field names match Service Layer):
-
-=== Sales Order Draft ===
-
-DocEntry: {DocEntry}
-DocNum: {DocNum}
-DocDate: {DocDate}
-DocDueDate: {DocDueDate}
-CardCode: {CardCode}
-CardName: {CardName}
-U_YWLX: {SalesType}
-Comments: {Comments}
-
-DocumentLines:
-LineNum | ItemCode | Quantity | WarehouseCode | UnitPrice | LineTotal
-0       | {ItemCode} | {Quantity} | {WarehouseCode} | {UnitPrice} | {LineTotal}
-1       | {ItemCode} | {Quantity} | {WarehouseCode} | {UnitPrice} | {LineTotal}
-...
-
-DocTotal: {DocTotal}
-
-Warnings:
-- {warning1}
-- {warning2}
-
-Options:
-[Confirm generating draft]
-[Cancel, do not generate]
-
-**Data sharing pattern \u2014 File-based handoff:** Every sub-agent in the pipeline MUST persist its work results as files under a shared project directory, never rely on in-memory data passing between steps. Deep agents have built-in file capabilities, so no middleware is needed.
-
-Rules:
-1. The **orchestrator** generates a unique project ID at the start (e.g., timestamp-based) and passes it to each sub-agent in the task context
-2. Each sub-agent reads input from \`/project/{project-id}/\` and writes output files into the same directory
-3. Establish clear file naming conventions so downstream steps know exactly which files to read (e.g., \`extracted.json\`, \`sku.json\`, \`customer.json\`, \`so_draft.json\`)
-4. The orchestrator's system prompt MUST specify for each edge: which files the target sub-agent should read and which files it should produce
-
-**Step 2: Topology design.** Design the agent topology and use \`show_widget\` to render an interactive diagram showing the flow: Orchestrator \u2192 Stage 1 \u2192 Stage 2 \u2192 ... \u2192 Output. Each edge should be labeled with its business purpose.
-
-**Step 3: Design each sub-agent** as a **deep_agent** type (one at a time). For each:
-- Responsibility, system prompt, middleware, file input/output contract (which files from \`/project/{project-id}/\` it reads, which files it writes)
-- Deep agents have built-in file capabilities (ls, read, write, edit, glob, grep), so do NOT add filesystem middleware.
-- **Ask for confirmation before moving to the next sub-agent.**
-
-**Step 4: Design the orchestrator.** Responsibility, system prompt, topology edges, sub-agent list.
-
- **Step 5: Self-review checklist.** Before presenting to the user, verify:
- - Completeness (every stage covered by an edge?)
- - Purposes clear (each edge's business intent?)
- - Order correct (serial chain logical?)
- - Edge cases (invalid input, failure, timeout?)
-
- **Step 6: Write the workflow description (Spec).** After designing the topology and sub-agents, compose a comprehensive **\`description\`** for the orchestrator. This description serves as the workflow's specification \u2014 anyone reading it should understand exactly what this workflow does without needing to inspect individual sub-agent configs.
-
- The description MUST include ALL of the following:
-
- | Section | Content |
- |---------|---------|
- | **Overview** | One-sentence summary of the workflow's purpose and business value |
- | **Steps** | Numbered list of each stage in the pipeline. For each step: which sub-agent handles it, what it does, what tools it uses, what files it reads from \`/project/{project-id}/\`, and what files it writes. |
- | **Data Flow** | How data moves between steps via files under \`/project/{project-id}/\`. For each step: which files it reads as input and which files it writes as output. |
- | **Logic & Conditions** | Any conditional branching, decision points, retry logic, or exception handling. When does the workflow take path A vs path B? What happens on failure? |
- | **Tools Used** | Summary table or list of all tools used across sub-agents, grouped by sub-agent |
- | **Expected Input** | What input does the workflow expect from the user? (format, examples) |
- | **Expected Output** | What does the workflow produce at the end? (format, examples) |
-
- **Formatting rules:**
-  - Write in **English**
- - Use **Markdown** for formatting (headings, lists, tables, code blocks)
- - Be detailed but concise \u2014 each section should be 1-5 lines
- - Avoid placeholder text like "TODO" or "TBD"
-
-  **Example structure** (\u5B50 Agent \u5747\u4E3A deep_agent \u7C7B\u578B\uFF0C\u65E0\u9700 filesystem \u4E2D\u95F4\u4EF6):
-
- \`\`\`markdown
- ## Overview
- \u672C\u5DE5\u4F5C\u6D41\u81EA\u52A8\u4ECE\u591A\u4E2A\u6570\u636E\u6E90\u91C7\u96C6\u7ADE\u54C1\u4EF7\u683C\uFF0C\u751F\u6210\u5BF9\u6BD4\u5206\u6790\u62A5\u544A\u5E76\u63A8\u9001\u901A\u77E5\u3002
-
- ## Steps
-  1. **\u6570\u636E\u91C7\u96C6 (data-collector)** \u2014 \u4F7F\u7528 browser \u5DE5\u5177\u722C\u53D6\u6307\u5B9AURL\u7684\u7ADE\u54C1\u4EF7\u683C\u6570\u636E\uFF0C\u8C03\u7528 metrics API \u62C9\u53D6\u5386\u53F2\u4EF7\u683C\u3002\u8F93\u51FA \u2192 \`raw_prices.json\`
-  2. **\u6570\u636E\u6E05\u6D17 (data-cleaner)** \u2014 \u8BFB\u53D6 \`raw_prices.json\`\uFF0C\u4F7F\u7528 code_eval \u6267\u884C Python \u811A\u672C\u6E05\u6D17\u5F02\u5E38\u503C\u548C\u7F3A\u5931\u503C\uFF0C\u7EDF\u4E00\u8D27\u5E01\u5355\u4F4D\u3002\u8F93\u51FA \u2192 \`cleaned_prices.json\`
-   3. **\u62A5\u544A\u751F\u6210 (report-generator)** \u2014 \u8BFB\u53D6 \`cleaned_prices.json\` \u548C\u6A21\u677F\u6587\u4EF6\uFF0Ccode_eval \u8BA1\u7B97\u6DA8\u8DCC\u5E45\u548C\u8D8B\u52BF\uFF0C\u751F\u6210 Markdown \u5BF9\u6BD4\u62A5\u544A\u3002\u8F93\u51FA \u2192 \`report.md\`
-  4. **\u901A\u77E5\u63A8\u9001 (notifier)** \u2014 \u8BFB\u53D6 \`report.md\`\uFF0C\u8C03\u7528 scheduler \u5B89\u6392\u5B9A\u65F6\u53D1\u9001\uFF0C\u4F7F\u7528 ask_user_to_clarify \u8BF7\u6C42\u53D1\u9001\u786E\u8BA4\u3002\u8F93\u51FA\u53D1\u9001\u7ED3\u679C\u3002
-
- ## Data Flow
- All data is shared via files under \`/project/{project-id}/\`:
- \`\u7528\u6237\u8F93\u5165\` \u2192 data-collector writes \`raw_prices.json\` \u2192 data-cleaner reads \`raw_prices.json\`, writes \`cleaned_prices.json\` \u2192 report-generator reads \`cleaned_prices.json\`, writes \`report.md\` \u2192 notifier reads \`report.md\`, pushes
-
- ## Logic & Conditions
- - data-collector \u722C\u53D6\u5931\u8D25\u65F6\u91CD\u8BD5\u6700\u591A3\u6B21\uFF0C\u95F4\u969430\u79D2
- - \u82E5\u67D0\u4E00\u5546\u54C1\u4EF7\u683C\u7F3A\u5931\u8D85\u8FC77\u5929\uFF0C\u6807\u8BB0\u4E3A\u300C\u6570\u636E\u4E0D\u5168\u300D\u5E76\u5728\u62A5\u544A\u4E2D\u9AD8\u4EAE
- - report-generator \u8BA1\u7B97\u6DA8\u5E45\u8D85\u8FC720%\u65F6\u81EA\u52A8\u6807\u8BB0\u300C\u5F02\u5E38\u6CE2\u52A8\u300D\u8B66\u544A
- - \u4EFB\u4F55\u6B65\u9AA4\u5931\u8D25\u65F6\uFF0Cworkflow \u505C\u6B62\u5E76\u5C06\u9519\u8BEF\u4FE1\u606F\u8F93\u51FA\u5230\u6700\u7EC8\u62A5\u544A
-
- ## Tools Used
- | \u5B50Agent | \u5DE5\u5177 |
- |---------|------|
- | data-collector | browser, metrics |
-| data-cleaner | code_eval |
-| report-generator | code_eval |
- | notifier | scheduler, ask_user_to_clarify |
-
- ## Expected Input
- - \u7ADE\u54C1URL\u5217\u8868\uFF08\u6BCF\u884C\u4E00\u4E2A\uFF09
- - \u65E5\u671F\u8303\u56F4\uFF08\u8D77\u59CB-\u7ED3\u675F\uFF0C\u683C\u5F0F YYYY-MM-DD\uFF09
- - \u63A8\u9001\u6E20\u9053\u9009\u62E9\uFF08\u90AE\u4EF6/\u9489\u9489/\u4F01\u4E1A\u5FAE\u4FE1\uFF09
-
- ## Expected Output
- - Markdown \u683C\u5F0F\u5BF9\u6BD4\u62A5\u544A\uFF0C\u5305\u542B\u4EF7\u683C\u8D8B\u52BF\u56FE\u3001\u6DA8\u8DCC\u5E45\u3001\u5F02\u5E38\u6807\u8BB0
- - \u62A5\u544A\u6587\u4EF6\u8DEF\u5F84\u53CA\u63A8\u9001\u72B6\u6001\u786E\u8BA4
- \`\`\`
+## Workflow C: Workflow DSL Agent (WORKFLOW type)
 
- **The description field is the single source of truth for the workflow.** When the user clicks the info icon on the workflow in the automation view, they will see this description rendered as a Popover. It must be comprehensive enough to stand alone as a spec document.
+Use this when the process is fully known. A workflow is a deterministic LangGraph state machine compiled from a concise JSON DSL.
 
- ### Phase 2: Confirm
+### When to choose WORKFLOW
 
- Present the full design: topology diagram, all sub-agent configs, orchestrator config, AND the workflow description (spec). **Ask for explicit approval:** "Ready to build? I'll create {N} sub-agents, then the orchestrator. Proceed?" **Do NOT build until the user confirms.**
+| WORKFLOW (DSL) | PROCESSING (deprecated) |
+|---|---|
+| 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 |
+| No LLM routing decisions | Orchestrator uses LLM to route |
 
-### Phase 3: Build
+### Phase 0: Load the Skill
 
-Create sub-agents FIRST, then the orchestrator:
+**BEFORE designing, you MUST load the create-workflow skill:**
 
 \`\`\`
-1. create_agent(name: "stage-1", type: "deep_agent", ...)
-2. create_agent(name: "stage-2", type: "deep_agent", ...)
-3. create_agent(name: "stage-3", type: "deep_agent", ...)
-4. create_processing_agent(
-     name: "orchestrator",
-     prompt: "...",
-     edges: [
-       { from: "orchestrator", to: "stage-1-id", purpose: "Validate input" },
-       { from: "stage-1-id", to: "stage-2-id", purpose: "Transform data" },
-       { from: "stage-2-id", to: "stage-3-id", purpose: "Generate output" },
-     ],
-     subAgents: ["stage-1-id", "stage-2-id", "stage-3-id"],
-   )
+skill(skill_name: "create-workflow")
 \`\`\`
 
-First edge's \`from\` uses orchestrator name as placeholder (auto-resolved). Subsequent edges chain from previous sub-agent IDs.
-
-### Phase 4: Test (ask first)
+### Phase 1: Design
 
-You may ask: "Want me to test the orchestrator end-to-end?" If yes, delegate to the **Agent Reviewer** sub-agent.
+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.
 
-### Phase 5: Bind channel (ask)
+### Phase 2: Confirm
 
-After the workflow is created, ask the user if they want to bind an email address (or Lark/Slack sender) to drive the workflow. This allows external users to trigger the workflow by sending messages to the channel.
+Present the design. Ask: "Ready to create this workflow?"
 
-**Step 1: Check installations.** Call \`manage_binding\` with \`action: "list_installations"\` to see available channel installations.
+### Phase 3: Build
 
-**Step 2: Ask user.** Present the available channels and ask: "Would you like to bind an email address to drive this workflow? If so, what email address should trigger it?"
+Call \`create_workflow\` with \`skillLoaded: true\`. Then \`validate_workflow(id)\`.
 
-**Step 3: Bind.** Call \`manage_binding\` with \`action: "create"\`, providing \`channel\`, \`senderId\` (the email), and \`agentId\` (the orchestrator's ID).
+### Phase 4: Test
 
-**IMPORTANT:** Only create a binding after the user explicitly provides the email address. Do NOT guess or fabricate sender information.
+Ask the user if they want to test.
 
 ---
 
-## Workflow C: Dynamic Agent (DEEP_AGENT type)
+## Workflow D: Dynamic Agent (DEEP_AGENT type)
 
 Use this for complex, open-ended tasks where the execution path cannot be fully predetermined. The DEEP_AGENT self-generates a dynamic todo list and iteratively works through it.
 
@@ -20007,7 +20169,7 @@ Follow the same Design \u2192 Confirm \u2192 Build cycle. Test only on request.
 2. Understand what the user wants to change
 3. **DESIGN**: Present the proposed changes clearly. Show a before/after diff.
 4. **CONFIRM**: Ask for explicit approval. Do NOT call update_agent until confirmed.
-5. **BUILD**: Call **update_agent** (or **update_processing_agent** for PROCESSING agents)
+5. **BUILD**: Call **update_agent** (or **update_workflow** for WORKFLOW agents)
 6. **TEST**: You may ask if they want to test. If yes, delegate to the **Agent Reviewer** sub-agent
 
 ## Deleting Agents
@@ -20038,28 +20200,53 @@ All fields except name, type, and prompt are optional.
 }
 \`\`\`
 
-### create_processing_agent (PROCESSING)
+### create_workflow (WORKFLOW)
 
-Creates a PROCESSING agent with a business-defined workflow topology. Sub-agents must already exist (created as **deep_agent** type).
+Creates a WORKFLOW agent from a concise DSL. Before calling, load the \`create-workflow\` skill for the complete DSL specification. Must pass \`skillLoaded: true\`.
 
 \`\`\`typescript
 {
-  name: string,              // Required. Display name for the orchestrator
-  description?: string,      // Required for good UX. Comprehensive workflow spec in Markdown (English). Must cover: Overview, Steps (with tools per step), Data Flow, Logic & Conditions, Tools Used, Expected Input, Expected Output. This is the single source of truth displayed in the automation view info popover.
-  prompt: string,            // Required. System prompt \u2014 how to route through the topology
-  edges: [{                  // Required. At least 1 edge defining the serial workflow chain
-    from: string,            // Source agent ID. First edge: use orchestrator name as placeholder (tool auto-replaces). Subsequent edges: previous sub-agent ID
-    to: string,              // Sub-agent ID to delegate to
-    purpose: string,         // Business purpose \u2014 what this step accomplishes
-  }],
-  tools?: string[],          // Optional. Tool keys from list_tools
-  subAgents: string[],       // Required. IDs of sub-agents in the pipeline
-  internalSubAgents?: AgentConfig[],  // Optional. Inline sub-agent configs
-  middleware?: MiddlewareConfig[],    // Optional. Additional middleware (topology is auto-added)
-  modelKey?: string,         // Optional. Model to use
+  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
+}
+\`\`\`
+
+### update_workflow
+
+Updates an existing WORKFLOW agent. Only include fields you want to change.
+
+\`\`\`typescript
+{
+  id: string,                // Required. Workflow agent ID
+  name?: string,             // Optional
+  description?: string,      // Optional
+  workflow?: { name: string, steps: WorkflowStep[] },  // Optional. Replacement DSL
+  tools?: string[],          // Optional
+  middleware?: MiddlewareConfig[],  // Optional
+  modelKey?: string,         // Optional
 }
 \`\`\`
 
+### validate_workflow
+
+Validates a workflow agent's DSL and returns any errors or warnings.
+
+\`\`\`typescript
+{
+  id: string,                // Required. Workflow agent ID to validate
+}
+\`\`\`
+
+Returns: \`{ valid: boolean, stepCount, issues: [{ type: "error"|"warning", message }] }\`
+
 ### Middleware Config Reference
 
 Each middleware entry uses this base shape:
@@ -20151,8 +20338,8 @@ Provides: \`schedule_at\`, \`schedule_after\`, \`schedule_recurring\`, \`cancel_
 |-------------|------|-------------|
 | defaultMaxRetries | number? | Default max retries for scheduled tasks. Default: \`0\` |
 
-#### topology
-Provides: \`read_topo_progress\` \u2014 enforces multi-agent workflow topology. **Required for PROCESSING agents \u2014 auto-injected by create_processing_agent.**
+#### topology [DEPRECATED \u2014 use WORKFLOW DSL instead]
+Provides: \`read_topo_progress\` \u2014 enforces multi-agent workflow topology for PROCESSING agents only. Not needed for WORKFLOW agents.
 | config field | type | description |
 |-------------|------|-------------|
 | edges | TopologyEdge[] | **Required.** Directed edges: \`{ from: string, to: string, purpose: string }\`. The \`purpose\` must describe the business intent of this delegation step. |
@@ -20208,29 +20395,6 @@ Use \`manage_binding\` to bind external senders (email, Lark, Slack) to agents.
 - **threadMode**: Always use \`"per_conversation"\` (new thread per conversation). Do NOT use \`"fixed"\`.
 - **channelInstallationId**: Auto-detected if only one installation exists for the channel. Use \`list_installations\` first if unsure.
 
-### update_processing_agent
-
-Updates a PROCESSING agent's topology edges, name, prompt, or sub-agents. Unlike update_agent, this properly handles placeholder resolution for edge \`from\` values and manages the topology middleware correctly.
-
-\`\`\`typescript
-{
-  id: string,                // Required. The PROCESSING agent ID to update
-  name?: string,             // Optional. New display name
-  description?: string,      // Optional. New short description
-  prompt?: string,           // Optional. New orchestrator system prompt
-  edges?: [{                 // Optional. New topology edges (serial chain)
-    from: string,            // First edge: orchestrator name placeholder. Subsequent: previous sub-agent ID
-    to: string,              // Sub-agent ID
-    purpose: string,         // Business purpose
-  }],
-  subAgents?: string[],      // Optional. New sub-agent IDs
-  middleware?: MiddlewareConfig[],  // Optional. Additional middleware (topology auto-managed)
-  modelKey?: string,         // Optional. New model
-}
-\`\`\`
-
-**When to use:** Use this whenever you need to change a PROCESSING agent's topology \u2014 adding/removing/recruiting pipeline stages, changing the flow order, or updating edge purposes. Use regular \`update_agent\` only for REACT and DEEP_AGENT agents.
-
 ### update_agent parameters
 
 \`\`\`typescript
@@ -20344,14 +20508,23 @@ var agentArchitectConfig = {
     "list_tools",
     "get_agent",
     "create_agent",
-    "create_processing_agent",
-    "update_processing_agent",
+    "create_workflow",
+    "validate_workflow",
+    "update_workflow",
     "update_agent",
     "delete_agent",
     "manage_binding"
   ],
   internalSubAgents: [agentReviewerConfig],
   middleware: [
+    {
+      id: "skill",
+      type: "skill",
+      name: "Skill",
+      description: "Load skill content and instructions",
+      enabled: true,
+      config: { readAll: true }
+    },
     {
       id: "widget",
       type: "widget",
@@ -23225,21 +23398,28 @@ export {
   agentInstanceManager,
   agentLatticeManager,
   buildGrepResultsDict,
+  buildInput,
   buildNamedVolumeName,
   buildSandboxMetadataEnv,
   buildSkillFile,
+  buildStateAnnotation,
   checkEmptyContent,
   clearEncryptionKeyCache,
+  compileWorkflow,
   computeSandboxName,
   configureStores,
+  createAgentNode,
   createAgentTeam,
   createExecuteSqlQueryTool,
   createFileData,
+  createHumanFeedbackNode,
   createInfoSqlTool,
   createListMetricsDataSourcesTool,
   createListMetricsServersTool,
   createListTablesSqlTool,
+  createMapNode,
   createModelSelectorMiddleware,
+  createNodeHandler,
   createProcessingAgent,
   createQueryCheckerSqlTool,
   createQueryMetricDefinitionTool,
@@ -23252,6 +23432,7 @@ export {
   createSchedulerMiddleware,
   createTeamMiddleware,
   createTeammateTools,
+  createTerminalNode,
   createUnknownToolHandlerMiddleware,
   createWidgetMiddleware,
   decrypt,
@@ -23261,7 +23442,9 @@ export {
   ensureBuiltinAgentsForTenant,
   eventBus,
   event_bus_default as eventBusDefault,
+  expand,
   extractFetcherError,
+  extractOutput,
   fileDataToString,
   formatContentWithLineNumbers,
   formatGrepMatches,
@@ -23297,6 +23480,7 @@ export {
   grepMatchesFromFiles,
   grepSearchFiles,
   hasChunkBuffer,
+  invokeWithRetry,
   isBuiltInSkill,
   isUsingDefaultKey,
   isValidCronExpression,
@@ -23307,6 +23491,7 @@ export {
   metricsServerManager,
   modelLatticeManager,
   normalizeSandboxName,
+  parallelLimit,
   parseCronExpression,
   parseSkillFrontmatter,
   performStringReplacement,
@@ -23326,6 +23511,8 @@ export {
   registerTeammateAgent,
   registerToolLattice,
   registerVectorStoreLattice,
+  renderTemplate,
+  resolvePath,
   sandboxLatticeManager,
   sanitizeToolCallId,
   scheduleLatticeManager,
@@ -23338,6 +23525,7 @@ export {
   unregisterTeammateAgent,
   updateFileData,
   validateAgentInput,
+  validateDSL,
   validateEncryptionKey,
   validatePath,
   validateSkillName,