@axiom-lattice/core 2.1.79 → 2.1.80

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,17 +18,1631 @@ var __copyProps = (to, from, except, desc) => {
       if (!__hasOwnProp.call(to, key) && key !== except)
         __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/base/BaseLatticeManager.ts
+var _BaseLatticeManager, BaseLatticeManager;
+var init_BaseLatticeManager = __esm({
+  "src/base/BaseLatticeManager.ts"() {
+    "use strict";
+    _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();
+    BaseLatticeManager = _BaseLatticeManager;
+  }
+});
+
+// src/memory_lattice/MemoryLatticeManager.ts
+var import_protocols2, _MemoryLatticeManager, MemoryLatticeManager, getCheckpointSaver, registerCheckpointSaver;
+var init_MemoryLatticeManager = __esm({
+  "src/memory_lattice/MemoryLatticeManager.ts"() {
+    "use strict";
+    init_BaseLatticeManager();
+    import_protocols2 = require("@axiom-lattice/protocols");
+    _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();
+    MemoryLatticeManager = _MemoryLatticeManager;
+    getCheckpointSaver = (key) => MemoryLatticeManager.getInstance().getCheckpointSaver(key);
+    registerCheckpointSaver = (key, saver) => MemoryLatticeManager.getInstance().registerCheckpointSaver(key, saver);
+  }
+});
+
+// src/memory_lattice/DefaultMemorySaver.ts
+var import_langgraph2, memory;
+var init_DefaultMemorySaver = __esm({
+  "src/memory_lattice/DefaultMemorySaver.ts"() {
+    "use strict";
+    import_langgraph2 = require("@langchain/langgraph");
+    init_MemoryLatticeManager();
+    memory = new import_langgraph2.MemorySaver();
+    registerCheckpointSaver("default", memory);
+  }
+});
+
+// src/memory_lattice/index.ts
+var memory_lattice_exports = {};
+__export(memory_lattice_exports, {
+  MemoryLatticeManager: () => MemoryLatticeManager,
+  MemoryType: () => import_protocols2.MemoryType,
+  getCheckpointSaver: () => getCheckpointSaver,
+  registerCheckpointSaver: () => registerCheckpointSaver
+});
+var init_memory_lattice = __esm({
+  "src/memory_lattice/index.ts"() {
+    "use strict";
+    init_DefaultMemorySaver();
+    init_MemoryLatticeManager();
+  }
+});
+
+// src/workflow/utils.ts
+function buildStateAnnotation(fields) {
+  const annotations = {};
+  if (fields) {
+    for (const [key, field] of Object.entries(fields)) {
+      annotations[key] = (0, import_langgraph15.Annotation)({
+        default: () => field.default ?? defaultValueForType(field.type),
+        reducer: buildReducer(field.reducer ?? "replace")
+      });
+    }
+  }
+  if (!annotations["messages"]) {
+    annotations["messages"] = (0, import_langgraph15.Annotation)({
+      default: () => [],
+      reducer: (prev, next) => [...prev, ...next]
+    });
+  }
+  annotations["phase"] = (0, import_langgraph15.Annotation)({
+    default: () => "init",
+    reducer: (_prev, next) => next
+  });
+  if (!annotations["status"]) {
+    annotations["status"] = (0, import_langgraph15.Annotation)({
+      default: () => "",
+      reducer: (_prev, next) => next
+    });
+  }
+  if (!annotations["_runId"]) {
+    annotations["_runId"] = (0, import_langgraph15.Annotation)({
+      default: () => void 0,
+      reducer: (_prev, next) => next ?? _prev
+    });
+  }
+  return import_langgraph15.Annotation.Root(annotations);
+}
+function defaultValueForType(type) {
+  switch (type) {
+    case "string":
+      return "";
+    case "number":
+      return null;
+    case "boolean":
+      return false;
+    case "object":
+      return null;
+    case "array":
+      return [];
+    default:
+      return null;
+  }
+}
+function buildReducer(kind) {
+  switch (kind) {
+    case "append":
+      return (prev, next) => {
+        const arr = Array.isArray(prev) ? prev : [];
+        return arr.concat(Array.isArray(next) ? next : [next]);
+      };
+    case "merge":
+      return (prev, next) => {
+        const obj = prev && typeof prev === "object" && !Array.isArray(prev) ? prev : {};
+        const merge = next && typeof next === "object" && !Array.isArray(next) ? next : {};
+        return { ...obj, ...merge };
+      };
+    case "replace":
+    default:
+      return (_prev, next) => next;
+  }
+}
+function resolvePath(obj, path3) {
+  const cleanPath = path3.startsWith("state.") ? path3.slice(6) : path3;
+  const parts = cleanPath.split(/\.|\[|\]\.?/).filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current === "object") {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function renderTemplate(template, state, item) {
+  return template.replace(/\$\{([^}]+)\}/g, (_match, expr) => {
+    const trimmed = expr.trim();
+    if (trimmed.startsWith("state.")) {
+      const val = resolvePath(state, trimmed);
+      return val === void 0 ? "" : formatValue(val);
+    }
+    if (trimmed.startsWith("item.") || trimmed === "item") {
+      if (!item) return "";
+      if (trimmed === "item") {
+        if (typeof item === "object" && "item" in item) {
+          return formatValue(item.item);
+        }
+        return formatValue(item);
+      }
+      const itemPath = trimmed;
+      const val = resolvePath({ item }, itemPath);
+      return val === void 0 ? "" : formatValue(val);
+    }
+    if (item && typeof item === "object") {
+      const firstSeg = trimmed.split(".")[0];
+      if (firstSeg in item) {
+        const val = resolvePath({ item }, `item.${trimmed}`);
+        return val === void 0 ? "" : formatValue(val);
+      }
+    }
+    return `\${${trimmed}}`;
+  });
+}
+function formatValue(val) {
+  if (typeof val === "string") return val;
+  if (val === null || val === void 0) return "";
+  if (Array.isArray(val)) {
+    const parts = val.map((item) => {
+      const content = item?.content ?? item?.kwargs?.content;
+      if (typeof content === "string") return content;
+      if (Array.isArray(content)) {
+        return content.filter((c) => c?.type === "text").map((c) => String(c.text ?? "")).join("\n");
+      }
+      if (content && typeof content === "object") return JSON.stringify(content, null, 2);
+      if (item && typeof item === "object") return JSON.stringify(item, null, 2);
+      return String(item);
+    });
+    const result = parts.filter(Boolean).join("\n");
+    return result || JSON.stringify(val, null, 2);
+  }
+  return JSON.stringify(val, null, 2);
+}
+function buildInput(input, state, item, outputSchema) {
+  let prompt = input?.template ? renderTemplate(input.template, state, item) : "";
+  if (outputSchema) {
+    const example = schemaToExample(outputSchema);
+    const schemaInstruction = `
+
+Output must be valid JSON in exactly this shape. Return ONLY the JSON, no other text or markdown:
+${example}`;
+    prompt = prompt + schemaInstruction;
+  }
+  return { messages: [new import_messages6.HumanMessage(prompt)] };
+}
+function schemaToExample(schema) {
+  const example = schemaValueToExample(schema);
+  return JSON.stringify(example, null, 2);
+}
+function schemaValueToExample(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value !== "object") return value;
+  const obj = value;
+  if (obj.type === "string") return "<string>";
+  if (obj.type === "number") return "<number>";
+  if (obj.type === "boolean") return "<boolean>";
+  if (obj.type === "integer") return "<integer>";
+  if (obj.type === "array" && obj.items) {
+    return [schemaValueToExample(obj.items)];
+  }
+  if (obj.type === "object" && obj.properties && typeof obj.properties === "object") {
+    const example2 = {};
+    for (const [k, v] of Object.entries(obj.properties)) {
+      example2[k] = schemaValueToExample(v);
+    }
+    return example2;
+  }
+  if (obj.type === "object") return {};
+  if (Array.isArray(value)) {
+    if (value.length === 1) {
+      return [schemaValueToExample(value[0])];
+    }
+    return value.map(schemaValueToExample);
+  }
+  const example = {};
+  for (const [k, v] of Object.entries(obj)) {
+    example[k] = schemaValueToExample(v);
+  }
+  return example;
+}
+function extractOutput(result) {
+  if ("structuredResponse" in result && result.structuredResponse !== void 0) {
+    return result.structuredResponse;
+  }
+  const messages = result.messages;
+  if (messages && Array.isArray(messages)) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (msg._getType() === "ai") {
+        const content = msg.content;
+        if (typeof content === "object" && content !== null && !Array.isArray(content)) {
+          return content;
+        }
+        if (Array.isArray(content)) {
+          const textParts = content.filter(
+            (c) => typeof c === "object" && c !== null && c.type === "text"
+          ).map((c) => c.text).join("\n");
+          if (textParts) {
+            try {
+              return JSON.parse(textParts);
+            } catch {
+              const fenced = extractJsonFromFence(textParts);
+              if (fenced !== void 0) return fenced;
+              return textParts;
+            }
+          }
+          return content;
+        }
+        if (typeof content === "string") {
+          try {
+            return JSON.parse(content);
+          } catch {
+            const fenced = extractJsonFromFence(content);
+            if (fenced !== void 0) return fenced;
+            return content;
+          }
+        }
+        return content;
+      }
+    }
+  }
+  const { messages: _msgs, ...rest } = result;
+  void _msgs;
+  return rest;
+}
+function extractJsonFromFence(text) {
+  const jsonFence = text.match(/```json\s*\n([\s\S]*?)```/);
+  if (jsonFence) {
+    try {
+      return JSON.parse(jsonFence[1].trim());
+    } catch {
+    }
+  }
+  const plainFence = text.match(/```\s*\n([\s\S]*?)```/);
+  if (plainFence) {
+    try {
+      return JSON.parse(plainFence[1].trim());
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function parallelLimit(items, limit, fn) {
+  const results = new Array(items.length);
+  let index = 0;
+  async function worker() {
+    while (index < items.length) {
+      const i = index++;
+      results[i] = await fn(items[i], i);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+  return results;
+}
+async function invokeWithRetry(fn, maxRetries, retryOn, timeoutMs) {
+  let lastError;
+  for (let i = 0; i <= maxRetries; i++) {
+    try {
+      const promise = fn();
+      if (timeoutMs && timeoutMs > 0) {
+        return await withTimeout(promise, timeoutMs);
+      }
+      return await promise;
+    } catch (err) {
+      if (err?.name === "GraphInterrupt") {
+        throw err;
+      }
+      lastError = err;
+      if (i === maxRetries) throw err;
+      if (retryOn?.length) {
+        const errName = err?.name ?? "";
+        if (!retryOn.includes(errName)) throw err;
+      }
+    }
+  }
+  throw lastError;
+}
+function withTimeout(promise, ms) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(`Operation timed out after ${ms}ms`)), ms)
+    )
+  ]);
+}
+function createAgentNode(node, resolveAgent, trackingStore) {
+  return async (state, config) => {
+    const runId = state._runId;
+    const tenantId = config?.configurable?.tenantId ?? "default";
+    const startedAt = Date.now();
+    let stepId;
+    if (trackingStore && runId) {
+      trackingStore.updateWorkflowRun(runId, {
+        status: "running",
+        completedAt: null
+      }).catch(() => {
+      });
+    }
+    try {
+      console.log(`[WF][${node.id}] START "${node.name}" | hasSchema=${!!node.output?.schema}`);
+      const responseFormat = node.output?.schema;
+      console.log(`[WF][${node.id}] resolving agent...`);
+      const client = await resolveAgent(node.ref, responseFormat, node.type);
+      console.log(`[WF][${node.id}] agent resolved, building input...`);
+      const input = buildInput(
+        node.input,
+        state,
+        void 0,
+        responseFormat ? void 0 : node.output?.schema
+      );
+      const renderedInput = input.messages[0]?.content ?? "";
+      console.log(`[WF][${node.id}] === INPUT (full) ===
+${renderedInput}
+=== END INPUT ===`);
+      if (trackingStore && runId) {
+        const step = await trackingStore.upsertRunStep({
+          runId,
+          tenantId,
+          stepType: node.type,
+          stepName: node.name,
+          input: { template: node.input?.template, rendered: renderedInput }
+        }).catch((e) => {
+          console.warn("Failed to upsert run step:", e.message);
+          return null;
+        });
+        stepId = step?.id;
+        if (step && step.status === "interrupted") {
+          trackingStore.updateRunStep(runId, step.id, { status: "running" }).catch(() => {
+          });
+        }
+      }
+      const subConfig = {
+        ...config,
+        configurable: {
+          ...config?.configurable ?? {},
+          thread_id: `${config?.configurable?.thread_id ?? "default"}:${node.id}`
+        }
+      };
+      let result;
+      try {
+        console.log(`[WF][${node.id}] invoking agent.invoke()...`);
+        result = await invokeWithRetry(
+          () => client.invoke(input, subConfig),
+          node.config?.maxRetries ?? 0,
+          node.config?.retryOn,
+          node.config?.timeout
+        );
+        console.log(`[WF][${node.id}] invoke SUCCESS, extracting output...`);
+      } catch (err) {
+        if (err?.name === "GraphInterrupt") {
+          if (trackingStore && runId && stepId) {
+            trackingStore.updateRunStep(runId, stepId, { status: "interrupted" }).catch(() => {
+            });
+          }
+          if (trackingStore && runId) {
+            trackingStore.updateWorkflowRun(runId, { status: "interrupted", completedAt: null }).catch(() => {
+            });
+          }
+          throw err;
+        }
+        const errMsg = err?.message ?? "";
+        console.log(`[WF][${node.id}] invoke FAILED: ${errMsg}`);
+        if (responseFormat && (errMsg.includes("tool_choice") || errMsg.includes("thinking") || errMsg.includes("reasoning") || errMsg.includes("InvalidParameter"))) {
+          console.log(`[WF][${node.id}] attempting fallback (text-based schema injection)...`);
+          const fallbackClient = await resolveAgent(node.ref, void 0, node.type);
+          const fallbackInput = buildInput(node.input, state, void 0, responseFormat);
+          result = await invokeWithRetry(
+            () => fallbackClient.invoke(fallbackInput, subConfig),
+            node.config?.maxRetries ?? 0,
+            node.config?.retryOn,
+            node.config?.timeout
+          );
+          console.log(`[WF][${node.id}] fallback invoke SUCCESS`);
+        } else {
+          throw err;
+        }
+      }
+      const output = extractOutput(result);
+      console.log(`[WF][${node.id}] === OUTPUT (full) | key=${node.output?.key} ===
+${JSON.stringify(output, null, 2)}
+=== END OUTPUT ===`);
+      const update = { phase: node.id };
+      if (node.output?.key) {
+        update[node.output.key] = output;
+      }
+      const subMessages = result.messages;
+      if (subMessages && Array.isArray(subMessages)) {
+        const aiMessages = subMessages.filter((m) => {
+          const t = typeof m._getType === "function" ? m._getType() : m.role ?? m.type;
+          return t === "ai";
+        });
+        if (aiMessages.length > 0) {
+          update.messages = aiMessages;
+        }
+      }
+      console.log(`[WF][${node.id}] DONE (${Date.now() - startedAt}ms)`);
+      if (trackingStore && runId && stepId) {
+        trackingStore.updateRunStep(runId, stepId, {
+          status: "completed",
+          output,
+          completedAt: /* @__PURE__ */ new Date(),
+          durationMs: Date.now() - startedAt
+        }).catch((e) => {
+          console.warn("Failed to update run step:", e.message);
+        });
+      }
+      return update;
+    } catch (err) {
+      if (err?.name === "GraphInterrupt") {
+        throw err;
+      }
+      if (trackingStore && runId) {
+        if (stepId) {
+          trackingStore.updateRunStep(runId, stepId, {
+            status: "failed",
+            errorMessage: err.message,
+            completedAt: /* @__PURE__ */ new Date(),
+            durationMs: Date.now() - startedAt
+          }).catch((e) => {
+            console.warn("Failed to update run step:", e.message);
+          });
+        }
+        trackingStore.updateWorkflowRun(runId, {
+          status: "failed",
+          errorMessage: err.message,
+          completedAt: /* @__PURE__ */ new Date()
+        }).catch((e) => {
+          console.warn("Failed to finalize WorkflowRun:", e.message);
+        });
+      }
+      throw err;
+    }
+  };
+}
+function createHumanFeedbackNode(node, resolveAgent, trackingStore) {
+  return async (state, config) => {
+    const runId = state._runId;
+    const tenantId = config?.configurable?.tenantId ?? "default";
+    const startedAt = Date.now();
+    let stepId;
+    if (trackingStore && runId) {
+      trackingStore.updateWorkflowRun(runId, {
+        status: "running",
+        completedAt: null
+      }).catch(() => {
+      });
+    }
+    try {
+      console.log(`[WF][${node.id}] HUMAN_FEEDBACK START "${node.config?.title || node.name}"`);
+      const responseFormat = node.output?.schema;
+      const client = await resolveAgent(void 0, responseFormat, node.type);
+      console.log(`[WF][${node.id}] agent resolved, building input...`);
+      const input = buildInput(
+        node.input,
+        state,
+        void 0,
+        responseFormat ? void 0 : node.output?.schema
+      );
+      const humanContent = input.messages[0]?.content ?? "";
+      input.messages = [
+        new import_messages6.SystemMessage(
+          `Follow this exact procedure. Do NOT skip any step.
+
+STEP 1: Read the prompt. It contains content to present to the user and a question to ask.
+
+STEP 2: Call ask_user_to_clarify. Your question text MUST contain the ACTUAL content from the prompt \u2014 copy-paste the relevant text, data, or facts directly into the question. A question like "Do you approve this recommendation?" is WRONG because the user has no idea what the recommendation says. Instead: "Do you approve this recommendation: [paste the actual recommendation text here]?"
+
+STEP 3: The tool will pause. The user will see your questions and respond. You will receive their answers.
+
+STEP 4: Based on the user's answers, produce your final output.`
+        ),
+        ...input.messages
+      ];
+      const renderedInput = humanContent;
+      if (trackingStore && runId) {
+        const step = await trackingStore.upsertRunStep({
+          runId,
+          tenantId,
+          stepType: node.type,
+          stepName: node.name,
+          input: { template: node.input?.template, rendered: renderedInput }
+        }).catch((e) => {
+          console.warn("Failed to upsert run step:", e.message);
+          return null;
+        });
+        stepId = step?.id;
+        if (step && step.status === "interrupted") {
+          trackingStore.updateRunStep(runId, step.id, { status: "running" }).catch(() => {
+          });
+        }
+      }
+      const subConfig = {
+        ...config,
+        configurable: {
+          ...config?.configurable ?? {},
+          thread_id: `${config?.configurable?.thread_id ?? "default"}:${node.id}`
+        }
+      };
+      console.log(`[WF][${node.id}] === INPUT (full) ===
+${renderedInput}
+=== END INPUT ===`);
+      const result = await invokeWithRetry(
+        () => client.invoke(input, subConfig),
+        node.config?.maxRetries ?? 0,
+        node.config?.retryOn,
+        node.config?.timeout
+      );
+      console.log(`[WF][${node.id}] invoke SUCCESS, extracting output...`);
+      const output = extractOutput(result);
+      console.log(`[WF][${node.id}] === OUTPUT (full) | key=${node.output?.key} ===
+${JSON.stringify(output, null, 2)}
+=== END OUTPUT ===`);
+      const update = { phase: node.id };
+      if (node.output?.key) {
+        update[node.output.key] = output;
+      }
+      if (output && typeof output === "object" && !Array.isArray(output)) {
+        Object.assign(update, output);
+      }
+      const subMessages = result.messages;
+      if (subMessages && Array.isArray(subMessages)) {
+        const aiMessages = subMessages.filter((m) => {
+          const t = typeof m._getType === "function" ? m._getType() : m.role ?? m.type;
+          return t === "ai";
+        });
+        if (aiMessages.length > 0) {
+          update.messages = aiMessages;
+        }
+      }
+      console.log(`[WF][${node.id}] DONE (${Date.now() - startedAt}ms)`);
+      if (trackingStore && runId && stepId) {
+        trackingStore.updateRunStep(runId, stepId, {
+          status: "completed",
+          output,
+          completedAt: /* @__PURE__ */ new Date(),
+          durationMs: Date.now() - startedAt
+        }).catch((e) => {
+          console.warn("Failed to update run step:", e.message);
+        });
+      }
+      return update;
+    } catch (err) {
+      if (err?.name === "GraphInterrupt") {
+        if (trackingStore && runId && stepId) {
+          trackingStore.updateRunStep(runId, stepId, {
+            status: "interrupted"
+          }).catch(() => {
+          });
+        }
+        if (trackingStore && runId) {
+          trackingStore.updateWorkflowRun(runId, {
+            status: "interrupted",
+            completedAt: null
+          }).catch(() => {
+          });
+        }
+        throw err;
+      }
+      if (trackingStore && runId) {
+        if (stepId) {
+          trackingStore.updateRunStep(runId, stepId, {
+            status: "failed",
+            errorMessage: err.message,
+            completedAt: /* @__PURE__ */ new Date(),
+            durationMs: Date.now() - startedAt
+          }).catch((e) => {
+            console.warn("Failed to update run step:", e.message);
+          });
+        }
+        trackingStore.updateWorkflowRun(runId, {
+          status: "failed",
+          errorMessage: err.message,
+          completedAt: /* @__PURE__ */ new Date()
+        }).catch((e) => {
+          console.warn("Failed to finalize WorkflowRun:", e.message);
+        });
+      }
+      throw err;
+    }
+  };
+}
+function createMapNode(node, resolveAgent, trackingStore) {
+  return async (state, config) => {
+    const runId = state._runId;
+    const tenantId = config?.configurable?.tenantId ?? "default";
+    const startedAt = Date.now();
+    let stepId;
+    if (trackingStore && runId) {
+      trackingStore.updateWorkflowRun(runId, {
+        status: "running",
+        completedAt: null
+      }).catch(() => {
+      });
+    }
+    try {
+      const items = resolvePath(state, node.source);
+      if (trackingStore && runId) {
+        const step = await trackingStore.upsertRunStep({
+          runId,
+          tenantId,
+          stepType: node.type,
+          stepName: node.name,
+          input: { source: node.source, itemCount: Array.isArray(items) ? items.length : 0 }
+        }).catch((e) => {
+          console.warn("Failed to upsert run step:", e.message);
+          return null;
+        });
+        stepId = step?.id;
+        if (step && step.status === "interrupted") {
+          trackingStore.updateRunStep(runId, step.id, { status: "running" }).catch(() => {
+          });
+        }
+      }
+      if (!Array.isArray(items)) {
+        throw new Error(
+          `Map source "${node.source}" resolved to ${typeof items}, expected array`
+        );
+      }
+      const batchSize = node.config?.batchSize ?? 50;
+      const maxConcurrency = node.config?.maxConcurrency ?? 10;
+      const innerConcurrency = node.config?.innerConcurrency ?? 5;
+      const itemKey = node.itemKey ?? "item";
+      const innerClient = await resolveAgent(node.node.ref, node.node.schema, node.type);
+      const batches = chunk(items, batchSize);
+      const batchResults = await parallelLimit(batches, maxConcurrency, async (batch) => {
+        const itemResults = await parallelLimit(batch, innerConcurrency, async (item, itemIdx) => {
+          const itemCtx = { [itemKey]: item };
+          const input = buildInput(node.node.input, state, itemCtx);
+          const subConfig = {
+            ...config,
+            configurable: {
+              ...config?.configurable ?? {},
+              thread_id: `${config?.configurable?.thread_id ?? "default"}:${node.id}:item:${itemIdx}`
+            }
+          };
+          const result = await invokeWithRetry(
+            () => innerClient.invoke(input, subConfig),
+            node.config?.maxRetries ?? 0,
+            node.config?.retryOn,
+            node.config?.timeout
+          );
+          return extractOutput(result);
+        });
+        return itemResults;
+      });
+      const allResults = batchResults.flat();
+      let finalOutput = allResults;
+      if (node.reduce) {
+        const reduceClient = await resolveAgent(node.reduce.ref, node.reduce.schema, node.type);
+        const tempResultsKey = node.output?.key ?? `${node.id}_results`;
+        const tempState = { ...state, [tempResultsKey]: allResults };
+        const reduceInput = buildInput(node.reduce.input, tempState);
+        const reduceResult = await invokeWithRetry(
+          () => reduceClient.invoke(reduceInput, {
+            ...config,
+            configurable: {
+              ...config?.configurable ?? {},
+              thread_id: `${config?.configurable?.thread_id ?? "default"}:${node.id}:reduce`
+            }
+          }),
+          node.config?.maxRetries ?? 0,
+          node.config?.retryOn,
+          node.config?.timeout
+        );
+        finalOutput = extractOutput(reduceResult);
+      }
+      const update = { phase: node.id };
+      if (node.output?.key) {
+        update[node.output.key] = finalOutput;
+      }
+      if (trackingStore && runId && stepId) {
+        trackingStore.updateRunStep(runId, stepId, {
+          status: "completed",
+          output: finalOutput,
+          completedAt: /* @__PURE__ */ new Date(),
+          durationMs: Date.now() - startedAt
+        }).catch((e) => {
+          console.warn("Failed to update run step:", e.message);
+        });
+      }
+      return update;
+    } catch (err) {
+      if (err?.name === "GraphInterrupt") {
+        if (trackingStore && runId && stepId) {
+          trackingStore.updateRunStep(runId, stepId, { status: "interrupted" }).catch(() => {
+          });
+        }
+        if (trackingStore && runId) {
+          trackingStore.updateWorkflowRun(runId, { status: "interrupted", completedAt: null }).catch(() => {
+          });
+        }
+        throw err;
+      }
+      console.error(`[WF][${node.id}] FAILED after ${Date.now() - startedAt}ms:`, err.stack || err.message);
+      if (trackingStore && runId) {
+        if (stepId) {
+          trackingStore.updateRunStep(runId, stepId, {
+            status: "failed",
+            errorMessage: err.message,
+            completedAt: /* @__PURE__ */ new Date(),
+            durationMs: Date.now() - startedAt
+          }).catch(() => {
+          });
+        }
+        trackingStore.updateWorkflowRun(runId, {
+          status: "failed",
+          errorMessage: err.message,
+          completedAt: /* @__PURE__ */ new Date()
+        }).catch(() => {
+        });
+      }
+      throw err;
+    }
+  };
+}
+function createInputNode(node, trackingStore) {
+  return async (state, config) => {
+    const tenantId = config?.configurable?.tenantId ?? "default";
+    const threadId = config?.configurable?.thread_id ?? "default";
+    const assistantId = config?.configurable?.assistantId || config?.configurable?.assistant_id || "unknown";
+    const messages = state.messages;
+    const humanMsg = messages?.find((m) => m._getType() === "human");
+    const inputText = typeof humanMsg?.content === "string" ? humanMsg.content : JSON.stringify(humanMsg?.content ?? "");
+    console.log(`[WF][n_input] input captured: "${inputText.slice(0, 200)}"`);
+    const update = { phase: node.id };
+    if (node.output?.key) update[node.output.key] = inputText;
+    if (trackingStore && !state._runId) {
+      try {
+        const run = await trackingStore.createWorkflowRun({
+          tenantId,
+          assistantId,
+          threadId,
+          topologyEdges: [],
+          metadata: { workflowName: node.name }
+        });
+        update._runId = run.id;
+        await trackingStore.createRunStep({
+          runId: run.id,
+          tenantId,
+          stepType: node.type,
+          stepName: node.name,
+          input: { rendered: inputText }
+        }).catch((e) => {
+          console.warn("Failed to create input run step:", e.message);
+        });
+      } catch (e) {
+        console.warn("Failed to create workflow run:", e.message);
+      }
+    }
+    return update;
+  };
+}
+function terminalStatusToRunStatus(status) {
+  switch (status) {
+    case "failed":
+      return "failed";
+    case "cancelled":
+      return "cancelled";
+    case "success":
+    default:
+      return "completed";
+  }
+}
+function createTerminalNode(node, trackingStore) {
+  const runStatus = terminalStatusToRunStatus(node.status);
+  return async (state) => {
+    const runId = state._runId;
+    if (trackingStore && runId) {
+      try {
+        await trackingStore.updateWorkflowRun(runId, {
+          status: runStatus,
+          completedAt: /* @__PURE__ */ new Date()
+        });
+      } catch (e) {
+        console.warn(`[WF][terminal] Failed to finalize WorkflowRun "${runId}":`, e.message);
+      }
+      try {
+        await trackingStore.createRunStep({
+          runId,
+          tenantId: state._tenantId ?? "default",
+          stepType: "terminal",
+          stepName: node.name,
+          input: { status: node.status }
+        });
+      } catch (e) {
+        console.warn(`[WF][terminal] Failed to create terminal RunStep:`, e.message);
+      }
+    }
+    return {
+      status: node.status,
+      phase: node.id
+    };
+  };
+}
+function createNodeHandler(node, resolveAgent, trackingStore) {
+  switch (node.type) {
+    case "agent":
+      return createAgentNode(node, resolveAgent, trackingStore);
+    case "human_feedback":
+      return createHumanFeedbackNode(node, resolveAgent, trackingStore);
+    case "map":
+      return createMapNode(node, resolveAgent, trackingStore);
+    case "terminal":
+      return createTerminalNode(node, trackingStore);
+    case "input":
+      return createInputNode(node, trackingStore);
+    default:
+      throw new Error(`Unknown node type: ${node.type}`);
+  }
+}
+function chunk(arr, size) {
+  const result = [];
+  for (let i = 0; i < arr.length; i += size) {
+    result.push(arr.slice(i, i + size));
+  }
+  return result;
+}
+var import_langgraph15, import_messages6;
+var init_utils = __esm({
+  "src/workflow/utils.ts"() {
+    "use strict";
+    import_langgraph15 = require("@langchain/langgraph");
+    import_messages6 = require("@langchain/core/messages");
+  }
+});
+
+// src/workflow/normalize.ts
+function uid(prefix) {
+  return `${prefix}_${_counter++}`;
+}
+function nodeId(stepId) {
+  return `n_${stepId}`;
+}
+function translate(template) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_m, expr) => {
+    const t = expr.trim();
+    if (t === "item") return "${item}";
+    return `\${state.${t}}`;
+  });
+}
+function inferFieldType(id) {
+  if (/s$|list|array|items|results/i.test(id)) return { type: "array", default: [] };
+  return { type: "string" };
+}
+function expandStep(step) {
+  switch (step.type ?? "agent") {
+    case "agent":
+      return expandAgent(step);
+    case "human":
+      return expandHuman(step);
+    case "condition":
+      return expandCondition(step);
+    case "map":
+      return expandMap(step);
+    case "parallel":
+      return expandParallel(step);
+    case "end":
+      return expandEnd(step);
+  }
+}
+function validateSchema(schema, stepId) {
+  if (schema.type !== "object") {
+    throw new Error(
+      `Step "${stepId}": schema.type must be "object", got "${String(schema.type)}". Use standard JSON Schema: { "type": "object", "properties": { ... } }`
+    );
+  }
+  if (!schema.properties || typeof schema.properties !== "object") {
+    throw new Error(
+      `Step "${stepId}": schema must have a "properties" object. Legacy shorthand like { "field": "string" } is not supported. Use: { "type": "object", "properties": { "field": { "type": "string" } } }`
+    );
+  }
+}
+function expandAgent(s) {
+  const sid = s.id || uid("agent");
+  const nid = nodeId(sid);
+  if (s.schema !== void 0 && s.schema !== null) {
+    if (typeof s.schema !== "object") {
+      throw new Error(
+        `Step "${sid}": schema must be a JSON Schema object, e.g. { "type": "object", "properties": { ... } }. Got ${typeof s.schema} (${JSON.stringify(s.schema)}).`
+      );
+    }
+    validateSchema(s.schema, sid);
+  }
+  const schema = s.schema && typeof s.schema === "object" ? s.schema : void 0;
+  console.log(`[WF EXPAND] agent step id="${sid}" nodeId="${nid}" | hasSchema=${!!schema}`);
+  return {
+    nodes: [{ id: nid, type: "agent", name: sid, input: { template: translate(s.prompt) }, output: { key: sid, ...schema ? { schema } : {} } }],
+    edges: [],
+    entryId: nid,
+    exitIds: [nid]
+  };
+}
+function expandHuman(s) {
+  const sid = s.id || uid("human");
+  const nid = nodeId(sid);
+  if (s.schema !== void 0 && s.schema !== null) {
+    if (typeof s.schema !== "object") {
+      throw new Error(
+        `Step "${sid}": schema must be a JSON Schema object, e.g. { "type": "object", "properties": { ... } }. Got ${typeof s.schema} (${JSON.stringify(s.schema)}).`
+      );
+    }
+    validateSchema(s.schema, sid);
+  }
+  const schema = s.schema && typeof s.schema === "object" ? s.schema : void 0;
+  return {
+    nodes: [{ id: nid, type: "human_feedback", name: sid, config: { title: s.title ?? sid }, input: { template: translate(s.prompt) }, output: { key: sid, ...schema ? { schema } : {} } }],
+    edges: [],
+    entryId: nid,
+    exitIds: [nid]
+  };
+}
+function expandCondition(s) {
+  const sid = s.id || uid("cond");
+  const nid = nodeId(sid);
+  if (s.branches) {
+    const branchExps = {};
+    for (const [key, steps] of Object.entries(s.branches)) {
+      branchExps[key] = expandSteps(Array.isArray(steps) ? steps : [steps]);
+    }
+    const allNodes = Object.values(branchExps).flatMap((e) => e.nodes);
+    const allEdges = Object.values(branchExps).flatMap((e) => e.edges);
+    const allExitIds = [...new Set(Object.values(branchExps).flatMap((e) => e.exitIds))];
+    const branchEntryIds = Object.fromEntries(
+      Object.entries(branchExps).map(([k, v]) => [k, v.entryId])
+    );
+    return {
+      nodes: allNodes,
+      edges: allEdges,
+      entryId: nid,
+      exitIds: allExitIds,
+      branchEntryIds
+    };
+  }
+  if (!s.then) {
+    throw new Error(`Condition step "${sid}": must have either "then" or "branches"`);
+  }
+  const thenSteps = Array.isArray(s.then) ? s.then : [s.then];
+  const elseSteps = s.else ? Array.isArray(s.else) ? s.else : [s.else] : [];
+  const thenExp = expandSteps(thenSteps);
+  const elseExp = expandSteps(elseSteps);
+  return {
+    nodes: [...thenExp.nodes, ...elseExp.nodes],
+    edges: [...thenExp.edges, ...elseExp.edges],
+    entryId: nid,
+    exitIds: [...thenExp.exitIds, ...elseExp.exitIds],
+    thenEntryId: thenExp.entryId,
+    elseEntryId: elseExp.entryId
+  };
+}
+function expandMap(s) {
+  const sid = s.id;
+  const nid = nodeId(sid);
+  const inner = s.each;
+  return {
+    nodes: [{
+      id: nid,
+      type: "map",
+      name: sid,
+      source: `state.${s.source}`,
+      itemKey: "item",
+      config: { batchSize: s.batch ?? 50, maxConcurrency: s.concurrency ?? 5, innerConcurrency: s.concurrency ?? 5 },
+      node: { type: "agent", input: inner.prompt ? { template: translate(inner.prompt) } : void 0, ...inner.schema && typeof inner.schema === "object" ? { schema: inner.schema } : {} },
+      ...s.reduce ? { reduce: { input: s.reduce.prompt ? { template: translate(s.reduce.prompt) } : void 0, ...s.reduce.schema && typeof s.reduce.schema === "object" ? { schema: s.reduce.schema } : {} } } : {},
+      output: { key: sid }
+    }],
+    edges: [],
+    entryId: nid,
+    exitIds: [nid]
+  };
+}
+function expandParallel(s) {
+  const nodes = [];
+  const edges = [];
+  const entryIds = [];
+  const exitIds = [];
+  for (const step of s.steps) {
+    const exp = expandStep(step);
+    nodes.push(...exp.nodes);
+    edges.push(...exp.edges);
+    entryIds.push(exp.entryId);
+    if (exp.exitIds.length > 0) exitIds.push(...exp.exitIds);
+  }
+  return { nodes, edges, entryId: entryIds[0], exitIds };
+}
+function expandEnd(s) {
+  const sid = uid("end");
+  const nid = nodeId(sid);
+  return { nodes: [{ id: nid, type: "terminal", name: sid, status: s.status ?? "success" }], edges: [], entryId: nid, exitIds: [] };
+}
+function expandSteps(steps, fromStart = false) {
+  if (steps.length === 0) return { nodes: [], edges: [], entryId: "END", exitIds: ["END"] };
+  const allNodes = [];
+  const allEdges = [];
+  let prevExitIds = [];
+  let firstEntryId = null;
+  for (let i = 0; i < steps.length; i++) {
+    const exp = expandStep(steps[i]);
+    if (exp.nodes.length > 0) allNodes.push(...exp.nodes);
+    if (exp.edges.length > 0) allEdges.push(...exp.edges);
+    if (firstEntryId === null) firstEntryId = exp.entryId;
+    if (prevExitIds.length > 0) addEdge(steps[i], exp, prevExitIds, allEdges);
+    else if (fromStart && i === 0) addEdge(steps[i], exp, ["START"], allEdges);
+    prevExitIds = exp.exitIds.length > 0 ? exp.exitIds : prevExitIds;
+  }
+  return { nodes: allNodes, edges: allEdges, entryId: firstEntryId || "END", exitIds: prevExitIds };
+}
+function toSafeStateExpr(expr) {
+  const match = expr.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)/);
+  if (!match) return `state.${expr}`;
+  const field = match[0];
+  const rest = expr.slice(field.length);
+  return `state["${field}"]${rest}`;
+}
+function addEdge(step, exp, fromIds, allEdges) {
+  if (step.type === "condition") {
+    const s = step;
+    if (s.if.includes("{{")) {
+      throw new Error(
+        `Condition step "${s.id || "unnamed"}": the \`if\` field contains "{{". Use a plain state field name or JavaScript expression (e.g. "intent", "score >= 60"). Template markers {{...}} are only for \`prompt\` fields, not \`if\`. Found: "${s.if}"`
+      );
+    }
+    if (s.branches) {
+      const condExp = exp;
+      const exprCode = toSafeStateExpr(s.if);
+      const mapping = {};
+      for (const [key, branchId] of Object.entries(condExp.branchEntryIds)) {
+        if (branchId) mapping[key] = branchId;
+      }
+      for (const fromId of fromIds) allEdges.push({ from: fromId, type: "conditional", rule: { type: "expression", code: exprCode, mapping } });
+    } else {
+      const condExp = exp;
+      const exprCode = `${toSafeStateExpr(s.if)} ? 'then' : 'else'`;
+      const mapping = {};
+      if (condExp.thenEntryId) mapping.then = condExp.thenEntryId;
+      if (condExp.elseEntryId) mapping.else = condExp.elseEntryId;
+      for (const fromId of fromIds) allEdges.push({ from: fromId, type: "conditional", rule: { type: "expression", code: exprCode, mapping } });
+    }
+  } else if (step.type === "parallel") {
+    for (const fromId of fromIds) {
+      for (const sub of step.steps) allEdges.push({ from: fromId, to: expandStep(sub).entryId });
+    }
+  } else {
+    for (const fromId of fromIds) allEdges.push({ from: fromId, to: exp.entryId });
+  }
+}
+function collectIds(steps) {
+  const ids = [];
+  function walk(s) {
+    const id = s.type === "condition" ? s.id || uid("cond") : s.type === "parallel" ? s.id || uid("par") : s.type === "end" ? uid("end") : s.id || s.id || uid("human");
+    if (s.type !== "end" && s.type !== "condition") ids.push(id);
+    if (s.type === "condition") {
+      const c = s;
+      if (c.branches) {
+        for (const steps2 of Object.values(c.branches)) {
+          (Array.isArray(steps2) ? steps2 : [steps2]).forEach(walk);
+        }
+      } else {
+        (Array.isArray(c.then) ? c.then : [c.then]).forEach(walk);
+        if (c.else) (Array.isArray(c.else) ? c.else : [c.else]).forEach(walk);
+      }
+    }
+    if (s.type === "parallel") s.steps.forEach(walk);
+  }
+  steps.forEach(walk);
+  return [...new Set(ids)];
+}
+function collectSourceIds(steps) {
+  const ids = [];
+  function walk(s) {
+    if (s.type === "map") ids.push(s.source);
+    if (s.type === "condition") {
+      const c = s;
+      if (c.branches) {
+        for (const steps2 of Object.values(c.branches)) {
+          (Array.isArray(steps2) ? steps2 : [steps2]).forEach(walk);
+        }
+      } else {
+        (Array.isArray(c.then) ? c.then : [c.then]).forEach(walk);
+        if (c.else) (Array.isArray(c.else) ? c.else : [c.else]).forEach(walk);
+      }
+    }
+    if (s.type === "parallel") s.steps.forEach(walk);
+  }
+  steps.forEach(walk);
+  return [...new Set(ids)];
+}
+function expand(dsl) {
+  _counter = 0;
+  console.log(`[WF EXPAND] expanding workflow "${dsl.name}" | stepCount=${dsl.steps.length}`);
+  const inputNode = {
+    id: "n_input",
+    type: "input",
+    name: "input",
+    output: { key: "input" }
+  };
+  const expanded = expandSteps(dsl.steps, true);
+  const edges = expanded.entryId === "END" ? [{ from: "START", to: "n_input" }] : [
+    ...expanded.edges.map((e) => ({ ...e, from: e.from === "START" ? "n_input" : e.from })),
+    { from: "START", to: "n_input" }
+  ];
+  const nodes = [inputNode, ...expanded.nodes];
+  const ids = collectIds(dsl.steps);
+  const sourceIds = collectSourceIds(dsl.steps);
+  const fields = { input: { type: "string" } };
+  for (const id of ids) fields[id] = inferFieldType(id);
+  for (const id of sourceIds) {
+    if (!fields[id]) fields[id] = inferFieldType(id);
+  }
+  const result = { version: "1.0", name: dsl.name, state: { fields }, nodes, edges };
+  console.log(`[WF EXPAND] done | nodeCount=${result.nodes.length} | nodeIds=[${result.nodes.map((n) => `${n.id}:${n.type}`).join(", ")}] | fieldIds=[${Object.keys(fields).join(", ")}]`);
+  return result;
+}
+var _counter;
+var init_normalize = __esm({
+  "src/workflow/normalize.ts"() {
+    "use strict";
+    _counter = 0;
+  }
+});
+
+// src/workflow/compile.ts
+var compile_exports = {};
+__export(compile_exports, {
+  compileWorkflow: () => compileWorkflow,
+  validateDSL: () => validateDSL
+});
+function compileWorkflow(dsl, resolveAgent, checkpointer, trackingStore) {
+  console.log(`[WF COMPILE] compiling "${dsl.name}" | stepCount=${dsl.steps.length}`);
+  const ir = expand(dsl);
+  validateAndThrow(ir);
+  console.log(`[WF COMPILE] validation passed`);
+  const StateAnnotation = buildStateAnnotation(ir.state?.fields);
+  const builder = new import_langgraph16.StateGraph(StateAnnotation);
+  for (const node of ir.nodes) {
+    console.log(`[WF COMPILE] registering node: id=${node.id} type=${node.type} name=${node.name}`);
+    const handler = createNodeHandler(node, resolveAgent, trackingStore);
+    builder.addNode(node.id, handler);
+  }
+  for (const node of ir.nodes) {
+    if (node.type === "terminal") {
+      builder.addEdge(node.id, import_langgraph16.END);
+    }
+  }
+  for (const edge of ir.edges) {
+    const from = edge.from === "START" ? import_langgraph16.START : edge.from;
+    if (edge.type === "conditional") {
+      if (!edge.rule) {
+        throw new Error(`Conditional edge from "${edge.from}" has no rule`);
+      }
+      const router = buildRouter(edge.rule);
+      builder.addConditionalEdges(from, router, edge.rule.mapping);
+    } else {
+      const targets = Array.isArray(edge.to) ? edge.to : [edge.to];
+      for (const to of targets) {
+        builder.addEdge(from, to === "END" ? import_langgraph16.END : to);
+      }
+    }
+  }
+  const graph = builder.compile({ checkpointer, name: ir.name });
+  console.log(`[WF COMPILE] graph compiled successfully, ready to run`);
+  return graph;
+}
+function validateDSL(dsl) {
+  const errors = [];
+  const nodeIds = /* @__PURE__ */ new Set();
+  for (const node of dsl.nodes) {
+    if (nodeIds.has(node.id)) {
+      errors.push({ type: "error", message: `Duplicate node id "${node.id}"` });
+    }
+    nodeIds.add(node.id);
+  }
+  const terminalIds = new Set(
+    dsl.nodes.filter((n) => n.type === "terminal").map((n) => n.id)
+  );
+  const declaredFields = new Set(Object.keys(dsl.state?.fields ?? {}));
+  for (const edge of dsl.edges) {
+    if (edge.from !== "START" && !nodeIds.has(edge.from)) {
+      errors.push({ type: "error", message: `Edge from "${edge.from}" references unknown node` });
+    }
+    if (edge.from !== "START" && terminalIds.has(edge.from)) {
+      errors.push({ type: "error", message: `Terminal node "${edge.from}" cannot have outgoing edges` });
+    }
+    const targets = Array.isArray(edge.to) ? edge.to : edge.to ? [edge.to] : [];
+    for (const to of targets) {
+      if (to !== "END" && !nodeIds.has(to)) {
+        errors.push({ type: "error", message: `Edge to "${to}" references unknown node` });
+      }
+    }
+    if (edge.type === "conditional" && edge.rule) {
+      for (const targetId of Object.values(edge.rule.mapping)) {
+        if (targetId !== "END" && !nodeIds.has(targetId)) {
+          errors.push({ type: "error", message: `Conditional edge mapping references unknown node "${targetId}"` });
+        }
+      }
+      if (edge.rule.type === "state_field" && edge.rule.field) {
+        if (!declaredFields.has(edge.rule.field)) {
+          errors.push({ type: "warning", message: `Conditional edge reads "${edge.rule.field}" but it is not declared in state.fields` });
+        }
+      }
+    }
+  }
+  for (const node of dsl.nodes) {
+    if (node.type === "terminal") {
+      const hasIncoming = dsl.edges.some((e) => {
+        const targets = Array.isArray(e.to) ? e.to : e.to ? [e.to] : [];
+        return targets.includes(node.id) || e.type === "conditional" && e.rule && Object.values(e.rule.mapping).includes(node.id);
+      });
+      if (!hasIncoming) {
+        errors.push({ type: "warning", message: `Terminal node "${node.id}" has no incoming edge` });
+      }
+    }
+  }
+  return errors;
+}
+function validateAndThrow(dsl) {
+  const errors = validateDSL(dsl);
+  const critical = errors.filter((e) => e.type === "error");
+  if (critical.length > 0) {
+    throw new Error(critical.map((e) => e.message).join("; "));
+  }
+}
+function buildRouter(rule) {
+  if (rule.type === "state_field") {
+    if (!rule.field) throw new Error("state_field rule requires a field name");
+    return (state) => {
+      const value = resolvePath(state, `state.${rule.field}`);
+      const key = String(value);
+      if (rule.mapping[key] !== void 0) return key;
+      if (rule.mapping["default"] !== void 0) return "default";
+      throw new Error(
+        `Conditional router produced key "${key}" (from field "${rule.field}"), but it is not in mapping: ${JSON.stringify(Object.keys(rule.mapping))}`
+      );
+    };
+  }
+  if (rule.type === "expression") {
+    if (!rule.code) throw new Error("expression rule requires code");
+    const fn = new Function("state", `return ${rule.code}`);
+    return (state) => {
+      const value = fn(state);
+      const key = String(value);
+      if (rule.mapping[key] !== void 0) return key;
+      if (rule.mapping["default"] !== void 0) return "default";
+      throw new Error(
+        `Conditional router produced key "${key}" (from expression "${rule.code}"), but it is not in mapping: ${JSON.stringify(Object.keys(rule.mapping))}`
+      );
+    };
+  }
+  throw new Error(`Unknown rule type: ${rule.type}`);
+}
+var import_langgraph16;
+var init_compile = __esm({
+  "src/workflow/compile.ts"() {
+    "use strict";
+    import_langgraph16 = require("@langchain/langgraph");
+    init_utils();
+    init_normalize();
+  }
+});
 
 // src/index.ts
 var index_exports = {};
@@ -52,7 +1669,7 @@ __export(index_exports, {
   EmbeddingsLatticeManager: () => EmbeddingsLatticeManager,
   FileSystemSkillStore: () => FileSystemSkillStore,
   FilesystemBackend: () => FilesystemBackend,
-  HumanMessage: () => import_messages6.HumanMessage,
+  HumanMessage: () => import_messages7.HumanMessage,
   InMemoryA2AApiKeyStore: () => InMemoryA2AApiKeyStore,
   InMemoryAssistantStore: () => InMemoryAssistantStore,
   InMemoryBindingStore: () => InMemoryBindingStore,
@@ -111,21 +1728,28 @@ __export(index_exports, {
   agentInstanceManager: () => agentInstanceManager,
   agentLatticeManager: () => agentLatticeManager,
   buildGrepResultsDict: () => buildGrepResultsDict,
+  buildInput: () => buildInput,
   buildNamedVolumeName: () => buildNamedVolumeName,
   buildSandboxMetadataEnv: () => buildSandboxMetadataEnv,
   buildSkillFile: () => buildSkillFile,
+  buildStateAnnotation: () => buildStateAnnotation,
   checkEmptyContent: () => checkEmptyContent,
   clearEncryptionKeyCache: () => clearEncryptionKeyCache,
+  compileWorkflow: () => compileWorkflow,
   computeSandboxName: () => computeSandboxName,
   configureStores: () => configureStores,
+  createAgentNode: () => createAgentNode,
   createAgentTeam: () => createAgentTeam,
   createExecuteSqlQueryTool: () => createExecuteSqlQueryTool,
   createFileData: () => createFileData,
+  createHumanFeedbackNode: () => createHumanFeedbackNode,
   createInfoSqlTool: () => createInfoSqlTool,
   createListMetricsDataSourcesTool: () => createListMetricsDataSourcesTool,
   createListMetricsServersTool: () => createListMetricsServersTool,
   createListTablesSqlTool: () => createListTablesSqlTool,
+  createMapNode: () => createMapNode,
   createModelSelectorMiddleware: () => createModelSelectorMiddleware,
+  createNodeHandler: () => createNodeHandler,
   createProcessingAgent: () => createProcessingAgent,
   createQueryCheckerSqlTool: () => createQueryCheckerSqlTool,
   createQueryMetricDefinitionTool: () => createQueryMetricDefinitionTool,
@@ -138,6 +1762,7 @@ __export(index_exports, {
   createSchedulerMiddleware: () => createSchedulerMiddleware,
   createTeamMiddleware: () => createTeamMiddleware,
   createTeammateTools: () => createTeammateTools,
+  createTerminalNode: () => createTerminalNode,
   createUnknownToolHandlerMiddleware: () => createUnknownToolHandlerMiddleware,
   createWidgetMiddleware: () => createWidgetMiddleware,
   decrypt: () => decrypt,
@@ -147,7 +1772,9 @@ __export(index_exports, {
   ensureBuiltinAgentsForTenant: () => ensureBuiltinAgentsForTenant,
   eventBus: () => eventBus,
   eventBusDefault: () => event_bus_default,
+  expand: () => expand,
   extractFetcherError: () => extractFetcherError,
+  extractOutput: () => extractOutput,
   fileDataToString: () => fileDataToString,
   formatContentWithLineNumbers: () => formatContentWithLineNumbers,
   formatGrepMatches: () => formatGrepMatches,
@@ -157,323 +1784,88 @@ __export(index_exports, {
   getAgentConfig: () => getAgentConfig,
   getAllAgentConfigs: () => getAllAgentConfigs,
   getAllBuiltInSkillMetas: () => getAllBuiltInSkillMetas,
-  getAllToolDefinitions: () => getAllToolDefinitions,
-  getBindingRegistry: () => getBindingRegistry,
-  getBuiltInSkillContent: () => getBuiltInSkillContent,
-  getBuiltInSkillMeta: () => getBuiltInSkillMeta,
-  getBuiltInSkillNames: () => getBuiltInSkillNames,
-  getCheckpointSaver: () => getCheckpointSaver,
-  getChunkBuffer: () => getChunkBuffer,
-  getEmbeddingsClient: () => getEmbeddingsClient,
-  getEmbeddingsLattice: () => getEmbeddingsLattice,
-  getEncryptionKey: () => getEncryptionKey,
-  getLoggerLattice: () => getLoggerLattice,
-  getModelLattice: () => getModelLattice,
-  getNextCronTime: () => getNextCronTime,
-  getQueueLattice: () => getQueueLattice,
-  getSandBoxManager: () => getSandBoxManager,
-  getScheduleLattice: () => getScheduleLattice,
-  getStoreLattice: () => getStoreLattice,
-  getToolClient: () => getToolClient,
-  getToolDefinition: () => getToolDefinition,
-  getToolLattice: () => getToolLattice,
-  getVectorStoreClient: () => getVectorStoreClient,
-  getVectorStoreLattice: () => getVectorStoreLattice,
-  globSearchFiles: () => globSearchFiles,
-  grepMatchesFromFiles: () => grepMatchesFromFiles,
-  grepSearchFiles: () => grepSearchFiles,
-  hasChunkBuffer: () => hasChunkBuffer,
-  isBuiltInSkill: () => isBuiltInSkill,
-  isUsingDefaultKey: () => isUsingDefaultKey,
-  isValidCronExpression: () => isValidCronExpression,
-  isValidSandboxName: () => isValidSandboxName,
-  isValidSkillName: () => isValidSkillName,
-  loggerLatticeManager: () => loggerLatticeManager,
-  mcpManager: () => mcpManager,
-  metricsServerManager: () => metricsServerManager,
-  modelLatticeManager: () => modelLatticeManager,
-  normalizeSandboxName: () => normalizeSandboxName,
-  parseCronExpression: () => parseCronExpression,
-  parseSkillFrontmatter: () => parseSkillFrontmatter,
-  performStringReplacement: () => performStringReplacement,
-  queueLatticeManager: () => queueLatticeManager,
-  registerAgentLattice: () => registerAgentLattice,
-  registerAgentLatticeWithTenant: () => registerAgentLatticeWithTenant,
-  registerAgentLattices: () => registerAgentLattices,
-  registerCheckpointSaver: () => registerCheckpointSaver,
-  registerChunkBuffer: () => registerChunkBuffer,
-  registerEmbeddingsLattice: () => registerEmbeddingsLattice,
-  registerExistingTool: () => registerExistingTool,
-  registerLoggerLattice: () => registerLoggerLattice,
-  registerModelLattice: () => registerModelLattice,
-  registerQueueLattice: () => registerQueueLattice,
-  registerScheduleLattice: () => registerScheduleLattice,
-  registerStoreLattice: () => registerStoreLattice,
-  registerTeammateAgent: () => registerTeammateAgent,
-  registerToolLattice: () => registerToolLattice,
-  registerVectorStoreLattice: () => registerVectorStoreLattice,
-  sandboxLatticeManager: () => sandboxLatticeManager,
-  sanitizeToolCallId: () => sanitizeToolCallId,
-  scheduleLatticeManager: () => scheduleLatticeManager,
-  setBindingRegistry: () => setBindingRegistry,
-  skillLatticeManager: () => skillLatticeManager,
-  sqlDatabaseManager: () => sqlDatabaseManager,
-  storeLatticeManager: () => storeLatticeManager,
-  toolLatticeManager: () => toolLatticeManager,
-  truncateIfTooLong: () => truncateIfTooLong,
-  unregisterTeammateAgent: () => unregisterTeammateAgent,
-  updateFileData: () => updateFileData,
-  validateAgentInput: () => validateAgentInput,
-  validateEncryptionKey: () => validateEncryptionKey,
-  validatePath: () => validatePath,
-  validateSkillName: () => validateSkillName,
-  validateToolInput: () => validateToolInput,
-  vectorStoreLatticeManager: () => vectorStoreLatticeManager
-});
-module.exports = __toCommonJS(index_exports);
-
-// 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;
+  getAllToolDefinitions: () => getAllToolDefinitions,
+  getBindingRegistry: () => getBindingRegistry,
+  getBuiltInSkillContent: () => getBuiltInSkillContent,
+  getBuiltInSkillMeta: () => getBuiltInSkillMeta,
+  getBuiltInSkillNames: () => getBuiltInSkillNames,
+  getCheckpointSaver: () => getCheckpointSaver,
+  getChunkBuffer: () => getChunkBuffer,
+  getEmbeddingsClient: () => getEmbeddingsClient,
+  getEmbeddingsLattice: () => getEmbeddingsLattice,
+  getEncryptionKey: () => getEncryptionKey,
+  getLoggerLattice: () => getLoggerLattice,
+  getModelLattice: () => getModelLattice,
+  getNextCronTime: () => getNextCronTime,
+  getQueueLattice: () => getQueueLattice,
+  getSandBoxManager: () => getSandBoxManager,
+  getScheduleLattice: () => getScheduleLattice,
+  getStoreLattice: () => getStoreLattice,
+  getToolClient: () => getToolClient,
+  getToolDefinition: () => getToolDefinition,
+  getToolLattice: () => getToolLattice,
+  getVectorStoreClient: () => getVectorStoreClient,
+  getVectorStoreLattice: () => getVectorStoreLattice,
+  globSearchFiles: () => globSearchFiles,
+  grepMatchesFromFiles: () => grepMatchesFromFiles,
+  grepSearchFiles: () => grepSearchFiles,
+  hasChunkBuffer: () => hasChunkBuffer,
+  invokeWithRetry: () => invokeWithRetry,
+  isBuiltInSkill: () => isBuiltInSkill,
+  isUsingDefaultKey: () => isUsingDefaultKey,
+  isValidCronExpression: () => isValidCronExpression,
+  isValidSandboxName: () => isValidSandboxName,
+  isValidSkillName: () => isValidSkillName,
+  loggerLatticeManager: () => loggerLatticeManager,
+  mcpManager: () => mcpManager,
+  metricsServerManager: () => metricsServerManager,
+  modelLatticeManager: () => modelLatticeManager,
+  normalizeSandboxName: () => normalizeSandboxName,
+  parallelLimit: () => parallelLimit,
+  parseCronExpression: () => parseCronExpression,
+  parseSkillFrontmatter: () => parseSkillFrontmatter,
+  performStringReplacement: () => performStringReplacement,
+  queueLatticeManager: () => queueLatticeManager,
+  registerAgentLattice: () => registerAgentLattice,
+  registerAgentLatticeWithTenant: () => registerAgentLatticeWithTenant,
+  registerAgentLattices: () => registerAgentLattices,
+  registerCheckpointSaver: () => registerCheckpointSaver,
+  registerChunkBuffer: () => registerChunkBuffer,
+  registerEmbeddingsLattice: () => registerEmbeddingsLattice,
+  registerExistingTool: () => registerExistingTool,
+  registerLoggerLattice: () => registerLoggerLattice,
+  registerModelLattice: () => registerModelLattice,
+  registerQueueLattice: () => registerQueueLattice,
+  registerScheduleLattice: () => registerScheduleLattice,
+  registerStoreLattice: () => registerStoreLattice,
+  registerTeammateAgent: () => registerTeammateAgent,
+  registerToolLattice: () => registerToolLattice,
+  registerVectorStoreLattice: () => registerVectorStoreLattice,
+  renderTemplate: () => renderTemplate,
+  resolvePath: () => resolvePath,
+  sandboxLatticeManager: () => sandboxLatticeManager,
+  sanitizeToolCallId: () => sanitizeToolCallId,
+  scheduleLatticeManager: () => scheduleLatticeManager,
+  setBindingRegistry: () => setBindingRegistry,
+  skillLatticeManager: () => skillLatticeManager,
+  sqlDatabaseManager: () => sqlDatabaseManager,
+  storeLatticeManager: () => storeLatticeManager,
+  toolLatticeManager: () => toolLatticeManager,
+  truncateIfTooLong: () => truncateIfTooLong,
+  unregisterTeammateAgent: () => unregisterTeammateAgent,
+  updateFileData: () => updateFileData,
+  validateAgentInput: () => validateAgentInput,
+  validateDSL: () => validateDSL,
+  validateEncryptionKey: () => validateEncryptionKey,
+  validatePath: () => validatePath,
+  validateSkillName: () => validateSkillName,
+  validateToolInput: () => validateToolInput,
+  vectorStoreLatticeManager: () => vectorStoreLatticeManager
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/model_lattice/ModelLatticeManager.ts
+init_BaseLatticeManager();
 
 // src/model_lattice/ModelLattice.ts
 var import_deepseek = require("@langchain/deepseek");
@@ -722,6 +2114,7 @@ var import_zod = __toESM(require("zod"));
 
 // src/tool_lattice/ToolLatticeManager.ts
 var import_tools = require("@langchain/core/tools");
+init_BaseLatticeManager();
 
 // src/util/genUIMarkdown.ts
 var genUIMarkdown = (type, data) => {
@@ -1001,6 +2394,9 @@ function getBindingRegistry() {
   return registry;
 }
 
+// src/store_lattice/StoreLatticeManager.ts
+init_BaseLatticeManager();
+
 // src/store_lattice/InMemoryThreadStore.ts
 var InMemoryThreadStore = class {
   constructor() {
@@ -2666,6 +4062,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;
@@ -5999,6 +7403,9 @@ ${serverKeys.map(
 // src/tool_lattice/code_eval/index.ts
 var import_zod16 = __toESM(require("zod"));
 
+// src/sandbox_lattice/SandboxLatticeManager.ts
+init_BaseLatticeManager();
+
 // src/deep_agent_new/backends/volumeFilesystem.ts
 var VolumeFilesystem = class {
   constructor(client, mountPrefix = "") {
@@ -7265,90 +8672,16 @@ var createBrowserGetInfoTool = ({ vmIsolation }) => {
 };
 
 // src/index.ts
-var import_messages6 = require("@langchain/core/messages");
+var import_messages7 = require("@langchain/core/messages");
 
 // src/agent_lattice/types.ts
 var import_protocols = require("@axiom-lattice/protocols");
 
-// src/memory_lattice/DefaultMemorySaver.ts
-var import_langgraph2 = require("@langchain/langgraph");
-
-// src/memory_lattice/MemoryLatticeManager.ts
-var import_protocols2 = require("@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/agent_lattice/AgentLatticeManager.ts
+init_BaseLatticeManager();
 
-// src/memory_lattice/DefaultMemorySaver.ts
-var memory = new import_langgraph2.MemorySaver();
-registerCheckpointSaver("default", memory);
+// src/agent_lattice/builders/ReActAgentGraphBuilder.ts
+init_memory_lattice();
 
 // src/agent_lattice/builders/state.ts
 var import_zod41 = require("@langchain/langgraph/zod");
@@ -7753,81 +9086,429 @@ When iterating based on feedback:
 3. **Look for repeated work** \u2014 if all test runs involved writing the same helper script, bundle that script into \`resources/scripts/\` and have the skill reference it instead.
 4. **Explain the why** \u2014 if you're adding a constraint because of a failure, explain the context so the model understands when to apply it and when it's safe to deviate.
 
-Repeat the test \u2192 review \u2192 improve loop until the user is satisfied.
+Repeat the test \u2192 review \u2192 improve loop until the user is satisfied.
+
+---
+
+## Step 5: Optimize the Description (Optional)
+
+After the skill works well, offer to optimize the description for better triggering accuracy.
+
+### How Triggering Works
+
+The agent sees skills as a list of name + description pairs. It decides whether to consult a skill based on that description. Important: agents only consult skills for tasks they can't easily handle on their own. Simple one-step queries may not trigger a skill even if the description matches \u2014 so make sure the description emphasizes the COMPLEX or SPECIALIZED nature of the task.
+
+### Optimization Approach
+
+1. Create 10-15 eval queries \u2014 a mix of should-trigger and should-not-trigger prompts
+2. For **should-trigger** (6-8): different phrasings of the same intent \u2014 formal, casual, indirect. Include cases where the user doesn't explicitly name the skill but clearly needs it
+3. For **should-not-trigger** (6-8): focus on near-misses \u2014 queries that share keywords but need something different. Don't make them obviously irrelevant
+4. Test the description against these queries and adjust based on misfires
+5. Show the user before/after and explain what changed
+
+---
+
+## Step 6: Package and Present
+
+When the skill is ready:
+1. Verify the SKILL.md is at \`/root/.agents/skills/{skill-name}/SKILL.md\` with correct frontmatter
+2. Confirm all resource files are in place under \`resources/\`
+3. Tell the user the skill is ready and available at its path
+4. Remind them that the skill will now appear in the available skills list for any agent using the skill system
+
+## Updating Existing Skills
+
+When the user wants to improve an existing skill:
+1. Read the current SKILL.md from \`/root/.agents/skills/{skill-name}/SKILL.md\`
+2. Understand what it currently does and where it falls short
+3. Follow the same interview \u2192 draft \u2192 test \u2192 iterate loop
+4. **Preserve the original name** \u2014 the directory name and \`name\` frontmatter field should stay the same
+5. Write the updated version back to the same path
+
+---
+
+## Example Walkthrough
+
+**User**: "I want a skill that helps me analyze CSV data"
+
+**You** (interview):
+- "What kinds of analysis \u2014 summary stats, filtering, charting?"
+- "Are the CSVs always the same format or varied?"
+- "Should it output results as text, new CSV, or visualizations?"
+
+**User**: "Mostly summary stats and filtering. The files vary but all have headers."
+
+**You** (draft frontmatter):
+\`\`\`yaml
+---
+name: csv-analyzer
+description: Analyze CSV data with statistical summaries, filtering, and aggregation. Use whenever users want to explore, summarize, or extract insights from CSV files \u2014 even if they don't say "analyze" explicitly.
+metadata:
+  category: data
+  version: "1.0"
+---
+\`\`\`
+
+**You** (draft body): Write a workflow that teaches the agent to:
+1. Inspect the CSV structure and headers
+2. Let the user choose analysis type (summary, filter, aggregate)
+3. Execute the analysis and present results clearly
+4. Handle edge cases: missing headers, empty files, mixed types
+
+**You** (write): Create \`/root/.agents/skills/csv-analyzer/SKILL.md\`
+
+**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:
 
-## Step 5: Optimize the Description (Optional)
+ - **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.
 
-After the skill works well, offer to optimize the description for better triggering accuracy.
+ ## Design Patterns
 
-### How Triggering Works
+ ### Pattern 1: Linear Pipeline
 
-The agent sees skills as a list of name + description pairs. It decides whether to consult a skill based on that description. Important: agents only consult skills for tasks they can't easily handle on their own. Simple one-step queries may not trigger a skill even if the description matches \u2014 so make sure the description emphasizes the COMPLEX or SPECIALIZED nature of the task.
+ \`\`\`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" }
+   ]
+ }
+ \`\`\`
 
-### Optimization Approach
+ ### Pattern 2: Classify then Route
 
-1. Create 10-15 eval queries \u2014 a mix of should-trigger and should-not-trigger prompts
-2. For **should-trigger** (6-8): different phrasings of the same intent \u2014 formal, casual, indirect. Include cases where the user doesn't explicitly name the skill but clearly needs it
-3. For **should-not-trigger** (6-8): focus on near-misses \u2014 queries that share keywords but need something different. Don't make them obviously irrelevant
-4. Test the description against these queries and adjust based on misfires
-5. Show the user before/after and explain what changed
+ \`\`\`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
 
-## Step 6: Package and Present
+  For routing to 3+ categories, use \`branches\` instead of nested \`then\`/\`else\`:
 
-When the skill is ready:
-1. Verify the SKILL.md is at \`/root/.agents/skills/{skill-name}/SKILL.md\` with correct frontmatter
-2. Confirm all resource files are in place under \`resources/\`
-3. Tell the user the skill is ready and available at its path
-4. Remind them that the skill will now appear in the available skills list for any agent using the skill system
+  \`\`\`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" }
+   ]
+ }
+ \`\`\`
 
-## Updating Existing Skills
+ ### 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" }
+   ]
+ }
+ \`\`\`
 
-When the user wants to improve an existing skill:
-1. Read the current SKILL.md from \`/root/.agents/skills/{skill-name}/SKILL.md\`
-2. Understand what it currently does and where it falls short
-3. Follow the same interview \u2192 draft \u2192 test \u2192 iterate loop
-4. **Preserve the original name** \u2014 the directory name and \`name\` frontmatter field should stay the same
-5. Write the updated version back to the same path
+ ### 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
 
-## Example Walkthrough
+ 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?
 
-**User**: "I want a skill that helps me analyze CSV data"
+ ## Step 2: Prepare Dependencies
 
-**You** (interview):
-- "What kinds of analysis \u2014 summary stats, filtering, charting?"
-- "Are the CSVs always the same format or varied?"
-- "Should it output results as text, new CSV, or visualizations?"
+ 1. Call \`list_tools\` to see available tools for the workflow agent.
 
-**User**: "Mostly summary stats and filtering. The files vary but all have headers."
+ ## Step 3: Write the DSL
 
-**You** (draft frontmatter):
-\`\`\`yaml
----
-name: csv-analyzer
-description: Analyze CSV data with statistical summaries, filtering, and aggregation. Use whenever users want to explore, summarize, or extract insights from CSV files \u2014 even if they don't say "analyze" explicitly.
-metadata:
-  category: data
-  version: "1.0"
----
-\`\`\`
+ Use \`create_workflow\` with \`skillLoaded: true\`. Never write \`state.fields\`, \`edges\`, \`version\`, or \`output.key\` \u2014 they are auto-generated.
 
-**You** (draft body): Write a workflow that teaches the agent to:
-1. Inspect the CSV structure and headers
-2. Let the user choose analysis type (summary, filter, aggregate)
-3. Execute the analysis and present results clearly
-4. Handle edge cases: missing headers, empty files, mixed types
+ **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)
 
-**You** (write): Create \`/root/.agents/skills/csv-analyzer/SKILL.md\`
+ ## Step 4: Test
 
-**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."
+ After creating, optionally call \`validate_workflow(id)\` to check the workflow compiles correctly. Then test with \`invoke_agent\`.
 
-Then iterate based on what the user says.
-`
+ ## 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];
@@ -8064,15 +9745,15 @@ function formatContentWithLineNumbers(content, startLine = 1) {
       for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
         const start = chunkIdx * MAX_LINE_LENGTH;
         const end = Math.min(start + MAX_LINE_LENGTH, line.length);
-        const chunk = line.substring(start, end);
+        const chunk2 = line.substring(start, end);
         if (chunkIdx === 0) {
           resultLines.push(
-            `${lineNum.toString().padStart(LINE_NUMBER_WIDTH)}	${chunk}`
+            `${lineNum.toString().padStart(LINE_NUMBER_WIDTH)}	${chunk2}`
           );
         } else {
           const continuationMarker = `${lineNum}.${chunkIdx}`;
           resultLines.push(
-            `${continuationMarker.padStart(LINE_NUMBER_WIDTH)}	${chunk}`
+            `${continuationMarker.padStart(LINE_NUMBER_WIDTH)}	${chunk2}`
           );
         }
       }
@@ -10742,6 +12423,7 @@ var import_uuid2 = require("uuid");
 var import_protocols8 = require("@axiom-lattice/protocols");
 
 // src/schedule_lattice/ScheduleLatticeManager.ts
+init_BaseLatticeManager();
 var import_protocols5 = require("@axiom-lattice/protocols");
 
 // src/schedule_lattice/DefaultScheduleClient.ts
@@ -11733,6 +13415,7 @@ var getScheduleLattice = (key) => scheduleLatticeManager.getScheduleLattice(key)
 var import_events = require("events");
 
 // src/queue_lattice/QueueLatticeManager.ts
+init_BaseLatticeManager();
 var import_protocols6 = require("@axiom-lattice/protocols");
 
 // src/queue_lattice/MemoryQueueClient.ts
@@ -12070,9 +13753,9 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
   }
   async addChunk(threadId, arg2, arg3) {
     const buffer2 = this.getOrCreateBuffer(threadId);
-    let chunk;
+    let chunk2;
     if (typeof arg2 === "string" && arg3 !== void 0) {
-      chunk = {
+      chunk2 = {
         type: import_protocols7.MessageChunkTypes.AI,
         data: {
           id: arg2,
@@ -12080,10 +13763,10 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
         }
       };
     } else {
-      chunk = arg2;
+      chunk2 = arg2;
     }
-    buffer2.chunks.push(chunk);
-    buffer2.chunks$.next(chunk);
+    buffer2.chunks.push(chunk2);
+    buffer2.chunks$.next(chunk2);
     buffer2.updatedAt = Date.now();
     buffer2.expiresAt = Date.now() + this.config.ttl;
     buffer2.status = "active" /* ACTIVE */;
@@ -12130,12 +13813,12 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
   async getAccumulatedContent(threadId) {
     const buffer2 = this.getBufferIfValid(threadId);
     if (!buffer2) return "";
-    return buffer2.chunks.map((chunk) => chunk.data?.content || "").join("");
+    return buffer2.chunks.map((chunk2) => chunk2.data?.content || "").join("");
   }
   async getChunksByMessageId(threadId, messageId) {
     const buffer2 = this.getBufferIfValid(threadId);
     if (!buffer2) return [];
-    return buffer2.chunks.filter((chunk) => chunk.data?.id === messageId);
+    return buffer2.chunks.filter((chunk2) => chunk2.data?.id === messageId);
   }
   async clearThread(threadId) {
     this.buffers.delete(threadId);
@@ -12203,12 +13886,12 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
     const filtered$ = buffer2.chunks$.pipe(
       (0, import_rxjs.observeOn)(import_rxjs.asyncScheduler),
       // 1. 从指定 messageId 开始
-      (0, import_operators.filter)((chunk) => {
-        if (chunk.data?.id === messageId) startYieldChunk = true;
+      (0, import_operators.filter)((chunk2) => {
+        if (chunk2.data?.id === messageId) startYieldChunk = true;
         return startYieldChunk;
       }),
       // 2. 包含指定的停止类型，但收到后停止
-      (0, import_operators.takeWhile)((chunk) => !typesToStop.includes(chunk.type), true)
+      (0, import_operators.takeWhile)((chunk2) => !typesToStop.includes(chunk2.type), true)
     );
     yield* (0, import_rxjs_for_await.eachValueFrom)(filtered$);
   }
@@ -12255,6 +13938,7 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
 };
 
 // src/chunk_buffer_lattice/ChunkBufferLatticeManager.ts
+init_BaseLatticeManager();
 var ChunkBufferLatticeManager = class _ChunkBufferLatticeManager extends BaseLatticeManager {
   /**
    * Private constructor for singleton pattern
@@ -12422,26 +14106,26 @@ var Agent = class {
           }
         );
         try {
-          for await (const chunk of agentStream) {
+          for await (const chunk2 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];
+            if (chunk2[0] === "updates") {
+              const update = chunk2[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];
+            } else if (chunk2[0] === "messages") {
+              const messages2 = chunk2[1];
               data = messages2?.[0]?.toDict();
             }
-            if (chunk?.[1]?.__interrupt__) {
-              const interruptData = chunk?.[1]?.__interrupt__[0];
+            if (chunk2?.[1]?.__interrupt__) {
+              const interruptData = chunk2?.[1]?.__interrupt__[0];
               data = {
                 type: "interrupt",
                 id: interruptData.id,
@@ -12784,8 +14468,8 @@ var Agent = class {
     return {
       [Symbol.asyncIterator]: async function* () {
         try {
-          for await (const chunk of stream) {
-            yield chunk;
+          for await (const chunk2 of stream) {
+            yield chunk2;
           }
         } catch (error) {
           if (error?.message === "Thread aborted") {
@@ -13972,7 +15656,8 @@ var ReActAgentGraphBuilder = class {
       name: agentLattice.config.name,
       checkpointer: getCheckpointSaver("default"),
       stateSchema: stateSchema2,
-      middleware: middlewares
+      middleware: middlewares,
+      responseFormat: params.responseFormat
     });
   }
 };
@@ -14145,6 +15830,7 @@ function createAgentWorkerGraph() {
 var agentWorkerGraph = createAgentWorkerGraph();
 
 // src/deep_agent_new/middleware/subagents.ts
+init_MemoryLatticeManager();
 var DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools.";
 var EXCLUDED_STATE_KEYS = ["messages", "todos", "jumpTo"];
 var DEFAULT_GENERAL_PURPOSE_DESCRIPTION = "General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. This agent has access to all tools as the main agent.";
@@ -16273,6 +17959,7 @@ ${BASE_PROMPT}` : BASE_PROMPT;
 }
 
 // src/agent_lattice/builders/DeepAgentGraphBuilder.ts
+init_MemoryLatticeManager();
 var DeepAgentGraphBuilder = class {
   /**
    * 构建Deep Agent Graph
@@ -16315,6 +18002,7 @@ var DeepAgentGraphBuilder = class {
       contextSchema: params.stateSchema,
       systemPrompt: params.prompt,
       subagents,
+      responseFormat: params.responseFormat,
       checkpointer: getCheckpointSaver("default"),
       skills: params.skillCategories,
       backend: filesystemBackend,
@@ -16324,6 +18012,9 @@ var DeepAgentGraphBuilder = class {
   }
 };
 
+// src/agent_team/builders/TeamAgentGraphBuilder.ts
+init_MemoryLatticeManager();
+
 // src/agent_team/agent_team.ts
 var import_v35 = require("zod/v3");
 var import_langchain63 = require("langchain");
@@ -17024,6 +18715,7 @@ function createTeammateTools(options) {
 }
 
 // src/agent_team/middleware/team.ts
+init_MemoryLatticeManager();
 var TEAM_LEAD_AGENT_ID = "team_lead";
 var DEFAULT_POLL_INTERVAL_MS = 5e3;
 var DEFAULT_SCHEDULE_LATTICE_KEY = "default";
@@ -18323,6 +20015,7 @@ ${BASE_PROMPT2}` : BASE_PROMPT2;
 }
 
 // src/agent_lattice/builders/ProcessingAgentGraphBuilder.ts
+init_MemoryLatticeManager();
 var ProcessingAgentGraphBuilder = class {
   async build(agentLattice, params) {
     const tools = params.tools.map((t) => {
@@ -18362,6 +20055,7 @@ var ProcessingAgentGraphBuilder = class {
       contextSchema: params.stateSchema,
       systemPrompt: params.prompt,
       subagents,
+      responseFormat: params.responseFormat,
       checkpointer: getCheckpointSaver("default"),
       skills: params.skillCategories,
       backend: filesystemBackend,
@@ -18593,6 +20287,102 @@ function extractLastHumanMessage(messages) {
   return "";
 }
 
+// src/agent_lattice/builders/WorkflowAgentGraphBuilder.ts
+var import_langchain67 = require("langchain");
+init_MemoryLatticeManager();
+var import_protocols10 = require("@axiom-lattice/protocols");
+init_compile();
+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 (!(0, import_protocols10.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 = (0, import_langchain67.createAgent)({
+      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 = (0, import_langchain67.createAgent)({
+            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 = (0, import_langchain67.createAgent)({
+            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() {
@@ -18617,6 +20407,7 @@ var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
     this.builders.set(import_protocols.AgentType.TEAM, new TeamAgentGraphBuilder());
     this.builders.set(import_protocols.AgentType.PROCESSING, new ProcessingAgentGraphBuilder());
     this.builders.set(import_protocols.AgentType.A2A_REMOTE, new RemoteAgentGraphBuilder());
+    this.builders.set(import_protocols.AgentType.WORKFLOW, new WorkflowAgentGraphBuilder());
   }
   /**
    * 注册自定义Builder
@@ -18643,7 +20434,7 @@ var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
 };
 
 // src/agent_lattice/builders/AgentParamsBuilder.ts
-var import_protocols10 = require("@axiom-lattice/protocols");
+var import_protocols11 = require("@axiom-lattice/protocols");
 var AgentParamsBuilder = class {
   /**
    * constructor
@@ -18661,8 +20452,8 @@ var AgentParamsBuilder = class {
    * @returns Agent build parameters
    */
   async buildParams(agentLattice, options) {
-    const skills = (0, import_protocols10.isDeepAgentConfig)(agentLattice.config) || (0, import_protocols10.isProcessingAgentConfig)(agentLattice.config) ? agentLattice.config.skillCategories : void 0;
-    const toolKeys = options?.overrideTools || (0, import_protocols10.getToolsFromConfig)(agentLattice.config);
+    const skills = (0, import_protocols11.isDeepAgentConfig)(agentLattice.config) || (0, import_protocols11.isProcessingAgentConfig)(agentLattice.config) ? agentLattice.config.skillCategories : void 0;
+    const toolKeys = options?.overrideTools || (0, import_protocols11.getToolsFromConfig)(agentLattice.config);
     const tools = toolKeys.map((toolKey) => {
       const toolLattice = toolLatticeManager.getToolLattice(toolKey);
       if (!toolLattice) {
@@ -18679,7 +20470,7 @@ var AgentParamsBuilder = class {
     if (!model) {
       throw new Error(`Model "${modelKey}" does not exist`);
     }
-    const subAgentKeys = (0, import_protocols10.getSubAgentsFromConfig)(agentLattice.config);
+    const subAgentKeys = (0, import_protocols11.getSubAgentsFromConfig)(agentLattice.config);
     const subAgents = await Promise.all(subAgentKeys.map(async (agentKey) => {
       const subAgentLattice = await this.getAgentLatticeFunc(agentKey);
       if (!subAgentLattice) {
@@ -18692,7 +20483,7 @@ var AgentParamsBuilder = class {
       };
     }));
     let internalSubAgents = [];
-    if ((0, import_protocols10.isDeepAgentConfig)(agentLattice.config) || (0, import_protocols10.isProcessingAgentConfig)(agentLattice.config)) {
+    if ((0, import_protocols11.isDeepAgentConfig)(agentLattice.config) || (0, import_protocols11.isProcessingAgentConfig)(agentLattice.config)) {
       internalSubAgents = agentLattice.config.internalSubAgents?.map((i) => ({
         key: i.key,
         config: i
@@ -18704,6 +20495,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
@@ -18732,6 +20524,7 @@ function mergeAgentConfig(parent, child) {
 }
 
 // src/store_lattice/configureStores.ts
+init_MemoryLatticeManager();
 var _disposables = [];
 var _cleanupRegistered = false;
 function registerSignalCleanup() {
@@ -19289,7 +21082,7 @@ ${body}` : `${frontmatter}
 // src/agent_lattice/agentArchitectTools.ts
 var import_zod53 = __toESM(require("zod"));
 var import_uuid5 = require("uuid");
-var import_protocols11 = require("@axiom-lattice/protocols");
+var import_protocols12 = require("@axiom-lattice/protocols");
 function getTenantId(exeConfig) {
   const runConfig = exeConfig?.configurable?.runConfig || {};
   return runConfig.tenantId || "default";
@@ -19397,7 +21190,7 @@ registerToolLattice(
         key: id,
         name: input.name,
         description: input.description || "",
-        type: input.type === "deep_agent" ? import_protocols11.AgentType.DEEP_AGENT : import_protocols11.AgentType.REACT,
+        type: input.type === "deep_agent" ? import_protocols12.AgentType.DEEP_AGENT : import_protocols12.AgentType.REACT,
         prompt: input.prompt,
         ...input.tools && input.tools.length > 0 ? { tools: input.tools } : {},
         ...input.middleware && input.middleware.length > 0 ? { middleware: input.middleware } : {},
@@ -19486,7 +21279,7 @@ registerToolLattice(
         key: id,
         name: input.name,
         description: input.description || "",
-        type: import_protocols11.AgentType.PROCESSING,
+        type: import_protocols12.AgentType.PROCESSING,
         prompt: input.prompt,
         ...input.tools && input.tools.length > 0 ? { tools: input.tools } : {},
         middleware,
@@ -19513,6 +21306,190 @@ registerToolLattice(
     }
   }
 );
+var workflowStepLazy = import_zod53.default.lazy(
+  () => import_zod53.default.discriminatedUnion("type", [
+    import_zod53.default.object({ type: import_zod53.default.literal("agent").optional(), id: import_zod53.default.string().optional(), name: import_zod53.default.string().optional(), prompt: import_zod53.default.string(), schema: import_zod53.default.record(import_zod53.default.any()) }),
+    import_zod53.default.object({ type: import_zod53.default.literal("human"), id: import_zod53.default.string().optional(), prompt: import_zod53.default.string(), title: import_zod53.default.string().optional(), schema: import_zod53.default.union([import_zod53.default.boolean(), import_zod53.default.record(import_zod53.default.any())]).optional() }),
+    import_zod53.default.object({ type: import_zod53.default.literal("condition"), id: import_zod53.default.string().optional(), if: import_zod53.default.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: import_zod53.default.union([import_zod53.default.lazy(() => workflowStepLazy), import_zod53.default.array(import_zod53.default.lazy(() => workflowStepLazy))]).optional(), else: import_zod53.default.union([import_zod53.default.lazy(() => workflowStepLazy), import_zod53.default.array(import_zod53.default.lazy(() => workflowStepLazy))]).optional(), branches: import_zod53.default.record(import_zod53.default.union([import_zod53.default.lazy(() => workflowStepLazy), import_zod53.default.array(import_zod53.default.lazy(() => workflowStepLazy))])).optional() }),
+    import_zod53.default.object({ type: import_zod53.default.literal("map"), id: import_zod53.default.string(), source: import_zod53.default.string(), each: import_zod53.default.object({ prompt: import_zod53.default.string(), schema: import_zod53.default.record(import_zod53.default.any()) }), reduce: import_zod53.default.object({ prompt: import_zod53.default.string(), schema: import_zod53.default.record(import_zod53.default.any()) }).optional(), batch: import_zod53.default.number().int().min(1).optional(), concurrency: import_zod53.default.number().int().min(1).optional() }),
+    import_zod53.default.object({ type: import_zod53.default.literal("parallel"), id: import_zod53.default.string().optional(), steps: import_zod53.default.array(import_zod53.default.lazy(() => workflowStepLazy)) }),
+    import_zod53.default.object({ type: import_zod53.default.literal("end"), status: import_zod53.default.enum(["success", "failed"]).optional() })
+  ])
+);
+var workflowDSLSchema = import_zod53.default.object({
+  name: import_zod53.default.string().describe("Workflow identifier (kebab-case slug)"),
+  steps: import_zod53.default.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 = import_zod53.default.object({
+  name: import_zod53.default.string().describe("Display name for the workflow agent"),
+  description: import_zod53.default.string().optional().describe("Short description of what this workflow does"),
+  skillLoaded: import_zod53.default.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: import_zod53.default.array(import_zod53.default.string()).optional().describe("Tool keys for the workflow's built-in general agent"),
+  middleware: import_zod53.default.array(middlewareConfigSchema).optional().describe("Middleware configs for the workflow's general agent"),
+  modelKey: import_zod53.default.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: import_protocols12.AgentType.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 Promise.resolve().then(() => (init_compile(), compile_exports));
+        const { getCheckpointSaver: getCheckpointSaver2 } = await Promise.resolve().then(() => (init_memory_lattice(), memory_lattice_exports));
+        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: import_zod53.default.object({
+      id: import_zod53.default.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 !== import_protocols12.AgentType.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 Promise.resolve().then(() => (init_compile(), compile_exports));
+        const { getCheckpointSaver: getCheckpointSaver2 } = await Promise.resolve().then(() => (init_memory_lattice(), memory_lattice_exports));
+        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 = import_zod53.default.object({
+  id: import_zod53.default.string().describe("The workflow agent ID to update"),
+  name: import_zod53.default.string().optional().describe("New display name"),
+  description: import_zod53.default.string().optional().describe("New description"),
+  workflow: workflowDSLSchema.optional().describe("Replacement Workflow DSL definition. Omit to keep the existing."),
+  tools: import_zod53.default.array(import_zod53.default.string()).optional().describe("Replacement tool keys for the general agent"),
+  middleware: import_zod53.default.array(middlewareConfigSchema).optional().describe("Replacement middleware configs"),
+  modelKey: import_zod53.default.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 !== import_protocols12.AgentType.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 Promise.resolve().then(() => (init_compile(), compile_exports));
+          const { getCheckpointSaver: getCheckpointSaver2 } = await Promise.resolve().then(() => (init_memory_lattice(), memory_lattice_exports));
+          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 = import_zod53.default.object({
   id: import_zod53.default.string().describe("The PROCESSING agent ID to update"),
   name: import_zod53.default.string().optional().describe("New display name for the orchestrator"),
@@ -19554,7 +21531,7 @@ registerToolLattice(
         return JSON.stringify({ error: `Agent '${input.id}' not found` });
       }
       const existingConfig = existing.graphDefinition || {};
-      if (existingConfig.type !== import_protocols11.AgentType.PROCESSING) {
+      if (existingConfig.type !== import_protocols12.AgentType.PROCESSING) {
         return JSON.stringify({ error: `Agent '${input.id}' is not a PROCESSING agent (type: ${existingConfig.type})` });
       }
       const normalize = (s) => s.toLowerCase().replace(/[_\-\s]/g, "");
@@ -19769,24 +21746,16 @@ 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}` });
     }
   }
 );
 
 // src/agent_lattice/agentArchitectConfig.ts
-var import_protocols13 = require("@axiom-lattice/protocols");
+var import_protocols14 = require("@axiom-lattice/protocols");
 
 // src/agent_lattice/agentArchitectPrompt.ts
 var AGENT_ARCHITECT_PROMPT = `# Agent Architect
@@ -19803,12 +21772,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.
 
@@ -19819,7 +21788,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?"
@@ -19831,8 +21800,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
@@ -19870,7 +21840,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.
@@ -19908,233 +21878,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.
-
-**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:
+## Workflow B: Processing Agent (PROCESSING type) [DEPRECATED]
 
-**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)
+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.
 
-\`\`\`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.
 
@@ -20185,7 +21983,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
@@ -20216,28 +22014,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:
@@ -20329,8 +22152,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. |
@@ -20386,29 +22209,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
@@ -20426,7 +22226,7 @@ Updates a PROCESSING agent's topology edges, name, prompt, or sub-agents. Unlike
 `;
 
 // src/agent_lattice/agentReviewerConfig.ts
-var import_protocols12 = require("@axiom-lattice/protocols");
+var import_protocols13 = require("@axiom-lattice/protocols");
 
 // src/agent_lattice/agentReviewerPrompt.ts
 var AGENT_REVIEWER_PROMPT = `# Agent Reviewer
@@ -20489,7 +22289,7 @@ var agentReviewerConfig = {
   key: AGENT_REVIEWER_KEY,
   name: "Agent Reviewer",
   description: "Review and test AI agents. Use this agent to check agent configurations for correctness and to test agents by invoking them with realistic messages.",
-  type: import_protocols12.AgentType.REACT,
+  type: import_protocols13.AgentType.REACT,
   prompt: AGENT_REVIEWER_PROMPT,
   tools: [
     "invoke_agent",
@@ -20515,21 +22315,30 @@ var agentArchitectConfig = {
   key: AGENT_ARCHITECT_KEY,
   name: "Agent Architect",
   description: "Design and manage AI agents through natural language conversation. Use this agent when you want to create a new agent, modify an existing agent, or manage your agent collection (list, view, update, delete).",
-  type: import_protocols13.AgentType.DEEP_AGENT,
+  type: import_protocols14.AgentType.DEEP_AGENT,
   prompt: AGENT_ARCHITECT_PROMPT,
   tools: [
     "list_agents",
     "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",
@@ -20996,7 +22805,11 @@ var getAgentClient = (tenantId, key, options) => agentLatticeManager.initializeC
 var getAgentClientAsync = async (tenantId, key, options) => agentLatticeManager.initializeClientAsync(tenantId, key, options);
 var createAgentClientFromAgentLattice = async (agentLattice, options) => await agentLatticeManager.createAgentClientFromConfig(agentLattice, options);
 
+// src/index.ts
+init_memory_lattice();
+
 // src/embeddings_lattice/EmbeddingsLatticeManager.ts
+init_BaseLatticeManager();
 var EmbeddingsLatticeManager = class _EmbeddingsLatticeManager extends BaseLatticeManager {
   /**
    * Get EmbeddingsLatticeManager singleton instance
@@ -21089,6 +22902,7 @@ var getEmbeddingsLattice = (key) => embeddingsLatticeManager.getEmbeddingsLattic
 var getEmbeddingsClient = (key) => embeddingsLatticeManager.getEmbeddingsClient(key);
 
 // src/vectorstore_lattice/VectorStoreLatticeManager.ts
+init_BaseLatticeManager();
 var VectorStoreLatticeManager = class _VectorStoreLatticeManager extends BaseLatticeManager {
   /**
    * Get VectorStoreLatticeManager singleton instance
@@ -21181,7 +22995,8 @@ var getVectorStoreLattice = (key) => vectorStoreLatticeManager.getVectorStoreLat
 var getVectorStoreClient = (key) => vectorStoreLatticeManager.getVectorStoreClient(key);
 
 // src/logger_lattice/LoggerLatticeManager.ts
-var import_protocols14 = require("@axiom-lattice/protocols");
+init_BaseLatticeManager();
+var import_protocols15 = require("@axiom-lattice/protocols");
 
 // src/logger_lattice/PinoLoggerClient.ts
 var import_pino = __toESM(require("pino"));
@@ -21403,11 +23218,11 @@ var LoggerLatticeManager = class _LoggerLatticeManager extends BaseLatticeManage
     if (client) {
       loggerClient = client;
     } else {
-      if (config.type === import_protocols14.LoggerType.PINO) {
+      if (config.type === import_protocols15.LoggerType.PINO) {
         loggerClient = new PinoLoggerClient(config);
-      } else if (config.type === import_protocols14.LoggerType.CONSOLE) {
+      } else if (config.type === import_protocols15.LoggerType.CONSOLE) {
         loggerClient = new ConsoleLoggerClient(config);
-      } else if (config.type === import_protocols14.LoggerType.CUSTOM) {
+      } else if (config.type === import_protocols15.LoggerType.CUSTOM) {
         throw new Error(
           `Custom logger client must be provided. Please pass the client to registerLattice.`
         );
@@ -21496,6 +23311,7 @@ var registerLoggerLattice = (key, config, client) => loggerLatticeManager.regist
 var getLoggerLattice = (key) => loggerLatticeManager.getLoggerLattice(key);
 
 // src/skill_lattice/SkillLatticeManager.ts
+init_BaseLatticeManager();
 var SkillLatticeManager = class _SkillLatticeManager extends BaseLatticeManager {
   /**
    * Get SkillLatticeManager singleton instance
@@ -21867,6 +23683,7 @@ var skillLatticeManager = SkillLatticeManager.getInstance();
 
 // src/mcp_lattice/McpLatticeManager.ts
 var import_mcp_adapters = require("@langchain/mcp-adapters");
+init_BaseLatticeManager();
 var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
   constructor() {
     super(...arguments);
@@ -23319,6 +25136,11 @@ function clearEncryptionKeyCache() {
   cachedKey = null;
   keyValidated = false;
 }
+
+// src/workflow/index.ts
+init_compile();
+init_normalize();
+init_utils();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_TASK_EVENT,
@@ -23402,21 +25224,28 @@ function clearEncryptionKeyCache() {
   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,
@@ -23429,6 +25258,7 @@ function clearEncryptionKeyCache() {
   createSchedulerMiddleware,
   createTeamMiddleware,
   createTeammateTools,
+  createTerminalNode,
   createUnknownToolHandlerMiddleware,
   createWidgetMiddleware,
   decrypt,
@@ -23438,7 +25268,9 @@ function clearEncryptionKeyCache() {
   ensureBuiltinAgentsForTenant,
   eventBus,
   eventBusDefault,
+  expand,
   extractFetcherError,
+  extractOutput,
   fileDataToString,
   formatContentWithLineNumbers,
   formatGrepMatches,
@@ -23474,6 +25306,7 @@ function clearEncryptionKeyCache() {
   grepMatchesFromFiles,
   grepSearchFiles,
   hasChunkBuffer,
+  invokeWithRetry,
   isBuiltInSkill,
   isUsingDefaultKey,
   isValidCronExpression,
@@ -23484,6 +25317,7 @@ function clearEncryptionKeyCache() {
   metricsServerManager,
   modelLatticeManager,
   normalizeSandboxName,
+  parallelLimit,
   parseCronExpression,
   parseSkillFrontmatter,
   performStringReplacement,
@@ -23503,6 +25337,8 @@ function clearEncryptionKeyCache() {
   registerTeammateAgent,
   registerToolLattice,
   registerVectorStoreLattice,
+  renderTemplate,
+  resolvePath,
   sandboxLatticeManager,
   sanitizeToolCallId,
   scheduleLatticeManager,
@@ -23515,6 +25351,7 @@ function clearEncryptionKeyCache() {
   unregisterTeammateAgent,
   updateFileData,
   validateAgentInput,
+  validateDSL,
   validateEncryptionKey,
   validatePath,
   validateSkillName,