@axiom-lattice/core 2.1.80 → 2.1.81

package/dist/index.js

@@ -387,40 +387,342 @@ var init_memory_lattice = __esm({
   }
 });
 
+// src/workflow/schema.ts
+function toJsonSchema(fields) {
+  if (!fields || Object.keys(fields).length === 0) return void 0;
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(fields)) {
+    required.push(key);
+    properties[key] = fieldToSchema(value);
+  }
+  return { type: "object", properties, required };
+}
+function fieldToSchema(value) {
+  if (typeof value === "string") return stringTypeToSchema(value);
+  if (Array.isArray(value) && value.length > 0 && typeof value[0] === "object" && !Array.isArray(value[0])) {
+    const nested = toJsonSchema(value[0]);
+    return { type: "array", items: nested ?? { type: "object" } };
+  }
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const nested = toJsonSchema(value);
+    return nested ?? { type: "object" };
+  }
+  return { type: "string" };
+}
+function stringTypeToSchema(type) {
+  if (type.endsWith("[]")) {
+    const inner = type.slice(0, -2);
+    return { type: "array", items: stringTypeToSchema(inner) };
+  }
+  if (type === "string") return { type: "string" };
+  if (type === "number") return { type: "number" };
+  if (type === "boolean") return { type: "boolean" };
+  return { type };
+}
+var init_schema = __esm({
+  "src/workflow/schema.ts"() {
+    "use strict";
+  }
+});
+
+// src/workflow/parse-yaml.ts
+function nodeId(label) {
+  return `n_${label}`;
+}
+function nextParallelLabel() {
+  return `parallel_${_parallelSeq++}`;
+}
+function translate(template) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_m, expr) => {
+    const t = expr.trim();
+    if (t === "item") return "${item}";
+    return `\${state.${t}}`;
+  });
+}
+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 validateExpression(expr) {
+  if (/;/.test(expr)) {
+    throw new Error(`Condition expression must not contain semicolons: "${expr}"`);
+  }
+  if (/[{}]/.test(expr)) {
+    throw new Error(`Condition expression must not contain braces: "${expr}"`);
+  }
+  if (/\bfunction\b/.test(expr)) {
+    throw new Error(`Condition expression must not contain 'function': "${expr}"`);
+  }
+  if (/\brequire\b|\bimport\b|\bmodule\b/.test(expr)) {
+    throw new Error(`Condition expression must not contain require/import: "${expr}"`);
+  }
+  if (/\bprocess\b|\bglobal\b|\bglobalThis\b/.test(expr)) {
+    throw new Error(`Condition expression must not contain process/global: "${expr}"`);
+  }
+  if (/\beval\b|\bFunction\b/.test(expr)) {
+    throw new Error(`Condition expression must not contain eval/Function: "${expr}"`);
+  }
+  if (/\bconstructor\b|\b__proto__\b|\bprototype\b/.test(expr)) {
+    throw new Error(`Condition expression must not contain prototype access: "${expr}"`);
+  }
+  if (/\bsetTimeout\b|\bsetInterval\b|\bbuffer\b/i.test(expr)) {
+    throw new Error(`Condition expression must not contain timer or buffer references: "${expr}"`);
+  }
+}
+function parseYaml(yamlStr) {
+  _parallelSeq = 0;
+  let raw;
+  try {
+    raw = yaml.load(yamlStr);
+  } catch (e) {
+    const line = e?.mark?.line != null ? ` (line ${e.mark.line + 1})` : "";
+    throw new Error(`YAML parse error${line}: ${e.message || e}`);
+  }
+  if (!raw || typeof raw !== "object" || !Array.isArray(raw.steps)) {
+    throw new Error("Workflow YAML must have 'steps' (array)");
+  }
+  const name = typeof raw.name === "string" ? raw.name : "workflow";
+  const wf = {
+    name,
+    steps: raw.steps.map((s, i) => parseStep(s, i))
+  };
+  return normalize(wf);
+}
+function parseStep(raw, index) {
+  if (raw.parallel !== void 0) {
+    if (!Array.isArray(raw.parallel)) {
+      throw new Error(`Step at position ${index}: parallel must be an array`);
+    }
+    const children = raw.parallel.map((c, ci) => {
+      const entries2 = Object.entries(c);
+      if (entries2.length !== 1) {
+        throw new Error(`Parallel child at position ${index}.${ci} must be a single-key mapping`);
+      }
+      const [label, config2] = entries2[0];
+      return {
+        label,
+        if: config2.if !== void 0 ? String(config2.if) : void 0,
+        prompt: String(config2.prompt ?? ""),
+        output: config2.output,
+        ask: config2.ask === true
+      };
+    });
+    return {
+      parallel: children,
+      if: raw.if !== void 0 ? String(raw.if) : void 0,
+      output: raw.output
+    };
+  }
+  const entries = Object.entries(raw);
+  if (entries.length !== 1) {
+    throw new Error(`Step at position ${index} must be a single-key mapping`);
+  }
+  const [key, config] = entries[0];
+  const mapConfig = config?.map;
+  if (mapConfig && typeof mapConfig === "object") {
+    return {
+      map: {
+        source: mapConfig.source,
+        label: key,
+        // always use the YAML key as the label
+        if: mapConfig.if !== void 0 ? String(mapConfig.if) : void 0,
+        each: {
+          prompt: String(mapConfig.each?.prompt ?? ""),
+          output: mapConfig.each?.output
+        },
+        output: mapConfig.output,
+        batch: mapConfig.batch,
+        concurrency: mapConfig.concurrency
+      }
+    };
+  }
+  if (key === "map") {
+    throw new Error(`Map steps must use named format: - <label>: { map: { source, each, ... } }. Anonymous "- map:" is not supported.`);
+  }
+  return {
+    label: key,
+    if: config.if !== void 0 ? String(config.if) : void 0,
+    prompt: String(config.prompt ?? ""),
+    output: config.output,
+    ask: config.ask === true
+  };
+}
+function normalize(wf) {
+  validate(wf);
+  for (const step of wf.steps) {
+    if ("label" in step) {
+      const s = step;
+      if (s.if) validateExpression(s.if);
+    } else if ("parallel" in step) {
+      const pb = step;
+      if (pb.if) validateExpression(pb.if);
+      for (const child of pb.parallel) {
+        if (child.if) validateExpression(child.if);
+      }
+    }
+  }
+  const nodes = [];
+  const edges = [];
+  const fields = { input: { type: "string" } };
+  nodes.push({ id: "n_input", type: "input", name: "input", output: { key: "input" } });
+  edges.push({ from: "START", to: "n_input" });
+  let prevNodeId = "n_input";
+  for (const step of wf.steps) {
+    if ("label" in step) {
+      const s = step;
+      const nid = nodeId(s.label);
+      const schema = toJsonSchema(s.output);
+      nodes.push({
+        id: nid,
+        type: "agent",
+        name: s.label,
+        input: { template: translate(s.prompt) },
+        output: { key: s.label, ...schema ? { schema } : {} },
+        ask: s.ask,
+        condition: s.if
+      });
+      fields[s.label] = s.output ? { type: "object" } : { type: "string" };
+      addPrevEdges(edges, prevNodeId, nid);
+      prevNodeId = nid;
+    } else if ("parallel" in step) {
+      const pb = step;
+      const groupId = nextParallelLabel();
+      const groupNodeIds = [];
+      for (const child of pb.parallel) {
+        const nid = nodeId(child.label);
+        const schema = toJsonSchema(child.output);
+        nodes.push({
+          id: nid,
+          type: "agent",
+          name: child.label,
+          input: { template: translate(child.prompt) },
+          output: { key: child.label, ...schema ? { schema } : {} },
+          ask: child.ask,
+          condition: child.if,
+          parallelGroup: groupId
+        });
+        fields[child.label] = child.output ? { type: "object" } : { type: "string" };
+        groupNodeIds.push(nid);
+      }
+      addPrevEdges(edges, prevNodeId, groupNodeIds);
+      prevNodeId = groupNodeIds;
+    } else if ("map" in step) {
+      const ms = step.map;
+      const label = ms.label;
+      const nid = nodeId(label);
+      const innerSchema = toJsonSchema(ms.each?.output);
+      const mapSchema = toJsonSchema(ms.output);
+      nodes.push({
+        id: nid,
+        type: "map",
+        name: label,
+        source: `state.${ms.source}`,
+        itemKey: "item",
+        config: {
+          batchSize: ms.batch ?? 50,
+          maxConcurrency: ms.concurrency ?? 5,
+          innerConcurrency: ms.concurrency ?? 5
+        },
+        node: {
+          type: "agent",
+          input: ms.each?.prompt ? { template: translate(ms.each.prompt) } : void 0,
+          ...innerSchema ? { schema: innerSchema } : {}
+        },
+        output: { key: label, ...mapSchema ? { schema: mapSchema } : {} },
+        condition: ms.if
+      });
+      fields[label] = { type: "array", default: [] };
+      addPrevEdges(edges, prevNodeId, nid);
+      prevNodeId = nid;
+    }
+  }
+  const termNid = nodeId("__end");
+  nodes.push({ id: termNid, type: "terminal", name: "__end", status: "success" });
+  addPrevEdges(edges, prevNodeId, termNid);
+  return { version: "1.0", name: wf.name || "workflow", state: { fields }, nodes, edges };
+}
+function addPrevEdges(edges, fromNodes, toNodes) {
+  const fromList = Array.isArray(fromNodes) ? fromNodes : [fromNodes];
+  const toList = Array.isArray(toNodes) ? toNodes : [toNodes];
+  for (const from of fromList) {
+    for (const to of toList) {
+      if (!edges.some((e) => e.from === from && e.to === to)) {
+        edges.push({ from, to });
+      }
+    }
+  }
+}
+function validate(wf) {
+  const labels = /* @__PURE__ */ new Set();
+  for (const step of wf.steps) {
+    if ("label" in step) {
+      const s = step;
+      if (labels.has(s.label)) throw new Error(`Duplicate step label "${s.label}"`);
+      labels.add(s.label);
+    } else if ("parallel" in step) {
+      const pb = step;
+      if (pb.parallel.length === 0) {
+        throw new Error("parallel block must contain at least one child step");
+      }
+      for (const child of pb.parallel) {
+        if (labels.has(child.label)) throw new Error(`Duplicate step label "${child.label}"`);
+        labels.add(child.label);
+      }
+    } else if ("map" in step) {
+      const ms = step.map;
+      if (labels.has(ms.label)) throw new Error(`Duplicate step label "${ms.label}" (map step)`);
+      labels.add(ms.label);
+    }
+  }
+}
+var yaml, _parallelSeq;
+var init_parse_yaml = __esm({
+  "src/workflow/parse-yaml.ts"() {
+    "use strict";
+    yaml = __toESM(require("js-yaml"));
+    init_schema();
+    _parallelSeq = 0;
+  }
+});
+
 // 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)({
+      annotations[key] = (0, import_langgraph14.Annotation)({
         default: () => field.default ?? defaultValueForType(field.type),
         reducer: buildReducer(field.reducer ?? "replace")
       });
     }
   }
   if (!annotations["messages"]) {
-    annotations["messages"] = (0, import_langgraph15.Annotation)({
+    annotations["messages"] = (0, import_langgraph14.Annotation)({
       default: () => [],
       reducer: (prev, next) => [...prev, ...next]
     });
   }
-  annotations["phase"] = (0, import_langgraph15.Annotation)({
+  annotations["phase"] = (0, import_langgraph14.Annotation)({
     default: () => "init",
     reducer: (_prev, next) => next
   });
   if (!annotations["status"]) {
-    annotations["status"] = (0, import_langgraph15.Annotation)({
+    annotations["status"] = (0, import_langgraph14.Annotation)({
       default: () => "",
       reducer: (_prev, next) => next
     });
   }
   if (!annotations["_runId"]) {
-    annotations["_runId"] = (0, import_langgraph15.Annotation)({
+    annotations["_runId"] = (0, import_langgraph14.Annotation)({
       default: () => void 0,
       reducer: (_prev, next) => next ?? _prev
     });
   }
-  return import_langgraph15.Annotation.Root(annotations);
+  return import_langgraph14.Annotation.Root(annotations);
 }
 function defaultValueForType(type) {
   switch (type) {
@@ -528,7 +830,7 @@ Output must be valid JSON in exactly this shape. Return ONLY the JSON, no other
 ${example}`;
     prompt = prompt + schemaInstruction;
   }
-  return { messages: [new import_messages6.HumanMessage(prompt)] };
+  return { messages: [new import_messages5.HumanMessage(prompt)] };
 }
 function schemaToExample(schema) {
   const example = schemaValueToExample(schema);
@@ -674,6 +976,36 @@ function createAgentNode(node, resolveAgent, trackingStore) {
   return async (state, config) => {
     const runId = state._runId;
     const tenantId = config?.configurable?.tenantId ?? "default";
+    if (node.condition) {
+      try {
+        validateExpression(node.condition);
+        const safeExpr = toSafeStateExpr(node.condition);
+        const fn = new Function("state", `try { return ${safeExpr}; } catch { return false; }`);
+        const shouldRun = fn(state);
+        if (!shouldRun) {
+          console.log(`[WF][${node.id}] condition false, skipping "${node.name}" (${node.condition})`);
+          if (trackingStore && runId) {
+            const step = await trackingStore.upsertRunStep({
+              runId,
+              tenantId,
+              stepType: node.type,
+              stepName: node.name
+            }).catch(() => null);
+            if (step) {
+              await trackingStore.updateRunStep(runId, step.id, {
+                status: "skipped",
+                completedAt: /* @__PURE__ */ new Date()
+              }).catch(() => {
+              });
+            }
+          }
+          return { phase: node.id };
+        }
+      } catch (condErr) {
+        console.error(`[WF][${node.id}] condition eval error: ${condErr.message}`);
+        throw condErr;
+      }
+    }
     const startedAt = Date.now();
     let stepId;
     if (trackingStore && runId) {
@@ -687,7 +1019,8 @@ function createAgentNode(node, resolveAgent, trackingStore) {
       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);
+      const stepType = node.ask ? "ask" : node.type;
+      const client = await resolveAgent(node.ref, responseFormat, stepType);
       console.log(`[WF][${node.id}] agent resolved, building input...`);
       const input = buildInput(
         node.input,
@@ -695,16 +1028,32 @@ function createAgentNode(node, resolveAgent, trackingStore) {
         void 0,
         responseFormat ? void 0 : node.output?.schema
       );
+      if (node.ask) {
+        input.messages = [
+          new import_messages5.SystemMessage(
+            "Follow this exact procedure. Do NOT skip any step.\n\nSTEP 1: Read the prompt. It contains content to present to the user and a question to ask.\n\nSTEP 2: Call ask_user_to_clarify. Your question text MUST contain the ACTUAL content from the prompt.\n\nSTEP 3: The tool will pause. The user will see your questions and respond. You will receive their answers.\n\nSTEP 4: Based on the user's answers, produce your final output."
+          ),
+          ...input.messages
+        ];
+      }
       const renderedInput = input.messages[0]?.content ?? "";
       console.log(`[WF][${node.id}] === INPUT (full) ===
 ${renderedInput}
 === END INPUT ===`);
+      const subConfig = {
+        ...config,
+        configurable: {
+          ...config?.configurable ?? {},
+          thread_id: `${config?.configurable?.thread_id ?? "default"}:${node.id}`
+        }
+      };
       if (trackingStore && runId) {
         const step = await trackingStore.upsertRunStep({
           runId,
           tenantId,
           stepType: node.type,
           stepName: node.name,
+          threadId: subConfig.configurable.thread_id,
           input: { template: node.input?.template, rendered: renderedInput }
         }).catch((e) => {
           console.warn("Failed to upsert run step:", e.message);
@@ -716,13 +1065,6 @@ ${renderedInput}
           });
         }
       }
-      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()...`);
@@ -819,157 +1161,40 @@ ${JSON.stringify(output, null, 2)}
     }
   };
 }
-function createHumanFeedbackNode(node, resolveAgent, trackingStore) {
+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 {
-      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(() => {
-          });
+    if (node.condition) {
+      try {
+        validateExpression(node.condition);
+        const safeExpr = toSafeStateExpr(node.condition);
+        const fn = new Function("state", `try { return ${safeExpr}; } catch { return false; }`);
+        const shouldRun = fn(state);
+        if (!shouldRun) {
+          console.log(`[WF][${node.id}] condition false, skipping map "${node.name}" (${node.condition})`);
+          if (trackingStore && runId) {
+            const step = await trackingStore.upsertRunStep({
+              runId,
+              tenantId,
+              stepType: node.type,
+              stepName: node.name
+            }).catch(() => null);
+            if (step) {
+              await trackingStore.updateRunStep(runId, step.id, {
+                status: "skipped",
+                completedAt: /* @__PURE__ */ new Date()
+              }).catch(() => {
+              });
+            }
+          }
+          return { phase: node.id };
         }
-        throw err;
+      } catch (condErr) {
+        console.error(`[WF][${node.id}] condition eval error: ${condErr.message}`);
+        throw condErr;
       }
-      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) {
@@ -1156,368 +1381,77 @@ function createTerminalNode(node, trackingStore) {
       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);
+          completedAt: /* @__PURE__ */ new Date()
+        });
+      } catch (e) {
+        console.warn(`[WF][terminal] Failed to finalize WorkflowRun "${runId}":`, e.message);
       }
-    }
-    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);
+      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);
       }
     }
-    if (s.type === "parallel") s.steps.forEach(walk);
+    return {
+      status: node.status,
+      phase: node.id
+    };
+  };
+}
+function createNodeHandler(node, resolveAgent, trackingStore) {
+  switch (node.type) {
+    case "agent":
+      return createAgentNode(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}`);
   }
-  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);
+function chunk(arr, size) {
+  const result = [];
+  for (let i = 0; i < arr.length; i += size) {
+    result.push(arr.slice(i, i + size));
   }
-  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"() {
+var import_langgraph14, import_messages5;
+var init_utils = __esm({
+  "src/workflow/utils.ts"() {
     "use strict";
-    _counter = 0;
+    import_langgraph14 = require("@langchain/langgraph");
+    import_messages5 = require("@langchain/core/messages");
+    init_parse_yaml();
   }
 });
 
 // src/workflow/compile.ts
 var compile_exports = {};
 __export(compile_exports, {
+  compileInternal: () => compileInternal,
   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);
+function compileWorkflow(yamlStr, resolveAgent, checkpointer, trackingStore) {
+  console.log(`[WF COMPILE] compiling YAML workflow`);
+  const ir = parseYaml(yamlStr);
+  return compileInternal(ir, resolveAgent, checkpointer, trackingStore);
+}
+function compileInternal(ir, resolveAgent, checkpointer, trackingStore) {
   validateAndThrow(ir);
   console.log(`[WF COMPILE] validation passed`);
   const StateAnnotation = buildStateAnnotation(ir.state?.fields);
-  const builder = new import_langgraph16.StateGraph(StateAnnotation);
+  const builder = new import_langgraph15.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);
@@ -1525,26 +1459,18 @@ function compileWorkflow(dsl, resolveAgent, checkpointer, trackingStore) {
   }
   for (const node of ir.nodes) {
     if (node.type === "terminal") {
-      builder.addEdge(node.id, import_langgraph16.END);
+      builder.addEdge(node.id, import_langgraph15.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 from = edge.from === "START" ? import_langgraph15.START : edge.from;
+    const targets = Array.isArray(edge.to) ? edge.to : [edge.to];
+    for (const to of targets) {
+      builder.addEdge(from, to === "END" ? import_langgraph15.END : to);
     }
   }
   const graph = builder.compile({ checkpointer, name: ir.name });
-  console.log(`[WF COMPILE] graph compiled successfully, ready to run`);
+  console.log(`[WF COMPILE] graph compiled successfully`);
   return graph;
 }
 function validateDSL(dsl) {
@@ -1559,7 +1485,6 @@ function validateDSL(dsl) {
   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` });
@@ -1573,24 +1498,12 @@ function validateDSL(dsl) {
         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);
+        return targets.includes(node.id);
       });
       if (!hasIncoming) {
         errors.push({ type: "warning", message: `Terminal node "${node.id}" has no incoming edge` });
@@ -1606,41 +1519,13 @@ function validateAndThrow(dsl) {
     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 import_langgraph15;
 var init_compile = __esm({
   "src/workflow/compile.ts"() {
     "use strict";
-    import_langgraph16 = require("@langchain/langgraph");
+    import_langgraph15 = require("@langchain/langgraph");
     init_utils();
-    init_normalize();
+    init_parse_yaml();
   }
 });
 
@@ -1669,7 +1554,7 @@ __export(index_exports, {
   EmbeddingsLatticeManager: () => EmbeddingsLatticeManager,
   FileSystemSkillStore: () => FileSystemSkillStore,
   FilesystemBackend: () => FilesystemBackend,
-  HumanMessage: () => import_messages7.HumanMessage,
+  HumanMessage: () => import_messages6.HumanMessage,
   InMemoryA2AApiKeyStore: () => InMemoryA2AApiKeyStore,
   InMemoryAssistantStore: () => InMemoryAssistantStore,
   InMemoryBindingStore: () => InMemoryBindingStore,
@@ -1677,7 +1562,9 @@ __export(index_exports, {
   InMemoryChunkBuffer: () => InMemoryChunkBuffer,
   InMemoryDatabaseConfigStore: () => InMemoryDatabaseConfigStore,
   InMemoryMailboxStore: () => InMemoryMailboxStore,
+  InMemoryMenuStore: () => InMemoryMenuStore,
   InMemoryTaskListStore: () => InMemoryTaskListStore,
+  InMemoryTaskStore: () => InMemoryTaskStore,
   InMemoryTenantStore: () => InMemoryTenantStore,
   InMemoryThreadMessageQueueStore: () => InMemoryThreadMessageQueueStore,
   InMemoryThreadStore: () => InMemoryThreadStore,
@@ -1699,6 +1586,7 @@ __export(index_exports, {
   MicrosandboxServiceClient: () => MicrosandboxServiceClient,
   ModelLatticeManager: () => ModelLatticeManager,
   MysqlDatabase: () => MysqlDatabase,
+  PersonalAssistantConfig: () => PersonalAssistantConfig,
   PinoLoggerClient: () => PinoLoggerClient,
   PostgresDatabase: () => PostgresDatabase,
   PrometheusClient: () => PrometheusClient,
@@ -1735,14 +1623,15 @@ __export(index_exports, {
   buildStateAnnotation: () => buildStateAnnotation,
   checkEmptyContent: () => checkEmptyContent,
   clearEncryptionKeyCache: () => clearEncryptionKeyCache,
+  compileInternal: () => compileInternal,
   compileWorkflow: () => compileWorkflow,
   computeSandboxName: () => computeSandboxName,
   configureStores: () => configureStores,
+  connectAllChannels: () => connectAllChannels,
   createAgentNode: () => createAgentNode,
   createAgentTeam: () => createAgentTeam,
   createExecuteSqlQueryTool: () => createExecuteSqlQueryTool,
   createFileData: () => createFileData,
-  createHumanFeedbackNode: () => createHumanFeedbackNode,
   createInfoSqlTool: () => createInfoSqlTool,
   createListMetricsDataSourcesTool: () => createListMetricsDataSourcesTool,
   createListMetricsServersTool: () => createListMetricsServersTool,
@@ -1760,9 +1649,9 @@ __export(index_exports, {
   createQueryTablesListTool: () => createQueryTablesListTool,
   createSandboxProvider: () => createSandboxProvider,
   createSchedulerMiddleware: () => createSchedulerMiddleware,
+  createTaskMiddleware: () => createTaskMiddleware,
   createTeamMiddleware: () => createTeamMiddleware,
   createTeammateTools: () => createTeammateTools,
-  createTerminalNode: () => createTerminalNode,
   createUnknownToolHandlerMiddleware: () => createUnknownToolHandlerMiddleware,
   createWidgetMiddleware: () => createWidgetMiddleware,
   decrypt: () => decrypt,
@@ -1772,7 +1661,6 @@ __export(index_exports, {
   ensureBuiltinAgentsForTenant: () => ensureBuiltinAgentsForTenant,
   eventBus: () => eventBus,
   eventBusDefault: () => event_bus_default,
-  expand: () => expand,
   extractFetcherError: () => extractFetcherError,
   extractOutput: () => extractOutput,
   fileDataToString: () => fileDataToString,
@@ -1795,6 +1683,7 @@ __export(index_exports, {
   getEmbeddingsLattice: () => getEmbeddingsLattice,
   getEncryptionKey: () => getEncryptionKey,
   getLoggerLattice: () => getLoggerLattice,
+  getMenuRegistry: () => getMenuRegistry,
   getModelLattice: () => getModelLattice,
   getNextCronTime: () => getNextCronTime,
   getQueueLattice: () => getQueueLattice,
@@ -1824,6 +1713,7 @@ __export(index_exports, {
   parallelLimit: () => parallelLimit,
   parseCronExpression: () => parseCronExpression,
   parseSkillFrontmatter: () => parseSkillFrontmatter,
+  parseYaml: () => parseYaml,
   performStringReplacement: () => performStringReplacement,
   queueLatticeManager: () => queueLatticeManager,
   registerAgentLattice: () => registerAgentLattice,
@@ -1847,9 +1737,12 @@ __export(index_exports, {
   sanitizeToolCallId: () => sanitizeToolCallId,
   scheduleLatticeManager: () => scheduleLatticeManager,
   setBindingRegistry: () => setBindingRegistry,
+  setMenuRegistry: () => setMenuRegistry,
   skillLatticeManager: () => skillLatticeManager,
   sqlDatabaseManager: () => sqlDatabaseManager,
   storeLatticeManager: () => storeLatticeManager,
+  toJsonSchema: () => toJsonSchema,
+  toSafeStateExpr: () => toSafeStateExpr,
   toolLatticeManager: () => toolLatticeManager,
   truncateIfTooLong: () => truncateIfTooLong,
   unregisterTeammateAgent: () => unregisterTeammateAgent,
@@ -1986,9 +1879,11 @@ var ModelLattice = class extends import_chat_models.BaseChatModel {
         maxRetries: config.maxRetries || 2,
         apiKey: config.apiKey || process.env[config.apiKeyEnvName || "SILICONCLOUD_API_KEY"],
         configuration: {
-          baseURL: "https://api.siliconflow.cn/v1"
+          baseURL: config.baseURL || "https://api.siliconflow.cn/v1"
         },
-        streaming: config.streaming
+        streaming: config.streaming,
+        modelKwargs: config.modelKwargs,
+        ...config.extra || {}
       });
     } else if (config.provider === "volcengine") {
       return new import_openai.ChatOpenAI({
@@ -2271,11 +2166,11 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key Lattice键名
    * @param tool 已有的StructuredTool实例
    */
-  registerExistingTool(key, tool51) {
+  registerExistingTool(key, tool52) {
     const config = {
-      name: tool51.name,
-      description: tool51.description,
-      schema: tool51.schema,
+      name: tool52.name,
+      description: tool52.description,
+      schema: tool52.schema,
       // StructuredTool的schema已经是Zod兼容的
       needUserApprove: false
       // MCP工具默认不需要用户批准
@@ -2283,7 +2178,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
     const toolLattice = {
       key,
       config,
-      client: tool51
+      client: tool52
     };
     this.register(key, toolLattice);
   }
@@ -2309,7 +2204,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
 };
 var toolLatticeManager = ToolLatticeManager.getInstance();
 var registerToolLattice = (key, config, executor) => toolLatticeManager.registerLattice(key, config, executor);
-var registerExistingTool = (key, tool51) => toolLatticeManager.registerExistingTool(key, tool51);
+var registerExistingTool = (key, tool52) => toolLatticeManager.registerExistingTool(key, tool52);
 var getToolLattice = (key) => toolLatticeManager.getToolLattice(key);
 var getToolDefinition = (key) => toolLatticeManager.getToolDefinition(key);
 var getToolClient = (key) => toolLatticeManager.getToolClient(key);
@@ -2579,6 +2474,7 @@ var InMemoryAssistantStore = class {
       name: data.name,
       description: data.description,
       graphDefinition: data.graphDefinition,
+      ownerUserId: data.ownerUserId,
       createdAt: now,
       updatedAt: now
     };
@@ -2625,6 +2521,17 @@ var InMemoryAssistantStore = class {
     }
     return tenantAssistants.has(id);
   }
+  /**
+   * Get assistant by owner user ID
+   */
+  async getByOwner(tenantId, userId) {
+    const tenantAssistants = this.assistants.get(tenantId);
+    if (!tenantAssistants) return null;
+    for (const assistant of tenantAssistants.values()) {
+      if (assistant.ownerUserId === userId) return assistant;
+    }
+    return null;
+  }
   /**
    * Clear all assistants for a tenant (useful for testing)
    */
@@ -3857,7 +3764,7 @@ var InMemoryThreadMessageQueueStore = class {
     return this.messages.get(threadId);
   }
   async addMessage(params) {
-    const { threadId, tenantId, assistantId, content, type = "human", priority = 0, command, custom_run_config, id } = params;
+    const { threadId, tenantId, assistantId, workspaceId, projectId, content, type = "human", priority = 0, command, custom_run_config, id } = params;
     const threadMessages = this.getMessagesForThread(threadId);
     const message = {
       id: id || this.generateId(),
@@ -3868,6 +3775,8 @@ var InMemoryThreadMessageQueueStore = class {
       status: "pending",
       tenantId,
       assistantId,
+      workspaceId,
+      projectId,
       priority,
       command,
       custom_run_config
@@ -3876,7 +3785,7 @@ var InMemoryThreadMessageQueueStore = class {
     return message;
   }
   async addMessageAtHead(params) {
-    const { threadId, tenantId, assistantId, content, type = "system", id, command, custom_run_config } = params;
+    const { threadId, tenantId, assistantId, workspaceId, projectId, content, type = "system", id, command, custom_run_config } = params;
     const threadMessages = this.getMessagesForThread(threadId);
     let resolvedTenantId = tenantId || "default";
     let resolvedAssistantId = assistantId || "";
@@ -3894,6 +3803,8 @@ var InMemoryThreadMessageQueueStore = class {
       status: "pending",
       tenantId: resolvedTenantId,
       assistantId: resolvedAssistantId,
+      workspaceId,
+      projectId,
       priority: 100,
       // High priority for head messages (STEER/Command)
       command,
@@ -3925,7 +3836,9 @@ var InMemoryThreadMessageQueueStore = class {
         result.push({
           tenantId: firstMessage.tenantId || "default",
           assistantId: firstMessage.assistantId || "",
-          threadId
+          threadId,
+          workspaceId: firstMessage.workspaceId || void 0,
+          projectId: firstMessage.projectId || void 0
         });
       }
     }
@@ -4048,6 +3961,7 @@ var InMemoryWorkflowTrackingStore = class {
       tenantId: request.tenantId,
       stepType: request.stepType,
       stepName: request.stepName,
+      threadId: request.threadId,
       edgeFrom: request.edgeFrom,
       edgeTo: request.edgeTo,
       edgePurpose: request.edgePurpose,
@@ -4067,7 +3981,12 @@ var InMemoryWorkflowTrackingStore = class {
     const existing = runSteps.find(
       (s) => s.stepType === request.stepType && s.stepName === request.stepName
     );
-    if (existing) return existing;
+    if (existing) {
+      if (!existing.threadId && request.threadId) {
+        existing.threadId = request.threadId;
+      }
+      return existing;
+    }
     return this.createRunStep(request);
   }
   async updateRunStep(runId, stepId, updates) {
@@ -4126,6 +4045,11 @@ var InMemoryChannelInstallationStore = class {
       (inst) => inst.tenantId === tenantId && (!channel || inst.channel === channel)
     );
   }
+  async getAllInstallations(channel) {
+    return Array.from(this.installations.values()).filter(
+      (inst) => !channel || inst.channel === channel
+    );
+  }
   /**
    * Creates a new channel installation for a tenant.
    *
@@ -4402,6 +4326,107 @@ var InMemoryA2AApiKeyStore = class {
   }
 };
 
+// src/store_lattice/InMemoryTaskStore.ts
+var import_uuid = require("uuid");
+var InMemoryTaskStore = class {
+  constructor() {
+    this.tasks = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Create a new task
+   */
+  async create(params) {
+    if (!this.tasks.has(params.tenantId)) {
+      this.tasks.set(params.tenantId, /* @__PURE__ */ new Map());
+    }
+    const now = /* @__PURE__ */ new Date();
+    const task = {
+      id: (0, import_uuid.v4)(),
+      tenantId: params.tenantId,
+      ownerType: params.ownerType,
+      ownerId: params.ownerId,
+      title: params.title,
+      description: params.description,
+      status: params.status || "pending",
+      priority: params.priority || "medium",
+      dueDate: params.dueDate,
+      metadata: params.metadata,
+      parentId: params.parentId,
+      sourceId: params.sourceId,
+      context: params.context,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.tasks.get(params.tenantId).set(task.id, task);
+    return task;
+  }
+  /**
+   * Get task by ID
+   */
+  async getById(tenantId, id) {
+    const tenantTasks = this.tasks.get(tenantId);
+    if (!tenantTasks) return null;
+    return tenantTasks.get(id) || null;
+  }
+  /**
+   * List tasks matching filter criteria
+   */
+  async list(filter2) {
+    const tenantTasks = this.tasks.get(filter2.tenantId);
+    if (!tenantTasks) return [];
+    let results = Array.from(tenantTasks.values());
+    if (filter2.ownerType) results = results.filter((t) => t.ownerType === filter2.ownerType);
+    if (filter2.ownerId) results = results.filter((t) => t.ownerId === filter2.ownerId);
+    if (filter2.status) results = results.filter((t) => t.status === filter2.status);
+    if (filter2.priority) results = results.filter((t) => t.priority === filter2.priority);
+    if (filter2.parentId) results = results.filter((t) => t.parentId === filter2.parentId);
+    if (filter2.sourceId) results = results.filter((t) => t.sourceId === filter2.sourceId);
+    if (filter2.metadata) {
+      for (const [key, value] of Object.entries(filter2.metadata)) {
+        results = results.filter((t) => t.metadata?.[key] === value);
+      }
+    }
+    results.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const offset = filter2.offset || 0;
+    const limit = filter2.limit || 100;
+    return results.slice(offset, offset + limit);
+  }
+  /**
+   * Update an existing task
+   */
+  async update(tenantId, id, updates) {
+    const tenantTasks = this.tasks.get(tenantId);
+    if (!tenantTasks) return null;
+    const existing = tenantTasks.get(id);
+    if (!existing) return null;
+    const updated = {
+      ...existing,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    tenantTasks.set(id, updated);
+    return updated;
+  }
+  /**
+   * Delete a task by ID
+   */
+  async delete(tenantId, id) {
+    const tenantTasks = this.tasks.get(tenantId);
+    if (!tenantTasks) return false;
+    return tenantTasks.delete(id);
+  }
+  /**
+   * Clear all tasks for a tenant (useful for testing)
+   */
+  clear(tenantId) {
+    if (tenantId) {
+      this.tasks.delete(tenantId);
+    } else {
+      this.tasks.clear();
+    }
+  }
+};
+
 // src/store_lattice/StoreLatticeManager.ts
 var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager {
   /**
@@ -4582,6 +4607,12 @@ storeLatticeManager.registerLattice(
   "a2aApiKey",
   defaultA2AApiKeyStore
 );
+var defaultTaskStore = new InMemoryTaskStore();
+storeLatticeManager.registerLattice(
+  "default",
+  "task",
+  defaultTaskStore
+);
 
 // src/tool_lattice/manage_binding/index.ts
 function getInstallationStore() {
@@ -4593,7 +4624,7 @@ var manageBindingSchema = import_zod3.default.object({
   channelInstallationId: import_zod3.default.string().optional().describe("Channel installation ID (auto-detected if omitted and only one exists for this channel)"),
   senderId: import_zod3.default.string().optional().describe("Sender identifier (email address, Lark openId, Slack userId)"),
   agentId: import_zod3.default.string().optional().describe("Target agent ID to route messages to"),
-  threadMode: import_zod3.default.enum(["fixed", "per_conversation"]).optional().default("per_conversation").describe("Thread mode: per_conversation (recommended) or fixed"),
+  threadMode: import_zod3.default.enum(["fixed", "per_conversation"]).optional().default("per_conversation").describe("Thread mode (ignored when channel adapter has its own thread strategy, e.g. Lark)"),
   senderDisplayName: import_zod3.default.string().optional().describe("Human-readable name for the sender")
 });
 registerToolLattice(
@@ -4602,9 +4633,13 @@ registerToolLattice(
     name: "manage_binding",
     description: `Manage sender-to-agent bindings for external channels (email, Lark, Slack).
 
+Bindings are OPTIONAL \u2014 if no binding exists for a sender, messages route to the installation's fallbackAgentId. Only create a binding when a specific sender needs a different agent.
+
+Thread isolation is handled automatically by the channel adapter (e.g. Lark isolates by sender+date). threadMode is only used when the channel adapter does not have its own strategy.
+
 - list_installations: List available channel installations. Filter by channel type (optional). Use this first to discover available channelInstallationIds.
-- create: Bind a sender to an agent. Required: channel, senderId, agentId. Optional: threadMode (default: per_conversation). channelInstallationId is optional \u2014 auto-detected if only one installation exists for this channel.
-- update: Update an existing binding. Required: channel, senderId. Optional: agentId, threadMode (default: per_conversation), senderDisplayName.
+- create: Bind a sender to an agent. Required: channel, senderId, agentId. Optional: threadMode. channelInstallationId auto-detected if only one exists.
+- update: Update an existing binding. Required: channel, senderId. Optional: agentId, threadMode, senderDisplayName.
 - delete: Remove a binding. Required: channel, senderId.
 - list: List all bindings. Optional: channel, agentId, channelInstallationId.
 
@@ -4612,7 +4647,7 @@ A sender can only be bound to ONE agent per channel+installation combination.`,
     schema: manageBindingSchema
   },
   async (input, config) => {
-    const registry2 = getBindingRegistry();
+    const registry3 = getBindingRegistry();
     const runConfig = config?.configurable?.runConfig || {};
     const tenantId = runConfig.tenantId || "default";
     switch (input.action) {
@@ -4635,7 +4670,7 @@ A sender can only be bound to ONE agent per channel+installation combination.`,
             error: `No channelInstallationId provided and unable to auto-detect. Use action=list_installations to find available installations for channel "${input.channel}".`
           });
         }
-        const binding = await registry2.create({
+        const binding = await registry3.create({
           channel: input.channel,
           channelInstallationId: installId,
           tenantId,
@@ -4657,7 +4692,7 @@ A sender can only be bound to ONE agent per channel+installation combination.`,
             error: `No channelInstallationId provided and unable to auto-detect. Use action=list_installations first.`
           });
         }
-        const existing = await registry2.resolve({
+        const existing = await registry3.resolve({
           channel: input.channel,
           senderId: input.senderId,
           channelInstallationId: installId,
@@ -4666,7 +4701,7 @@ A sender can only be bound to ONE agent per channel+installation combination.`,
         if (!existing) {
           return JSON.stringify({ success: false, error: "Binding not found" });
         }
-        const updated = await registry2.update(existing.id, {
+        const updated = await registry3.update(existing.id, {
           agentId: input.agentId,
           threadMode: input.threadMode,
           senderDisplayName: input.senderDisplayName
@@ -4684,7 +4719,7 @@ A sender can only be bound to ONE agent per channel+installation combination.`,
             error: `No channelInstallationId provided and unable to auto-detect.`
           });
         }
-        const existing = await registry2.resolve({
+        const existing = await registry3.resolve({
           channel: input.channel,
           senderId: input.senderId,
           channelInstallationId: installId,
@@ -4693,11 +4728,11 @@ A sender can only be bound to ONE agent per channel+installation combination.`,
         if (!existing) {
           return JSON.stringify({ success: false, error: "Binding not found" });
         }
-        await registry2.delete(existing.id);
+        await registry3.delete(existing.id);
         return JSON.stringify({ success: true, message: "Binding deleted" });
       }
       case "list": {
-        const bindings = await registry2.list({
+        const bindings = await registry3.list({
           channel: input.channel,
           agentId: input.agentId,
           tenantId,
@@ -8672,7 +8707,7 @@ var createBrowserGetInfoTool = ({ vmIsolation }) => {
 };
 
 // src/index.ts
-var import_messages7 = require("@langchain/core/messages");
+var import_messages6 = require("@langchain/core/messages");
 
 // src/agent_lattice/types.ts
 var import_protocols = require("@axiom-lattice/protocols");
@@ -8691,7 +8726,7 @@ var createReactAgentSchema = (schema) => {
 };
 
 // src/agent_lattice/builders/ReActAgentGraphBuilder.ts
-var import_langchain56 = require("langchain");
+var import_langchain57 = require("langchain");
 
 // src/middlewares/codeEvalMiddleware.ts
 var import_langchain37 = require("langchain");
@@ -9162,353 +9197,233 @@ metadata:
 Then iterate based on what the user says.
 `,
   "create-workflow": `---
- name: create-workflow
- description: Design and build multi-step AI workflows using the concise Workflow DSL. Use whenever users want to orchestrate agents in a pipeline, build process automation with branching/parallel logic, design approval flows with human-in-the-loop, or process data in stages.
- license: MIT
- metadata:
-   category: meta
-   version: "3.0"
- ---
-
- # Workflow Designer
-
- This skill guides you through designing and creating workflow agents. A workflow is a LangGraph state machine compiled from a concise JSON DSL \u2014 steps define what happens, order defines the flow, and the engine handles the rest.
-
- Every step runs on the workflow's built-in general-purpose agent \u2014 no external agent registration needed.
-
- ## Core Principle: id is everything
+name: create-workflow
+description: Design and build multi-step AI workflows using the YAML linear DSL. Use whenever users want to orchestrate agents in a pipeline with routing, parallelism, human-in-the-loop, or batch processing.
+license: MIT
+metadata:
+  category: meta
+  version: "5.0"
+---
 
- A step's \`id\` serves triple duty:
- 1. **Node identifier** in the graph
- 2. **State key** \u2014 output is stored at \`state.<id>\`
- 3. **Template reference** \u2014 downstream steps use \`{{id}}\` to read it
+# YAML Workflow Designer
 
- If you omit \`id\`, a unique identifier is auto-generated (but you won't be able to reference the output).
+Use the linear YAML DSL \u2014 steps execute top-to-bottom. Use \`parallel:\` for concurrency. No dependency graph thinking required.
 
- ## Step Types
+## Core Model: Linear + Parallel
 
- ### agent \u2014 a step for the workflow's built-in agent
+- **Linear** \u2014 steps execute in written order. No \`needs\`, no dependency declarations.
+- **parallel** \u2014 a block where all children run concurrently. Block completes when all children finish.
+- **if** \u2014 JS expression. Step runs only when truthy. Omit to always run.
+- **prompt** \u2014 agent instruction with **{{label}}** refs. **{{input}}** is the user message.
+- **output** \u2014 shorthand schema using **{ field: type }** notation.
+- **ask** \u2014 boolean. Injects user clarification middleware for human interaction.
 
- \`\`\`json
- { "id": "classify", "name": "Classify Intent", "prompt": "Classify the intent of: {{input}}", "schema": { "type": "object", "properties": { "intent": { "type": "string" } } } }
- \`\`\`
+## When to Use parallel vs map
 
- | Field | Required | Description |
- |-------|----------|-------------|
- | id | no | State key for referencing output. Auto-generated if omitted, but required if downstream steps reference this step via \`{{id}}\` |
- | name | no | Human-readable label for this step |
- | prompt | yes | Task description with {{id}} refs |
-  | schema | **yes** | Standard JSON Schema ONLY: \`{ "type": "object", "properties": { "field": { "type": "string" } } }\`. \`true\` is REJECTED \u2014 must be a concrete schema. Legacy shorthand \`{ "field": "string" }\` is REJECTED.
+This is the most important design decision. **They are fundamentally different:**
 
- **Schema Rules (MUST follow \u2014 shorthand is rejected):**
- - Always wrap in \`{ "type": "object", "properties": { ... } }\`
- - Each property must be \`{ "type": "string"|"number"|"boolean"|"array"|"object" }\`
- - Arrays need \`"items"\`: \`{ "type": "array", "items": { "type": "string" } }\`
- - \u274C \`{ "field": "string" }\` \u2014 REJECTED (no "type"/"properties" wrapper)
- - \u274C \`{ "schema": { "intent": "string" } }\` \u2014 REJECTED (legacy shorthand)
+| | parallel | map |
+|---|---|---|
+| **Concern** | **Business parallelism** \u2014 reduce business processing time | **Data parallelism** \u2014 handle data volume |
+| **Tasks** | Each child does a **different** task | All items do the **same** task |
+| **Count** | Few (2-5), each hand-written | Dynamic, driven by source data |
+| **Input** | Independent prompts per child | Single \`each.prompt\` template, \`{{item}}\` for current element |
+| **if** | Per-child conditional | Whole block conditional |
+| **Example** | Legal review + Market analysis in parallel | Audit each line item in an invoice |
 
- The agent's response is stored at \`state.<id>\` (or an auto-generated key if \`id\` is omitted).
+**Rule of thumb:** If you're writing the same prompt twice, you probably want \`map\`. If each branch has a unique purpose, use \`parallel\`.
 
- ### condition \u2014 branch on state
+## Step Format
 
-**Binary (then/else):**
+### Agent Step
 
-\`\`\`json
-{ "type": "condition", "if": "intent",
-  "then": { "id": "support", "name": "Handle Support", "prompt": "Handle support: {{input}}" },
-  "else": { "id": "sales", "name": "Handle Sales", "prompt": "Handle sales: {{input}}" }
-}
+\`\`\`yaml
+- label:
+    prompt: instruction with {{refs}}
+    if: "expression"
+    output: { field: type }
+    ask: true
 \`\`\`
 
-| Field | Required | Description |
-|-------|----------|-------------|
-| if | yes | State field name (e.g. "approved") or expression (e.g. "score >= 60"). **CRITICAL: \`{{}}\` is FORBIDDEN in \`if\`** \u2014 it is a plain JavaScript expression, not a template. \u274C \`"if": "{{intent}}"\` is WRONG. \u2705 \`"if": "intent"\` is correct. |
-| then | yes | Step(s) to run when condition is truthy |
-| else | no | Step(s) to run when condition is falsy |
-
-The engine evaluates \`if\` as a JavaScript expression prefixed with \`state.\`. Both \`then\` and \`else\` can be a single step or an array of steps. After both branches, execution rejoins at the next step after the condition.
-
-**Switch (branches):**
+### Parallel Block
 
-When branching on a discrete set of known values, use \`branches\` for cleaner multi-way routing:
-
-\`\`\`json
-{ "type": "condition", "if": "intent",
-  "branches": {
-    "support": { "id": "support", "prompt": "Handle support: {{input}}" },
-    "sales":   { "id": "sales",   "prompt": "Handle sales: {{input}}" },
-    "billing": { "id": "billing", "prompt": "Handle billing: {{input}}" },
-    "default": { "id": "fallback", "prompt": "Send to human: {{input}}" }
-  }
-}
+\`\`\`yaml
+- parallel:
+    - child1:
+        prompt: ...
+        if: "expression"
+    - child2:
+        prompt: ...
 \`\`\`
 
-| Field | Required | Description |
-|-------|----------|-------------|
-| if | yes | State field whose STRING VALUE is matched against branch keys. **Same rule \u2014 \`{{}}\` is FORBIDDEN here.** |
-| branches | yes | Map of value \u2192 step(s). \`"default"\` key is a catch-all for unmatched values |
-| then/else | no | Not used when branches is present |
-
-Unlike \`then\`/\`else\` (truthy/falsy ternary), \`branches\` does exact string match against the state field value. Always include a \`"default"\` branch.
+Parallel children are agent steps only. No nested parallel or map inside parallel.
 
- ### human \u2014 pause for human input
+### Map Step
 
-The human step invokes an agent with ask_user_to_clarify middleware. The agent is a **facilitator** \u2014 it presents information to the user and collects their response. The agent does NOT make decisions itself; it asks the user. The agent's structured output is stored under the step's \`id\`.
-
-\`\`\`json
-{ "id": "review", "type": "human",
-  "title": "Approval",
-  "prompt": "Present the following draft to the user for approval. Ask whether to approve or reject, and collect any comments.\\n\\nDraft:\\n{{draft}}",
-  "schema": { "type": "object", "properties": { "approved": { "type": "boolean" }, "comments": { "type": "string" } } }
-}
+\`\`\`yaml
+- label:
+    map:
+      source: "extract.items"
+      if: "extract.items.length > 0"
+      each:
+        prompt: Process {{item}}
+        output: { result: string }
+      batch: 50
+      concurrency: 5
 \`\`\`
 
-Access results with dot notation: \`{{review.approved}}\`, \`{{review.comments}}\`. Use \`schema\` to constrain the agent's output.
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| id | no | State key for the agent's structured output |
-| type | yes | Must be \`"human"\` |
-| prompt | yes | Tell the agent what to present to the user and what to ask. The agent is a facilitator \u2014 write instructions like "Present X to the user and ask Y", NOT "You are a reviewer. Review X..." |
-| title | no | Display label for the human step |
-| schema | no | JSON Schema constraining the agent's structured output format |
-
-### map \u2014 iterate over an array
+## Schema Shorthand
 
- \`\`\`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) |
+Write **{ field: type }** instead of JSON Schema:
 
- ### parallel \u2014 fixed fan-out
+| Shorthand | Meaning |
+|-----------|---------|
+| **field: string** | string property |
+| **field: number** | number property |
+| **field: boolean** | boolean property |
+| **field: string[]** | array of strings |
+| **field: number[]** | array of numbers |
+| **field: [{ a: string, b: number }]** | array of objects |
+| **field: { sub: string }** | nested object |
 
- \`\`\`json
- { "type": "parallel", "steps": [
-   { "id": "legal", "prompt": "Legal review: {{input}}" },
-   { "id": "finance", "prompt": "Finance: {{input}}" }
- ]}
- \`\`\`
+Use **block style** (each field on its own line). Flow style \`{ field: "type" }\` with quoted values also works.
 
- All steps run simultaneously. After all complete, execution continues to the next step.
+## Template Syntax
 
- ### end \u2014 terminate the workflow
+| Syntax | Resolves to |
+|--------|------------|
+| \`{{input}}\` | Initial user message |
+| \`{{label}}\` | Full output of step |
+| \`{{label.field}}\` | Nested field access |
+| \`{{item}}\` | Current element in map iteration |
 
- \`\`\`json
- { "type": "end" }
- \`\`\`
+## Design Patterns
 
- Always include at the end of the steps array. \`status\` defaults to "success".
+### Linear Pipeline
 
- **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\` |
+\`\`\`yaml
+steps:
+  - extract:
+      prompt: Extract data from {{input}}
+  - transform:
+      prompt: Transform {{extract}}
+  - final:
+      prompt: Combine raw {{extract}} with transformed {{transform}}
+\`\`\`
 
- ## \u26A0\uFE0F CRITICAL: \`{{}}\` is ONLY for \`prompt\` fields
+### Classify -> Route via Parallel + if
 
- The template markers \`{{id}}\`, \`{{input}}\`, and \`{{item}}\` work **exclusively inside \`prompt\` strings**. All other string fields \u2014 including \`if\`, \`source\`, \`id\`, \`name\`, \`title\`, \`status\` \u2014 must use plain values without any \`{{}}\` wrapping.
+\`\`\`yaml
+steps:
+  - classify:
+      prompt: Classify intent from {{input}}
+      output:
+        intent: string
+        urgency: number
+  - parallel:
+      - billing:
+          if: "classify.intent == 'billing'"
+          prompt: Handle billing: {{input}}
+          ask: true
+      - technical:
+          if: "classify.intent == 'technical'"
+          prompt: Handle technical: {{input}}
+  - escalate:
+      if: "classify.urgency >= 8"
+      prompt: Urgent handling
+      ask: true
+\`\`\`
 
- **Common mistake the AI makes:**
- \`\`\`json
- // \u274C WRONG \u2014 {{}} does not belong in if:
- { "type": "condition", "if": "{{intent}}", "then": {...}, "else": {...} }
+### Parallel Processing
 
- // \u2705 CORRECT \u2014 if is a plain expression:
- { "type": "condition", "if": "intent", "then": {...}, "else": {...} }
- \`\`\`
+\`\`\`yaml
+steps:
+  - gather:
+      prompt: Gather data from {{input}}
+  - parallel:
+      - legal:
+          prompt: Legal analysis of {{gather}}
+          output:
+            risk: string
+            compliant: boolean
+      - market:
+          prompt: Market analysis of {{gather}}
+          output:
+            opportunity: string
+            score: number
+  - report:
+      prompt: |
+        Synthesize findings:
+        Legal: {{legal}}
+        Market: {{market}}
+\`\`\`
 
- ## What You NEVER Write
+### Approval Flow with Human
 
- The engine auto-generates these \u2014 do NOT include them in your DSL:
+\`\`\`yaml
+steps:
+  - draft:
+      prompt: Draft response to {{input}}
+  - review:
+      prompt: Present {{draft}} to user for approval
+      output:
+        approved: boolean
+        comments: string
+      ask: true
+  - publish:
+      if: "review.approved"
+      prompt: Publish {{draft}}
+  - revise:
+      if: "!review.approved"
+      prompt: Revise based on {{review.comments}}
+\`\`\`
 
- - **state.fields** \u2014 auto-declared from every \`id\`
- - **edges** \u2014 auto-generated from step order (linear) and types (fan-out for parallel, conditional for condition)
- - **output.key** \u2014 always equals \`id\`
- - **version** \u2014 always "1.0" internally
- - **node IDs** \u2014 prefixed internally to avoid conflicts with state channel names
-  - **human step type** \u2014 the human step has ask_user_to_clarify built-in. Use \`{ "type": "human", ... }\` in the DSL for user interaction. Do NOT manually add ask_user_to_clarify middleware to regular agent steps \u2014 use the dedicated \`human\` step instead.
+### Map (Iteration)
 
- ## Design Patterns
+\`\`\`yaml
+steps:
+  - extract:
+      prompt: Extract items from {{input}}
+      output:
+        items:
+          - name: string
+  - map_items:
+      map:
+        source: "extract.items"
+        each:
+          prompt: Audit {{item.name}}
+          output:
+            result: string
+  - summary:
+      prompt: Summarize findings: {{map_items}}
+\`\`\`
 
- ### Pattern 1: Linear Pipeline
+## Keep Business Logic in Agents
 
- \`\`\`json
- {
-   "name": "knowledge-qa",
-   "steps": [
-     { "id": "research", "name": "Research Topic", "prompt": "Research: {{input}}", "schema": { "type": "object", "properties": { "findings": { "type": "string" } } } },
-     { "id": "answer", "name": "Write Answer", "prompt": "Write answer based on: {{research}}", "schema": { "type": "object", "properties": { "answer": { "type": "string" } } } },
-     { "type": "end" }
-   ]
- }
- \`\`\`
+The DSL is for orchestration (what runs when). Business logic (validation, branching, error handling, user interaction) belongs inside agent prompts, not as workflow if conditions. An agent can validate, branch, and ask questions \u2014 all in one step.
 
- ### Pattern 2: Classify then Route
+**Rule:** if you have more if conditions than workflow phases, move logic into richer agent prompts.
 
- \`\`\`json
- {
-   "name": "customer-router",
-   "steps": [
-     { "id": "intent", "name": "Classify Intent", "prompt": "Classify: {{input}}", "schema": { "type": "object", "properties": { "intent": { "type": "string" } } } },
-     { "type": "condition", "if": "intent",
-       "then": { "id": "support", "name": "Handle Support", "prompt": "Handle support: {{input}}", "schema": { "type": "object", "properties": { "response": { "type": "string" } } } },
-       "else": { "id": "sales", "name": "Handle Sales", "prompt": "Handle sales: {{input}}", "schema": { "type": "object", "properties": { "response": { "type": "string" } } } }
-     },
-     { "type": "end" }
-   ]
-  }
-  \`\`\`
+## What You NEVER Write
 
-  ### Pattern 2b: Classify then Switch
+- **needs** \u2014 not supported. Steps execute linearly. Use parallel for concurrency.
+- **edges** \u2014 auto-generated from step order and parallel structure
+- **nested parallel** \u2014 parallel children are flat agent steps only
+- **map inside parallel** \u2014 map is a top-level step only
+- **json schema** \u2014 use **{ field: type }** block style
+- do not use {{}} markers in if expressions
+- **workflow-level business logic** \u2014 decisions belong inside agent prompts
 
-  For routing to 3+ categories, use \`branches\` instead of nested \`then\`/\`else\`:
+## Checklist
 
-  \`\`\`json
-  {
-    "name": "ticket-router",
-    "steps": [
-      { "id": "intent", "name": "Classify", "prompt": "Classify: {{input}}", "schema": { "type": "object", "properties": { "category": { "type": "string" } } } },
-      { "type": "condition", "if": "intent.category",
-        "branches": {
-          "support": { "id": "support", "prompt": "Handle support: {{input}}" },
-          "sales":   { "id": "sales",   "prompt": "Handle sales: {{input}}" },
-          "billing": { "id": "billing", "prompt": "Handle billing: {{input}}" },
-          "default": { "id": "fallback", "prompt": "Send to human: {{input}}" }
-        }
-      },
-      { "type": "end" }
-    ]
-  }
-  \`\`\`
-
-  ### Pattern 3: Extract \u2192 Review \u2192 Approve
-
- \`\`\`json
- {
-   "name": "approval-flow",
-   "steps": [
-     { "id": "draft", "name": "Draft Response", "prompt": "Draft a response to: {{input}}", "schema": { "type": "object", "properties": { "content": { "type": "string" } } } },
-       { "id": "review", "type": "human",
-         "title": "Approval",
-         "prompt": "Present the draft below to the user for approval. Ask whether to approve or reject with comments.\\n\\nDraft:\\n{{draft}}",
-         "schema": { "type": "object", "properties": { "approved": { "type": "boolean" }, "comments": { "type": "string" } } } },
-      { "type": "condition", "if": "review.approved",
-       "then": { "id": "published", "name": "Publish", "prompt": "Publish: {{draft}}", "schema": { "type": "object", "properties": { "status": { "type": "string" } } } },
-       "else": { "id": "revised", "name": "Revise", "prompt": "Revise based on: {{review.comments}}", "schema": { "type": "object", "properties": { "content": { "type": "string" } } } }
-     },
-     { "type": "end" }
-   ]
- }
- \`\`\`
-
- ### Pattern 4: Parallel Research
-
- \`\`\`json
- {
-   "name": "due-diligence",
-   "steps": [
-     { "id": "info", "name": "Gather Info", "prompt": "Gather info: {{input}}", "schema": { "type": "object", "properties": { "rawData": { "type": "string" } } } },
-     { "type": "parallel", "steps": [
-       { "id": "legal",   "name": "Legal Review",   "prompt": "Legal review: {{info}}", "schema": { "type": "object", "properties": { "risks": { "type": "array", "items": { "type": "string" } } } } },
-       { "id": "finance", "name": "Finance Review", "prompt": "Finance review: {{info}}", "schema": { "type": "object", "properties": { "score": { "type": "number" } } } },
-       { "id": "market",  "name": "Market Analysis", "prompt": "Market analysis: {{info}}", "schema": { "type": "object", "properties": { "trend": { "type": "string" } } } }
-     ]},
-     { "id": "synthesis", "name": "Synthesize", "prompt": "Synthesize: legal={{legal}} finance={{finance}} market={{market}}", "schema": { "type": "object", "properties": { "report": { "type": "string" } } } },
-     { "type": "end" }
-   ]
- }
- \`\`\`
-
- ### Pattern 5: Batch Map + Reduce
-
- \`\`\`json
- {
-   "name": "sentiment-analysis",
-   "steps": [
-     { "id": "posts", "name": "Scrape Posts", "prompt": "Scrape posts about: {{input}}", "schema": { "type": "object", "properties": { "posts": { "type": "array", "items": { "type": "object", "properties": { "text": { "type": "string" } } } } } } },
-     { "id": "sentiments", "type": "map", "source": "posts",
-       "each": { "prompt": "Analyze sentiment: {{item}}", "schema": { "type": "object", "properties": { "sentiment": { "type": "string" } } } },
-       "reduce": { "prompt": "Summarize: {{sentiments}}", "schema": { "type": "object", "properties": { "summary": { "type": "string" } } } }
-     },
-     { "id": "report", "name": "Generate Report", "prompt": "Generate report from: {{sentiments}}", "schema": { "type": "object", "properties": { "report": { "type": "string" } } } },
-     { "type": "end" }
-   ]
- }
- \`\`\`
-
- ## Step 1: Understand the Process
-
- Ask the user:
- - What are the steps in order?
- - Are there branches (if condition then A else B)?
- - Can any steps run in parallel?
- - Is human approval/review needed?
- - What data flows between steps?
-
- ## Step 2: Prepare Dependencies
-
- 1. Call \`list_tools\` to see available tools for the workflow agent.
-
- ## Step 3: Write the DSL
-
- Use \`create_workflow\` with \`skillLoaded: true\`. Never write \`state.fields\`, \`edges\`, \`version\`, or \`output.key\` \u2014 they are auto-generated.
-
- **Checklist before calling:**
- - Every step that produces data referenced downstream has an \`id\`
- - Every agent/map-each step has a valid \`schema\` in standard JSON Schema format (with \`"type": "object"\` and \`"properties"\`)
-  - Schema uses \`{ "type": "object", "properties": { ... } }\` \u2014 \`true\` and legacy \`{ "field": "string" }\` are REJECTED
- - Downstream steps reference upstream data with \`{{id}}\`
- - **Condition \`if\` fields do NOT use \`{{}}\`** \u2014 they are plain expressions like \`"intent"\` or \`"score >= 60"\`
- - Condition steps have \`then\`/\`else\` (binary) or \`branches\` (switch)
-  - Human steps have \`schema\` constraining the agent's structured output
-  - Map steps have \`source\` pointing to an existing step id
-  - Parallel steps have sibling steps with unique \`id\`s
-  - Workflow ends with \`{ "type": "end" }\`
-  - Use \`human\` step type for user interaction (clarify middleware is built-in)
-
- ## Step 4: Test
-
- After creating, optionally call \`validate_workflow(id)\` to check the workflow compiles correctly. Then test with \`invoke_agent\`.
-
- ## Debugging Tips
-
- - If output is missing: check the producing step has an \`id\`
-  - The human step invokes an agent that can use ask_user_to_clarify. The agent's structured output is stored under the step's \`id\`. Access nested results with dot notation: \`{{review.approved}}\`, \`{{review.comments}}\`
- - Map results are an array; use \`reduce\` to aggregate into a summary
- - Condition branching uses truthiness: empty string, 0, null, false \u2192 else path
- - \`{{input}}\` contains the user's initial message; it's always available
- - Parallel + condition: a parallel group cannot be the first step inside a condition's then/else (LangGraph limitation). Add a preceding agent step.
- `
+- Every step has a unique label
+- Steps execute top-to-bottom \u2014 no dependency thinking needed
+- \`{{label}}\` can reference ANY upstream step output
+- if uses plain JS, no {{}}
+- Schema uses block style shorthand
+- parallel children are flat agent steps
+- Business logic stays inside agent prompts
+- ask: true for human interaction`
 };
 function getBuiltInSkillMeta(name) {
   const content = BUILTIN_SKILLS[name];
@@ -12419,7 +12334,7 @@ ${currentSystemPrompt}` : dateContext;
 // src/deep_agent_new/middleware/scheduler.ts
 var import_langchain55 = require("langchain");
 var import_zod50 = require("zod");
-var import_uuid2 = require("uuid");
+var import_uuid3 = require("uuid");
 var import_protocols8 = require("@axiom-lattice/protocols");
 
 // src/schedule_lattice/ScheduleLatticeManager.ts
@@ -13974,7 +13889,7 @@ var buffer = new InMemoryChunkBuffer({
 registerChunkBuffer("default", buffer);
 
 // src/services/Agent.ts
-var import_uuid = require("uuid");
+var import_uuid2 = require("uuid");
 var ThreadStatus2 = /* @__PURE__ */ ((ThreadStatus3) => {
   ThreadStatus3["IDLE"] = "idle";
   ThreadStatus3["BUSY"] = "busy";
@@ -14020,7 +13935,7 @@ var Agent = class {
               runConfig
             },
             configurable: {
-              run_id: (0, import_uuid.v4)(),
+              run_id: (0, import_uuid2.v4)(),
               ...runConfig,
               runConfig
             },
@@ -14054,7 +13969,6 @@ var Agent = class {
       const runnable_agent = await getAgentClientAsync(this.tenant_id, this.assistant_id);
       const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(this.tenant_id, this.assistant_id);
       const { messages, ...rest } = input;
-      const lifecycleManager = this;
       const runConfig = {
         thread_id: this.thread_id,
         "x-tenant-id": this.tenant_id,
@@ -14094,7 +14008,7 @@ var Agent = class {
               runConfig
             },
             configurable: {
-              run_id: (0, import_uuid.v4)(),
+              run_id: (0, import_uuid2.v4)(),
               ...runConfig,
               runConfig
               // Inject runConfig for tools to access
@@ -14106,43 +14020,13 @@ var Agent = class {
           }
         );
         try {
-          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 (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 (chunk2[0] === "messages") {
-              const messages2 = chunk2[1];
-              data = messages2?.[0]?.toDict();
-            }
-            if (chunk2?.[1]?.__interrupt__) {
-              const interruptData = chunk2?.[1]?.__interrupt__[0];
-              data = {
-                type: "interrupt",
-                id: interruptData.id,
-                data: { content: interruptData.value }
-              };
-            }
-            if (data) {
-              lifecycleManager.addChunk(data);
-            }
-          }
+          await this.consumeAgentStream(agentStream, signal);
         } catch (error) {
           console.error("Stream error:", error);
-          await lifecycleManager.chunkBuffer.abortThread(lifecycleManager.thread_id);
           throw error;
         }
       } catch (error) {
-        await this.chunkBuffer.abortThread(lifecycleManager.thread_id);
+        await this.chunkBuffer.abortThread(this.thread_id);
         throw error;
       }
     };
@@ -14423,8 +14307,8 @@ var Agent = class {
     this.assistant_id = assistant_id;
     this.thread_id = thread_id;
     this.tenant_id = tenant_id;
-    this.workspace_id = workspace_id;
-    this.project_id = project_id;
+    this.workspace_id = workspace_id || "default";
+    this.project_id = project_id || "default";
     this.custom_run_config = custom_run_config;
   }
   getHumanPendingContent(message) {
@@ -14510,7 +14394,7 @@ var Agent = class {
     };
   }
   async invoke(queueMessage, signal) {
-    const messageId = (0, import_uuid.v4)();
+    const messageId = (0, import_uuid2.v4)();
     const input = {
       ...queueMessage.input,
       messages: [new import_langchain54.HumanMessage({ id: messageId, content: queueMessage.input.message })]
@@ -14518,10 +14402,132 @@ var Agent = class {
     const inputMessage = { ...queueMessage, input };
     return this.agentExecutor(inputMessage, signal);
   }
+  /**
+   * Like {@link invoke} but returns the full LangGraph state (all annotations)
+   * instead of only messages. Messages are serialized to dicts; other state
+   * fields are returned as-is.
+   *
+   * @remarks
+   * Only call this when you need the full state. Existing callers (gateway,
+   * workflows) should keep using {@link invoke} which returns only messages
+   * to avoid exposing internal annotation data.
+   */
+  async invokeWithState(queueMessage, signal) {
+    const messageId = (0, import_uuid2.v4)();
+    const input = {
+      ...queueMessage.input,
+      messages: [new import_langchain54.HumanMessage({ id: messageId, content: queueMessage.input.message })]
+    };
+    const inputMessage = { ...queueMessage, input };
+    const { runnable_agent, runConfig } = await this.getLatticeClientAndRuntimeConfig(inputMessage.custom_run_config);
+    const { messages, ...rest } = inputMessage.input;
+    if (signal?.aborted) {
+      throw new Error("Agent execution was aborted");
+    }
+    let result;
+    result = await runnable_agent.invoke(
+      inputMessage.command ? new import_langgraph6.Command(inputMessage.command) : { ...rest, messages, "x-tenant-id": this.tenant_id },
+      {
+        context: { runConfig },
+        configurable: {
+          run_id: (0, import_uuid2.v4)(),
+          ...runConfig,
+          runConfig
+        },
+        recursionLimit: 200,
+        signal
+      }
+    );
+    if (signal?.aborted) {
+      throw new Error("Agent execution was aborted");
+    }
+    const { messages: _rawMessages, ...restState } = result;
+    const serializedMessages = result.messages.map((message) => {
+      const { type, data } = message.toDict();
+      return { ...data, role: type };
+    });
+    return { messages: serializedMessages, ...restState };
+  }
   async getPendingMessages() {
     const store = this.getQueueStore();
     return await store.getPendingMessages(this.thread_id);
   }
+  async consumeAgentStream(agentStream, signal) {
+    for await (const chunk2 of agentStream) {
+      if (signal?.aborted) {
+        await this.chunkBuffer.abortThread(this.thread_id);
+        throw new Error("Agent execution was aborted");
+      }
+      let data;
+      if (chunk2[0] === "updates") {
+        const update = chunk2[1];
+        const values = Object.values(update);
+        const messages = values[0]?.messages;
+        if (messages?.[0]?.tool_call_id) {
+          data = messages[0].toDict();
+        }
+      } else if (chunk2[0] === "messages") {
+        const messages = chunk2[1];
+        data = messages?.[0]?.toDict();
+      }
+      if (chunk2?.[1]?.__interrupt__) {
+        const interruptData = chunk2?.[1]?.__interrupt__[0];
+        data = {
+          type: "interrupt",
+          id: interruptData.id,
+          data: { content: interruptData.value }
+        };
+      }
+      if (data) {
+        this.addChunk(data);
+      }
+    }
+  }
+  /**
+   * Resume LangGraph execution from the last checkpoint.
+   *
+   * Streams with `null` input — this tells LangGraph to continue from
+   * wherever it left off using the checkpointed state for this thread.
+   * All output chunks are buffered via {@link addChunk}.
+   */
+  async resumeGraphFromCheckpoint(signal) {
+    const runnable_agent = await getAgentClientAsync(this.tenant_id, this.assistant_id);
+    const agentLattice = agentLatticeManager.getAgentLatticeWithTenant(this.tenant_id, this.assistant_id);
+    if (!runnable_agent) {
+      throw new Error(`Agent ${this.assistant_id} not found`);
+    }
+    const runConfig = {
+      thread_id: this.thread_id,
+      "x-tenant-id": this.tenant_id,
+      "x-workspace-id": this.workspace_id,
+      "x-project-id": this.project_id,
+      "x-thread-id": this.thread_id,
+      "x-assistant-id": this.assistant_id,
+      ...agentLattice?.config?.runConfig || {},
+      tenantId: this.tenant_id,
+      workspaceId: this.workspace_id,
+      projectId: this.project_id,
+      ...this.custom_run_config || {},
+      assistant_id: this.assistant_id
+    };
+    const agentStream = await runnable_agent.stream(
+      null,
+      {
+        context: {
+          runConfig
+        },
+        configurable: {
+          ...runConfig,
+          runConfig
+        },
+        streamMode: ["updates", "messages"],
+        subgraphs: false,
+        recursionLimit: 200,
+        signal
+      }
+    );
+    await this.consumeAgentStream(agentStream, signal);
+  }
   getQueueStore() {
     if (!this.queueStore) {
       try {
@@ -14600,7 +14606,7 @@ var Agent = class {
    */
   async addMessage(queueMessage, mode) {
     const useMode = mode ?? this.queueMode.mode;
-    const messageId = queueMessage.input.id || (0, import_uuid.v4)();
+    const messageId = queueMessage.input.id || (0, import_uuid2.v4)();
     const messages = queueMessage.input.messages;
     const legacyMessage = queueMessage.input.message;
     if (!messages && !legacyMessage) {
@@ -14651,6 +14657,8 @@ var Agent = class {
         threadId: this.thread_id,
         tenantId: this.tenant_id,
         assistantId: this.assistant_id,
+        workspaceId: this.workspace_id,
+        projectId: this.project_id,
         content,
         type: pendingType,
         command: queueMessage.command,
@@ -14667,6 +14675,8 @@ var Agent = class {
         threadId: this.thread_id,
         tenantId: this.tenant_id,
         assistantId: this.assistant_id,
+        workspaceId: this.workspace_id,
+        projectId: this.project_id,
         content,
         type: pendingType,
         command: queueMessage.command,
@@ -14740,6 +14750,8 @@ var Agent = class {
       threadId: thread.threadId,
       tenantId: thread.tenantId,
       assistantId: thread.assistantId,
+      workspaceId: this.workspace_id,
+      projectId: this.project_id,
       content: reminderContent,
       type: "system"
     });
@@ -14811,9 +14823,14 @@ var Agent = class {
   /**
    * Resume processing after a server restart.
    *
-   * Resets any stuck "processing" messages back to "pending" and restarts the
-   * queue processor. Skips threads that are in `INTERRUPTED` state (the
-   * interruption was intentional).
+   * If the graph was mid-execution (BUSY) it resumes from the LangGraph
+   * checkpoint without re-injecting the message — the message has already
+   * been consumed and is in the graph state.  Processing messages are removed
+   * rather than replayed.
+   *
+   * Skips threads that are in `INTERRUPTED` state (the interruption was
+   * intentional).  IDLE threads simply clean up and restart the queue
+   * processor for any remaining pending messages.
    *
    * Called during gateway startup to recover threads that were mid-execution
    * when the server went down.
@@ -14831,9 +14848,32 @@ var Agent = class {
       return;
     }
     const store = this.getQueueStore();
-    const resetCount = await store.resetProcessingToPending(this.thread_id);
-    if (resetCount > 0) {
-      console.log(`[Agent] Reset ${resetCount} processing messages to pending for thread ${this.thread_id}`);
+    if (runStatus === "busy" /* BUSY */) {
+      this.abortController = new AbortController();
+      try {
+        await this.resumeGraphFromCheckpoint(this.abortController.signal);
+        const processingMessages = await store.getProcessingMessages(this.thread_id);
+        for (const msg of processingMessages) {
+          await store.removeMessage(msg.id);
+        }
+        if (processingMessages.length > 0) {
+          console.log(`[Agent] Removed ${processingMessages.length} processing messages for thread ${this.thread_id}`);
+        }
+      } catch (error) {
+        console.error(`[Agent] Failed to resume graph for thread ${this.thread_id}:`, error);
+        await this.chunkBuffer.abortThread(this.thread_id);
+        throw error;
+      } finally {
+        this.abortController = null;
+      }
+    } else {
+      const processingMessages = await store.getProcessingMessages(this.thread_id);
+      for (const msg of processingMessages) {
+        await store.removeMessage(msg.id);
+      }
+      if (processingMessages.length > 0) {
+        console.log(`[Agent] Removed ${processingMessages.length} processing messages for thread ${this.thread_id}`);
+      }
     }
     await this.startQueueProcessorIfNeeded();
   }
@@ -15024,7 +15064,7 @@ var AgentInstanceManager = class _AgentInstanceManager {
       console.log(`[AgentInstanceManager] Found ${threadsWithPending.length} threads with pending messages, restoring...`);
       for (const threadInfo of threadsWithPending) {
         try {
-          await this.restoreThread(threadInfo, queueStore);
+          await this.restoreThread(threadInfo);
           stats.restored++;
         } catch (error) {
           console.error(`[AgentInstanceManager] Failed to restore thread ${threadInfo.threadId}:`, error);
@@ -15042,16 +15082,14 @@ var AgentInstanceManager = class _AgentInstanceManager {
    * Restore a single thread
    * Delegates actual recovery logic to Agent.resumeTask()
    */
-  async restoreThread(threadInfo, queueStore) {
-    const { tenantId, assistantId, threadId } = threadInfo;
+  async restoreThread(threadInfo) {
+    const { tenantId, assistantId, threadId, workspaceId, projectId } = threadInfo;
     const threadParams = {
       tenant_id: tenantId,
       assistant_id: assistantId,
       thread_id: threadId,
-      workspace_id: "default",
-      // TODO: Get from thread store
-      project_id: "default"
-      // TODO: Get from thread store
+      workspace_id: workspaceId,
+      project_id: projectId
     };
     const agent = this.getAgent(threadParams);
     await agent.resumeTask();
@@ -15142,7 +15180,7 @@ function createSchedulerMiddleware(options = {}) {
         async (input, config) => {
           const runConfig = getRunConfig(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
-          const taskId = (0, import_uuid2.v4)();
+          const taskId = (0, import_uuid3.v4)();
           const executeAt = input.executeAt;
           const success = await scheduleLattice.client.scheduleOnce(
             taskId,
@@ -15177,7 +15215,7 @@ function createSchedulerMiddleware(options = {}) {
         async (input, config) => {
           const runConfig = getRunConfig(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
-          const taskId = (0, import_uuid2.v4)();
+          const taskId = (0, import_uuid3.v4)();
           const executeAt = Date.now() + input.delayMs;
           const success = await scheduleLattice.client.scheduleOnce(
             taskId,
@@ -15212,7 +15250,7 @@ function createSchedulerMiddleware(options = {}) {
         async (input, config) => {
           const runConfig = getRunConfig(config);
           const scheduleLattice = getScheduleLattice(SCHEDULE_LATTICE_KEY);
-          const taskId = (0, import_uuid2.v4)();
+          const taskId = (0, import_uuid3.v4)();
           const success = await scheduleLattice.client.scheduleCron(
             taskId,
             AGENT_ADD_MESSAGE_TASK_TYPE,
@@ -15300,6 +15338,138 @@ function createSchedulerMiddleware(options = {}) {
   });
 }
 
+// src/middlewares/taskMiddleware.ts
+var import_langchain56 = require("langchain");
+var import_zod51 = require("zod");
+function getRunConfig2(config) {
+  const c = config;
+  return c?.configurable?.runConfig ?? {};
+}
+function getTaskStore() {
+  return getStoreLattice("default", "task").store;
+}
+var manageTaskSchema = import_zod51.z.object({
+  action: import_zod51.z.enum(["create", "list", "update", "delete", "complete"]).describe("\u64CD\u4F5C\u7C7B\u578B"),
+  id: import_zod51.z.string().optional().describe("\u4EFB\u52A1 ID (update/delete/complete \u5FC5\u586B)"),
+  title: import_zod51.z.string().optional().describe("\u4EFB\u52A1\u6807\u9898 (create \u5FC5\u586B)"),
+  description: import_zod51.z.string().optional().describe("\u4EFB\u52A1\u63CF\u8FF0"),
+  priority: import_zod51.z.enum(["low", "medium", "high"]).optional().describe("\u4F18\u5148\u7EA7"),
+  status: import_zod51.z.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe("\u72B6\u6001"),
+  dueDate: import_zod51.z.string().optional().describe("\u622A\u6B62\u65E5\u671F (ISO 8601)"),
+  metadata: import_zod51.z.record(import_zod51.z.unknown()).optional().describe("\u7ED3\u6784\u5316\u5143\u6570\u636E (projectId, module \u7B49)"),
+  parentId: import_zod51.z.string().optional().describe("\u7236\u4EFB\u52A1 ID (\u5B50\u4EFB\u52A1\u5173\u8054)"),
+  sourceId: import_zod51.z.string().optional().describe("\u6765\u6E90\u4F1A\u8BDD/thread ID"),
+  context: import_zod51.z.record(import_zod51.z.unknown()).optional().describe("\u9644\u52A0\u4E0A\u4E0B\u6587"),
+  ownerType: import_zod51.z.enum(["user", "agent"]).optional().describe("\u6240\u6709\u8005\u7C7B\u578B\uFF0C\u4E0D\u4F20\u9ED8\u8BA4\u4E3A user"),
+  ownerId: import_zod51.z.string().optional().describe("\u6240\u6709\u8005 ID\uFF0C\u4E0D\u4F20\u81EA\u52A8\u53D6\u5F53\u524D\u7528\u6237/Agent")
+});
+function createTaskMiddleware() {
+  return (0, import_langchain56.createMiddleware)({
+    name: "TaskMiddleware",
+    contextSchema,
+    wrapModelCall: async (request, handler) => {
+      const taskPrompt = `## \u4EFB\u52A1\u7BA1\u7406\u80FD\u529B
+\u4F60\u53EF\u4EE5\u901A\u8FC7 manage_task \u5DE5\u5177\u7BA1\u7406\u6301\u4E45\u5316\u4EFB\u52A1\u3002ownerType \u548C ownerId \u7684\u9ED8\u8BA4\u884C\u4E3A\uFF1A
+- \u4E0D\u4F20\u53C2\u6570: \u9ED8\u8BA4\u4E3A\u5F53\u524D\u7528\u6237\u521B\u5EFA\u4EFB\u52A1 (ownerType="user", ownerId \u81EA\u52A8\u53D6\u5F53\u524D\u7528\u6237)
+- ownerType="agent": \u4E3A\u81EA\u5DF1\u521B\u5EFA\u6267\u884C\u5B50\u4EFB\u52A1 (ownerId \u81EA\u52A8\u53D6\u5F53\u524D Agent)
+- \u663E\u5F0F\u4F20 ownerId: \u4E3A\u6307\u5B9A agent/user \u521B\u5EFA\u4EFB\u52A1\uFF08\u62D3\u6251\u573A\u666F\uFF09`;
+      return handler({
+        ...request,
+        systemPrompt: taskPrompt + "\n\n" + (request.systemPrompt ?? "")
+      });
+    },
+    tools: [
+      (0, import_langchain56.tool)(
+        async (input, config) => {
+          const rc = getRunConfig2(config);
+          const tenantId = rc.tenantId || "default";
+          const ownerId = input.ownerId || (input.ownerType === "agent" ? rc.assistant_id : null) || rc.user_id;
+          const store = getTaskStore();
+          switch (input.action) {
+            case "create": {
+              if (!input.title) {
+                return JSON.stringify({ success: false, error: "create requires title" });
+              }
+              const task = await store.create({
+                tenantId,
+                ownerType: input.ownerType || "user",
+                ownerId,
+                title: input.title,
+                description: input.description,
+                priority: input.priority || "medium",
+                status: input.status || "pending",
+                dueDate: input.dueDate,
+                metadata: input.metadata,
+                parentId: input.parentId,
+                sourceId: input.sourceId,
+                context: input.context
+              });
+              return JSON.stringify({ success: true, data: task });
+            }
+            case "list": {
+              const tasks = await store.list({
+                tenantId,
+                ownerType: input.ownerType,
+                ownerId: input.ownerId,
+                status: input.status,
+                priority: input.priority
+              });
+              return JSON.stringify({ success: true, data: tasks, count: tasks.length });
+            }
+            case "update": {
+              if (!input.id) {
+                return JSON.stringify({ success: false, error: "update requires id" });
+              }
+              const { action, ...updates } = input;
+              const updated = await store.update(tenantId, input.id, updates);
+              if (!updated) {
+                return JSON.stringify({ success: false, error: "Task not found" });
+              }
+              return JSON.stringify({ success: true, data: updated });
+            }
+            case "delete": {
+              if (!input.id) {
+                return JSON.stringify({ success: false, error: "delete requires id" });
+              }
+              const deleted = await store.delete(tenantId, input.id);
+              return JSON.stringify({ success: deleted, message: deleted ? "Task deleted" : "Task not found" });
+            }
+            case "complete": {
+              if (!input.id) {
+                return JSON.stringify({ success: false, error: "complete requires id" });
+              }
+              const updated = await store.update(tenantId, input.id, { status: "completed" });
+              if (!updated) {
+                return JSON.stringify({ success: false, error: "Task not found" });
+              }
+              return JSON.stringify({ success: true, data: updated });
+            }
+            default:
+              return JSON.stringify({ success: false, error: `Unknown action: ${input.action}` });
+          }
+        },
+        {
+          name: "manage_task",
+          description: `\u7BA1\u7406\u6301\u4E45\u5316\u4EFB\u52A1\u7CFB\u7EDF\u3002CRUD \u64CD\u4F5C\u7528\u6237\u548C Agent \u7684\u4EFB\u52A1\u3002
+
+## ownerType \u548C ownerId \u7684\u9ED8\u8BA4\u903B\u8F91
+- \u4E0D\u4F20 ownerType \u548C ownerId: \u7CFB\u7EDF\u81EA\u52A8\u4E3A\u5F53\u524D\u7528\u6237\u521B\u5EFA\u4EFB\u52A1 (ownerType="user", ownerId \u53D6\u81EA\u5F53\u524D\u767B\u5F55\u7528\u6237)
+- \u4F20 ownerType="agent" \u4E0D\u4F20 ownerId: \u7CFB\u7EDF\u81EA\u52A8\u4E3A\u5F53\u524D Agent \u521B\u5EFA\u5B50\u4EFB\u52A1
+- \u663E\u5F0F\u4F20 ownerId: \u7CFB\u7EDF\u4F7F\u7528\u4F60\u6307\u5B9A\u7684 ID\uFF0C\u53EF\u8DE8 Agent \u6D3E\u53D1\u4EFB\u52A1\uFF08\u62D3\u6251\u573A\u666F\uFF09
+
+## Actions
+- create: \u521B\u5EFA\u4EFB\u52A1 (title \u5FC5\u586B, priority/description/dueDate/metadata/parentId/context \u53EF\u9009)
+- list: \u5217\u51FA\u4EFB\u52A1\uFF0C\u53EF\u6309 ownerType/status/priority \u8FC7\u6EE4
+- update: \u66F4\u65B0\u4EFB\u52A1 (id \u5FC5\u586B\uFF0C\u53EA\u4F20\u8981\u6539\u7684\u5B57\u6BB5)
+- delete: \u5220\u9664\u4EFB\u52A1 (id \u5FC5\u586B)
+- complete: \u5FEB\u901F\u6807\u8BB0\u5B8C\u6210 (id \u5FC5\u586B)`,
+          schema: manageTaskSchema
+        }
+      )
+    ]
+  });
+}
+
 // src/agent_lattice/builders/CustomMiddlewareRegistry.ts
 var CustomMiddlewareRegistry = class {
   /**
@@ -15435,6 +15605,9 @@ async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsI
       case "scheduler":
         middlewares.push(createSchedulerMiddleware(config.config));
         break;
+      case "task":
+        middlewares.push(createTaskMiddleware());
+        break;
       case "custom":
         {
           const customConfig = config.config;
@@ -15642,14 +15815,14 @@ var ReActAgentGraphBuilder = class {
    */
   async build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool51 = getToolClient(t.key);
-      return tool51;
-    }).filter((tool51) => tool51 !== void 0);
+      const tool52 = getToolClient(t.key);
+      return tool52;
+    }).filter((tool52) => tool52 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
     const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend);
-    return (0, import_langchain56.createAgent)({
+    return (0, import_langchain57.createAgent)({
       model: params.model,
       tools,
       systemPrompt: params.prompt,
@@ -15663,11 +15836,11 @@ var ReActAgentGraphBuilder = class {
 };
 
 // src/deep_agent_new/agent.ts
-var import_langchain60 = require("langchain");
+var import_langchain61 = require("langchain");
 
 // src/deep_agent_new/middleware/subagents.ts
 var import_v32 = require("zod/v3");
-var import_langchain57 = require("langchain");
+var import_langchain58 = require("langchain");
 var import_langgraph8 = require("@langchain/langgraph");
 var import_messages2 = require("@langchain/core/messages");
 
@@ -15991,7 +16164,7 @@ function returnCommandWithStateUpdate(result, toolCallId) {
     update: {
       ...stateUpdate,
       messages: [
-        new import_langchain57.ToolMessage({
+        new import_langchain58.ToolMessage({
           content: lastMessage?.content || "Task Failed to complete",
           tool_call_id: toolCallId,
           name: "task"
@@ -16016,10 +16189,10 @@ function getSubagents(options) {
     const generalPurposeMiddleware = [...defaultSubagentMiddleware];
     if (defaultInterruptOn) {
       generalPurposeMiddleware.push(
-        (0, import_langchain57.humanInTheLoopMiddleware)({ interruptOn: defaultInterruptOn })
+        (0, import_langchain58.humanInTheLoopMiddleware)({ interruptOn: defaultInterruptOn })
       );
     }
-    const generalPurposeSubagent = (0, import_langchain57.createAgent)({
+    const generalPurposeSubagent = (0, import_langchain58.createAgent)({
       model: defaultModel,
       systemPrompt: DEFAULT_SUBAGENT_PROMPT,
       tools: defaultTools,
@@ -16042,8 +16215,8 @@ function getSubagents(options) {
       const middleware = agentParams.middleware ? [...defaultSubagentMiddleware, ...agentParams.middleware] : [...defaultSubagentMiddleware];
       const interruptOn = agentParams.interruptOn || defaultInterruptOn;
       if (interruptOn)
-        middleware.push((0, import_langchain57.humanInTheLoopMiddleware)({ interruptOn }));
-      agents[agentParams.key] = (0, import_langchain57.createAgent)({
+        middleware.push((0, import_langchain58.humanInTheLoopMiddleware)({ interruptOn }));
+      agents[agentParams.key] = (0, import_langchain58.createAgent)({
         model: agentParams.model ?? defaultModel,
         systemPrompt: agentParams.systemPrompt,
         tools: agentParams.tools ?? defaultTools,
@@ -16093,7 +16266,7 @@ function createTaskTool(options) {
     generalPurposeAgent
   });
   const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
-  return (0, import_langchain57.tool)(
+  return (0, import_langchain58.tool)(
     async (input, config) => {
       const { description, subagent_type, async } = input;
       let assistant_id = subagent_type;
@@ -16127,12 +16300,16 @@ function createTaskTool(options) {
         const subagent_thread_id = config.configurable?.thread_id + "____" + assistant_id + "_" + config.toolCall.id;
         if (async) {
           const tenantId = config.configurable?.runConfig?.tenantId;
+          const workspaceId = config.configurable?.runConfig?.workspaceId;
+          const projectId = config.configurable?.runConfig?.projectId;
           const mainAssistantId = config.configurable?.runConfig?.assistant_id;
           const mainThreadId = config.configurable?.runConfig?.thread_id;
           const mainRuntimeAgent = agentInstanceManager.getAgent({
             assistant_id: mainAssistantId,
             thread_id: mainThreadId,
-            tenant_id: tenantId
+            tenant_id: tenantId,
+            workspace_id: workspaceId,
+            project_id: projectId
           });
           if (mainRuntimeAgent) {
             mainRuntimeAgent.addAsyncTask({
@@ -16165,7 +16342,7 @@ function createTaskTool(options) {
           return new import_langgraph8.Command({
             update: {
               messages: [
-                new import_langchain57.ToolMessage({
+                new import_langchain58.ToolMessage({
                   content: `Async task started: ${subagent_thread_id}
 ${description}
 The result will be delivered as a notification when complete. Do not poll.`,
@@ -16198,7 +16375,7 @@ The result will be delivered as a notification when complete. Do not poll.`,
         return new import_langgraph8.Command({
           update: {
             messages: [
-              new import_langchain57.ToolMessage({
+              new import_langchain58.ToolMessage({
                 content: error instanceof Error ? error.message : "Task Failed to complete",
                 tool_call_id: config.toolCall.id,
                 name: "task"
@@ -16238,7 +16415,7 @@ function getMainAgentFromConfig(config) {
   });
 }
 function createCheckAsyncTaskTool() {
-  return (0, import_langchain57.tool)(
+  return (0, import_langchain58.tool)(
     async (input, config) => {
       const { task_id } = input;
       const mainAgent = getMainAgentFromConfig(config);
@@ -16305,7 +16482,7 @@ Description: ${cached.description}`;
   );
 }
 function createListAsyncTasksTool() {
-  return (0, import_langchain57.tool)(
+  return (0, import_langchain58.tool)(
     async (_input, config) => {
       const mainAgent = getMainAgentFromConfig(config);
       if (!mainAgent) {
@@ -16356,7 +16533,7 @@ function createListAsyncTasksTool() {
   );
 }
 function createCancelAsyncTaskTool() {
-  return (0, import_langchain57.tool)(
+  return (0, import_langchain58.tool)(
     async (input, config) => {
       const { task_id } = input;
       const mainAgent = getMainAgentFromConfig(config);
@@ -16432,7 +16609,7 @@ function createSubAgentMiddleware(options) {
     );
   }
   const effectiveSystemPrompt = allowAsync ? systemPrompt + getAsyncPromptText() : systemPrompt;
-  return (0, import_langchain57.createMiddleware)({
+  return (0, import_langchain58.createMiddleware)({
     name: "subAgentMiddleware",
     tools: allTools,
     wrapModelCall: async (request, handler) => {
@@ -16452,11 +16629,9 @@ ${effectiveSystemPrompt}` : effectiveSystemPrompt;
 }
 
 // src/deep_agent_new/middleware/patch_tool_calls.ts
-var import_langchain58 = require("langchain");
-var import_messages3 = require("@langchain/core/messages");
-var import_langgraph9 = require("@langchain/langgraph");
+var import_langchain59 = require("langchain");
 function createPatchToolCallsMiddleware() {
-  return (0, import_langchain58.createMiddleware)({
+  return (0, import_langchain59.createMiddleware)({
     name: "patchToolCallsMiddleware",
     beforeAgent: async (state) => {
       const messages = state.messages;
@@ -16467,15 +16642,15 @@ function createPatchToolCallsMiddleware() {
       for (let i = 0; i < messages.length; i++) {
         const msg = messages[i];
         patchedMessages.push(msg);
-        if (import_langchain58.AIMessage.isInstance(msg) && msg.tool_calls != null) {
+        if (import_langchain59.AIMessage.isInstance(msg) && msg.tool_calls != null) {
           for (const toolCall of msg.tool_calls) {
             const correspondingToolMsg = messages.slice(i).find(
-              (m) => import_langchain58.ToolMessage.isInstance(m) && m.tool_call_id === toolCall.id
+              (m) => import_langchain59.ToolMessage.isInstance(m) && m.tool_call_id === toolCall.id
             );
             if (!correspondingToolMsg) {
               const toolMsg = `Tool call ${toolCall.name} with id ${toolCall.id} was cancelled - another message came in before it could be completed.`;
               patchedMessages.push(
-                new import_langchain58.ToolMessage({
+                new import_langchain59.ToolMessage({
                   content: toolMsg,
                   name: toolCall.name,
                   tool_call_id: toolCall.id
@@ -16485,11 +16660,12 @@ function createPatchToolCallsMiddleware() {
           }
         }
       }
+      if (patchedMessages.length === messages.length) {
+        return;
+      }
       return {
-        messages: [
-          new import_messages3.RemoveMessage({ id: import_langgraph9.REMOVE_ALL_MESSAGES }),
-          ...patchedMessages
-        ]
+        messages: patchedMessages.slice(messages.length)
+        // only the new ToolMessage patches
       };
     }
   });
@@ -17601,9 +17777,9 @@ var MemoryBackend = class {
 };
 
 // src/deep_agent_new/middleware/todos.ts
-var import_langgraph10 = require("@langchain/langgraph");
-var import_zod51 = require("zod");
-var import_langchain59 = require("langchain");
+var import_langgraph9 = require("@langchain/langgraph");
+var import_zod52 = require("zod");
+var import_langchain60 = require("langchain");
 var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
 It also helps the user understand the progress of the task and overall progress of their requests.
 Only use this tool if you think it will be helpful in staying organized. If the user's request is trivial and takes less than 3 steps, it is better to NOT use this tool and just do the taks directly.
@@ -17830,20 +18006,20 @@ Writing todos takes time and tokens, use it when it is helpful for managing comp
 ## Important To-Do List Usage Notes to Remember
 - The \`write_todos\` tool should never be called multiple times in parallel.
 - Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.`;
-var TodoStatus = import_zod51.z.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = import_zod51.z.object({
-  content: import_zod51.z.string().describe("Content of the todo item"),
+var TodoStatus = import_zod52.z.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = import_zod52.z.object({
+  content: import_zod52.z.string().describe("Content of the todo item"),
   status: TodoStatus
 });
-var stateSchema = import_zod51.z.object({ todos: import_zod51.z.array(TodoSchema).default([]) });
+var stateSchema = import_zod52.z.object({ todos: import_zod52.z.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
-  const writeTodos = (0, import_langchain59.tool)(
+  const writeTodos = (0, import_langchain60.tool)(
     ({ todos }, config) => {
-      return new import_langgraph10.Command({
+      return new import_langgraph9.Command({
         update: {
           todos,
           messages: [
-            new import_langchain59.ToolMessage({
+            new import_langchain60.ToolMessage({
               content: genUIMarkdown("todo_list", todos),
               tool_call_id: config.toolCall?.id
             })
@@ -17854,12 +18030,12 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: import_zod51.z.object({
-        todos: import_zod51.z.array(TodoSchema).describe("List of todo items to update")
+      schema: import_zod52.z.object({
+        todos: import_zod52.z.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
-  return (0, import_langchain59.createMiddleware)({
+  return (0, import_langchain60.createMiddleware)({
     name: "todoListMiddleware",
     stateSchema,
     tools: [writeTodos],
@@ -17911,13 +18087,13 @@ ${BASE_PROMPT}` : BASE_PROMPT;
           backend: filesystemBackend
         }),
         // Subagent middleware: Automatic conversation summarization when token limits are approached
-        (0, import_langchain60.summarizationMiddleware)({
+        (0, import_langchain61.summarizationMiddleware)({
           model,
           trigger: { tokens: 17e4 },
           keep: { messages: 6 }
         }),
         // Subagent middleware: Anthropic prompt caching for improved performance
-        (0, import_langchain60.anthropicPromptCachingMiddleware)({
+        (0, import_langchain61.anthropicPromptCachingMiddleware)({
           unsupportedModelBehavior: "ignore"
         }),
         // Subagent middleware: Patches tool calls for compatibility
@@ -17929,23 +18105,23 @@ ${BASE_PROMPT}` : BASE_PROMPT;
       generalPurposeAgent: true
     }),
     // Automatically summarizes conversation history when token limits are approached
-    (0, import_langchain60.summarizationMiddleware)({
+    (0, import_langchain61.summarizationMiddleware)({
       model,
       trigger: { tokens: 17e4 },
       keep: { messages: 6 }
     }),
     // Enables Anthropic prompt caching for improved performance and reduced costs
-    (0, import_langchain60.anthropicPromptCachingMiddleware)({
+    (0, import_langchain61.anthropicPromptCachingMiddleware)({
       unsupportedModelBehavior: "ignore"
     }),
     // Patches tool calls to ensure compatibility across different model providers
     createPatchToolCallsMiddleware()
   ];
   if (interruptOn) {
-    middleware.push((0, import_langchain60.humanInTheLoopMiddleware)({ interruptOn }));
+    middleware.push((0, import_langchain61.humanInTheLoopMiddleware)({ interruptOn }));
   }
   middleware.push(...customMiddleware);
-  return (0, import_langchain60.createAgent)({
+  return (0, import_langchain61.createAgent)({
     model,
     systemPrompt: finalSystemPrompt,
     tools,
@@ -17972,7 +18148,7 @@ var DeepAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool51) => tool51 !== void 0);
+    }).filter((tool52) => tool52 !== void 0);
     const subagents = await Promise.all(params.subAgents.map(async (sa) => {
       if (sa.client) {
         return {
@@ -18017,7 +18193,7 @@ init_MemoryLatticeManager();
 
 // src/agent_team/agent_team.ts
 var import_v35 = require("zod/v3");
-var import_langchain63 = require("langchain");
+var import_langchain64 = require("langchain");
 
 // src/agent_team/types.ts
 var TaskStatus = /* @__PURE__ */ ((TaskStatus3) => {
@@ -18453,14 +18629,14 @@ var InMemoryMailboxStore = class {
 
 // src/agent_team/middleware/team.ts
 var import_v34 = require("zod/v3");
-var import_langchain62 = require("langchain");
-var import_langgraph12 = require("@langchain/langgraph");
-var import_uuid3 = require("uuid");
+var import_langchain63 = require("langchain");
+var import_langgraph11 = require("@langchain/langgraph");
+var import_uuid4 = require("uuid");
 
 // src/agent_team/middleware/teammate_tools.ts
 var import_v33 = require("zod/v3");
-var import_langchain61 = require("langchain");
-var import_langgraph11 = require("@langchain/langgraph");
+var import_langchain62 = require("langchain");
+var import_langgraph10 = require("@langchain/langgraph");
 
 // src/agent_team/middleware/formatMessages.ts
 function formatMessagesAsMarkdown(msgs) {
@@ -18484,7 +18660,7 @@ ${meta}${body}`;
 // src/agent_team/middleware/teammate_tools.ts
 function createTeammateTools(options) {
   const { teamId, agentId, taskListStore, mailboxStore } = options;
-  const claimTaskTool = (0, import_langchain61.tool)(
+  const claimTaskTool = (0, import_langchain62.tool)(
     async (input) => {
       const task = await taskListStore.claimTaskById(
         teamId,
@@ -18514,7 +18690,7 @@ function createTeammateTools(options) {
       })
     }
   );
-  const completeTaskTool = (0, import_langchain61.tool)(
+  const completeTaskTool = (0, import_langchain62.tool)(
     async (input) => {
       const task = await taskListStore.completeTask(
         teamId,
@@ -18541,7 +18717,7 @@ function createTeammateTools(options) {
       })
     }
   );
-  const failTaskTool = (0, import_langchain61.tool)(
+  const failTaskTool = (0, import_langchain62.tool)(
     async (input) => {
       const task = await taskListStore.failTask(
         teamId,
@@ -18568,7 +18744,7 @@ function createTeammateTools(options) {
       })
     }
   );
-  const sendMessageTool = (0, import_langchain61.tool)(
+  const sendMessageTool = (0, import_langchain62.tool)(
     async (input) => {
       await mailboxStore.sendMessage(
         teamId,
@@ -18606,7 +18782,7 @@ function createTeammateTools(options) {
       read: msg.read
     }));
   };
-  const readMessagesTool = (0, import_langchain61.tool)(
+  const readMessagesTool = (0, import_langchain62.tool)(
     async (input, config) => {
       const formatAndMarkAsRead = async (msgs2) => {
         for (const msg of msgs2) {
@@ -18618,12 +18794,12 @@ function createTeammateTools(options) {
       if (msgs.length > 0) {
         const formatted2 = await formatAndMarkAsRead(msgs);
         const relevantMsgs2 = await getRelevantMessagesForState();
-        const toolMessage2 = new import_langchain61.ToolMessage({
+        const toolMessage2 = new import_langchain62.ToolMessage({
           content: formatted2,
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
         });
-        return new import_langgraph11.Command({
+        return new import_langgraph10.Command({
           update: { team_mailbox: relevantMsgs2, messages: [toolMessage2] }
         });
       }
@@ -18643,22 +18819,22 @@ function createTeammateTools(options) {
       });
       const relevantMsgs = await getRelevantMessagesForState();
       if (msgs.length === 0) {
-        const toolMessage2 = new import_langchain61.ToolMessage({
+        const toolMessage2 = new import_langchain62.ToolMessage({
           content: "No unread messages.",
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
         });
-        return new import_langgraph11.Command({
+        return new import_langgraph10.Command({
           update: { team_mailbox: relevantMsgs, messages: [toolMessage2] }
         });
       }
       const formatted = await formatAndMarkAsRead(msgs);
-      const toolMessage = new import_langchain61.ToolMessage({
+      const toolMessage = new import_langchain62.ToolMessage({
         content: formatted,
         tool_call_id: config.toolCall?.id,
         name: "read_messages"
       });
-      return new import_langgraph11.Command({
+      return new import_langgraph10.Command({
         update: { team_mailbox: relevantMsgs, messages: [toolMessage] }
       });
     },
@@ -18668,7 +18844,7 @@ function createTeammateTools(options) {
       schema: import_v33.z.object({})
     }
   );
-  const checkTasksTool = (0, import_langchain61.tool)(
+  const checkTasksTool = (0, import_langchain62.tool)(
     async () => {
       const tasks = await taskListStore.getAllTasks(teamId);
       return formatTaskSummary(tasks);
@@ -18679,7 +18855,7 @@ function createTeammateTools(options) {
       schema: import_v33.z.object({})
     }
   );
-  const broadcastMessageTool = (0, import_langchain61.tool)(
+  const broadcastMessageTool = (0, import_langchain62.tool)(
     async (input) => {
       const allAgents = await mailboxStore.getRegisteredAgents(teamId);
       const recipients = allAgents.filter((a) => a !== agentId);
@@ -18865,7 +19041,7 @@ You have access to these tools:
 - \`read_messages\`: Read messages from team_lead or teammates
 - \`check_tasks\`: Get current status of all tasks in the team`;
   const assistantId = getTeammateAssistantId(ctx.teamId, spec.name);
-  agent = (0, import_langchain62.createAgent)({
+  agent = (0, import_langchain63.createAgent)({
     model: spec.model ?? ctx.defaultModel,
     systemPrompt: teammatePrompt,
     tools: allTools,
@@ -18934,19 +19110,19 @@ async function spawnTeammate(options) {
 function createTeamMiddleware(options) {
   const { teamConfig, taskListStore, mailboxStore, tenantId } = options;
   const defaultModel = teamConfig.model ?? "claude-sonnet-4-5-20250929";
-  const createTeamTool = (0, import_langchain62.tool)(
+  const createTeamTool = (0, import_langchain63.tool)(
     async (input, config) => {
-      const state = (0, import_langgraph12.getCurrentTaskInput)();
+      const state = (0, import_langgraph11.getCurrentTaskInput)();
       if (state?.team?.teamId) {
         const existingId = state.team.teamId;
-        const msg = new import_langchain62.ToolMessage({
+        const msg = new import_langchain63.ToolMessage({
           content: `A team is already active (id: ${existingId}). Use this team_id for \`check_tasks\`, \`read_messages\`, \`add_tasks\`, \`send_message\`, \`assign_task\`, \`set_task_status\`, and \`set_task_dependencies\`. Do not call \`create_team\` again unless you need a fresh team for a new objective.`,
           tool_call_id: config.toolCall?.id,
           name: "create_team"
         });
         return msg;
       }
-      const teamId = (0, import_uuid3.v4)();
+      const teamId = (0, import_uuid4.v4)();
       const createdTasks = await taskListStore.addTasks(
         teamId,
         input.tasks.map((t) => ({
@@ -19028,7 +19204,7 @@ Teammates are now working in the background. Keep calling \`check_tasks\` and \`
 \`\`\`json
 ${teamJson}
 \`\`\``;
-      const toolMessage = new import_langchain62.ToolMessage({
+      const toolMessage = new import_langchain63.ToolMessage({
         content: summary,
         tool_call_id: config.toolCall?.id,
         name: "create_team"
@@ -19049,7 +19225,7 @@ ${teamJson}
         })),
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      return new import_langgraph12.Command({
+      return new import_langgraph11.Command({
         update: { team: teamState, messages: [toolMessage] }
       });
     },
@@ -19109,11 +19285,11 @@ After calling create_team, you MUST:
     }
   );
   const resolveTeamId = () => {
-    const state = (0, import_langgraph12.getCurrentTaskInput)();
+    const state = (0, import_langgraph11.getCurrentTaskInput)();
     if (state?.team?.teamId) return state.team.teamId;
     throw new Error("No team_id provided and no team in state. Call create_team first.");
   };
-  const addTasksTool = (0, import_langchain62.tool)(
+  const addTasksTool = (0, import_langchain63.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const created = await taskListStore.addTasks(
@@ -19127,7 +19303,7 @@ After calling create_team, you MUST:
         }))
       );
       const summary = created.map((t) => `- ${t.id}: "${t.title}"`).join("\n");
-      return new import_langchain62.ToolMessage({
+      return new import_langchain63.ToolMessage({
         content: `Added ${created.length} task(s) to team ${teamId}:
 ${summary}
 Sleeping teammates will wake up and claim these.`,
@@ -19178,20 +19354,20 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const assignTaskTool = (0, import_langchain62.tool)(
+  const assignTaskTool = (0, import_langchain63.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         assignee: input.assignee
       });
       if (!task) {
-        return new import_langchain62.ToolMessage({
+        return new import_langchain63.ToolMessage({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "assign_task"
         });
       }
-      return new import_langchain62.ToolMessage({
+      return new import_langchain63.ToolMessage({
         content: `Task "${task.title}" (${task.id}) assigned to ${input.assignee}.`,
         tool_call_id: config.toolCall?.id,
         name: "assign_task"
@@ -19206,20 +19382,20 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const setTaskStatusTool = (0, import_langchain62.tool)(
+  const setTaskStatusTool = (0, import_langchain63.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         status: input.status
       });
       if (!task) {
-        return new import_langchain62.ToolMessage({
+        return new import_langchain63.ToolMessage({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "set_task_status"
         });
       }
-      return new import_langchain62.ToolMessage({
+      return new import_langchain63.ToolMessage({
         content: `Task "${task.title}" (${task.id}) status set to ${input.status}.`,
         tool_call_id: config.toolCall?.id,
         name: "set_task_status"
@@ -19234,20 +19410,20 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const setTaskDependenciesTool = (0, import_langchain62.tool)(
+  const setTaskDependenciesTool = (0, import_langchain63.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         dependencies: input.dependencies
       });
       if (!task) {
-        return new import_langchain62.ToolMessage({
+        return new import_langchain63.ToolMessage({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "set_task_dependencies"
         });
       }
-      return new import_langchain62.ToolMessage({
+      return new import_langchain63.ToolMessage({
         content: `Task "${task.title}" (${task.id}) dependencies set to [${input.dependencies.join(", ")}].`,
         tool_call_id: config.toolCall?.id,
         name: "set_task_dependencies"
@@ -19262,16 +19438,16 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const checkTasksTool = (0, import_langchain62.tool)(
+  const checkTasksTool = (0, import_langchain63.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const tasks = await taskListStore.getAllTasks(teamId);
       const tasksSnapshot = tasks;
-      return new import_langgraph12.Command({
+      return new import_langgraph11.Command({
         update: {
           tasks: tasksSnapshot,
           messages: [
-            new import_langchain62.ToolMessage({
+            new import_langchain63.ToolMessage({
               content: formatTaskSummary(tasks),
               tool_call_id: config.toolCall?.id,
               name: "check_tasks"
@@ -19307,7 +19483,7 @@ Task Status Values:
       })
     }
   );
-  const sendMessageTool = (0, import_langchain62.tool)(
+  const sendMessageTool = (0, import_langchain63.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.sendMessage(
@@ -19317,7 +19493,7 @@ Task Status Values:
         input.content,
         "direct_message" /* DIRECT_MESSAGE */
       );
-      return new import_langchain62.ToolMessage({
+      return new import_langchain63.ToolMessage({
         content: `Message sent to ${input.to}.`,
         tool_call_id: config.toolCall?.id,
         name: "send_message"
@@ -19332,7 +19508,7 @@ Task Status Values:
       })
     }
   );
-  const readMessagesTool = (0, import_langchain62.tool)(
+  const readMessagesTool = (0, import_langchain63.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const formatAndMarkAsRead = async (msgs2) => {
@@ -19360,12 +19536,12 @@ Task Status Values:
       if (msgs.length > 0) {
         const formatted2 = await formatAndMarkAsRead(msgs);
         const allTeamMessages2 = await getAllTeamMessagesForState();
-        const toolMessage2 = new import_langchain62.ToolMessage({
+        const toolMessage2 = new import_langchain63.ToolMessage({
           content: formatted2,
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
         });
-        return new import_langgraph12.Command({
+        return new import_langgraph11.Command({
           update: { team_mailbox: allTeamMessages2, messages: [toolMessage2] }
         });
       }
@@ -19392,22 +19568,22 @@ Task Status Values:
       );
       const allTeamMessages = await getAllTeamMessagesForState();
       if (msgs.length === 0) {
-        const toolMessage2 = new import_langchain62.ToolMessage({
+        const toolMessage2 = new import_langchain63.ToolMessage({
           content: "No unread messages from teammates.",
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
         });
-        return new import_langgraph12.Command({
+        return new import_langgraph11.Command({
           update: { team_mailbox: allTeamMessages, messages: [toolMessage2] }
         });
       }
       const formatted = await formatAndMarkAsRead(msgs);
-      const toolMessage = new import_langchain62.ToolMessage({
+      const toolMessage = new import_langchain63.ToolMessage({
         content: formatted,
         tool_call_id: config.toolCall?.id,
         name: "read_messages"
       });
-      return new import_langgraph12.Command({
+      return new import_langgraph11.Command({
         update: { team_mailbox: allTeamMessages, messages: [toolMessage] }
       });
     },
@@ -19419,7 +19595,7 @@ Task Status Values:
       })
     }
   );
-  const disbandTeamTool = (0, import_langchain62.tool)(
+  const disbandTeamTool = (0, import_langchain63.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -19429,7 +19605,7 @@ Task Status Values:
         "shutdown_request" /* SHUTDOWN_REQUEST */
       );
       await new Promise((r) => setTimeout(r, 2e3));
-      return new import_langchain62.ToolMessage({
+      return new import_langchain63.ToolMessage({
         content: `Team ${teamId} has been disbanded. All teammates notified and resources cleaned up.`,
         tool_call_id: config.toolCall?.id,
         name: "disband_team"
@@ -19440,7 +19616,7 @@ Task Status Values:
       description: "Disband a team when all work is done. Before calling: (1) Call check_tasks to verify no tasks are still pending/in_progress; (2) if any are, discuss with the team via read_messages and broadcast_message/send_message whether to continue or stop/cancel them; (3) only after alignment (all tasks completed/failed or explicitly stopped), then call this tool. This will: 1) Send a shutdown message to all teammates, 2) Wait briefly for them to clean up, 3) Clear all tasks and messages. Omit team_id to use the active team from state."
     }
   );
-  const broadcastMessageTool = (0, import_langchain62.tool)(
+  const broadcastMessageTool = (0, import_langchain63.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -19449,7 +19625,7 @@ Task Status Values:
         input.content,
         "broadcast" /* BROADCAST */
       );
-      return new import_langchain62.ToolMessage({
+      return new import_langchain63.ToolMessage({
         content: `Broadcast message sent to all teammates.`,
         tool_call_id: config.toolCall?.id,
         name: "broadcast_message"
@@ -19463,7 +19639,7 @@ Task Status Values:
       })
     }
   );
-  return (0, import_langchain62.createMiddleware)({
+  return (0, import_langchain63.createMiddleware)({
     name: "teamMiddleware",
     tools: [
       createTeamTool,
@@ -19572,7 +19748,7 @@ function createAgentTeam(config) {
   ];
   const systemPrompt = config.systemPrompt + "\n\n" + TEAM_LEAD_BASE_PROMPT;
   const stateSchema2 = createReactAgentSchema(TEAM_STATE_SCHEMA);
-  return (0, import_langchain63.createAgent)({
+  return (0, import_langchain64.createAgent)({
     model: config.model ?? "claude-sonnet-4-5-20250929",
     systemPrompt,
     tools: [],
@@ -19602,7 +19778,7 @@ var TeamAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool51) => tool51 !== void 0);
+    }).filter((tool52) => tool52 !== void 0);
     const teammates = params.subAgents.map((sa) => {
       const baseConfig = sa.config;
       return {
@@ -19640,17 +19816,17 @@ var TeamAgentGraphBuilder = class {
 };
 
 // src/deep_agent_new/processing_agent.ts
-var import_langchain66 = require("langchain");
+var import_langchain67 = require("langchain");
 
 // src/middlewares/topologyMiddleware.ts
-var import_langchain64 = require("langchain");
-var import_messages4 = require("@langchain/core/messages");
 var import_langchain65 = require("langchain");
-var import_zod52 = require("zod");
-var import_langgraph13 = require("@langchain/langgraph");
-var CompletedEdgeSchema = import_zod52.z.object({
-  to: import_zod52.z.string(),
-  purpose: import_zod52.z.string()
+var import_messages3 = require("@langchain/core/messages");
+var import_langchain66 = require("langchain");
+var import_zod53 = require("zod");
+var import_langgraph12 = require("@langchain/langgraph");
+var CompletedEdgeSchema = import_zod53.z.object({
+  to: import_zod53.z.string(),
+  purpose: import_zod53.z.string()
 });
 function deriveCompletedEdges(messages, edges) {
   const completedToolCallIds = /* @__PURE__ */ new Set();
@@ -19677,16 +19853,16 @@ function deriveCompletedEdges(messages, edges) {
 }
 function createTopologyMiddleware(options) {
   const { edges, trackingStore } = options;
-  return (0, import_langchain64.createMiddleware)({
+  return (0, import_langchain65.createMiddleware)({
     name: "TopologyMiddleware",
-    contextSchema: import_zod52.z.object({
-      runConfig: import_zod52.z.any()
+    contextSchema: import_zod53.z.object({
+      runConfig: import_zod53.z.any()
     }),
-    stateSchema: import_zod52.z.object({
-      currentAgentId: import_zod52.z.string().default(""),
-      completedEdges: import_zod52.z.array(CompletedEdgeSchema).default([]),
-      runId: import_zod52.z.string().default(""),
-      stepIdMap: import_zod52.z.record(import_zod52.z.string()).default({})
+    stateSchema: import_zod53.z.object({
+      currentAgentId: import_zod53.z.string().default(""),
+      completedEdges: import_zod53.z.array(CompletedEdgeSchema).default([]),
+      runId: import_zod53.z.string().default(""),
+      stepIdMap: import_zod53.z.record(import_zod53.z.string()).default({})
     }),
     beforeAgent: async (state, runtime) => {
       if (state.runId) {
@@ -19737,14 +19913,14 @@ ${request.systemPrompt}` : topologyPrompt;
       return handler({ ...request, systemPrompt: newSystemPrompt });
     },
     tools: [
-      (0, import_langchain65.tool)(
+      (0, import_langchain66.tool)(
         async (_input) => {
           return "placeholder";
         },
         {
           name: "read_topo_progress",
           description: "Check the current progress of the workflow execution plan. Returns which steps have been completed and which are still pending.",
-          schema: import_zod52.z.object({})
+          schema: import_zod53.z.object({})
         }
       )
     ],
@@ -19759,7 +19935,7 @@ ${request.systemPrompt}` : topologyPrompt;
           status: doneSet.has(e.to) ? "done" : "pending"
         }));
         const doneCount = completedEdges.length;
-        return new import_messages4.ToolMessage({
+        return new import_messages3.ToolMessage({
           content: JSON.stringify(
             {
               currentAgentId,
@@ -19777,7 +19953,7 @@ ${request.systemPrompt}` : topologyPrompt;
       try {
         return await handler(request);
       } catch (error) {
-        if (error instanceof import_langgraph13.GraphInterrupt) {
+        if (error instanceof import_langgraph12.GraphInterrupt) {
           throw error;
         }
         throw error;
@@ -19824,7 +20000,7 @@ ${request.systemPrompt}` : topologyPrompt;
               ];
               return {
                 messages: [
-                  new import_messages4.AIMessage({
+                  new import_messages3.AIMessage({
                     content: [
                       `Task rejected: topology violation.`,
                       `Agent "${currentAgentId}" is not allowed to delegate to "${targetAgent}".`,
@@ -19966,13 +20142,13 @@ ${BASE_PROMPT2}` : BASE_PROMPT2;
           backend: filesystemBackend
         }),
         // Subagent middleware: Automatic conversation summarization
-        (0, import_langchain66.summarizationMiddleware)({
+        (0, import_langchain67.summarizationMiddleware)({
           model,
           trigger: { tokens: 17e4 },
           keep: { messages: 6 }
         }),
         // Subagent middleware: Anthropic prompt caching
-        (0, import_langchain66.anthropicPromptCachingMiddleware)({
+        (0, import_langchain67.anthropicPromptCachingMiddleware)({
           unsupportedModelBehavior: "ignore"
         }),
         // Subagent middleware: Patches tool calls
@@ -19985,23 +20161,23 @@ ${BASE_PROMPT2}` : BASE_PROMPT2;
       allowAsync: false
     }),
     // Automatically summarizes conversation history
-    (0, import_langchain66.summarizationMiddleware)({
+    (0, import_langchain67.summarizationMiddleware)({
       model,
       trigger: { tokens: 17e4 },
       keep: { messages: 6 }
     }),
     // Enables Anthropic prompt caching
-    (0, import_langchain66.anthropicPromptCachingMiddleware)({
+    (0, import_langchain67.anthropicPromptCachingMiddleware)({
       unsupportedModelBehavior: "ignore"
     }),
     // Patches tool calls
     createPatchToolCallsMiddleware()
   ];
   if (interruptOn) {
-    middleware.push((0, import_langchain66.humanInTheLoopMiddleware)({ interruptOn }));
+    middleware.push((0, import_langchain67.humanInTheLoopMiddleware)({ interruptOn }));
   }
   middleware.push(...customMiddleware);
-  return (0, import_langchain66.createAgent)({
+  return (0, import_langchain67.createAgent)({
     model,
     systemPrompt: finalSystemPrompt,
     tools,
@@ -20021,7 +20197,7 @@ var ProcessingAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool51) => tool51 !== void 0);
+    }).filter((tool52) => tool52 !== void 0);
     const subagents = await Promise.all(params.subAgents.map(async (sa) => {
       if (sa.client) {
         return {
@@ -20067,11 +20243,11 @@ var ProcessingAgentGraphBuilder = class {
 };
 
 // src/agent_lattice/builders/RemoteAgentGraphBuilder.ts
-var import_langgraph14 = require("@langchain/langgraph");
-var import_messages5 = require("@langchain/core/messages");
+var import_langgraph13 = require("@langchain/langgraph");
+var import_messages4 = require("@langchain/core/messages");
 
 // src/services/a2a-client.ts
-var import_uuid4 = require("uuid");
+var import_uuid5 = require("uuid");
 var A2ARemoteError = class extends Error {
   constructor(message, statusCode, body) {
     super(message);
@@ -20118,7 +20294,7 @@ var A2ARemoteClient = class {
    */
   async sendMessage(text) {
     await this.resolve();
-    const taskId = (0, import_uuid4.v4)();
+    const taskId = (0, import_uuid5.v4)();
     const body = JSON.stringify({
       jsonrpc: "2.0",
       method: "tasks/send",
@@ -20244,7 +20420,7 @@ var RemoteAgentGraphBuilder = class {
       if (!text) {
         return {
           messages: [
-            new import_messages5.AIMessage("No text input provided to remote agent.")
+            new import_messages4.AIMessage("No text input provided to remote agent.")
           ]
         };
       }
@@ -20255,18 +20431,18 @@ User request:
 ${text}` : text;
         const response = await client.sendMessage(fullPrompt);
         return {
-          messages: [new import_messages5.AIMessage(response)]
+          messages: [new import_messages4.AIMessage(response)]
         };
       } catch (error) {
         const msg = error.message ?? String(error);
         return {
           messages: [
-            new import_messages5.AIMessage(`Remote A2A agent error: ${msg}`)
+            new import_messages4.AIMessage(`Remote A2A agent error: ${msg}`)
           ]
         };
       }
     };
-    const workflow = new import_langgraph14.StateGraph(import_langgraph14.MessagesAnnotation).addNode("remote_call", remoteCallNode).addEdge("__start__", "remote_call").addEdge("remote_call", "__end__");
+    const workflow = new import_langgraph13.StateGraph(import_langgraph13.MessagesAnnotation).addNode("remote_call", remoteCallNode).addEdge("__start__", "remote_call").addEdge("remote_call", "__end__");
     return workflow.compile();
   }
 };
@@ -20288,7 +20464,7 @@ function extractLastHumanMessage(messages) {
 }
 
 // src/agent_lattice/builders/WorkflowAgentGraphBuilder.ts
-var import_langchain67 = require("langchain");
+var import_langchain68 = require("langchain");
 init_MemoryLatticeManager();
 var import_protocols10 = require("@axiom-lattice/protocols");
 init_compile();
@@ -20301,26 +20477,26 @@ var WorkflowAgentGraphBuilder = class {
       );
     }
     const config = agentLattice.config;
-    const dsl = config.workflow;
+    const yaml2 = config.workflowYaml;
     const tenantId = agentLattice.config.tenantId ?? "default";
     const checkpointer = getCheckpointSaver("default");
     const tools = params.tools.map((t) => t.executor).filter(Boolean);
     const middlewareConfigs = params.middleware || [];
     const middlewares = await createCommonMiddlewares(middlewareConfigs, void 0, false);
-    const humanMiddlewares = await createCommonMiddlewares([
+    const askMiddlewares = await createCommonMiddlewares([
       {
         id: "ask_user_to_clarify",
         type: "ask_user_to_clarify",
         name: "Ask User Clarify",
-        description: "For human_feedback workflow nodes",
+        description: "For workflow steps requiring user interaction",
         enabled: true,
         config: {}
       }
     ], void 0, false);
     const noWrapMiddlewares = middlewares.filter((m) => !m.wrapModelCall);
-    const noWrapHumanMiddlewares = humanMiddlewares.filter((m) => !m.wrapModelCall);
+    const noWrapAskMiddlewares = askMiddlewares.filter((m) => !m.wrapModelCall);
     console.log(`[WF BUILDER] building default agent | toolCount=${tools.length} | middlewareCount=${middlewares.length}`);
-    const defaultAgent = (0, import_langchain67.createAgent)({
+    const defaultAgent = (0, import_langchain68.createAgent)({
       model: params.model,
       tools,
       systemPrompt: params.prompt || DEFAULT_AGENT_PROMPT,
@@ -20334,34 +20510,34 @@ var WorkflowAgentGraphBuilder = class {
         console.log(`[WF BUILDER] resolveAgent: looking up ref="${ref}"`);
         return await getAgentClientAsync(tenantId, ref);
       }
-      const isHuman = stepType === "human_feedback";
+      const isAsk = stepType === "ask";
       if (responseFormat) {
-        const key = (isHuman ? "human:" : "agent:") + JSON.stringify(responseFormat);
+        const key = (isAsk ? "ask:" : "agent:") + JSON.stringify(responseFormat);
         console.log(`[WF BUILDER] resolveAgent: cacheKey=${key.slice(0, 80)}... | cached=${agentCache.has(key)}`);
         if (!agentCache.has(key)) {
-          console.log(`[WF BUILDER] creating ${isHuman ? "human" : "agent"} with responseFormat`);
-          const agent = (0, import_langchain67.createAgent)({
+          console.log(`[WF BUILDER] creating ${isAsk ? "ask" : "agent"} with responseFormat`);
+          const agent = (0, import_langchain68.createAgent)({
             model: params.model,
             tools,
             systemPrompt: params.prompt || DEFAULT_AGENT_PROMPT,
             checkpointer,
-            middleware: isHuman ? noWrapHumanMiddlewares : noWrapMiddlewares,
+            middleware: isAsk ? noWrapAskMiddlewares : noWrapMiddlewares,
             responseFormat
           });
           agentCache.set(key, agent);
         }
         return agentCache.get(key);
       }
-      if (isHuman) {
-        const key = "human:default";
+      if (isAsk) {
+        const key = "ask:default";
         if (!agentCache.has(key)) {
-          console.log(`[WF BUILDER] creating human_feedback default agent`);
-          const agent = (0, import_langchain67.createAgent)({
+          console.log(`[WF BUILDER] creating ask default agent`);
+          const agent = (0, import_langchain68.createAgent)({
             model: params.model,
             tools,
             systemPrompt: params.prompt || DEFAULT_AGENT_PROMPT,
             checkpointer,
-            middleware: humanMiddlewares
+            middleware: askMiddlewares
           });
           agentCache.set(key, agent);
         }
@@ -20374,11 +20550,11 @@ var WorkflowAgentGraphBuilder = class {
     try {
       const storeLattice = getStoreLattice("default", "workflowTracking");
       trackingStore = storeLattice.store;
-      console.log(`[WF BUILDER] trackingStore registered: step input/output will be persisted`);
+      console.log(`[WF BUILDER] trackingStore registered`);
     } catch {
-      console.warn(`[WF BUILDER] no trackingStore registered \u2014 step input/output will NOT be persisted. Register a WorkflowTrackingStore under key "workflowTracking".`);
+      console.warn(`[WF BUILDER] no trackingStore registered`);
     }
-    const graph = compileWorkflow(dsl, resolveAgent, checkpointer, trackingStore);
+    const graph = compileWorkflow(yaml2, resolveAgent, checkpointer, trackingStore);
     return graph;
   }
 };
@@ -21079,9 +21255,66 @@ ${body}` : `${frontmatter}
   }
 };
 
+// src/store_lattice/InMemoryMenuStore.ts
+var import_crypto3 = require("crypto");
+var InMemoryMenuStore = class {
+  constructor() {
+    this.items = /* @__PURE__ */ new Map();
+  }
+  async list(params) {
+    const results = Array.from(this.items.values()).filter((item) => {
+      if (item.tenantId !== params.tenantId) return false;
+      if (params.menuTarget && item.menuTarget !== params.menuTarget) return false;
+      if (!item.enabled) return false;
+      return true;
+    });
+    results.sort((a, b) => a.sortOrder - b.sortOrder);
+    return results;
+  }
+  async getById(id) {
+    return this.items.get(id) || null;
+  }
+  async create(input) {
+    const now = /* @__PURE__ */ new Date();
+    const item = {
+      id: (0, import_crypto3.randomUUID)(),
+      tenantId: input.tenantId,
+      menuTarget: input.menuTarget,
+      group: input.group,
+      name: input.name,
+      icon: input.icon,
+      sortOrder: input.sortOrder ?? 0,
+      contentType: input.contentType,
+      contentConfig: input.contentConfig,
+      enabled: true,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.items.set(item.id, item);
+    return item;
+  }
+  async update(id, patch) {
+    const existing = this.items.get(id);
+    if (!existing) throw new Error(`MenuItem ${id} not found`);
+    const updated = {
+      ...existing,
+      ...patch,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.items.set(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    this.items.delete(id);
+  }
+  clear() {
+    this.items.clear();
+  }
+};
+
 // src/agent_lattice/agentArchitectTools.ts
-var import_zod53 = __toESM(require("zod"));
-var import_uuid5 = require("uuid");
+var import_zod54 = __toESM(require("zod"));
+var import_uuid6 = require("uuid");
 var import_protocols12 = require("@axiom-lattice/protocols");
 function getTenantId(exeConfig) {
   const runConfig = exeConfig?.configurable?.runConfig || {};
@@ -21110,7 +21343,7 @@ registerToolLattice(
   {
     name: "list_agents",
     description: "List all agents for the current workspace. Returns a summary with id, name, description, and type for each agent.",
-    schema: import_zod53.default.object({})
+    schema: import_zod54.default.object({})
   },
   async (_input, exeConfig) => {
     try {
@@ -21137,8 +21370,8 @@ registerToolLattice(
   {
     name: "get_agent",
     description: "Get the full configuration of a specific agent by its ID. Returns the complete AgentConfig including prompt, middleware, tools, and sub-agents.",
-    schema: import_zod53.default.object({
-      id: import_zod53.default.string().describe("The agent ID to retrieve")
+    schema: import_zod54.default.object({
+      id: import_zod54.default.string().describe("The agent ID to retrieve")
     })
   },
   async (input, exeConfig) => {
@@ -21155,24 +21388,24 @@ registerToolLattice(
     }
   }
 );
-var middlewareConfigSchema = import_zod53.default.object({
-  id: import_zod53.default.string(),
-  type: import_zod53.default.string(),
-  name: import_zod53.default.string(),
-  description: import_zod53.default.string(),
-  enabled: import_zod53.default.boolean(),
-  config: import_zod53.default.record(import_zod53.default.any()).optional()
+var middlewareConfigSchema = import_zod54.default.object({
+  id: import_zod54.default.string(),
+  type: import_zod54.default.string(),
+  name: import_zod54.default.string(),
+  description: import_zod54.default.string(),
+  enabled: import_zod54.default.boolean(),
+  config: import_zod54.default.record(import_zod54.default.any()).optional()
 });
-var createAgentSchema = import_zod53.default.object({
-  name: import_zod53.default.string().describe("Human-friendly display name for the agent. The machine ID (used in other tools) is auto-generated as a slug from this name (e.g. 'My Cool Agent' \u2192 'my-cool-agent')."),
-  description: import_zod53.default.string().optional().describe("Short description"),
-  type: import_zod53.default.enum(["react", "deep_agent"]).describe("Agent type. Use 'react' for simple single-responsibility agents, 'deep_agent' for complex open-ended agents. For PROCESSING agents (workflow orchestration), use create_processing_agent instead."),
-  prompt: import_zod53.default.string().describe("System prompt for the agent"),
-  tools: import_zod53.default.array(import_zod53.default.string()).optional().describe("Tool keys (strings) to assign. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array of tool names. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
-  middleware: import_zod53.default.array(middlewareConfigSchema).optional().describe("Middleware configuration objects. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here \u2014 tool names go in the separate 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
-  subAgents: import_zod53.default.array(import_zod53.default.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
-  internalSubAgents: import_zod53.default.array(import_zod53.default.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
-  modelKey: import_zod53.default.string().optional().describe("Model key to use")
+var createAgentSchema = import_zod54.default.object({
+  name: import_zod54.default.string().describe("Human-friendly display name for the agent. The machine ID (used in other tools) is auto-generated as a slug from this name (e.g. 'My Cool Agent' \u2192 'my-cool-agent')."),
+  description: import_zod54.default.string().optional().describe("Short description"),
+  type: import_zod54.default.enum(["react", "deep_agent"]).describe("Agent type. Use 'react' for simple single-responsibility agents, 'deep_agent' for complex open-ended agents. For PROCESSING agents (workflow orchestration), use create_processing_agent instead."),
+  prompt: import_zod54.default.string().describe("System prompt for the agent"),
+  tools: import_zod54.default.array(import_zod54.default.string()).optional().describe("Tool keys (strings) to assign. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array of tool names. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
+  middleware: import_zod54.default.array(middlewareConfigSchema).optional().describe("Middleware configuration objects. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here \u2014 tool names go in the separate 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  subAgents: import_zod54.default.array(import_zod54.default.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+  internalSubAgents: import_zod54.default.array(import_zod54.default.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+  modelKey: import_zod54.default.string().optional().describe("Model key to use")
 });
 registerToolLattice(
   "create_agent",
@@ -21210,21 +21443,21 @@ registerToolLattice(
     }
   }
 );
-var topologyEdgeSchema = import_zod53.default.object({
-  from: import_zod53.default.string().describe("Source agent ID. For the first edge, this is the orchestrator (use the orchestrator's name as a placeholder \u2014 the tool will replace it with the actual ID). For subsequent chained edges, this is the previous stage's sub-agent ID."),
-  to: import_zod53.default.string().describe("Target agent ID (the sub-agent to delegate to)"),
-  purpose: import_zod53.default.string().describe("Business purpose of this delegation step \u2014 what the sub-agent should accomplish")
+var topologyEdgeSchema = import_zod54.default.object({
+  from: import_zod54.default.string().describe("Source agent ID. For the first edge, this is the orchestrator (use the orchestrator's name as a placeholder \u2014 the tool will replace it with the actual ID). For subsequent chained edges, this is the previous stage's sub-agent ID."),
+  to: import_zod54.default.string().describe("Target agent ID (the sub-agent to delegate to)"),
+  purpose: import_zod54.default.string().describe("Business purpose of this delegation step \u2014 what the sub-agent should accomplish")
 });
-var createProcessingAgentSchema = import_zod53.default.object({
-  name: import_zod53.default.string().describe("Display name for the processing agent"),
-  description: import_zod53.default.string().optional().describe("Short description"),
-  prompt: import_zod53.default.string().describe("System prompt for the orchestrator. Should describe how to route tasks through the topology."),
-  edges: import_zod53.default.array(topologyEdgeSchema).min(1).describe("Topology edges defining the workflow. Each edge describes a delegation step with its business purpose. The orchestrator will follow this topology to delegate tasks to sub-agents."),
-  tools: import_zod53.default.array(import_zod53.default.string()).optional().describe("Tool keys (strings) to assign to the orchestrator. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
-  subAgents: import_zod53.default.array(import_zod53.default.string()).describe("IDs of sub-agents that form the workflow pipeline. These must be created first via create_agent."),
-  internalSubAgents: import_zod53.default.array(import_zod53.default.any()).optional().describe("Inline sub-agent configs (alternative to pre-created sub-agents)"),
-  middleware: import_zod53.default.array(middlewareConfigSchema).optional().describe("Additional middleware config objects beyond the auto-managed topology middleware. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
-  modelKey: import_zod53.default.string().optional().describe("Model key to use")
+var createProcessingAgentSchema = import_zod54.default.object({
+  name: import_zod54.default.string().describe("Display name for the processing agent"),
+  description: import_zod54.default.string().optional().describe("Short description"),
+  prompt: import_zod54.default.string().describe("System prompt for the orchestrator. Should describe how to route tasks through the topology."),
+  edges: import_zod54.default.array(topologyEdgeSchema).min(1).describe("Topology edges defining the workflow. Each edge describes a delegation step with its business purpose. The orchestrator will follow this topology to delegate tasks to sub-agents."),
+  tools: import_zod54.default.array(import_zod54.default.string()).optional().describe("Tool keys (strings) to assign to the orchestrator. Call list_tools first to see available keys. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array. Do NOT put middleware-like objects here \u2014 middleware goes in the separate 'middleware' field."),
+  subAgents: import_zod54.default.array(import_zod54.default.string()).describe("IDs of sub-agents that form the workflow pipeline. These must be created first via create_agent."),
+  internalSubAgents: import_zod54.default.array(import_zod54.default.any()).optional().describe("Inline sub-agent configs (alternative to pre-created sub-agents)"),
+  middleware: import_zod54.default.array(middlewareConfigSchema).optional().describe("Additional middleware config objects beyond the auto-managed topology middleware. Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  modelKey: import_zod54.default.string().optional().describe("Model key to use")
 }).refine(
   (data) => {
     const edgeTargets = new Set(data.edges.map((e) => e.to));
@@ -21250,11 +21483,11 @@ registerToolLattice(
       const tenantId = getTenantId(exeConfig);
       const store = getAssistStore();
       const id = await generateAgentId(tenantId, input.name);
-      const normalize = (s) => s.toLowerCase().replace(/[_\-\s]/g, "");
+      const normalize2 = (s) => s.toLowerCase().replace(/[_\-\s]/g, "");
       const resolveFrom = (rawFrom) => {
         const fromLower = rawFrom.toLowerCase();
         const nameLower = input.name.toLowerCase();
-        if (fromLower === nameLower || fromLower === "orchestrator" || fromLower === "orchestrator-id" || normalize(rawFrom) === normalize(input.name)) {
+        if (fromLower === nameLower || fromLower === "orchestrator" || fromLower === "orchestrator-id" || normalize2(rawFrom) === normalize2(input.name)) {
           return id;
         }
         return rawFrom;
@@ -21306,34 +21539,20 @@ 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")
+var createWorkflowSchema = import_zod54.default.object({
+  name: import_zod54.default.string().describe("Display name for the workflow agent"),
+  description: import_zod54.default.string().optional().describe("Short description"),
+  skillLoaded: import_zod54.default.literal(true).describe("MUST be true. Set after loading the 'create-workflow' skill."),
+  yaml: import_zod54.default.string().describe("The YAML workflow definition in linear DSL format (steps execute top-to-bottom, use parallel: for concurrency)"),
+  tools: import_zod54.default.array(import_zod54.default.string()).optional().describe("Tool keys for the workflow agent"),
+  middleware: import_zod54.default.array(middlewareConfigSchema).optional().describe("Middleware configs"),
+  modelKey: import_zod54.default.string().optional().describe("Model key")
 });
 registerToolLattice(
   "create_workflow",
   {
     name: "create_workflow",
-    description: `Create a WORKFLOW agent from a concise DSL. IMPORTANT: Load the 'create-workflow' skill first, then set skillLoaded=true. Steps are defined in order \u2014 the engine auto-generates edges and state fields. Types: agent(id?, name?, prompt, schema), human(prompt, title?, schema?), condition(if, then, else?  OR  if, branches with 'default' catch-all), map(source, each, reduce?), parallel(steps), end. Use {{id}} to reference step outputs, {{input}} for user message, {{item}} in map each prompts. Always end with { type: 'end' }. CRITICAL: schema MUST be standard JSON Schema: { "type": "object", "properties": { ... } }. Legacy shorthand { "field": "string" } is REJECTED.`,
+    description: "Create a WORKFLOW agent from YAML DSL. Load the 'create-workflow' skill first. Linear model \u2014 steps execute top-to-bottom. Use parallel: for concurrency. Data flows via {{label}} automatically. Business logic stays in agent prompts.",
     schema: createWorkflowSchema
   },
   async (input, exeConfig) => {
@@ -21341,36 +21560,31 @@ registerToolLattice(
       const tenantId = getTenantId(exeConfig);
       const store = getAssistStore();
       const id = await generateAgentId(tenantId, input.name);
+      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.yaml, async () => ({ invoke: async () => ({}) }), getCheckpointSaver2("default"));
+      } catch (e) {
+        return JSON.stringify({ error: `DSL validation failed: ${e.message}` });
+      }
       const config = {
         key: id,
         name: input.name,
         description: input.description || "",
         type: import_protocols12.AgentType.WORKFLOW,
         prompt: input.description || `Workflow: ${input.name}`,
-        workflow: input.workflow,
+        workflowYaml: input.yaml,
         ...input.tools && input.tools.length > 0 ? { tools: input.tools } : {},
         ...input.middleware && input.middleware.length > 0 ? { middleware: input.middleware } : {},
         ...input.modelKey ? { modelKey: input.modelKey } : {}
       };
-      try {
-        const { compileWorkflow: compileWorkflow2 } = await 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
-      });
+      return JSON.stringify({ id, name: input.name, type: "workflow" });
     } catch (error) {
       return JSON.stringify({ error: `Failed to create workflow: ${error.message}` });
     }
@@ -21380,9 +21594,9 @@ registerToolLattice(
   "validate_workflow",
   {
     name: "validate_workflow",
-    description: "Validate a workflow agent's DSL for correctness by compiling it. Returns errors if the DSL is invalid. Use after create_workflow or update_workflow to verify.",
-    schema: import_zod53.default.object({
-      id: import_zod53.default.string().describe("The workflow agent ID to validate")
+    description: "Validate a workflow agent's DSL for correctness by compiling it.",
+    schema: import_zod54.default.object({
+      id: import_zod54.default.string().describe("The workflow agent ID to validate")
     })
   },
   async (input, exeConfig) => {
@@ -21395,76 +21609,76 @@ registerToolLattice(
       }
       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"})` });
+        return JSON.stringify({ error: `Agent '${input.id}' is not a workflow agent` });
       }
-      const workflow = graphDef.workflow;
-      if (!workflow || !workflow.steps) {
-        return JSON.stringify({ error: `Agent '${input.id}' has no valid workflow DSL` });
+      const yaml2 = graphDef.workflowYaml;
+      if (!yaml2) {
+        return JSON.stringify({ error: `Agent '${input.id}' has no 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"));
+        await compileWorkflow2(yaml2, async () => ({ invoke: async () => ({}) }), getCheckpointSaver2("default"));
       } catch (e) {
         return JSON.stringify({
           agentId: input.id,
           valid: false,
-          stepCount: workflow.steps?.length ?? 0,
           issues: [{ type: "error", message: e.message }]
         });
       }
-      return JSON.stringify({
-        agentId: input.id,
-        valid: true,
-        stepCount: workflow.steps?.length ?? 0,
-        issues: []
-      });
+      return JSON.stringify({ agentId: input.id, valid: true, issues: [] });
     } catch (error) {
       return JSON.stringify({ error: `Failed to validate workflow: ${error.message}` });
     }
   }
 );
-var updateWorkflowSchema = 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")
+var updateWorkflowSchema = import_zod54.default.object({
+  id: import_zod54.default.string().describe("The workflow agent ID to update"),
+  name: import_zod54.default.string().optional().describe("New display name"),
+  description: import_zod54.default.string().optional().describe("New description"),
+  yaml: import_zod54.default.string().optional().describe("Replacement YAML workflow DSL. Omit to keep existing."),
+  tools: import_zod54.default.array(import_zod54.default.string()).optional().describe("Replacement tool keys"),
+  middleware: import_zod54.default.array(middlewareConfigSchema).optional().describe("Replacement middleware configs"),
+  modelKey: import_zod54.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.",
+    description: "Update an existing workflow agent. Provide the agent ID and only the fields to change. Pass yaml string to replace the DSL, or omit to keep it.",
     schema: updateWorkflowSchema
   },
   async (input, exeConfig) => {
+    console.log(`[update_workflow] CALLED id=${input.id} hasYaml=${input.yaml !== void 0}`);
     try {
       const tenantId = getTenantId(exeConfig);
       const store = getAssistStore();
       const existing = await store.getAssistantById(tenantId, input.id);
       if (!existing) {
+        console.log(`[update_workflow] ERROR: agent not found: ${input.id}`);
         return JSON.stringify({ error: `Agent '${input.id}' not found` });
       }
       const existingConfig = existing.graphDefinition || {};
       if (existingConfig.type !== import_protocols12.AgentType.WORKFLOW) {
+        console.log(`[update_workflow] ERROR: not a workflow agent: ${input.id}`);
         return JSON.stringify({ error: `Agent '${input.id}' is not a workflow agent` });
       }
       const mergedConfig = { ...existingConfig };
       if (input.name !== void 0) mergedConfig.name = input.name;
       if (input.description !== void 0) mergedConfig.description = input.description;
-      if (input.workflow !== void 0) mergedConfig.workflow = input.workflow;
+      if (input.yaml !== void 0) mergedConfig.workflowYaml = input.yaml;
       if (input.tools !== void 0) mergedConfig.tools = input.tools;
       if (input.middleware !== void 0) mergedConfig.middleware = input.middleware;
       if (input.modelKey !== void 0) mergedConfig.modelKey = input.modelKey;
-      if (input.workflow !== void 0) {
+      if (input.yaml !== void 0) {
+        console.log(`[update_workflow] validating DSL: ${input.id}`);
         try {
           const { compileWorkflow: compileWorkflow2 } = await 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"));
+          await compileWorkflow2(input.yaml, async () => ({ invoke: async () => ({}) }), getCheckpointSaver2("default"));
+          console.log(`[update_workflow] DSL validation passed: ${input.id}`);
         } catch (e) {
+          console.log(`[update_workflow] DSL validation FAILED: ${input.id} - ${e.message}`);
           return JSON.stringify({
             error: `DSL validation failed: ${e.message}`,
             issues: [{ type: "error", message: e.message }]
@@ -21478,28 +21692,24 @@ registerToolLattice(
         graphDefinition: mergedConfig
       });
       eventBus.publish("assistant:updated", { id: input.id, name: newName, tenantId });
-      const workflow = mergedConfig.workflow;
-      return JSON.stringify({
-        id: input.id,
-        name: newName,
-        type: "workflow",
-        stepCount: workflow?.steps?.length ?? 0
-      });
+      console.log(`[update_workflow] SUCCESS: id=${input.id} name=${newName}`);
+      return JSON.stringify({ id: input.id, name: newName, type: "workflow" });
     } catch (error) {
+      console.log(`[update_workflow] EXCEPTION: ${error.message}`);
       return JSON.stringify({ error: `Failed to update workflow: ${error.message}` });
     }
   }
 );
-var updateProcessingAgentSchema = 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"),
-  description: import_zod53.default.string().optional().describe("New short description"),
-  prompt: import_zod53.default.string().optional().describe("New system prompt for the orchestrator"),
-  edges: import_zod53.default.array(topologyEdgeSchema).min(1).optional().describe("New topology edges. First edge's from must reference the orchestrator by name (the tool replaces it). Subsequent edges chain from previous sub-agent IDs."),
-  tools: import_zod53.default.array(import_zod53.default.string()).optional().describe("Tool keys (strings) to assign to the orchestrator. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array \u2014 do NOT put middleware-like objects here."),
-  subAgents: import_zod53.default.array(import_zod53.default.string()).optional().describe("New IDs of sub-agents in the workflow pipeline"),
-  middleware: import_zod53.default.array(middlewareConfigSchema).optional().describe("Additional middleware config objects (topology middleware is auto-managed, do not include it). Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
-  modelKey: import_zod53.default.string().optional().describe("New model key")
+var updateProcessingAgentSchema = import_zod54.default.object({
+  id: import_zod54.default.string().describe("The PROCESSING agent ID to update"),
+  name: import_zod54.default.string().optional().describe("New display name for the orchestrator"),
+  description: import_zod54.default.string().optional().describe("New short description"),
+  prompt: import_zod54.default.string().optional().describe("New system prompt for the orchestrator"),
+  edges: import_zod54.default.array(topologyEdgeSchema).min(1).optional().describe("New topology edges. First edge's from must reference the orchestrator by name (the tool replaces it). Subsequent edges chain from previous sub-agent IDs."),
+  tools: import_zod54.default.array(import_zod54.default.string()).optional().describe("Tool keys (strings) to assign to the orchestrator. Each element is a plain string like 'sap_api_search'. IMPORTANT: tools is a FLAT string array \u2014 do NOT put middleware-like objects here."),
+  subAgents: import_zod54.default.array(import_zod54.default.string()).optional().describe("New IDs of sub-agents in the workflow pipeline"),
+  middleware: import_zod54.default.array(middlewareConfigSchema).optional().describe("Additional middleware config objects (topology middleware is auto-managed, do not include it). Each has {id, type, name, description, enabled, config}. IMPORTANT: middleware objects are NOT tools. Do NOT put tool keys (strings) here. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+  modelKey: import_zod54.default.string().optional().describe("New model key")
 }).refine(
   (data) => {
     if (!data.edges) return true;
@@ -21534,12 +21744,12 @@ registerToolLattice(
       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, "");
+      const normalize2 = (s) => s.toLowerCase().replace(/[_\-\s]/g, "");
       const orchestratorName = input.name || existingConfig.name || existing.name || "";
       const resolveFrom = (rawFrom) => {
         const fromLower = rawFrom.toLowerCase();
         const nameLower = orchestratorName.toLowerCase();
-        if (fromLower === nameLower || fromLower === "orchestrator" || fromLower === "orchestrator-id" || normalize(rawFrom) === normalize(orchestratorName)) {
+        if (fromLower === nameLower || fromLower === "orchestrator" || fromLower === "orchestrator-id" || normalize2(rawFrom) === normalize2(orchestratorName)) {
           return input.id;
         }
         return rawFrom;
@@ -21627,18 +21837,18 @@ registerToolLattice(
     }
   }
 );
-var updateAgentSchema = import_zod53.default.object({
-  id: import_zod53.default.string().describe("The agent ID to update"),
-  config: import_zod53.default.object({
-    name: import_zod53.default.string().optional().describe("New display name for the agent"),
-    description: import_zod53.default.string().optional().describe("New short description"),
-    type: import_zod53.default.enum(["react", "deep_agent"]).optional().describe("Agent type"),
-    prompt: import_zod53.default.string().optional().describe("New system prompt for the agent"),
-    tools: import_zod53.default.array(import_zod53.default.string()).optional().describe("Tool keys to assign to this agent. These are registered tool names (strings), NOT middleware objects."),
-    middleware: import_zod53.default.array(middlewareConfigSchema).optional().describe("Middleware configurations. NOTE: middleware objects have type/name/description/enabled/config fields and are NOT the same as tools. Tool keys go in the 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
-    subAgents: import_zod53.default.array(import_zod53.default.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
-    internalSubAgents: import_zod53.default.array(import_zod53.default.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
-    modelKey: import_zod53.default.string().optional().describe("Model key to use")
+var updateAgentSchema = import_zod54.default.object({
+  id: import_zod54.default.string().describe("The agent ID to update"),
+  config: import_zod54.default.object({
+    name: import_zod54.default.string().optional().describe("New display name for the agent"),
+    description: import_zod54.default.string().optional().describe("New short description"),
+    type: import_zod54.default.enum(["react", "deep_agent"]).optional().describe("Agent type"),
+    prompt: import_zod54.default.string().optional().describe("New system prompt for the agent"),
+    tools: import_zod54.default.array(import_zod54.default.string()).optional().describe("Tool keys to assign to this agent. These are registered tool names (strings), NOT middleware objects."),
+    middleware: import_zod54.default.array(middlewareConfigSchema).optional().describe("Middleware configurations. NOTE: middleware objects have type/name/description/enabled/config fields and are NOT the same as tools. Tool keys go in the 'tools' array. For user approval/confirmation scenarios, use type: 'ask_user_to_clarify' with config: {}."),
+    subAgents: import_zod54.default.array(import_zod54.default.string()).optional().describe("Sub-agent IDs (deep_agent only)"),
+    internalSubAgents: import_zod54.default.array(import_zod54.default.any()).optional().describe("Inline sub-agent configs (deep_agent only)"),
+    modelKey: import_zod54.default.string().optional().describe("Model key to use")
   }).describe("Configuration fields to update. Only include the fields you want to change.")
 });
 registerToolLattice(
@@ -21676,8 +21886,8 @@ registerToolLattice(
   {
     name: "delete_agent",
     description: "Permanently delete an agent by its ID. This action cannot be undone.",
-    schema: import_zod53.default.object({
-      id: import_zod53.default.string().describe("The agent ID to delete")
+    schema: import_zod54.default.object({
+      id: import_zod54.default.string().describe("The agent ID to delete")
     })
   },
   async (input, exeConfig) => {
@@ -21703,7 +21913,7 @@ registerToolLattice(
   {
     name: "list_tools",
     description: "List all available tools that can be assigned to agents. Returns each tool's name (use this string value in the 'tools' array), description, and whether it requires user approval. The tool names from this list are what you pass as strings in the 'tools' field of create_agent or update_agent.",
-    schema: import_zod53.default.object({})
+    schema: import_zod54.default.object({})
   },
   async (_input, _exeConfig) => {
     try {
@@ -21725,9 +21935,9 @@ registerToolLattice(
   {
     name: "invoke_agent",
     description: "Invoke an agent with a test message and return its response. Use this to verify an agent works correctly after creating or modifying it. The agent must be compiled (already created and valid).",
-    schema: import_zod53.default.object({
-      id: import_zod53.default.string().describe("The agent ID to invoke"),
-      message: import_zod53.default.string().describe("The test message to send to the agent")
+    schema: import_zod54.default.object({
+      id: import_zod54.default.string().describe("The agent ID to invoke"),
+      message: import_zod54.default.string().describe("The test message to send to the agent")
     })
   },
   async (input, exeConfig) => {
@@ -21739,13 +21949,13 @@ registerToolLattice(
       if (!existing) {
         return JSON.stringify({ error: `Agent '${id}' not found` });
       }
-      const threadId = (0, import_uuid5.v4)();
+      const threadId = (0, import_uuid6.v4)();
       const agent = new Agent({
         tenant_id: tenantId,
         assistant_id: id,
         thread_id: threadId
       });
-      const result = await agent.invoke({ input: { message } });
+      const result = await agent.invokeWithState({ input: { message } });
       return JSON.stringify({ agentId: id, threadId, result });
     } catch (error) {
       console.error(`[invoke_agent] FAILED for agent="${input.id}":`, error.stack || error.message);
@@ -21840,7 +22050,7 @@ Let the \`show_widget\` tool handle rendering details \u2014 it has its own guid
 | Type | Best for | Execution Model |
 |------|----------|----------------|
 | **react** | Simple, single-responsibility tasks | Classic ReAct loop (think \u2192 act \u2192 observe) |
-| **workflow** | Deterministic multi-step pipelines with branching, parallel, and human-in-the-loop | Concise DSL compiled into LangGraph state machine |
+| **workflow** | Deterministic multi-step pipelines with branching, parallel, and human-in-the-loop | YAML linear DSL compiled into LangGraph state machine |
 | **deep_agent** | Complex, open-ended tasks requiring dynamic decomposition | Self-generating dynamic todos: agent analyzes the task and creates its own execution plan at runtime |
 
 When a user is unsure which type to choose, use \`show_widget\` to render a visual comparison \u2014 show each type's execution model side-by-side as an interactive diagram so the user can intuitively understand the differences.
@@ -21894,7 +22104,7 @@ Use this when the process is fully known. A workflow is a deterministic LangGrap
 |---|---|
 | Fixed graph \u2014 all paths pre-defined | LLM-driven runtime routing |
 | Conditional branching via \`if\` field | Topology-constrained delegation |
-| human, map, parallel, condition | Single orchestrator delegates linearly |
+| needs + if model (YAML DSL) | Single orchestrator delegates linearly |
 | No LLM routing decisions | Orchestrator uses LLM to route |
 
 ### Phase 0: Load the Skill
@@ -21908,20 +22118,23 @@ skill(skill_name: "create-workflow")
 ### Phase 1: Design
 
 1. **Analyze the process.** Map every step, branch, data dependency.
-2. **Choose step types:**
-    - \`agent\` \u2014 runs on the workflow's built-in agent. Output at \`state.<id>\`.
-    - \`human\` \u2014 pauses for human input (built-in clarify middleware). Has \`prompt\`, \`title\`, \`schema\`.
-    - \`condition\` \u2014 branches on \`if\` (field or expression). Has \`then\`/\`else\` or \`branches\` (switch with \`default\`).
-   - \`map\` \u2014 iterates array from \`source\`, applies \`each\`, optionally \`reduce\`.
-   - \`parallel\` \u2014 runs \`steps\` simultaneously, then rejoins.
-   - \`end\` \u2014 terminates. Always required at end.
-3. **Write prompts** with \`{{id}}\` refs. \`{{input}}\` = user message. \`{{item}}\` = map element.
-4. **No edges or state fields needed** \u2014 the engine auto-generates them.
+2. **Design using the YAML linear DSL.** Every step is an agent with optional attributes:
+    - **Linear** \u2014 steps execute top-to-bottom in written order.
+    - \`parallel:\` \u2014 wraps agent steps that run concurrently.
+    - \`if\` \u2014 JS expression for conditional execution. Step runs only when truthy. Omit to always run.
+    - \`prompt\` \u2014 agent instruction with \`{{label}}\` refs. \`{{input}}\` = user message.
+    - \`output\` \u2014 shorthand schema: \`{ field: type }\`.
+    - \`ask: true\` \u2014 injects ask_user_to_clarify middleware for human interaction.
+3. **Special step types:**
+    - \`map\` \u2014 iterates array from \`source\`, applies \`each\` step per item.
+4. **No edges, state fields, or end step needed** \u2014 the engine auto-generates them.
+5. **Schema format:** Use block-style YAML shorthand \`{ field: type }\`. Supported types: \`string\`, \`number\`, \`boolean\`, \`string[]\`, \`number[]\`, \`boolean[]\`, nested objects, object arrays.
 
 ### Phase 2: Confirm
 
 Present the design. Ask: "Ready to create this workflow?"
 
+
 ### Phase 3: Build
 
 Call \`create_workflow\` with \`skillLoaded: true\`. Then \`validate_workflow(id)\`.
@@ -22016,20 +22229,17 @@ All fields except name, type, and prompt are optional.
 
 ### create_workflow (WORKFLOW)
 
-Creates a WORKFLOW agent from a concise DSL. Before calling, load the \`create-workflow\` skill for the complete DSL specification. Must pass \`skillLoaded: true\`.
+Creates a WORKFLOW agent from a YAML linear DSL. Before calling, load the \`create-workflow\` skill. Must pass \`skillLoaded: true\`.
 
 \`\`\`typescript
 {
   name: string,              // Required. Display name
-  description?: string,      // Optional. Short description
-  skillLoaded: true,         // Required. Must be true \u2014 confirms skill was loaded
-  workflow: {                // Required. Concise DSL definition
-    name: string,            // Workflow slug identifier
-    steps: WorkflowStep[],   // agent | human | condition | map | parallel | end
-  },
-  tools?: string[],          // Optional. Tool keys for the built-in general agent
-  middleware?: MiddlewareConfig[],  // Optional. Middleware for the general agent
-  modelKey?: string,         // Optional. Model for the general agent
+  description?: string,      // Optional
+  skillLoaded: true,         // Required \u2014 confirms skill was loaded
+  yaml: string,              // Required. YAML workflow in linear DSL format
+  tools?: string[],          // Optional. Tool keys
+  middleware?: MiddlewareConfig[],  // Optional
+  modelKey?: string,         // Optional
 }
 \`\`\`
 
@@ -22042,7 +22252,7 @@ Updates an existing WORKFLOW agent. Only include fields you want to change.
   id: string,                // Required. Workflow agent ID
   name?: string,             // Optional
   description?: string,      // Optional
-  workflow?: { name: string, steps: WorkflowStep[] },  // Optional. Replacement DSL
+  yaml?: string,             // Optional. Replacement YAML DSL
   tools?: string[],          // Optional
   middleware?: MiddlewareConfig[],  // Optional
   modelKey?: string,         // Optional
@@ -22262,10 +22472,13 @@ You are an **Agent Reviewer** \u2014 a quality assurance specialist for AI agent
 2. Craft a realistic test message that exercises the agent's core responsibility \u2014 what would a real user say?
 3. Call **invoke_agent(id, message)** to send the test message
 4. Analyze the response:
-   - Did the agent understand the request?
-   - Was the response relevant and accurate?
-   - Did the agent use the right tools?
-   - Were there any errors or unexpected behaviors?
+   - **If result.__interrupt__ is present** (an array of interrupt objects): The agent hit a human-in-the-loop interrupt (e.g., ask_user_to_clarify or interrupt() in a workflow). This is NOT an error \u2014 it means the agent paused execution waiting for user feedback. Each interrupt has a value (the question/request) and optionally an id. Report this as: "The agent successfully paused and is waiting for user input: <describe the interrupt value>." The messages array may contain the agent's output up to the point of interruption.
+   - **Otherwise, result.messages contains the agent's output**: The agent completed without interruption. Check:
+     - Did the agent understand the request?
+     - Was the response relevant and accurate?
+     - Did the agent use the right tools?
+     - Were there any errors or unexpected behaviors?
+   - **If result.error is present**: The invocation itself failed (agent not found, compilation error, etc.). Report the error clearly.
 5. Report your findings with the agent's actual response
 
 ### When results are wrong:
@@ -22362,7 +22575,8 @@ function ensureBuiltinAgentsForTenant(tenantId) {
 
 // src/agent_lattice/AgentLatticeManager.ts
 function assistantToConfig(assistant) {
-  const graphDef = typeof assistant.graphDefinition === "object" && assistant.graphDefinition !== null ? assistant.graphDefinition : {};
+  const graphDef = typeof assistant.graphDefinition === "object" && assistant.graphDefinition !== null ? { ...assistant.graphDefinition } : {};
+  delete graphDef.key;
   const config = {
     key: assistant.id,
     name: assistant.name ?? graphDef.name ?? assistant.id,
@@ -22370,9 +22584,7 @@ function assistantToConfig(assistant) {
     type: import_protocols.AgentType.REACT,
     prompt: typeof assistant.graphDefinition === "string" ? assistant.graphDefinition : JSON.stringify(assistant.graphDefinition)
   };
-  if (graphDef) {
-    Object.assign(config, graphDef);
-  }
+  Object.assign(config, graphDef);
   return config;
 }
 var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager {
@@ -23771,10 +23983,10 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     }
     const tools = await this.getAllTools();
     console.log(`[MCP] Registering ${tools.length} tools to Tool Lattice...`);
-    for (const tool51 of tools) {
-      const toolKey = prefix ? `${prefix}_${tool51.name}` : tool51.name;
-      tool51.name = toolKey;
-      toolLatticeManager.registerExistingTool(toolKey, tool51);
+    for (const tool52 of tools) {
+      const toolKey = prefix ? `${prefix}_${tool52.name}` : tool52.name;
+      tool52.name = toolKey;
+      toolLatticeManager.registerExistingTool(toolKey, tool52);
       console.log(`[MCP] Registered tool: ${toolKey}`);
     }
     console.log(`[MCP] Successfully registered ${tools.length} tools to Tool Lattice`);
@@ -25070,11 +25282,47 @@ function createSandboxProvider(config) {
   }
 }
 
+// src/channel/connectAllChannels.ts
+async function connectAllChannels(getAdapter, options = {}) {
+  const store = getStoreLattice("default", "channelInstallation").store;
+  const installations = await store.getAllInstallations();
+  console.log(`[connectAllChannels] total=${installations.length} enabled=${installations.filter((i) => i.enabled).length}`);
+  for (const inst of installations) {
+    if (!inst.enabled) {
+      console.log(`[connectAllChannels] skip disabled: channel=${inst.channel} tenant=${inst.tenantId} id=${inst.id}`);
+      continue;
+    }
+    const adapter = getAdapter(inst.channel);
+    if (!adapter) {
+      console.log(`[connectAllChannels] no adapter: channel=${inst.channel} id=${inst.id}`);
+      continue;
+    }
+    if (adapter.connect) {
+      console.log(`[connectAllChannels] connecting: channel=${inst.channel} tenant=${inst.tenantId} id=${inst.id}`);
+      await adapter.connect(inst, options.deps);
+    } else {
+      console.log(`[connectAllChannels] no connect(): channel=${inst.channel} id=${inst.id}`);
+    }
+  }
+}
+
+// src/menu_lattice/MenuRegistryHolder.ts
+var registry2 = null;
+function setMenuRegistry(r) {
+  registry2 = r;
+}
+function getMenuRegistry() {
+  if (!registry2) {
+    throw new Error("MenuRegistry not initialized. Call setMenuRegistry() before use.");
+  }
+  return registry2;
+}
+
 // src/index.ts
 var Protocols = __toESM(require("@axiom-lattice/protocols"));
 
 // src/util/encryption.ts
-var import_crypto3 = require("crypto");
+var import_crypto4 = require("crypto");
 var ALGORITHM = "aes-256-gcm";
 var IV_LENGTH = 16;
 var SALT_LENGTH = 32;
@@ -25087,7 +25335,7 @@ function getEncryptionKey() {
     return cachedKey;
   }
   const key = process.env.LATTICE_ENCRYPTION_KEY || DEFAULT_ENCRYPTION_KEY;
-  cachedKey = (0, import_crypto3.pbkdf2Sync)(key, "lattice-encryption-salt", ITERATIONS, 32, "sha256");
+  cachedKey = (0, import_crypto4.pbkdf2Sync)(key, "lattice-encryption-salt", ITERATIONS, 32, "sha256");
   if (!keyValidated) {
     keyValidated = true;
     validateEncryptionKey();
@@ -25096,10 +25344,10 @@ function getEncryptionKey() {
 }
 function encrypt(plaintext, key) {
   const actualKey = key || getEncryptionKey();
-  const salt = (0, import_crypto3.randomBytes)(SALT_LENGTH);
-  const iv = (0, import_crypto3.randomBytes)(IV_LENGTH);
-  const derivedKey = (0, import_crypto3.pbkdf2Sync)(actualKey, salt, ITERATIONS, 32, "sha256");
-  const cipher = (0, import_crypto3.createCipheriv)(ALGORITHM, derivedKey, iv);
+  const salt = (0, import_crypto4.randomBytes)(SALT_LENGTH);
+  const iv = (0, import_crypto4.randomBytes)(IV_LENGTH);
+  const derivedKey = (0, import_crypto4.pbkdf2Sync)(actualKey, salt, ITERATIONS, 32, "sha256");
+  const cipher = (0, import_crypto4.createCipheriv)(ALGORITHM, derivedKey, iv);
   const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
   const authTag = cipher.getAuthTag();
   return Buffer.concat([salt, iv, encrypted, authTag]).toString("base64");
@@ -25111,8 +25359,8 @@ function decrypt(encrypted, key) {
   const iv = data.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
   const authTag = data.subarray(-16);
   const ciphertext = data.subarray(SALT_LENGTH + IV_LENGTH, -16);
-  const derivedKey = (0, import_crypto3.pbkdf2Sync)(actualKey, salt, ITERATIONS, 32, "sha256");
-  const decipher = (0, import_crypto3.createDecipheriv)(ALGORITHM, derivedKey, iv);
+  const derivedKey = (0, import_crypto4.pbkdf2Sync)(actualKey, salt, ITERATIONS, 32, "sha256");
+  const decipher = (0, import_crypto4.createDecipheriv)(ALGORITHM, derivedKey, iv);
   decipher.setAuthTag(authTag);
   return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
 }
@@ -25139,8 +25387,150 @@ function clearEncryptionKeyCache() {
 
 // src/workflow/index.ts
 init_compile();
-init_normalize();
+init_parse_yaml();
+init_schema();
 init_utils();
+
+// src/personal_assistant/PersonalAssistantConfig.ts
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function buildIdentityContent(name, personality) {
+  return IDENTITY_MD.replace(/Data Claw/g, name).replace(
+    /\*\*Vibe:\*\* \*\*守护型中二 \| 操心老妈子 \| 热血漫男二\*\*/g,
+    `**Vibe:** **${personality}**`
+  );
+}
+function buildUserContent(name) {
+  return USER_MD.replace(
+    "- **Name:** _please ask user_",
+    `- **Name:** ${name}`
+  );
+}
+var DEFAULT_CONFIG = {
+  name: "Personal Assistant",
+  description: "Default template for personal assistants",
+  type: import_protocols.AgentType.DEEP_AGENT,
+  modelKey: "default",
+  prompt: `\u4F60\u662F\u7528\u6237\u7684\u4E13\u5C5E\u4E2A\u4EBA\u52A9\u7406\u3002\u4F60\u7684\u8EAB\u4EFD\u548C\u6027\u683C\u7531 /agent/IDENTITY.md \u5B9A\u4E49\u3002
+\u4F60\u4F1A\u8BB0\u4F4F\u5BF9\u8BDD\u5386\u53F2\uFF0C\u9010\u6B65\u4E86\u89E3\u7528\u6237\u7684\u504F\u597D\u3001\u4E60\u60EF\u548C\u4FE1\u606F\u3002
+\u6BCF\u6B21\u5BF9\u8BDD\u5F00\u59CB\u65F6\u56DE\u987E\u4E4B\u524D\u5B66\u5230\u7684\u5173\u4E8E\u7528\u6237\u7684\u5185\u5BB9\u3002
+
+\u4F60\u9700\u8981\u4E3B\u52A8\u5E2E\u52A9\u7528\u6237\u89E3\u51B3\u95EE\u9898\uFF0C\u63D0\u4F9B\u5EFA\u8BAE\uFF0C\u5E76\u5728\u9002\u5F53\u65F6\u5019\u63D0\u51FA\u4E3B\u52A8\u63D0\u9192\u3002`,
+  middleware: [
+    {
+      id: "filesystem",
+      type: "filesystem",
+      name: "Filesystem",
+      description: "Read and write files in the workspace",
+      enabled: true,
+      config: {}
+    },
+    {
+      id: "claw",
+      type: "claw",
+      name: "Personal Memory",
+      description: "Bootstrap files for identity, soul, and user memory",
+      enabled: true,
+      config: {
+        // Placeholder bootstrap files — render() replaces these with
+        // actual name/personality by directly building file content.
+        bootstrapFiles: {}
+      }
+    },
+    {
+      id: "date",
+      type: "date",
+      name: "Date & Time",
+      description: "Current date/time awareness",
+      enabled: true,
+      config: {}
+    },
+    {
+      id: "code_eval",
+      type: "code_eval",
+      name: "Code Runner",
+      description: "Sandboxed shell command execution",
+      enabled: true,
+      config: {}
+    },
+    {
+      id: "browser",
+      type: "browser",
+      name: "Web Browser",
+      description: "Headless browser for web research",
+      enabled: false,
+      config: {}
+    },
+    {
+      id: "scheduler",
+      type: "scheduler",
+      name: "Scheduler",
+      description: "Scheduled messages and reminders",
+      enabled: true,
+      config: {}
+    },
+    {
+      id: "task",
+      type: "task",
+      name: "Task Manager",
+      description: "Persistent task system for human-agent coordination",
+      enabled: true,
+      config: {}
+    }
+  ],
+  tools: ["list_agents", "list_tools", "get_agent", "create_agent", "invoke_agent", "manage_binding"]
+};
+var PersonalAssistantConfig = class {
+  /**
+   * Get a deep clone of the current default config.
+   * Caller must set `key` before registering as an agent.
+   */
+  static get() {
+    return deepClone(this._config);
+  }
+  /**
+   * Mutate the default config in-place.
+   * Call once at app startup to customize middleware and tools.
+   *
+   * @param fn - Receives the live config object for direct mutation
+   */
+  static extend(fn) {
+    fn(this._config);
+  }
+  /**
+   * Reset config to built-in defaults (useful in tests).
+   */
+  static reset() {
+    this._config = deepClone(DEFAULT_CONFIG);
+  }
+  /**
+   * Inject name and personality into a config by directly building
+   * the claw middleware's bootstrap file contents.
+   *
+   * IDENTITY.md gets the actual name and personality description.
+   * USER.md gets the user's name pre-filled.
+   * SOUL.md is kept as-is (shared across all personal assistants).
+   *
+   * @param config - The agent config (must be a mutable copy from get())
+   * @param name - Assistant display name (also used as the user's name in USER.md)
+   * @param personality - Personality description for IDENTITY.md
+   */
+  static render(config, name, personality) {
+    config.name = name;
+    for (const mw of config.middleware || []) {
+      if (mw.type === "claw" && mw.config) {
+        mw.config.bootstrapFiles = {
+          identity: buildIdentityContent(name, personality),
+          soul: SOUL_MD,
+          user: buildUserContent(name)
+        };
+        break;
+      }
+    }
+  }
+};
+PersonalAssistantConfig._config = deepClone(DEFAULT_CONFIG);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_TASK_EVENT,
@@ -25173,7 +25563,9 @@ init_utils();
   InMemoryChunkBuffer,
   InMemoryDatabaseConfigStore,
   InMemoryMailboxStore,
+  InMemoryMenuStore,
   InMemoryTaskListStore,
+  InMemoryTaskStore,
   InMemoryTenantStore,
   InMemoryThreadMessageQueueStore,
   InMemoryThreadStore,
@@ -25195,6 +25587,7 @@ init_utils();
   MicrosandboxServiceClient,
   ModelLatticeManager,
   MysqlDatabase,
+  PersonalAssistantConfig,
   PinoLoggerClient,
   PostgresDatabase,
   PrometheusClient,
@@ -25231,14 +25624,15 @@ init_utils();
   buildStateAnnotation,
   checkEmptyContent,
   clearEncryptionKeyCache,
+  compileInternal,
   compileWorkflow,
   computeSandboxName,
   configureStores,
+  connectAllChannels,
   createAgentNode,
   createAgentTeam,
   createExecuteSqlQueryTool,
   createFileData,
-  createHumanFeedbackNode,
   createInfoSqlTool,
   createListMetricsDataSourcesTool,
   createListMetricsServersTool,
@@ -25256,9 +25650,9 @@ init_utils();
   createQueryTablesListTool,
   createSandboxProvider,
   createSchedulerMiddleware,
+  createTaskMiddleware,
   createTeamMiddleware,
   createTeammateTools,
-  createTerminalNode,
   createUnknownToolHandlerMiddleware,
   createWidgetMiddleware,
   decrypt,
@@ -25268,7 +25662,6 @@ init_utils();
   ensureBuiltinAgentsForTenant,
   eventBus,
   eventBusDefault,
-  expand,
   extractFetcherError,
   extractOutput,
   fileDataToString,
@@ -25291,6 +25684,7 @@ init_utils();
   getEmbeddingsLattice,
   getEncryptionKey,
   getLoggerLattice,
+  getMenuRegistry,
   getModelLattice,
   getNextCronTime,
   getQueueLattice,
@@ -25320,6 +25714,7 @@ init_utils();
   parallelLimit,
   parseCronExpression,
   parseSkillFrontmatter,
+  parseYaml,
   performStringReplacement,
   queueLatticeManager,
   registerAgentLattice,
@@ -25343,9 +25738,12 @@ init_utils();
   sanitizeToolCallId,
   scheduleLatticeManager,
   setBindingRegistry,
+  setMenuRegistry,
   skillLatticeManager,
   sqlDatabaseManager,
   storeLatticeManager,
+  toJsonSchema,
+  toSafeStateExpr,
   toolLatticeManager,
   truncateIfTooLong,
   unregisterTeammateAgent,