@ai-setting/roy-agent-core 1.5.43 → 1.5.45

package/dist/shared/@ai-setting/{roy-agent-core-2jnzv9at.js → roy-agent-core-nn9dmffw.js}

@@ -1,7 +1,13 @@
+import {
+  buildWorkflowNodeMetadata,
+  getWorkflowNodeIdFromMetadata,
+  init_workflow_message_metadata,
+  patchAgentSessionIdOnMessage
+} from "./roy-agent-core-6atd905e.js";
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-69jskqjg.js";
+} from "./roy-agent-core-44g4dhzg.js";
 import {
   SkillNode,
   ToolNode,
@@ -9,12 +15,26 @@ import {
   init_skill_node,
   init_tool_node,
   init_workflow_node
-} from "./roy-agent-core-jvatggbb.js";
+} from "./roy-agent-core-6vxg2gmr.js";
+import {
+  WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME,
+  init_json_schema_to_zod,
+  init_submit_json_output_tool,
+  jsonSchemaToZod,
+  parseWorkflowJsonOutput,
+  validateJsonOutputSchema
+} from "./roy-agent-core-nhfy3p8q.js";
+import {
+  TemplateResolver,
+  init_template_resolver
+} from "./roy-agent-core-v002ynpa.js";
 import {
+  WorkflowError,
   createWorkflowEvent,
   init_event,
-  init_types
-} from "./roy-agent-core-5x94xmt6.js";
+  init_types,
+  init_workflow_error
+} from "./roy-agent-core-qnrf2aw6.js";
 import {
   AskUserError,
   createNodeInterruptEvent,
@@ -129,12 +149,14 @@ class DAGManager {
   nodeMap;
   extendedDefinition = null;
   cachedAnalysis = null;
-  constructor(workflow) {
+  allowCycles;
+  constructor(workflow, options) {
     if (!workflow.nodes || workflow.nodes.length === 0) {
       throw new Error("At least one node is required");
     }
     this.workflow = workflow;
     this.nodeMap = new Map;
+    this.allowCycles = options?.allowCycles ?? false;
     for (const node of workflow.nodes) {
       if (node.id === "") {
         throw new Error("Node ID cannot be empty");
@@ -386,7 +408,7 @@ class DAGManager {
     }
     return result;
   }
-  validate() {
+  validate(options) {
     const errors = [];
     const nodeIds = new Set;
     for (const node of this.workflow.nodes) {
@@ -407,7 +429,7 @@ class DAGManager {
         }
       }
     }
-    if (this.isCyclic()) {
+    if (!this.allowCycles && !options?.skipCycleCheck && this.isCyclic()) {
       errors.push("Workflow contains a cycle");
     }
     return {
@@ -455,6 +477,27 @@ class DAGManager {
     const analysis = this.analyze();
     return analysis.dependents.get(nodeId) || [];
   }
+  getDownstreamUntil(fromNodeId, untilNodeId) {
+    const result = [];
+    const visited = new Set;
+    const queue = [...this.getDependents(fromNodeId)];
+    while (queue.length > 0) {
+      const nodeId = queue.shift();
+      if (visited.has(nodeId))
+        continue;
+      visited.add(nodeId);
+      result.push(nodeId);
+      if (nodeId === untilNodeId) {
+        continue;
+      }
+      for (const dependent of this.getDependents(nodeId)) {
+        if (!visited.has(dependent)) {
+          queue.push(dependent);
+        }
+      }
+    }
+    return result;
+  }
   getDefinition() {
     return this.workflow;
   }
@@ -467,6 +510,20 @@ class DAGManager {
   getNodeCount() {
     return this.nodeMap.size;
   }
+  buildEdges(explicitEdges = []) {
+    const derivedEdges = [];
+    const explicitEdgeSet = new Set(explicitEdges.map((e) => `${e.from}->${e.to}`));
+    for (const node of this.workflow.nodes) {
+      const deps = node.depends_on || [];
+      for (const dep of deps) {
+        const edgeKey = `${dep}->${node.id}`;
+        if (!explicitEdgeSet.has(edgeKey)) {
+          derivedEdges.push({ from: dep, to: node.id });
+        }
+      }
+    }
+    return [...explicitEdges, ...derivedEdges];
+  }
 }
 var init_dag_manager = () => {};
 
@@ -542,6 +599,10 @@ class Scheduler {
     return this.ready.has(nodeId);
   }
   markCompleted(nodeId) {
+    if (nodeId === "__end__" || nodeId === "__END__") {
+      logger.debug(`[Scheduler] Workflow marked as completed via __end__`);
+      return;
+    }
     this.running.delete(nodeId);
     this.ready.delete(nodeId);
     this.pending.delete(nodeId);
@@ -569,6 +630,21 @@ class Scheduler {
     }
     this.skipped.add(nodeId);
   }
+  unmarkSkipped(nodeId) {
+    if (!this.skipped.has(nodeId)) {
+      return;
+    }
+    this.skipped.delete(nodeId);
+    this.pending.add(nodeId);
+  }
+  resetNodeForReEntry(nodeId) {
+    this.running.delete(nodeId);
+    this.completed.delete(nodeId);
+    this.failed.delete(nodeId);
+    this.skipped.delete(nodeId);
+    this.ready.delete(nodeId);
+    this.pending.add(nodeId);
+  }
   reset() {
     this.running.clear();
     this.completed.clear();
@@ -593,6 +669,11 @@ class Scheduler {
       skipped: Array.from(this.skipped).sort()
     };
   }
+  markCompletedFromRestore(nodeIds) {
+    for (const nodeId of nodeIds) {
+      this.markCompleted(nodeId);
+    }
+  }
   updateReadyNodes(completedNodes) {
     const allCompleted = new Set(completedNodes);
     for (const nodeId of this.completed) {
@@ -616,8 +697,70 @@ class Scheduler {
   setParallelLimit(limit) {
     this.options.parallelLimit = limit;
   }
+  getOutgoingEdges(nodeId, edges) {
+    return edges.filter((edge) => edge.from === nodeId);
+  }
+  processEdgesAfterCompletion(completedNodeId, edges, templateResolver, loopEnabled) {
+    const result = {
+      toStart: [],
+      reEntries: [],
+      skipped: [],
+      resetNodes: []
+    };
+    const completedNode = this.dagManager.getNode(completedNodeId);
+    if (completedNode?.condition) {
+      const conditionMet = templateResolver.evaluateCondition(completedNode.condition);
+      if (!conditionMet) {
+        for (const edge of this.getOutgoingEdges(completedNodeId, edges)) {
+          this.markSkipped(edge.to);
+          result.skipped.push({
+            nodeId: edge.to,
+            reason: `Inline condition false on node "${completedNodeId}"`
+          });
+        }
+        return result;
+      }
+    }
+    const outgoingEdges = this.getOutgoingEdges(completedNodeId, edges);
+    for (const edge of outgoingEdges) {
+      const conditionMet = !edge.when || templateResolver.evaluateCondition(edge.when);
+      if (conditionMet) {
+        if (this.skipped.has(edge.to)) {
+          this.unmarkSkipped(edge.to);
+        }
+        const isReEntry = loopEnabled && this.completed.has(edge.to);
+        const canStart = loopEnabled ? !this.running.has(edge.to) && !this.failed.has(edge.to) : !this.completed.has(edge.to) && !this.running.has(edge.to) && !this.failed.has(edge.to);
+        if (canStart) {
+          if (isReEntry) {
+            const downstream = this.dagManager.getDownstreamUntil(edge.to, completedNodeId);
+            for (const nodeId of downstream) {
+              this.resetNodeForReEntry(nodeId);
+              result.resetNodes.push(nodeId);
+            }
+            this.resetNodeForReEntry(edge.to);
+            result.resetNodes.push(edge.to);
+            result.reEntries.push(edge.to);
+          }
+          result.toStart.push(edge.to);
+        }
+      } else {
+        if (!this.skipped.has(edge.to)) {
+          result.skipped.push({
+            nodeId: edge.to,
+            reason: edge.when ? `Edge condition false: ${edge.when}` : "Edge condition false"
+          });
+        }
+        this.markSkipped(edge.to);
+      }
+    }
+    return result;
+  }
 }
-var init_scheduler = () => {};
+var logger;
+var init_scheduler = __esm(() => {
+  init_logger();
+  logger = createLogger("workflow.scheduler");
+});
 
 // src/env/workflow/engine/executor.ts
 var Executor;
@@ -625,6 +768,7 @@ var init_executor = __esm(() => {
   init_event();
   init_types();
   init_decorator();
+  init_workflow_message_metadata();
   Executor = class Executor {
     nodeRegistry;
     eventBus;
@@ -817,15 +961,33 @@ var init_executor = __esm(() => {
         role: "workflow.node.start",
         content: contentSummary,
         parts: [part],
-        metadata: {
-          _workflowNodeMetadata: true,
-          type: "workflow.node.start",
-          workflowNodeId: nodeId,
-          workflowNodeType: nodeType,
+        metadata: buildWorkflowNodeMetadata("workflow.node.start", nodeId, nodeType, {
           ...agentSessionId ? { agentSessionId } : {}
-        }
+        })
       });
     }
+    async attachAgentSessionToLastStart(sessionId, nodeId, agentSessionId) {
+      if (!this.sessionComponent?.getMessages || !this.sessionComponent.updateMessage) {
+        return;
+      }
+      const messages = await this.sessionComponent.getMessages(sessionId);
+      for (let i = messages.length - 1;i >= 0; i--) {
+        const msg = messages[i];
+        const meta = msg.metadata;
+        if (meta?.type !== "workflow.node.start") {
+          continue;
+        }
+        if (getWorkflowNodeIdFromMetadata(meta) !== nodeId) {
+          continue;
+        }
+        if (meta.agentSessionId) {
+          return;
+        }
+        const patched = patchAgentSessionIdOnMessage(meta, msg.parts, agentSessionId);
+        await this.sessionComponent.updateMessage(sessionId, msg.id, patched);
+        return;
+      }
+    }
     summarizeCall(nodeType, nodeId, input) {
       if (input === undefined || input === null) {
         return `[${nodeType}] ${nodeId} started`;
@@ -857,14 +1019,11 @@ var init_executor = __esm(() => {
         role: "workflow.node.interrupt",
         content: query,
         parts: [part],
-        metadata: {
-          _workflowNodeMetadata: true,
-          type: "workflow.node.interrupt",
-          workflowNodeId: nodeId,
-          workflowNodeType: nodeType,
+        metadata: buildWorkflowNodeMetadata("workflow.node.interrupt", nodeId, nodeType, {
           query,
-          agentSessionId
-        }
+          ...agentSessionId ? { agentSessionId } : {},
+          timestamp
+        })
       });
     }
     async writeNodeEnd(sessionId, nodeId, nodeType, output, error, durationMs, agentSessionId) {
@@ -884,14 +1043,10 @@ var init_executor = __esm(() => {
         role: "workflow.node.end",
         content: contentSummary,
         parts: [part],
-        metadata: {
-          _workflowNodeMetadata: true,
-          type: "workflow.node.end",
-          workflowNodeId: nodeId,
-          workflowNodeType: nodeType,
+        metadata: buildWorkflowNodeMetadata("workflow.node.end", nodeId, nodeType, {
           success: !error,
           ...agentSessionId ? { agentSessionId } : {}
-        }
+        })
       });
     }
     summarizeResult(nodeId, output, error, durationMs) {
@@ -913,7 +1068,7 @@ var init_executor = __esm(() => {
       const truncated = strOutput.length > 100 ? strOutput.substring(0, 100) + "..." : strOutput;
       return `✅ ${nodeId}: ${truncated} (${durationMs}ms)`;
     }
-    async writeNodeResume(sessionId, nodeId, response, agentSessionId) {
+    async writeNodeResume(sessionId, nodeId, nodeType, response, agentSessionId) {
       if (!this.sessionComponent)
         return;
       const timestamp = Date.now();
@@ -928,12 +1083,11 @@ var init_executor = __esm(() => {
         role: "workflow.node.resume",
         content: response,
         parts: [part],
-        metadata: {
-          _workflowNodeMetadata: true,
-          type: "workflow.node.resume",
-          workflowNodeId: nodeId,
-          ...agentSessionId ? { agentSessionId } : {}
-        }
+        metadata: buildWorkflowNodeMetadata("workflow.node.resume", nodeId, nodeType, {
+          response,
+          ...agentSessionId ? { agentSessionId } : {},
+          timestamp
+        })
       });
     }
   };
@@ -943,6 +1097,9 @@ var init_executor = __esm(() => {
   __legacyDecorateClassTS([
     TracedAs("workflow.executor.writeNodeStart", { recordParams: true, recordResult: true, log: true })
   ], Executor.prototype, "writeNodeStart", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.executor.attachAgentSessionToLastStart", { log: true })
+  ], Executor.prototype, "attachAgentSessionToLastStart", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.executor.writeNodeInterrupt", { recordParams: true, recordResult: true, log: true })
   ], Executor.prototype, "writeNodeInterrupt", null);
@@ -954,11 +1111,139 @@ var init_executor = __esm(() => {
   ], Executor.prototype, "writeNodeResume", null);
 });
 
+// src/env/workflow/utils/parse-agent-output-config.ts
+function parseAgentOutputConfig(config) {
+  const output = config.output;
+  if (!output) {
+    return { mode: "string" };
+  }
+  const mode = output.mode === "json" ? "json" : "string";
+  if (mode === "json") {
+    if (output.schema === undefined) {
+      throw new Error("AgentNode output.mode=json requires output.schema");
+    }
+    const schema = validateJsonOutputSchema(output.schema);
+    return { mode, schema };
+  }
+  return { mode: "string" };
+}
+var init_parse_agent_output_config = __esm(() => {
+  init_json_schema_to_zod();
+});
+
+// src/env/workflow/utils/extract-agent-json-output.ts
+function extractAgentJsonOutput(agentResult, schema) {
+  const candidates = [
+    agentResult.structuredOutput,
+    asRecord(agentResult.output),
+    extractFromToolCalls(agentResult),
+    extractFromMessages(agentResult.messages)
+  ];
+  for (const candidate of candidates) {
+    const validated = validateAgainstSchema(candidate, schema);
+    if (validated) {
+      return validated;
+    }
+  }
+  return;
+}
+function asRecord(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return;
+}
+function extractFromToolCalls(agentResult) {
+  const toolCalls = agentResult.metadata?.toolCallsDetail;
+  if (!toolCalls?.length) {
+    return;
+  }
+  for (let i = toolCalls.length - 1;i >= 0; i--) {
+    const tc = toolCalls[i];
+    if (tc.name === WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME && tc.arguments) {
+      return tc.arguments;
+    }
+  }
+  return;
+}
+function extractFromMessages(messages) {
+  if (!messages?.length) {
+    return;
+  }
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.toolName !== WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME || !msg.content) {
+      continue;
+    }
+    const fromMarker = parseWorkflowJsonOutput(msg.content);
+    if (fromMarker) {
+      return fromMarker;
+    }
+    try {
+      const parsed = JSON.parse(msg.content);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {}
+  }
+  return;
+}
+function validateAgainstSchema(data, schema) {
+  if (!data) {
+    return;
+  }
+  if (!schema) {
+    return data;
+  }
+  try {
+    return jsonSchemaToZod(schema).parse(data);
+  } catch {
+    return;
+  }
+}
+var init_extract_agent_json_output = __esm(() => {
+  init_submit_json_output_tool();
+  init_json_schema_to_zod();
+});
+
+// src/env/workflow/utils/build-agent-node-output.ts
+function buildAgentNodeOutput(agentResult, outputConfig) {
+  const base = {
+    metadata: agentResult.metadata,
+    workflowHistory: agentResult.messages
+  };
+  if (outputConfig.mode === "json") {
+    const schema = outputConfig.schema;
+    const jsonData = extractAgentJsonOutput(agentResult, schema);
+    if (!jsonData) {
+      throw new Error("AgentNode json output mode requires structured JSON from workflow_submit_output");
+    }
+    return {
+      result: jsonData,
+      ...jsonData,
+      metadata: {
+        ...agentResult.metadata,
+        outputMode: "json"
+      },
+      workflowHistory: agentResult.messages
+    };
+  }
+  return {
+    result: agentResult.output,
+    ...base
+  };
+}
+var init_build_agent_node_output = __esm(() => {
+  init_extract_agent_json_output();
+});
+
 // src/env/workflow/nodes/agent-node.ts
 var AgentNode;
 var init_agent_node = __esm(() => {
   init_workflow_hil();
   init_decorator();
+  init_parse_agent_output_config();
+  init_build_agent_node_output();
   AgentNode = class AgentNode {
     definition;
     agentRunner;
@@ -972,11 +1257,17 @@ var init_agent_node = __esm(() => {
     async execute(context) {
       const startTime = Date.now();
       try {
-        const config = this.definition.config || {};
+        const config = context.resolvedConfig ?? this.definition.config ?? {};
         const agentType = config.agent_type || "general";
-        const promptTemplate = config.prompt || "";
         const options = config.options || {};
-        const resolvedPrompt = this.resolveTemplate(promptTemplate, context);
+        const outputConfig = parseAgentOutputConfig(config);
+        let resolvedPrompt;
+        if (context.resolvedConfig && context.templateResolver) {
+          resolvedPrompt = config.prompt || "";
+        } else {
+          const promptTemplate = config.prompt || "";
+          resolvedPrompt = context.templateResolver?.resolveValue(promptTemplate) ?? promptTemplate;
+        }
         if (this.agentRunner.registerAgent && this.agentRunner.hasAgent) {
           if (!this.agentRunner.hasAgent(agentType)) {
             this.agentRunner.registerAgent(agentType, {
@@ -986,19 +1277,30 @@ var init_agent_node = __esm(() => {
             });
           }
         }
-        const userQuery = context.input?.userQuery;
+        const userQuery = context.input?.userQuery ?? context.workflowInput?.userQuery;
         let agentSessionId = context.agentSessionId;
+        if (!agentSessionId && context.sessionComponent) {
+          agentSessionId = await this.resolveAgentSessionIdFromWorkflow(context);
+          if (agentSessionId) {
+            context.agentSessionId = agentSessionId;
+          }
+        }
         if (!agentSessionId && context.sessionComponent) {
           agentSessionId = await this.createAgentSubSession(context);
           context.agentSessionId = agentSessionId;
+          if (context.attachAgentSessionToLastStart) {
+            await context.attachAgentSessionToLastStart(this.definition.id, agentSessionId);
+          }
         }
+        const allowedTools = ["ask_user"];
         const agentConfig = {
           type: agentType,
           prompt: resolvedPrompt,
           options: {
             timeout: options.timeout,
             model: options.model,
-            allowedTools: ["ask_user"]
+            allowedTools,
+            outputSchema: outputConfig.schema
           },
           workflowHistory: context.workflowHistory,
           nodeId: this.definition.id,
@@ -1011,11 +1313,7 @@ var init_agent_node = __esm(() => {
         const result = await this.agentRunner.run(agentConfig, resumeOptions);
         const duration = Date.now() - startTime;
         return {
-          output: {
-            result: result.output,
-            metadata: result.metadata,
-            workflowHistory: result.messages
-          },
+          output: buildAgentNodeOutput(result, outputConfig),
           error: undefined,
           duration
         };
@@ -1036,6 +1334,18 @@ var init_agent_node = __esm(() => {
         };
       }
     }
+    async resolveAgentSessionIdFromWorkflow(context) {
+      const sessionComponent = context.sessionComponent;
+      if (!sessionComponent) {
+        return;
+      }
+      const workflowSession = await sessionComponent.get(context.sessionId);
+      const agentSessions = workflowSession?.metadata?.agentSessions;
+      if (!agentSessions?.length) {
+        return;
+      }
+      return agentSessions.find((ref) => ref.nodeId === this.definition.id)?.sessionId;
+    }
     async createAgentSubSession(context) {
       const sessionComponent = context.sessionComponent;
       if (!sessionComponent) {
@@ -1082,142 +1392,9 @@ var init_agent_node = __esm(() => {
       }
       return agentSessionId;
     }
-    resolveTemplate(template, context) {
-      if (!template) {
-        return "";
-      }
-      let resolved = template;
-      resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
-        let value = this.getNestedValue(context.input, path);
-        if (value === undefined && context.workflowInput) {
-          value = this.getNestedValue(context.workflowInput, path);
-        }
-        return this.stringifyValue(value, match);
-      });
-      resolved = resolved.replace(/\{\{inputs\.([^}]+)\}\}/g, (match, path) => {
-        let value = this.getNestedValue(context.input, path);
-        if (value === undefined && context.workflowInput) {
-          value = this.getNestedValue(context.workflowInput, path);
-        }
-        return this.stringifyValue(value, match);
-      });
-      resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
-        const segments = path.split(".");
-        const nodeId = segments[0];
-        let nodeOutput = context.previousOutputs.get(nodeId);
-        if (nodeOutput === undefined) {
-          const normalizedUnderscore = nodeId.replace(/-/g, "_");
-          const normalizedHyphen = nodeId.replace(/_/g, "-");
-          if (normalizedUnderscore !== nodeId) {
-            nodeOutput = context.previousOutputs.get(normalizedUnderscore);
-          }
-          if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
-            nodeOutput = context.previousOutputs.get(normalizedHyphen);
-          }
-        }
-        if (nodeOutput === undefined) {
-          return match;
-        }
-        nodeOutput = this.extractFromWrapper(nodeOutput);
-        if (segments.length === 1) {
-          return this.stringifyValue(nodeOutput, match);
-        }
-        let value = nodeOutput;
-        let startIndex = 1;
-        if (segments.length > 1 && (segments[1] === "output" || segments[1] === "result" || segments[1] === "metadata")) {
-          startIndex = 2;
-        }
-        for (let i = startIndex;i < segments.length; i++) {
-          if (value === null || value === undefined) {
-            return match;
-          }
-          value = value[segments[i]];
-        }
-        return this.stringifyValue(value, match);
-      });
-      resolved = resolved.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
-        if (path.startsWith("input.") || path.startsWith("nodes.")) {
-          return match;
-        }
-        const segments = path.split(".");
-        const nodeId = segments[0];
-        let nodeOutput = context.previousOutputs.get(nodeId);
-        if (nodeOutput === undefined) {
-          const normalizedUnderscore = nodeId.replace(/-/g, "_");
-          const normalizedHyphen = nodeId.replace(/_/g, "-");
-          if (normalizedUnderscore !== nodeId) {
-            nodeOutput = context.previousOutputs.get(normalizedUnderscore);
-          }
-          if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
-            nodeOutput = context.previousOutputs.get(normalizedHyphen);
-          }
-        }
-        if (nodeOutput === undefined) {
-          return match;
-        }
-        nodeOutput = this.extractFromWrapper(nodeOutput);
-        if (segments.length === 1) {
-          return this.stringifyValue(nodeOutput, match);
-        }
-        let value = nodeOutput;
-        let startIndex = 1;
-        if (segments.length > 1 && (segments[1] === "output" || segments[1] === "result" || segments[1] === "metadata")) {
-          startIndex = 2;
-        }
-        for (let i = startIndex;i < segments.length; i++) {
-          if (value === null || value === undefined) {
-            return match;
-          }
-          value = value[segments[i]];
-        }
-        return this.stringifyValue(value, match);
-      });
-      return resolved;
-    }
-    stringifyValue(value, originalTemplate) {
-      if (value === undefined) {
-        return originalTemplate;
-      }
-      if (value === null) {
-        return "null";
-      }
-      if (typeof value === "string") {
-        return value;
-      }
-      return JSON.stringify(value);
-    }
-    extractFromWrapper(value) {
-      if (value === null || value === undefined) {
-        return value;
-      }
-      if (typeof value !== "object") {
-        return value;
-      }
-      if ("result" in value && "metadata" in value) {
-        return value.result;
-      }
-      if ("output" in value) {
-        return value.output;
-      }
-      return value;
-    }
-    getNestedValue(obj, path) {
-      if (!obj) {
-        return;
-      }
-      if ("input" in obj && path in obj["input"]) {
-        return obj["input"][path];
-      }
-      return path.split(".").reduce((current, key) => {
-        if (current && typeof current === "object") {
-          return current[key];
-        }
-        return;
-      }, obj);
-    }
   };
   __legacyDecorateClassTS([
-    TracedAs("agent.node.execute", { recordParams: true, recordResult: true, log: true })
+    TracedAs("workflow.agent.execute", { log: true })
   ], AgentNode.prototype, "execute", null);
   __legacyDecorateClassTS([
     TracedAs("agent.node.createAgentSubSession", { recordParams: true, recordResult: true, log: true })
@@ -1226,16 +1403,17 @@ var init_agent_node = __esm(() => {
 
 // src/env/workflow/nodes/ask-user-node.ts
 class AskUserNode {
+  definition;
   type = "ask_user";
   id;
-  config;
   constructor(definition) {
+    this.definition = definition;
     this.id = definition.id;
-    this.config = definition.config || {};
   }
   async execute(context) {
-    const query = this.config.query || "确认继续吗？";
-    const options = this.config.options;
+    const config = context.resolvedConfig ?? this.definition.config ?? {};
+    const query = config.query || "确认继续吗？";
+    const options = config.options;
     const fullQuery = options ? `${query} (选项: ${options.join(", ")})` : query;
     await context.eventBus.publish(createNodeInterruptEvent(context.runId, this.id, this.type, fullQuery));
     throw new AskUserError(context.runId, context.sessionId, this.id, this.type, query);
@@ -1264,7 +1442,8 @@ class NodeRegistry {
       agentComponent,
       agentRunner,
       workflowRunner,
-      sessionComponent
+      sessionComponent,
+      llmComponent
     } = options ?? {};
     this.toolRegistry = toolRegistry;
     this.skillRegistry = skillRegistry;
@@ -1275,8 +1454,11 @@ class NodeRegistry {
       if (agentRunner.setSessionComponent && sessionComponent) {
         agentRunner.setSessionComponent(sessionComponent);
       }
+      if (llmComponent && "setLLMComponent" in agentRunner && typeof agentRunner.setLLMComponent === "function") {
+        agentRunner.setLLMComponent(llmComponent);
+      }
     } else if (agentComponent) {
-      this.agentComponentAdapter = new AgentComponentAdapter(agentComponent, {}, sessionComponent);
+      this.agentComponentAdapter = new AgentComponentAdapter(agentComponent, {}, sessionComponent, llmComponent);
       this.agentRunner = this.agentComponentAdapter;
     }
     this.registerBuiltInTypes();
@@ -1346,9 +1528,24 @@ var init_node_registry = __esm(() => {
   init_ask_user_node();
 });
 
+// src/env/workflow/utils/agent-session-metadata.ts
+function updateAgentSessionStatus(agentSessions, nodeId, status) {
+  if (!agentSessions?.length) {
+    return agentSessions ?? [];
+  }
+  return agentSessions.map((ref) => ref.nodeId === nodeId ? { ...ref, status } : ref);
+}
+function markAllAgentSessionsCompleted(agentSessions) {
+  if (!agentSessions?.length) {
+    return agentSessions ?? [];
+  }
+  return agentSessions.map((ref) => ref.status === "active" || ref.status === "paused" ? { ...ref, status: "completed" } : ref);
+}
+var init_agent_session_metadata = () => {};
+
 // src/env/workflow/engine/engine.ts
 import { EventEmitter } from "events";
-var logger, WorkflowEngine;
+var logger2, WorkflowEngine;
 var init_engine = __esm(() => {
   init_event();
   init_workflow_hil();
@@ -1357,9 +1554,12 @@ var init_engine = __esm(() => {
   init_scheduler();
   init_executor();
   init_node_registry();
+  init_agent_session_metadata();
   init_logger();
   init_decorator();
-  logger = createLogger("workflow:engine");
+  init_template_resolver();
+  init_workflow_error();
+  logger2 = createLogger("workflow:engine");
   WorkflowEngine = class WorkflowEngine extends EventEmitter {
     activeSessions = new Map;
     sessionIdCounter = 0;
@@ -1375,10 +1575,12 @@ var init_engine = __esm(() => {
     static async create(options) {
       const agentComponent = options.env?.getComponent("agent");
       const sessionComponent = options.sessionComponent;
+      const llmComponent = options.env?.getComponent("llm");
       const nodeRegistry = new NodeRegistry({
         toolRegistry: options.toolRegistry,
         skillRegistry: options.skillRegistry,
         agentComponent,
+        llmComponent,
         workflowRunner: options.workflowRunner,
         sessionComponent
       });
@@ -1406,6 +1608,8 @@ var init_engine = __esm(() => {
         workflowName,
         workflowVersion: definition.version,
         status: "running",
+        runId,
+        startedAt: Date.now(),
         input: options?.input,
         agentSessions: []
       };
@@ -1416,7 +1620,7 @@ var init_engine = __esm(() => {
           metadata
         });
       }
-      logger.info(`[WorkflowEngine] Created session: ${sessionId}`);
+      logger2.info(`[WorkflowEngine] Created session: ${sessionId}`);
       return sessionId;
     }
     async run(sessionId, options) {
@@ -1486,24 +1690,32 @@ var init_engine = __esm(() => {
             }
           });
           metadata.input = { ...existingInput, ...newInput };
-          logger.info(`[WorkflowEngine] Updated session ${sessionId} input with resume user input`);
+          logger2.info(`[WorkflowEngine] Updated session ${sessionId} input with resume user input`);
         }
       }
       const messages = this.sessionComponent ? await this.sessionComponent.getMessages(sessionId) : [];
-      const { inferNextNode } = await import("./roy-agent-core-ffb9fq4v.js");
+      const {
+        inferNextNode,
+        extractResumeInfo,
+        enrichResumeInfoWithAgentSessions,
+        enrichResumePointWithAgentSessions
+      } = await import("./roy-agent-core-2vhsccvz.js");
       const entry = workflowDef.entry;
       const entryNode = Array.isArray(entry) ? entry[0] : entry;
-      const resumePoint = inferNextNode(messages, {
+      const agentSessions = metadata.agentSessions ?? [];
+      const resumeInfo = enrichResumeInfoWithAgentSessions(extractResumeInfo(messages), agentSessions);
+      const resumePoint = enrichResumePointWithAgentSessions(inferNextNode(messages, {
         entryNode: entryNode !== "__default_entry__" ? entryNode : undefined,
         edges: undefined
-      });
+      }), agentSessions);
       const sessionState = await this.initializeSessionState(sessionId, workflowDef, workflowId, workflowName, options);
       this.activeSessions.set(sessionId, sessionState);
-      return this.runWithResume(sessionId, resumePoint, options);
+      return this.runWithResume(sessionId, resumePoint, resumeInfo, options);
     }
     async initializeSessionState(sessionId, definition, workflowId, workflowName, options) {
-      const dagManager = new DAGManager(definition);
-      const validation = dagManager.validate();
+      const loopEnabled = options?.loopEnabled ?? definition.config?.loopEnabled ?? false;
+      const dagManager = new DAGManager(definition, { allowCycles: loopEnabled });
+      const validation = dagManager.validate({ skipCycleCheck: loopEnabled });
       if (!validation.valid) {
         throw new Error(`Invalid workflow: ${validation.errors.join(", ")}`);
       }
@@ -1516,10 +1728,28 @@ var init_engine = __esm(() => {
         debug: options?.debug ?? definition.config?.debug ?? false
       };
       const executor = new Executor(this.nodeRegistry, eventBus, executorOptions, this.sessionComponent);
+      const rawRuntimeInput = options?.workflowInput ?? options?.input;
+      let persistedInput = {};
+      if (this.sessionComponent) {
+        const existingSession = await this.sessionComponent.get(sessionId);
+        const metaInput = existingSession?.metadata?.input;
+        if (metaInput) {
+          const { userQuery: _omit, ...rest } = metaInput;
+          persistedInput = rest;
+        }
+      }
+      const { stripEphemeralResumeInput } = await import("./roy-agent-core-2vhsccvz.js");
+      const { workflowInput: runtimeInput } = stripEphemeralResumeInput(rawRuntimeInput);
+      const mergedWorkflowInput = { ...persistedInput, ...runtimeInput };
+      const workflowInput = Object.keys(mergedWorkflowInput).length > 0 ? mergedWorkflowInput : undefined;
       const config = {
         parallelLimit,
         timeout: options?.timeout ?? definition.config?.timeout ?? null,
-        debug: options?.debug ?? definition.config?.debug ?? false
+        debug: options?.debug ?? definition.config?.debug ?? false,
+        strict: options?.strict ?? definition.config?.strict ?? false,
+        maxIterations: options?.maxIterations ?? definition.config?.maxIterations ?? 100,
+        loopEnabled,
+        workflowInput
       };
       const abortController = new AbortController;
       let resolveCompleted;
@@ -1546,12 +1776,14 @@ var init_engine = __esm(() => {
         resolveCompleted,
         rejectCompleted,
         workflowHistory: [],
-        agentSessions: new Map
+        agentSessions: new Map,
+        edges: dagManager.buildEdges(definition.edges || []),
+        loopIterationCount: 0
       };
       this.setupEventHandlers(sessionState);
       return sessionState;
     }
-    async runWithResume(sessionId, resumePoint, options) {
+    async runWithResume(sessionId, resumePoint, resumeInfo, options) {
       const sessionState = this.activeSessions.get(sessionId);
       if (!sessionState) {
         throw new Error(`Session not found: ${sessionId}`);
@@ -1580,12 +1812,17 @@ var init_engine = __esm(() => {
       } else if (options?.input && typeof options.input === "object") {
         inputForExecution = options.input;
       }
+      if (resumeInfo?.nodeOutputs) {
+        const completedNodeIds = Array.from(resumeInfo.nodeOutputs.keys());
+        sessionState.scheduler.markCompletedFromRestore(completedNodeIds);
+      }
       this.scheduleAndExecute(sessionState, {
         input: inputForExecution,
         pendingNodeId,
-        agentSessionId
+        agentSessionId,
+        restoredOutputs: resumeInfo?.nodeOutputs
       }).catch((error) => {
-        logger.error(`Workflow ${sessionId} scheduling error:`, error);
+        logger2.error(`Workflow ${sessionId} scheduling error:`, error);
         this.failWorkflow(sessionState, error);
       });
       if (options?.sync !== false) {
@@ -1600,7 +1837,7 @@ var init_engine = __esm(() => {
       const sessionId = await this.createSession(workflow, options);
       const sessionState = await this.initializeSessionState(sessionId, definition, workflowId, workflowName, options);
       this.activeSessions.set(sessionId, sessionState);
-      return this.runWithResume(sessionId, { type: "entry_node" }, options);
+      return this.runWithResume(sessionId, { type: "entry_node" }, undefined, options);
     }
     async pause(sessionId) {
       const sessionState = this.activeSessions.get(sessionId);
@@ -1620,7 +1857,7 @@ var init_engine = __esm(() => {
         });
       }
       await sessionState.eventBus.publish(createWorkflowEvent("workflow.paused", this.getRunIdFromSessionId(sessionId), {}));
-      logger.info(`[WorkflowEngine] Workflow paused: ${sessionId}`);
+      logger2.info(`[WorkflowEngine] Workflow paused: ${sessionId}`);
     }
     async stop(sessionId, reason) {
       const sessionState = this.activeSessions.get(sessionId);
@@ -1659,15 +1896,12 @@ var init_engine = __esm(() => {
       eventBus.on("node.completed", async (event) => {
         if (event.type !== "node.completed")
           return;
-        sessionState.nodeOutputs.set(event.node_id, event.output);
-        scheduler.markCompleted(event.node_id);
         if (event.output && typeof event.output === "object" && "workflowHistory" in event.output) {
           const messages = event.output.workflowHistory;
           if (Array.isArray(messages)) {
             sessionState.workflowHistory.push(...messages);
           }
         }
-        this.checkAndFinalize(sessionState);
       });
       eventBus.on("node.failed", async (event) => {
         if (event.type !== "node.failed")
@@ -1678,20 +1912,27 @@ var init_engine = __esm(() => {
       eventBus.on("node.interrupt", async (event) => {
         if (event.type !== "node.interrupt")
           return;
-        logger.info(`Workflow paused at node "${event.node_id}" - ask_user pending`);
+        logger2.info(`Workflow paused at node "${event.node_id}" - ask_user pending`);
         sessionState.status = "paused";
         sessionState.abortController.abort();
         if (this.sessionComponent) {
           const metadata = await this.getSessionMetadata(sessionId);
+          const agentSessions = updateAgentSessionStatus(metadata.agentSessions, event.node_id, "paused");
           await this.sessionComponent.update(sessionId, {
-            metadata: { ...metadata, status: "paused" }
+            metadata: {
+              ...metadata,
+              status: "paused",
+              pendingNodeId: event.node_id,
+              pauseReason: "ask_user",
+              agentSessions
+            }
           });
         }
         await eventBus.publish(createWorkflowEvent("workflow.paused", runId, {
           pendingNodeId: event.node_id,
           query: event.query
         }));
-        await this.writeNodeInterrupt(sessionId, event.node_id, event.node_type, event.query, event.agent_session_id);
+        await sessionState.executor.writeNodeInterrupt(sessionId, event.node_id, event.node_type, event.query, event.agent_session_id);
         sessionState.resolveCompleted({
           runId,
           status: "paused",
@@ -1701,25 +1942,19 @@ var init_engine = __esm(() => {
         });
       });
     }
-    async writeNodeInterrupt(sessionId, nodeId, nodeType, query, agentSessionId) {
-      if (this.sessionComponent) {
-        await this.sessionComponent.addMessage(sessionId, {
-          role: "workflow.node.interrupt",
-          content: query,
-          metadata: {
-            type: "workflow.node.interrupt",
-            workflowNodeId: nodeId,
-            workflowNodeType: nodeType,
-            query,
-            agentSessionId,
-            timestamp: Date.now()
-          }
-        });
-      }
-    }
     async scheduleAndExecute(sessionState, options) {
       const { scheduler, executor, eventBus, abortController, nodeOutputs } = sessionState;
       const { input: globalInput, pendingNodeId, agentSessionId, restoredOutputs } = options || {};
+      const { stripEphemeralResumeInput } = await import("./roy-agent-core-2vhsccvz.js");
+      const { workflowInput: inputToPersist, userQuery: resumeUserQuery } = stripEphemeralResumeInput(globalInput);
+      if (inputToPersist) {
+        sessionState.config.workflowInput = {
+          ...sessionState.config.workflowInput || {},
+          ...inputToPersist
+        };
+      }
+      sessionState.loopIterationCount = 0;
+      const maxIterations = sessionState.config.maxIterations;
       if (restoredOutputs) {
         for (const [nodeId, output] of restoredOutputs) {
           nodeOutputs.set(nodeId, output);
@@ -1739,7 +1974,7 @@ var init_engine = __esm(() => {
             break;
           if (scheduled >= (sessionState.config.parallelLimit ?? Infinity))
             break;
-          await this.startNode(sessionState, nodeId, globalInput);
+          await this.startNode(sessionState, nodeId, sessionState.config.workflowInput);
           scheduled++;
         }
         return true;
@@ -1747,7 +1982,7 @@ var init_engine = __esm(() => {
       if (pendingNodeId) {
         await this.resumeNode(sessionState, pendingNodeId, {
           agentSessionId,
-          userQuery: globalInput?.userQuery
+          userQuery: resumeUserQuery
         });
       } else {
         await scheduleAvailableNodes();
@@ -1757,6 +1992,12 @@ var init_engine = __esm(() => {
         if (state.pending.length === 0 && state.running.length === 0) {
           break;
         }
+        if (sessionState.config.loopEnabled && sessionState.loopIterationCount >= maxIterations) {
+          logger2.error(`[WorkflowEngine] Max loop iterations ${maxIterations} exceeded`);
+          sessionState.rejectCompleted(new WorkflowError(`Workflow exceeded maximum loop iterations: ${maxIterations}`));
+          await this.stop(sessionState.sessionId, "Max iterations exceeded");
+          return;
+        }
         try {
           await this.waitForNextNodeEvent(sessionState, abortController.signal);
         } catch {
@@ -1809,15 +2050,8 @@ var init_engine = __esm(() => {
         scheduler.markFailed(nodeId);
         return;
       }
-      await this.writeNodeStart(sessionId, nodeId, nodeDef.type, input);
-      const context = this.createExecutionContext(sessionState, nodeId, input);
-      executor.executeNode(nodeDef, context).catch(async (error) => {
-        if (error instanceof AskUserError) {
-          await eventBus.publish(createNodeInterruptEvent(runId, nodeId, nodeDef.type, error.query, error.agentSessionId));
-          return;
-        }
-        scheduler.markFailed(nodeId);
-      });
+      const context = this.buildNodeContext(sessionState, nodeId, input);
+      await this.validateAndExecute(nodeDef, context, sessionState);
     }
     async writeNodeStart(sessionId, nodeId, nodeType, input) {
       if (this.sessionComponent) {
@@ -1833,66 +2067,143 @@ var init_engine = __esm(() => {
         });
       }
     }
-    async writeNodeResume(sessionId, nodeId, userResponse) {
-      if (this.sessionComponent && userResponse) {
-        await this.sessionComponent.addMessage(sessionId, {
-          role: "workflow.node.resume",
-          content: JSON.stringify({ userResponse }),
-          metadata: {
-            type: "workflow.node.resume",
-            workflowNodeId: nodeId,
-            timestamp: Date.now()
-          }
-        });
-      }
-    }
     async resumeNode(sessionState, nodeId, options) {
       const { scheduler, executor, eventBus, dagManager } = sessionState;
       const sessionId = sessionState.sessionId;
       const runId = this.getRunIdFromSessionId(sessionId);
       scheduler.markStarted(nodeId);
-      await this.writeNodeResume(sessionId, nodeId, options?.userQuery);
+      const nodeDef = dagManager.getNode(nodeId);
+      if (!nodeDef) {
+        scheduler.markFailed(nodeId);
+        return;
+      }
+      let agentSessionId = options?.agentSessionId;
+      if (!agentSessionId && this.sessionComponent) {
+        const session = await this.sessionComponent.get(sessionId);
+        const agentSessions = session?.metadata?.agentSessions;
+        const { resolveAgentSessionId } = await import("./roy-agent-core-2vhsccvz.js");
+        agentSessionId = resolveAgentSessionId(nodeId, undefined, agentSessions);
+      }
+      await sessionState.executor.writeNodeResume(sessionId, nodeId, nodeDef.type, options?.userQuery ?? "", agentSessionId);
       await eventBus.publish(createWorkflowEvent("node.started", runId, {
         node_id: nodeId,
-        agentSessionId: options?.agentSessionId,
+        agentSessionId,
         userQuery: options?.userQuery
       }));
-      const nodeDef = dagManager.getNode(nodeId);
+      const context = this.buildNodeContext(sessionState, nodeId, sessionState.config.workflowInput);
+      if (options?.userQuery !== undefined) {
+        context.input.userQuery = options.userQuery;
+      }
+      if (agentSessionId) {
+        context.agentSessionId = agentSessionId;
+      }
+      await this.validateAndExecute(nodeDef, context, sessionState);
+    }
+    async preExecuteValidation(nodeId, nodeDef, context, options) {
       if (!nodeDef) {
-        scheduler.markFailed(nodeId);
+        logger2.warn(`Node ${nodeId} has no configuration`);
         return;
       }
-      const context = this.createExecutionContext(sessionState, nodeId, { userQuery: options?.userQuery }, true);
-      if (options?.agentSessionId) {
-        context.agentSessionId = options.agentSessionId;
-      }
-      if (nodeDef.type === "agent" && options?.agentSessionId) {
-        const agentAdapter = this.nodeRegistry.getAgentAdapter?.();
-        if (agentAdapter?.resumeAgent) {
-          const agentConfig = {
-            type: nodeDef.config?.agent_type || "general",
-            prompt: nodeDef.config?.prompt || "",
-            nodeId,
-            runId,
-            workflowSessionId: sessionId
-          };
-          try {
-            await agentAdapter.resumeAgent(options.agentSessionId, options.userQuery || "", agentConfig);
-          } catch (error) {
-            console.error(`Failed to resume agent node ${nodeId}:`, error);
+      const config = nodeDef.config || {};
+      if (context.debug) {
+        logger2.debug(`Pre-execute validation for node ${nodeId}`, {
+          workflowInput: context.workflowInput,
+          previousOutputs: Array.from(context.previousOutputs.keys()),
+          hasTemplateResolver: !!context.templateResolver
+        });
+      }
+      if (context.templateResolver) {
+        const { unresolved } = context.templateResolver.resolveAndValidate(config);
+        if (unresolved.length > 0) {
+          if (options?.strict) {
+            context.templateResolver.resolveStrict(config, nodeId);
           }
+          logger2.warn(`[WorkflowEngine] Node "${nodeId}" has unresolved templates:`, unresolved);
         }
       }
-      executor.executeNode(nodeDef, context).catch((error) => {
+    }
+    async validateAndExecute(nodeDef, context, sessionState) {
+      const { scheduler, executor, eventBus } = sessionState;
+      const { nodeId } = context;
+      const strictMode = sessionState.config?.strict ?? false;
+      try {
+        await this.preExecuteValidation(nodeId, nodeDef, context, { strict: strictMode });
+      } catch (err) {
+        logger2.error(`[WorkflowEngine] Strict validation failed for node ${nodeId}:`, err);
+        scheduler.markFailed(nodeId);
+        return;
+      }
+      try {
+        const result = await executor.executeNode(nodeDef, context);
+        if (result.error) {
+          return;
+        }
+        sessionState.nodeOutputs.set(nodeId, result.output);
+        scheduler.markCompleted(nodeId);
+        if (result.output && typeof result.output === "object" && "workflowHistory" in result.output) {
+          const messages = result.output.workflowHistory;
+          if (Array.isArray(messages)) {
+            sessionState.workflowHistory.push(...messages);
+          }
+        }
+        await this.processConditionalEdgesAfterCompletion(sessionState, nodeId);
+        this.checkAndFinalize(sessionState);
+      } catch (error) {
         if (error instanceof AskUserError) {
-          const event = createNodeInterruptEvent(runId, nodeId, nodeDef.type, error.query, error.agentSessionId);
-          eventBus.publish(event);
+          await eventBus.publish(createNodeInterruptEvent(context.runId, nodeId, nodeDef.type, error.query, error.agentSessionId));
           return;
         }
         scheduler.markFailed(nodeId);
+      }
+    }
+    async processConditionalEdgesAfterCompletion(sessionState, completedNodeId) {
+      if (!sessionState.edges || sessionState.edges.length === 0) {
+        return;
+      }
+      const { scheduler, eventBus } = sessionState;
+      const runId = this.getRunIdFromSessionId(sessionState.sessionId);
+      const templateResolver = new TemplateResolver({
+        input: sessionState.config.workflowInput || {},
+        previousOutputs: new Map(sessionState.nodeOutputs)
       });
+      logger2.debug(`[WorkflowEngine] Processing edges after "${completedNodeId}" completed. edges=${JSON.stringify(sessionState.edges)}`);
+      const edgeResult = scheduler.processEdgesAfterCompletion(completedNodeId, sessionState.edges, templateResolver, sessionState.config.loopEnabled);
+      logger2.debug(`[WorkflowEngine] Edge processing result: ${JSON.stringify(edgeResult)}`);
+      for (const nodeId of edgeResult.resetNodes) {
+        sessionState.nodeOutputs.delete(nodeId);
+      }
+      for (const { nodeId, reason } of edgeResult.skipped) {
+        await eventBus.publish(createWorkflowEvent("node.skipped", runId, {
+          node_id: nodeId,
+          reason
+        }));
+      }
+      if (edgeResult.reEntries.length > 0) {
+        if (sessionState.config.loopEnabled) {
+          const nextCount = sessionState.loopIterationCount + edgeResult.reEntries.length;
+          if (nextCount > sessionState.config.maxIterations) {
+            logger2.error(`[WorkflowEngine] Max loop iterations ${sessionState.config.maxIterations} exceeded (next=${nextCount})`);
+            await this.failWorkflow(sessionState, new WorkflowError(`Workflow exceeded maximum loop iterations: ${sessionState.config.maxIterations}`));
+            return;
+          }
+          sessionState.loopIterationCount = nextCount;
+        } else {
+          sessionState.loopIterationCount += edgeResult.reEntries.length;
+        }
+        logger2.debug(`[WorkflowEngine] Loop iteration #${sessionState.loopIterationCount}: re-entering ${edgeResult.reEntries.join(", ")}`);
+      }
+      const workflowInput = sessionState.config.workflowInput || {};
+      for (const targetId of edgeResult.toStart) {
+        if (targetId === "__end__" || targetId === "__END__") {
+          logger2.info(`[WorkflowEngine] Workflow terminated via __end__ edge from node "${completedNodeId}"`);
+          scheduler.markCompleted("__end__");
+          await this.completeWorkflow(sessionState);
+        } else {
+          await this.startNode(sessionState, targetId, workflowInput);
+        }
+      }
     }
-    createExecutionContext(sessionState, nodeId, globalInput, forceGlobalInput) {
+    buildNodeContext(sessionState, nodeId, globalInput) {
       const nodeDef = sessionState.dagManager.getNode(nodeId);
       const runId = this.getRunIdFromSessionId(sessionState.sessionId);
       const deps = nodeDef.depends_on || [];
@@ -1903,15 +2214,16 @@ var init_engine = __esm(() => {
           input[depId] = depOutput;
         }
       }
-      const analysis = sessionState.dagManager.analyze();
-      const isEntryNode = analysis.entryNodes.includes(nodeId);
-      if ((isEntryNode || forceGlobalInput) && globalInput) {
-        Object.assign(input, globalInput);
-      }
+      const rawWorkflowInput = globalInput ?? sessionState.config.workflowInput ?? {};
+      const { userQuery: _ephemeral, ...workflowInput } = rawWorkflowInput;
+      const templateResolver = new TemplateResolver({
+        input: workflowInput,
+        previousOutputs: new Map(sessionState.nodeOutputs)
+      });
       const askUser = (query) => {
         throw new AskUserError(runId, sessionState.sessionId, nodeId, nodeDef.type, query);
       };
-      return {
+      const context = {
         runId,
         sessionId: sessionState.sessionId,
         workflowName: sessionState.workflowName,
@@ -1924,8 +2236,15 @@ var init_engine = __esm(() => {
         nodeOutputs: sessionState.nodeOutputs,
         workflowHistory: sessionState.workflowHistory,
         sessionComponent: this.sessionComponent,
-        askUser
+        askUser,
+        attachAgentSessionToLastStart: async (targetNodeId, agentSessionId) => {
+          await sessionState.executor.attachAgentSessionToLastStart(sessionState.sessionId, targetNodeId, agentSessionId);
+        },
+        workflowInput,
+        templateResolver,
+        resolvedConfig: templateResolver.resolveValue(nodeDef.config ?? {})
       };
+      return context;
     }
     checkAndFinalize(sessionState) {
       const state = sessionState.scheduler.getState();
@@ -1938,6 +2257,10 @@ var init_engine = __esm(() => {
       }
     }
     async completeWorkflow(sessionState) {
+      if (sessionState.status !== "running") {
+        return;
+      }
+      sessionState.status = "completed";
       const durationMs = Date.now() - sessionState.startedAt.getTime();
       const sessionId = sessionState.sessionId;
       const runId = this.getRunIdFromSessionId(sessionId);
@@ -1948,7 +2271,16 @@ var init_engine = __esm(() => {
       if (this.sessionComponent) {
         const metadata = await this.getSessionMetadata(sessionId);
         await this.sessionComponent.update(sessionId, {
-          metadata: { ...metadata, status: "completed" }
+          metadata: {
+            ...metadata,
+            status: "completed",
+            completedAt: Date.now(),
+            durationMs,
+            output,
+            pendingNodeId: undefined,
+            pauseReason: undefined,
+            agentSessions: markAllAgentSessionsCompleted(metadata.agentSessions)
+          }
         });
       }
       await sessionState.eventBus.publish(createWorkflowEvent("workflow.completed", runId, {
@@ -1964,6 +2296,10 @@ var init_engine = __esm(() => {
       this.cleanupSession(sessionState);
     }
     async failWorkflow(sessionState, error) {
+      if (sessionState.status !== "running") {
+        return;
+      }
+      sessionState.status = "failed";
       const durationMs = Date.now() - sessionState.startedAt.getTime();
       const sessionId = sessionState.sessionId;
       const runId = this.getRunIdFromSessionId(sessionId);
@@ -1971,7 +2307,12 @@ var init_engine = __esm(() => {
       if (this.sessionComponent) {
         const metadata = await this.getSessionMetadata(sessionId);
         await this.sessionComponent.update(sessionId, {
-          metadata: { ...metadata, status: "failed" }
+          metadata: {
+            ...metadata,
+            status: "failed",
+            failedAt: Date.now(),
+            durationMs
+          }
         });
       }
       await sessionState.eventBus.publish(createWorkflowEvent("workflow.failed", runId, {
@@ -2044,9 +2385,6 @@ var init_engine = __esm(() => {
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.stop", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "stop", null);
-  __legacyDecorateClassTS([
-    TracedAs("workflow.engine.writeNodeInterrupt", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "writeNodeInterrupt", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.scheduleAndExecute", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "scheduleAndExecute", null);
@@ -2059,12 +2397,15 @@ var init_engine = __esm(() => {
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.writeNodeStart", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "writeNodeStart", null);
-  __legacyDecorateClassTS([
-    TracedAs("workflow.engine.writeNodeResume", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "writeNodeResume", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.resumeNode", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "resumeNode", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.engine.preExecuteValidation", { log: true })
+  ], WorkflowEngine.prototype, "preExecuteValidation", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.engine.buildNodeContext", { log: true })
+  ], WorkflowEngine.prototype, "buildNodeContext", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.checkAndFinalize", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "checkAndFinalize", null);