oc-browser-relay 1.0.1 → 1.0.3

package/bundled-relay/index.js

@@ -22641,6 +22641,7 @@ var ERROR_CODES = {
   // 页面类
   ERR_PAGE_NOT_SUPPORTED: "ERR_PAGE_NOT_SUPPORTED",
   ERR_PAGE_NOT_READY: "ERR_PAGE_NOT_READY",
+  ERR_PAGE_BLOCKED: "ERR_PAGE_BLOCKED",
   ERR_PAGE_CHANGED: "ERR_PAGE_CHANGED",
   ERR_FIELD_NOT_FOUND: "ERR_FIELD_NOT_FOUND",
   ERR_ACTION_NOT_FOUND: "ERR_ACTION_NOT_FOUND",
@@ -23060,20 +23061,6 @@ var TemplateExecutor = class _TemplateExecutor {
     }
     return obj;
   }
-  evaluateCondition(condition, data) {
-    try {
-      if (condition.includes(".length")) {
-        const fieldName = condition.replace(".length", "").trim();
-        const value2 = data[fieldName];
-        return Array.isArray(value2) ? value2.length > 0 : false;
-      }
-      const value = data[condition];
-      return value !== void 0 && value !== null && value !== "";
-    } catch (err) {
-      console.error("[TemplateExecutor] \u6761\u4EF6\u5224\u65AD\u5931\u8D25:", condition, err);
-      return false;
-    }
-  }
   coerceArrayFields(template, data) {
     const requiredFields = template.requiredFields ?? [];
     const optionalFields = template.optionalFields ?? [];
@@ -23178,30 +23165,16 @@ ${topicLine}`;
     resolvedData = this.mergeXiaohongshuTopicsIntoContent(template, resolvedData);
     this.validateRequiredFields(template, resolvedData);
     this.validateRules(template, resolvedData);
-    const steps = [];
-    for (const workflowStep of template.workflow) {
-      if (workflowStep.condition) {
-        const shouldExecute = this.evaluateCondition(workflowStep.condition, resolvedData);
-        if (!shouldExecute) continue;
-      }
-      steps.push({
-        stepId: workflowStep.stepId,
-        name: workflowStep.name || workflowStep.stepId,
-        goal: workflowStep.goal,
-        tool: workflowStep.tool,
-        args: this.replaceObjectVariables(workflowStep.args, resolvedData),
-        onFailure: workflowStep.onFailure,
-        preconditions: workflowStep.preconditions,
-        expectedObservation: workflowStep.expectedObservation,
-        status: "pending"
-      });
+    const nodes = Array.isArray(template.nodes) ? this.replaceObjectVariables(template.nodes, resolvedData) : [];
+    if (nodes.length === 0) {
+      throw new Error("\u4EFB\u52A1\u6A21\u677F\u7F3A\u5C11 nodes \u5B9A\u4E49");
     }
     return {
       taskType: template.taskType,
       platform: template.platform,
       payload: resolvedData,
       context: template.siteId ? { siteId: template.siteId } : void 0,
-      steps
+      nodes
     };
   }
   async executePublishItem(template, item) {
@@ -23281,7 +23254,7 @@ function isActionRequiredWaitReason(waitReason) {
       return false;
   }
 }
-function mapTaskStatusToCurrentStepStatus(status) {
+function mapTaskStatusToCurrentNodeStatus(status) {
   switch (status) {
     case "queued":
       return "pending";
@@ -23312,8 +23285,8 @@ function mapToolNameToTaskOperation(tool) {
     case "switch_tab":
     case "apply_search_filters":
       return "click";
-    case "collect_search_notes":
-    case "collect_note_details":
+    case "collect_search_list":
+    case "collect_search_item_details":
     case "collect_structured_data":
       return "capture_response";
     case "validate_page":
@@ -23324,12 +23297,12 @@ function mapToolNameToTaskOperation(tool) {
       return "unknown";
   }
 }
-function buildTaskProgressView(steps, currentStepId, status, hint) {
-  if (!Array.isArray(steps) || steps.length === 0) {
+function buildTaskProgressView(entries, currentEntryId, status, hint) {
+  if (!Array.isArray(entries) || entries.length === 0) {
     return void 0;
   }
-  const total = steps.length;
-  const currentIndex = typeof currentStepId === "string" ? steps.findIndex((step) => step.stepId === currentStepId) : -1;
+  const total = entries.length;
+  const currentIndex = typeof currentEntryId === "string" ? entries.findIndex((entry) => entry.nodeId === currentEntryId) : -1;
   let current = 0;
   if (currentIndex >= 0) {
     current = currentIndex + 1;
@@ -23346,13 +23319,19 @@ function buildTaskProgressView(steps, currentStepId, status, hint) {
 }
 function buildTaskStatusView(input) {
   const waitReason = input.waitReason ?? mapTaskStatusToWaitReason(input.status);
-  const progress = buildTaskProgressView(input.steps, input.currentStepId, input.status, input.progressHint);
-  const resolvedCurrentStepStatus = input.currentStepStatus ?? mapTaskStatusToCurrentStepStatus(input.status);
-  const currentStep = input.currentStepId && resolvedCurrentStepStatus ? {
-    stepId: input.currentStepId,
-    tool: input.currentStepTool,
-    name: input.currentStepName,
-    status: resolvedCurrentStepStatus
+  const progressEntries = Array.isArray(input.nodes) && input.nodes.length > 0 ? input.nodes.map((node) => ({ nodeId: node.nodeId })) : input.progressEntries;
+  const progress = buildTaskProgressView(
+    progressEntries,
+    input.currentNodeId,
+    input.status,
+    input.progressHint
+  );
+  const resolvedCurrentNodeStatus = input.currentNodeStatus ?? mapTaskStatusToCurrentNodeStatus(input.status);
+  const currentNode = input.currentNodeId && resolvedCurrentNodeStatus ? {
+    nodeId: input.currentNodeId,
+    tool: input.currentNodeTool,
+    name: input.currentNodeName,
+    status: resolvedCurrentNodeStatus
   } : void 0;
   return {
     status: mapTaskStatusToViewStatus(input.status),
@@ -23360,13 +23339,120 @@ function buildTaskStatusView(input) {
     capability: input.capability,
     currentOperation: input.currentOperation,
     progress,
-    currentStep,
+    currentNode,
+    browsingContext: input.browsingContext,
     captureWindow: input.captureWindow,
     lastArtifact: input.lastArtifact ?? null
   };
 }
 
+// relay/src/runtime-node-execution.ts
+function deriveNodeIdempotency(node) {
+  if (node.idempotency) {
+    return node.idempotency;
+  }
+  switch (node.tool) {
+    case "get_page_state":
+    case "validate_page":
+    case "list_tabs":
+    case "collect_search_list":
+    case "collect_search_item_details":
+    case "collect_structured_data":
+      return "safe_retry";
+    case "trigger_action":
+    case "fill_field":
+    case "switch_tab":
+    case "open_tab":
+      return "conditional_retry";
+    case "upload_assets":
+    case "ensure_publish_ready":
+      return "non_idempotent";
+    default:
+      return "conditional_retry";
+  }
+}
+function buildRecoveryAnchor(task, nodeId, status) {
+  const activeContext = Array.isArray(task.browsingContexts) && task.currentContextId ? task.browsingContexts.find((context) => context.contextId === task.currentContextId) ?? null : null;
+  return {
+    nodeId,
+    status,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    contextId: task.currentContextId,
+    pageId: activeContext?.pageId ?? task.currentPageId,
+    pageSignature: activeContext?.pageSignature ?? null,
+    tabId: activeContext?.tabId ?? task.currentTabId,
+    windowId: activeContext?.windowId,
+    url: activeContext?.url
+  };
+}
+function ensureTaskNodeResults(task) {
+  task.payload.nodeResults = task.payload.nodeResults || {};
+  const nodes = Array.isArray(task.payload.nodes) ? task.payload.nodes : [];
+  for (const node of nodes) {
+    const previous = task.payload.nodeResults[node.nodeId];
+    task.payload.nodeResults[node.nodeId] = {
+      nodeId: node.nodeId,
+      status: previous?.status ?? "pending",
+      attempts: previous?.attempts ?? 0,
+      lastUpdatedAt: previous?.lastUpdatedAt,
+      idempotency: previous?.idempotency ?? deriveNodeIdempotency(node),
+      recoveryAnchor: previous?.recoveryAnchor ?? null,
+      error: previous?.error ?? null,
+      result: previous?.result ?? null
+    };
+  }
+  return task.payload.nodeResults;
+}
+function markNodeDispatched(task, node) {
+  const nodeResults = ensureTaskNodeResults(task);
+  const previous = nodeResults[node.nodeId];
+  nodeResults[node.nodeId] = {
+    nodeId: node.nodeId,
+    status: "running",
+    attempts: (previous?.attempts ?? 0) + 1,
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    idempotency: previous?.idempotency ?? deriveNodeIdempotency(node),
+    recoveryAnchor: buildRecoveryAnchor(task, node.nodeId, "running"),
+    error: null,
+    result: previous?.result ?? null
+  };
+}
+function updateNodeExecutionStatus(task, nodeId, status, options) {
+  const nodeResults = ensureTaskNodeResults(task);
+  const previous = nodeResults[nodeId];
+  if (!previous) {
+    return;
+  }
+  nodeResults[nodeId] = {
+    ...previous,
+    status,
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    recoveryAnchor: buildRecoveryAnchor(task, nodeId, status),
+    error: options?.error ?? previous.error ?? null,
+    result: options?.result ?? previous.result ?? null
+  };
+}
+
 // relay/src/task-status-view.ts
+function buildMirroredSteps(task) {
+  const nodes = Array.isArray(task.payload?.nodes) ? task.payload.nodes : [];
+  const nodeResults = task.payload?.nodeResults || {};
+  return nodes.map((node) => {
+    const nodeResult = nodeResults[node.nodeId];
+    return {
+      nodeId: node.nodeId,
+      name: node.name || node.nodeId,
+      goal: node.goal,
+      tool: node.tool,
+      args: node.args,
+      onFailure: node.onFailure,
+      preconditions: node.preconditions,
+      expectedObservation: node.expectedObservation,
+      status: nodeResult?.status === "pending" ? "pending" : nodeResult?.status === "running" ? "running" : nodeResult?.status === "skipped" ? "skipped" : nodeResult?.status === "failed" ? "failed" : "success",
+      result: nodeResult?.result ?? null
+    };
+  });
+}
 function resolveTaskCapability(task, captureCapability) {
   if (captureCapability) {
     return captureCapability;
@@ -23374,7 +23460,6 @@ function resolveTaskCapability(task, captureCapability) {
   switch (task.type) {
     case "publish_note":
     case "save_note_draft":
-    case "open_website":
     case "browser_action":
     case "search_notes":
       return "browser";
@@ -23395,22 +23480,44 @@ function isCaptureOperation(operation) {
       return false;
   }
 }
+function mapProcessStatusToRuntimeNodeStatus(status) {
+  switch (status) {
+    case "running":
+    case "waiting":
+      return "running";
+    case "succeeded":
+      return "success";
+    case "failed":
+      return "failed";
+    case "skipped":
+      return "skipped";
+    default:
+      return "pending";
+  }
+}
 function applyTaskStatusView(task, overrides) {
-  const steps = Array.isArray(task.payload?.steps) ? task.payload.steps : [];
-  const currentStepId = overrides?.currentStepId ?? task.currentStepId;
-  const matchedStep = currentStepId ? steps.find((step) => step.stepId === currentStepId) : void 0;
-  const nextOperation = overrides?.currentOperation ?? mapToolNameToTaskOperation(overrides?.currentStepTool ?? matchedStep?.tool);
+  const nodes = Array.isArray(task.payload?.nodes) ? task.payload.nodes : [];
+  const steps = buildMirroredSteps(task);
+  const currentNodeId = overrides?.currentNodeId ?? task.currentNodeId;
+  const matchedStep = currentNodeId ? steps.find((step) => step.nodeId === currentNodeId) : void 0;
+  const matchedNode = currentNodeId ? nodes.find((node) => node.nodeId === currentNodeId) : void 0;
+  const nextOperation = overrides?.currentOperation ?? mapToolNameToTaskOperation(overrides?.currentNodeTool ?? matchedStep?.tool);
   const captureWindow = overrides?.captureWindow ?? task.statusView?.captureWindow;
   task.statusView = buildTaskStatusView({
     status: task.status,
-    steps,
-    currentStepId,
-    currentStepTool: overrides?.currentStepTool ?? matchedStep?.tool,
-    currentStepName: overrides?.currentStepName ?? matchedStep?.name,
-    currentStepStatus: overrides?.currentStepStatus,
+    progressEntries: steps,
+    nodes,
+    currentNodeId: matchedNode?.nodeId ?? currentNodeId,
+    currentNodeTool: overrides?.currentNodeTool ?? matchedStep?.tool,
+    currentNodeName: overrides?.currentNodeName ?? matchedNode?.name ?? matchedStep?.name,
+    currentNodeStatus: overrides?.currentNodeStatus,
     capability: resolveTaskCapability(task, captureWindow?.capability),
     currentOperation: nextOperation,
     waitReason: overrides?.waitReason,
+    browsingContext: task.browsingContexts?.length ? {
+      activeContextId: task.currentContextId,
+      contexts: task.browsingContexts
+    } : void 0,
     captureWindow,
     lastArtifact: overrides?.lastArtifact ?? task.statusView?.lastArtifact,
     progressHint: overrides?.progressHint
@@ -23428,25 +23535,22 @@ function resolveCaptureWindowForStepProcess(task, currentOperation) {
   }
   return captureWindow;
 }
-function applyTaskStepProcessView(task, payload) {
-  const steps = Array.isArray(task.payload?.steps) ? task.payload.steps : [];
-  const matchedStep = steps.find((step) => step.stepId === payload.stepId);
-  if (matchedStep) {
-    if (payload.status === "running" || payload.status === "waiting") {
-      matchedStep.status = "running";
-    } else if (payload.status === "succeeded") {
-      matchedStep.status = "success";
-    } else if (payload.status === "failed") {
-      matchedStep.status = "failed";
-    } else if (payload.status === "skipped") {
-      matchedStep.status = "skipped";
-    }
+function applyTaskNodeProcessView(task, payload) {
+  const nodes = Array.isArray(task.payload?.nodes) ? task.payload.nodes : [];
+  const steps = buildMirroredSteps(task);
+  const matchedStep = steps.find((step) => step.nodeId === payload.nodeId);
+  const matchedNode = nodes.find((node) => node.nodeId === payload.nodeId);
+  if (matchedNode) {
+    task.currentNodeId = matchedNode.nodeId;
+  }
+  if (matchedNode) {
+    updateNodeExecutionStatus(task, payload.nodeId, mapProcessStatusToRuntimeNodeStatus(payload.status));
   }
   applyTaskStatusView(task, {
-    currentStepId: payload.stepId,
-    currentStepTool: payload.tool ?? matchedStep?.tool,
-    currentStepName: payload.name ?? matchedStep?.name,
-    currentStepStatus: payload.status,
+    currentNodeId: payload.nodeId,
+    currentNodeTool: payload.tool ?? matchedStep?.tool,
+    currentNodeName: payload.name ?? matchedNode?.name ?? matchedStep?.name,
+    currentNodeStatus: payload.status,
     currentOperation: payload.currentOperation,
     waitReason: "waitReason" in payload ? payload.waitReason : void 0,
     captureWindow: resolveCaptureWindowForStepProcess(task, payload.currentOperation)
@@ -23454,10 +23558,10 @@ function applyTaskStepProcessView(task, payload) {
   if (!task.statusView) {
     return;
   }
-  task.statusView.currentStep = {
-    stepId: payload.stepId,
+  task.statusView.currentNode = {
+    nodeId: payload.nodeId,
     tool: payload.tool ?? matchedStep?.tool,
-    name: payload.name ?? matchedStep?.name,
+    name: payload.name ?? matchedNode?.name ?? matchedStep?.name,
     status: payload.status
   };
   task.statusView.currentOperation = payload.currentOperation ?? task.statusView.currentOperation;
@@ -23555,28 +23659,28 @@ var TaskReadyRegistry = class {
   }
 };
 
-// relay/src/step-result-guard.ts
-function guardStepResult(task, orchestrator, result) {
+// relay/src/node-result-guard.ts
+function guardNodeResult(task, orchestrator, result) {
   if (!task) {
     return { accept: false, reason: "task_missing" };
   }
   if (!orchestrator) {
     return { accept: false, reason: "orchestrator_missing" };
   }
-  const expectedStep = task.payload?.steps?.[orchestrator.currentStepIndex];
-  if (!expectedStep) {
-    return { accept: false, reason: "step_missing" };
+  const expectedNode = task.payload?.nodes?.[orchestrator.currentStepIndex];
+  if (!expectedNode) {
+    return { accept: false, reason: "node_missing" };
   }
-  if (expectedStep.stepId !== result.stepId) {
+  if (expectedNode.nodeId !== result.nodeId) {
     return {
       accept: false,
-      reason: "step_mismatch",
-      expectedStepId: expectedStep.stepId
+      reason: "node_mismatch",
+      expectedNodeId: expectedNode.nodeId
     };
   }
   return {
     accept: true,
-    expectedStepId: expectedStep.stepId
+    expectedNodeId: expectedNode.nodeId
   };
 }
 
@@ -23585,6 +23689,8 @@ function isTerminalTaskStatus(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
 }
 function buildTaskFinalResult(task) {
+  const nodes = task.payload?.nodes || [];
+  const nodeResults = task.payload?.nodeResults || {};
   return {
     taskId: task.taskId,
     type: task.type,
@@ -23592,40 +23698,327 @@ function buildTaskFinalResult(task) {
     status: task.status,
     statusView: task.statusView,
     lastError: task.lastError ?? null,
-    currentStepId: task.currentStepId,
+    currentNodeId: task.currentNodeId,
+    currentContextId: task.currentContextId,
+    resolvedContextId: task.resolvedContextId,
+    candidateChildContextIds: task.candidateChildContextIds ?? [],
+    lastTriggeredNavigation: task.lastTriggeredNavigation ?? null,
+    browsingContexts: task.browsingContexts ?? [],
     updatedAt: task.updatedAt,
-    steps: (task.payload?.steps || []).map((step) => ({
-      stepId: step.stepId,
-      name: step.name,
-      tool: step.tool,
-      status: step.status,
-      result: step.result ?? null
-    })),
+    steps: nodes.map((node) => {
+      const nodeResult = nodeResults[node.nodeId];
+      return {
+        nodeId: node.nodeId,
+        name: node.name,
+        tool: node.tool,
+        status: nodeResult?.status === "pending" ? "pending" : nodeResult?.status === "running" ? "running" : nodeResult?.status === "skipped" ? "skipped" : nodeResult?.status === "failed" ? "failed" : "success",
+        result: nodeResult?.result ?? null
+      };
+    }),
+    nodes: nodes.map((node) => {
+      const mirroredNodeResult = nodeResults[node.nodeId];
+      return {
+        nodeId: node.nodeId,
+        name: node.name,
+        tool: node.tool,
+        status: mirroredNodeResult?.status ?? "pending",
+        attempts: mirroredNodeResult?.attempts ?? 0,
+        lastUpdatedAt: mirroredNodeResult?.lastUpdatedAt,
+        idempotency: mirroredNodeResult?.idempotency,
+        recoveryAnchor: mirroredNodeResult?.recoveryAnchor ?? null,
+        error: mirroredNodeResult?.error ?? null,
+        result: mirroredNodeResult?.result ?? null
+      };
+    }),
     lastArtifact: task.statusView?.lastArtifact ?? null
   };
 }
 
-// relay/src/task-step-result.ts
-function mapStepResultToStepStatus(result) {
+// shared/node-template-compiler.ts
+function deriveOnFailurePolicyFromRetry(node) {
+  if (node.onFailure) {
+    return node.onFailure;
+  }
+  if (!node.retry || node.retry.attempts <= 1) {
+    return void 0;
+  }
+  if (node.retry.attempts === 2) {
+    return { policy: "retry_once" };
+  }
+  return { policy: "retry_twice" };
+}
+function buildRuntimeNodeMeta(node) {
+  const runtimeNodeMeta = {};
+  if (node.inputs?.length) {
+    runtimeNodeMeta.inputs = node.inputs;
+  }
+  if (node.outputs?.length) {
+    runtimeNodeMeta.outputs = node.outputs;
+  }
+  if (node.fromContext && Object.keys(node.fromContext).length > 0) {
+    runtimeNodeMeta.fromContext = node.fromContext;
+  }
+  if (typeof node.storeAs === "string" && node.storeAs.length > 0) {
+    runtimeNodeMeta.storeAs = node.storeAs;
+  }
+  if (typeof node.outputScope === "string" && node.outputScope.length > 0) {
+    runtimeNodeMeta.outputScope = node.outputScope;
+  }
+  if (typeof node.timeoutMs === "number" && Number.isFinite(node.timeoutMs) && node.timeoutMs > 0) {
+    runtimeNodeMeta.timeoutMs = node.timeoutMs;
+  }
+  if (typeof node.optional === "boolean") {
+    runtimeNodeMeta.optional = node.optional;
+  }
+  if (node.assert?.length) {
+    runtimeNodeMeta.assert = node.assert;
+  }
+  if (node.fallback) {
+    runtimeNodeMeta.fallback = node.fallback;
+  }
+  if (node.retry) {
+    runtimeNodeMeta.retry = node.retry;
+  }
+  if (typeof node.when === "string" && node.when.trim().length > 0) {
+    runtimeNodeMeta.when = node.when;
+  }
+  return Object.keys(runtimeNodeMeta).length > 0 ? runtimeNodeMeta : void 0;
+}
+function compileNodeToExecution(node) {
+  const runtimeNodeMeta = buildRuntimeNodeMeta(node);
+  return {
+    nodeId: node.nodeId,
+    name: node.name || node.nodeId,
+    goal: node.goal,
+    tool: node.tool,
+    args: runtimeNodeMeta ? {
+      ...node.args,
+      __runtimeNode: runtimeNodeMeta
+    } : node.args,
+    onFailure: deriveOnFailurePolicyFromRetry(node),
+    preconditions: node.preconditions,
+    expectedObservation: node.expectedObservation,
+    status: "pending"
+  };
+}
+
+// relay/src/runtime-node-fallback.ts
+function readRuntimeNodeFallback(task, stepIndex) {
+  const node = task.payload?.nodes?.[stepIndex];
+  return node?.fallback ?? null;
+}
+function resolveFallbackStepIndex(task, currentStepIndex, result) {
+  if (result.ok) {
+    return null;
+  }
+  const fallback = readRuntimeNodeFallback(task, currentStepIndex);
+  if (!fallback || fallback.policy === "abort") {
+    return null;
+  }
+  if (fallback.nodeId) {
+    const nextIndex = Array.isArray(task.payload?.nodes) ? task.payload.nodes.findIndex((node) => node.nodeId === fallback.nodeId) : -1;
+    return nextIndex >= 0 ? nextIndex : null;
+  }
+  if (fallback.policy === "continue") {
+    return currentStepIndex + 1;
+  }
+  return null;
+}
+
+// relay/src/task-node-result.ts
+function mapNodeResultToExecutionStatus(result) {
   return result.ok ? "success" : "failed";
 }
-function normalizeStepResult(result, normalizedError) {
+function normalizeNodeResult(result, normalizedError) {
   return {
     ...result,
     error: normalizedError
   };
 }
-function persistStepResultOnTask(task, result) {
-  const steps = Array.isArray(task.payload?.steps) ? task.payload.steps : [];
-  const matchedStep = steps.find((step) => step.stepId === result.stepId);
-  if (!matchedStep) {
+function persistNodeResultOnTask(task, result) {
+  const nodes = Array.isArray(task.payload?.nodes) ? task.payload.nodes : [];
+  const matchedNode = nodes.find((node) => node.nodeId === result.nodeId);
+  if (!matchedNode) {
     return false;
   }
-  matchedStep.status = mapStepResultToStepStatus(result);
-  matchedStep.result = result;
+  updateNodeExecutionStatus(task, result.nodeId, mapNodeResultToExecutionStatus(result), {
+    result,
+    error: result.error
+  });
   return true;
 }
 
+// relay/src/runtime-task-orchestrator.ts
+function createTaskOrchestrator(task) {
+  const executionLength = getTaskExecutionLength(task);
+  if (executionLength === 0) {
+    return null;
+  }
+  const recovery = resolveNodeExecutionRecovery(task);
+  return {
+    currentStepIndex: recovery?.index ?? 0,
+    recovery: recovery?.state ?? null
+  };
+}
+function hydrateTaskFromRecoveryAnchor(task, anchor) {
+  if (!anchor) {
+    return;
+  }
+  if (anchor.contextId) {
+    task.currentContextId = anchor.contextId;
+  }
+  if (typeof anchor.tabId === "number") {
+    task.currentTabId = anchor.tabId;
+  }
+  if (anchor.pageId) {
+    task.currentPageId = anchor.pageId;
+  }
+  if (!anchor.contextId || typeof anchor.tabId !== "number") {
+    return;
+  }
+  const browsingContexts = Array.isArray(task.browsingContexts) ? [...task.browsingContexts] : [];
+  const existingIndex = browsingContexts.findIndex((context) => context.contextId === anchor.contextId);
+  const nextContext = {
+    contextId: anchor.contextId,
+    tabId: anchor.tabId,
+    windowId: anchor.windowId,
+    url: anchor.url,
+    pageId: anchor.pageId,
+    pageSignature: anchor.pageSignature ?? null,
+    role: "active",
+    origin: "detected",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (existingIndex >= 0) {
+    browsingContexts[existingIndex] = {
+      ...browsingContexts[existingIndex],
+      ...nextContext
+    };
+  } else {
+    browsingContexts.push(nextContext);
+  }
+  task.browsingContexts = browsingContexts;
+}
+function resolveNodeExecutionRecovery(task) {
+  const nodes = Array.isArray(task.payload?.nodes) ? task.payload.nodes : [];
+  if (nodes.length === 0) {
+    return {
+      index: 0,
+      state: null
+    };
+  }
+  const nodeResults = ensureTaskNodeResults(task);
+  for (let index = 0; index < nodes.length; index += 1) {
+    const node = nodes[index];
+    const nodeResult = nodeResults[node.nodeId];
+    const status = nodeResult?.status ?? "pending";
+    if (status === "success" || status === "skipped") {
+      continue;
+    }
+    const anchor = nodeResult?.recoveryAnchor ?? null;
+    hydrateTaskFromRecoveryAnchor(task, anchor);
+    if (status === "running") {
+      return {
+        index,
+        state: {
+          nodeId: node.nodeId,
+          anchor,
+          reason: "resume_running"
+        }
+      };
+    }
+    if (status === "failed") {
+      return {
+        index,
+        state: {
+          nodeId: node.nodeId,
+          anchor,
+          reason: "retry_failed"
+        }
+      };
+    }
+    return {
+      index,
+      state: index > 0 ? {
+        nodeId: node.nodeId,
+        anchor,
+        reason: "resume_after_completed_prefix"
+      } : null
+    };
+  }
+  return {
+    index: nodes.length,
+    state: null
+  };
+}
+function getTaskExecutionLength(task) {
+  return Array.isArray(task.payload?.nodes) ? task.payload.nodes.length : 0;
+}
+function resolveTaskExecutionStep(task, index) {
+  const node = task.payload?.nodes?.[index];
+  if (!node) {
+    return null;
+  }
+  const compiledNode = compileNodeToExecution(node);
+  const nodeResults = ensureTaskNodeResults(task);
+  const nodeResult = nodeResults[node.nodeId];
+  return {
+    ...compiledNode,
+    status: nodeResult?.status === "pending" ? "pending" : nodeResult?.status === "running" ? "running" : nodeResult?.status === "skipped" ? "skipped" : nodeResult?.status === "failed" ? "failed" : "success",
+    result: nodeResult?.result ?? null
+  };
+}
+function resolveCurrentTaskExecutionStep(task, orchestrator) {
+  return resolveTaskExecutionStep(task, orchestrator.currentStepIndex);
+}
+function markTaskExecutionDispatch(task, orchestrator) {
+  const step = resolveCurrentTaskExecutionStep(task, orchestrator);
+  if (!step) {
+    return null;
+  }
+  task.status = "running";
+  task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const activeNode = task.payload?.nodes?.[orchestrator.currentStepIndex];
+  if (activeNode) {
+    task.currentNodeId = activeNode.nodeId;
+    ensureTaskNodeResults(task);
+    markNodeDispatched(task, activeNode);
+  }
+  return step;
+}
+function advanceTaskOrchestrator(orchestrator, nextStepIndex) {
+  if (typeof nextStepIndex === "number" && Number.isFinite(nextStepIndex) && nextStepIndex >= 0) {
+    orchestrator.currentStepIndex = nextStepIndex;
+  } else {
+    orchestrator.currentStepIndex += 1;
+  }
+  return orchestrator.currentStepIndex;
+}
+function applyTaskExecutionResult(task, orchestrator, result) {
+  const observationError = typeof result.observation?.error === "string" ? result.observation.error : void 0;
+  const normalizedNodeError = result.error || (!result.ok ? {
+    code: "ERR_STEP_EXECUTION_FAILED",
+    message: observationError || "Step execution failed"
+  } : null);
+  const persistedNodeResult = normalizeNodeResult(result, normalizedNodeError);
+  persistNodeResultOnTask(task, persistedNodeResult);
+  const fallbackStepIndex = resolveFallbackStepIndex(
+    task,
+    orchestrator.currentStepIndex,
+    persistedNodeResult
+  );
+  task.status = result.ok || fallbackStepIndex != null ? "running" : "failed";
+  task.currentNodeId = result.nodeId;
+  task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  task.lastError = result.ok || fallbackStepIndex != null ? null : normalizedNodeError;
+  return {
+    persistedNodeResult,
+    fallbackStepIndex,
+    shouldContinue: result.ok || fallbackStepIndex != null,
+    nextStepIndex: result.ok ? orchestrator.currentStepIndex + 1 : fallbackStepIndex
+  };
+}
+
 // relay/src/index.ts
 var app = (0, import_express.default)();
 var server = createServer(app);
@@ -23755,8 +24148,8 @@ function requireTaskRuntimeId(task) {
 function updateTaskStatusView(task, overrides) {
   applyTaskStatusView(task, overrides);
 }
-function updateTaskStepProcessView(task, payload) {
-  applyTaskStepProcessView(task, payload);
+function updateTaskNodeProcessView(task, payload) {
+  applyTaskNodeProcessView(task, payload);
 }
 function removeBatchJobFromQueues(batchJobId, targetRuntimeId) {
   if (targetRuntimeId) {
@@ -23843,13 +24236,32 @@ async function loadTaskTemplate(platform, taskType, siteId) {
   });
   throw new Error(`TaskTemplate not found: ${missingTemplateKey}`);
 }
-function reindexSubmissionSteps(steps) {
-  return steps.map((step, index) => ({
-    ...step,
-    stepId: `s${index + 1}`,
-    name: step.name || `s${index + 1}`,
-    status: "pending"
-  }));
+async function hydrateTaskSubmissionWithTemplate(taskConfig) {
+  if (Array.isArray(taskConfig.nodes) && taskConfig.nodes.length > 0) {
+    return taskConfig;
+  }
+  const siteId = taskConfig.context?.siteId;
+  const template = await loadTaskTemplate(taskConfig.platform, taskConfig.taskType, siteId);
+  const baseSubmission = TemplateExecutor.isPublishItemTemplate(template) ? await templateExecutor.executePublishItem(template, TemplateExecutor.buildPublishItemInput(taskConfig.payload || {})) : await templateExecutor.execute(template, taskConfig.payload || {});
+  return {
+    ...baseSubmission,
+    taskType: taskConfig.taskType,
+    platform: taskConfig.platform,
+    targetRuntimeId: taskConfig.targetRuntimeId,
+    sourceClientId: taskConfig.sourceClientId,
+    context: {
+      ...baseSubmission.context,
+      ...taskConfig.context
+    },
+    payload: {
+      ...baseSubmission.payload || {},
+      ...taskConfig.payload || {}
+    },
+    options: {
+      ...baseSubmission.options,
+      ...taskConfig.options
+    }
+  };
 }
 function resolveImageRefs(noteSource, payload) {
   const imageRefs = Array.isArray(payload.imageRefs) ? payload.imageRefs.map(String) : null;
@@ -23884,11 +24296,19 @@ async function prepareResolvedAssets(filePaths) {
   }
   return assets;
 }
-function extractLegacyUploadPaths(taskConfig) {
+function extractDirectAssetPaths(taskConfig) {
+  const payloadImageRefs = Array.isArray(taskConfig.payload?.imageRefs) ? taskConfig.payload.imageRefs.filter((value) => typeof value === "string") : [];
+  if (payloadImageRefs.length > 0) {
+    return payloadImageRefs;
+  }
+  const payloadImages = Array.isArray(taskConfig.payload?.images) ? taskConfig.payload.images.filter((value) => typeof value === "string") : [];
+  if (payloadImages.length > 0) {
+    return payloadImages;
+  }
   const paths = [];
-  for (const step of taskConfig.steps || []) {
-    if (step.tool === "upload_assets" && Array.isArray(step.args?.assets)) {
-      for (const asset of step.args.assets) {
+  for (const node of taskConfig.nodes || []) {
+    if (node.tool === "upload_assets" && Array.isArray(node.args?.assets)) {
+      for (const asset of node.args.assets) {
         if (typeof asset === "string") {
           paths.push(asset);
         }
@@ -23897,14 +24317,14 @@ function extractLegacyUploadPaths(taskConfig) {
   }
   return paths;
 }
-function rewriteUploadStepsWithAssetIds(steps, assets) {
+function rewriteUploadNodesWithAssetIds(nodes, assets) {
   const assetIds = assets.map((asset) => asset.fileId || asset.id);
-  return steps.map((step) => {
-    if (step.tool !== "upload_assets") return step;
+  return (nodes || []).map((node) => {
+    if (node.tool !== "upload_assets") return node;
     return {
-      ...step,
+      ...node,
       args: {
-        ...step.args,
+        ...node.args,
         assets: assetIds
       }
     };
@@ -23943,11 +24363,11 @@ async function assembleTaskFromSubmission(taskConfig, source) {
     const relativeImages = resolveImageRefs(noteSource, normalizedPayload);
     resolvedFilePaths = relativeImages.map((relativePath) => path3.resolve(workspace.rootDir, relativePath));
   } else {
-    resolvedFilePaths = extractLegacyUploadPaths(taskConfig);
+    resolvedFilePaths = extractDirectAssetPaths(taskConfig);
   }
   console.log(`[Relay] \u89E3\u6790\u7684\u6587\u4EF6\u8DEF\u5F84:`, resolvedFilePaths);
   const assets = await prepareResolvedAssets(resolvedFilePaths);
-  const rewrittenSteps = rewriteUploadStepsWithAssetIds(taskConfig.steps || [], assets);
+  const rewrittenNodes = rewriteUploadNodesWithAssetIds(taskConfig.nodes, assets);
   const taskId = `task_${Date.now()}`;
   const task = {
     taskId,
@@ -23956,7 +24376,7 @@ async function assembleTaskFromSubmission(taskConfig, source) {
     platform: taskConfig.platform,
     payload: {
       ...normalizedPayload,
-      steps: rewrittenSteps
+      nodes: Array.isArray(rewrittenNodes) ? rewrittenNodes : void 0
     },
     assets,
     options: {
@@ -23972,6 +24392,7 @@ async function assembleTaskFromSubmission(taskConfig, source) {
     context: taskConfig.context,
     lastError: null
   };
+  ensureTaskNodeResults(task);
   updateTaskStatusView(task);
   return task;
 }
@@ -23987,14 +24408,13 @@ async function buildBatchItemSubmission(batchJob, item, itemIndex) {
     images: item.images,
     metadata: item.metadata
   }));
-  const steps = reindexSubmissionSteps(baseSubmission.steps || []);
   console.log("[Relay] \u6279\u91CF\u6761\u76EE\u6D3E\u751F\u7ED3\u679C:", {
     batchJobId: batchJob.batchJobId,
     itemIndex,
     noteSourceId: item.noteSourceId,
     topicCount: Array.isArray(item.topics) ? item.topics.length : 0,
     topics: item.topics || [],
-    stepTools: steps.map((step) => `${step.stepId}:${step.tool}`),
+    nodeTools: (baseSubmission.nodes || []).map((node) => `${node.nodeId}:${node.tool}`),
     contentTailPreview: typeof baseSubmission.payload?.content === "string" ? baseSubmission.payload.content.slice(-160) : ""
   });
   return {
@@ -24024,8 +24444,7 @@ async function buildBatchItemSubmission(batchJob, item, itemIndex) {
       humanLike: true,
       allowFallback: true,
       requireConfirmation: false
-    },
-    steps
+    }
   };
 }
 async function dispatchTask(task) {
@@ -24045,7 +24464,7 @@ async function dispatchTask(task) {
     siteId: task.context?.siteId,
     batchJobId: task.context?.batchJobId,
     batchItemIndex: task.context?.batchItemIndex,
-    stepTools: task.payload?.steps?.map((step) => `${step.stepId}:${step.tool}`) || []
+    nodeTools: task.payload?.nodes?.map((node) => `${node.nodeId}:${node.tool}`) || []
   });
   const taskMessage = {
     type: "task.submit",
@@ -24245,7 +24664,8 @@ async function registerAndDispatchTask(task) {
   return task;
 }
 async function submitTaskSubmission(taskConfig, source) {
-  const task = await assembleTaskFromSubmission(taskConfig, source);
+  const hydratedTaskConfig = await hydrateTaskSubmissionWithTemplate(taskConfig);
+  const task = await assembleTaskFromSubmission(hydratedTaskConfig, source);
   await registerAndDispatchTask(task);
   return task;
 }
@@ -24261,11 +24681,11 @@ async function handleRuntimeMessage(msg) {
     case "task.status":
       handleTaskStatus(msg);
       break;
-    case "step.started":
-      handleStepStarted(msg);
+    case "node.started":
+      handleNodeStarted(msg);
       break;
-    case "step.status":
-      handleStepStatus(msg);
+    case "node.status":
+      handleNodeStatus(msg);
       break;
     case "capture.started":
       handleCaptureStarted(msg);
@@ -24276,8 +24696,8 @@ async function handleRuntimeMessage(msg) {
     case "artifact.created":
       handleArtifactCreated(msg);
       break;
-    case "step.result":
-      handleStepResult(msg);
+    case "node.result":
+      handleNodeResult(msg);
       break;
     case "runtime.query.result":
       handleRuntimeQueryResult(msg);
@@ -24313,75 +24733,84 @@ function handleArtifactCreated(msg) {
   }
   applyArtifactCreatedToTask(task, payload);
 }
-function handleStepStarted(msg) {
+function handleNodeStarted(msg) {
   const payload = msg.payload;
   const task = tasks.get(payload.taskId);
   if (!task) {
     return;
   }
-  task.currentStepId = payload.stepId;
+  task.currentNodeId = payload.nodeId;
   task.updatedAt = payload.updatedAt || (/* @__PURE__ */ new Date()).toISOString();
-  updateTaskStepProcessView(task, payload);
+  updateTaskNodeProcessView(task, {
+    taskId: payload.taskId,
+    nodeId: payload.nodeId,
+    tool: payload.tool,
+    name: payload.name,
+    status: payload.status,
+    updatedAt: payload.updatedAt,
+    currentOperation: payload.currentOperation
+  });
 }
-function handleStepStatus(msg) {
+function handleNodeStatus(msg) {
   const payload = msg.payload;
   const task = tasks.get(payload.taskId);
   if (!task) {
     return;
   }
-  task.currentStepId = payload.stepId;
+  task.currentNodeId = payload.nodeId;
   task.updatedAt = payload.updatedAt || (/* @__PURE__ */ new Date()).toISOString();
-  updateTaskStepProcessView(task, payload);
+  updateTaskNodeProcessView(task, {
+    taskId: payload.taskId,
+    nodeId: payload.nodeId,
+    tool: payload.tool,
+    name: payload.name,
+    status: payload.status,
+    updatedAt: payload.updatedAt,
+    currentOperation: payload.currentOperation,
+    waitReason: payload.waitReason,
+    message: payload.message
+  });
 }
-function handleStepResult(msg) {
-  const result = msg.payload;
-  logRelayFlow("Received step result", {
-    taskId: result.taskId,
-    stepId: result.stepId,
-    ok: result.ok,
-    status: result.status,
-    error: result.error?.message,
-    observation: result.observation
+function handleNodeResult(msg) {
+  const rawResult = msg.payload;
+  logRelayFlow("Received node result", {
+    taskId: rawResult.taskId,
+    nodeId: rawResult.nodeId,
+    ok: rawResult.ok,
+    status: rawResult.status,
+    error: rawResult.error?.message,
+    observation: rawResult.observation
   });
-  const task = tasks.get(result.taskId);
-  const orchestrator = orchestrators.get(result.taskId);
-  const decision = guardStepResult(task, orchestrator, result);
+  const task = tasks.get(rawResult.taskId);
+  const orchestrator = orchestrators.get(rawResult.taskId);
+  const decision = guardNodeResult(task, orchestrator, rawResult);
   if (!decision.accept) {
     if (decision.reason === "task_missing") {
-      console.warn(`[Relay] \u5FFD\u7565 step.result\uFF1A\u4EFB\u52A1\u4E0D\u5B58\u5728 (${result.taskId})`);
+      console.warn(`[Relay] \u5FFD\u7565 node.result\uFF1A\u4EFB\u52A1\u4E0D\u5B58\u5728 (${rawResult.taskId})`);
     } else if (decision.reason === "orchestrator_missing") {
-      console.warn(`[Relay] \u5FFD\u7565 step.result\uFF1A\u7F16\u6392\u5668\u4E0D\u5B58\u5728\uFF0C\u53EF\u80FD\u662F\u8FDF\u5230/\u91CD\u590D\u7ED3\u679C (${result.taskId}/${result.stepId})`);
-    } else if (decision.reason === "step_missing") {
-      console.warn(`[Relay] \u5FFD\u7565 step.result\uFF1A\u5F53\u524D\u65E0\u53EF\u6267\u884C\u6B65\u9AA4\uFF0C\u53EF\u80FD\u662F\u8FDF\u5230\u7ED3\u679C (${result.taskId}/${result.stepId})`);
+      console.warn(`[Relay] \u5FFD\u7565 node.result\uFF1A\u7F16\u6392\u5668\u4E0D\u5B58\u5728\uFF0C\u53EF\u80FD\u662F\u8FDF\u5230/\u91CD\u590D\u7ED3\u679C (${rawResult.taskId}/${rawResult.nodeId})`);
+    } else if (decision.reason === "node_missing") {
+      console.warn(`[Relay] \u5FFD\u7565 node.result\uFF1A\u5F53\u524D\u65E0\u53EF\u6267\u884C\u8282\u70B9\uFF0C\u53EF\u80FD\u662F\u8FDF\u5230\u7ED3\u679C (${rawResult.taskId}/${rawResult.nodeId})`);
     } else {
       console.warn(
-        `[Relay] \u5FFD\u7565 step.result\uFF1Astep \u4E0D\u5339\u914D\uFF0Cexpected=${decision.expectedStepId}, got=${result.stepId}, task=${result.taskId}`
+        `[Relay] \u5FFD\u7565 node.result\uFF1Anode \u4E0D\u5339\u914D\uFF0Cexpected=${decision.expectedNodeId}, got=${rawResult.nodeId}, task=${rawResult.taskId}`
       );
     }
     return;
   }
   const resolvedTask = task;
-  const observationError = typeof result?.observation?.error === "string" ? result.observation.error : void 0;
-  const normalizedStepError = result.error || (!result.ok ? {
-    code: ERROR_CODES.ERR_STEP_EXECUTION_FAILED,
-    message: observationError || "Step execution failed"
-  } : null);
-  const persistedStepResult = normalizeStepResult(result, normalizedStepError);
-  persistStepResultOnTask(resolvedTask, persistedStepResult);
-  resolvedTask.status = result.ok ? "running" : "failed";
-  resolvedTask.currentStepId = result.stepId;
-  resolvedTask.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  resolvedTask.lastError = result.ok ? null : normalizedStepError;
+  const resolvedOrchestrator = orchestrator;
+  const appliedResult = applyTaskExecutionResult(resolvedTask, resolvedOrchestrator, rawResult);
   updateTaskStatusView(resolvedTask, {
-    currentStepId: result.stepId,
-    currentStepStatus: result.ok ? "succeeded" : "failed"
+    currentNodeId: rawResult.nodeId,
+    currentNodeStatus: appliedResult.persistedNodeResult.ok ? "succeeded" : "failed"
   });
-  if (result.ok) {
-    continueOrchestrator(result.taskId, result.stepId);
+  if (appliedResult.shouldContinue) {
+    continueOrchestrator(rawResult.taskId, rawResult.nodeId, appliedResult.nextStepIndex ?? void 0);
   } else {
-    orchestrators.delete(result.taskId);
+    orchestrators.delete(rawResult.taskId);
     notifyRuntimeTaskFinalized(resolvedTask, "failed");
-    void handleBatchTaskTerminal(result.taskId, "failed", resolvedTask.lastError);
+    void handleBatchTaskTerminal(rawResult.taskId, "failed", resolvedTask.lastError);
   }
 }
 function handleTaskStatus(msg) {
@@ -24391,21 +24820,26 @@ function handleTaskStatus(msg) {
   logRelayFlow("Received task status", {
     taskId: status.taskId,
     status: status.status,
-    currentStepId: status.currentStepId,
+    currentNodeId: status.currentNodeId,
     currentPageId: status.currentPageId,
     currentTabId: status.currentTabId,
     error: status.lastError?.message
   });
   task.status = status.status;
   task.lastError = status.lastError ?? task.lastError ?? null;
-  task.currentStepId = status.currentStepId ?? task.currentStepId;
+  task.currentNodeId = status.currentNodeId ?? task.currentNodeId;
   task.currentPageId = status.currentPageId ?? task.currentPageId;
   task.currentTabId = status.currentTabId ?? task.currentTabId;
+  task.currentContextId = status.currentContextId ?? task.currentContextId;
+  task.resolvedContextId = status.resolvedContextId ?? task.resolvedContextId;
+  task.candidateChildContextIds = Array.isArray(status.candidateChildContextIds) ? status.candidateChildContextIds : task.candidateChildContextIds;
+  task.lastTriggeredNavigation = status.lastTriggeredNavigation ?? task.lastTriggeredNavigation;
+  task.browsingContexts = Array.isArray(status.browsingContexts) ? status.browsingContexts : task.browsingContexts;
   task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   task.statusView = status.statusView ?? task.statusView;
   if (!task.statusView) {
     updateTaskStatusView(task, {
-      currentStepId: status.currentStepId
+      currentNodeId: status.currentNodeId
     });
   }
   if (status.status === "queued") {
@@ -24936,12 +25370,11 @@ app.post("/api/tools/:toolName/execute", async (req, res) => {
         taskType: "browser_action",
         platform: "browser",
         payload: input,
-        steps: [{
-          stepId: "s1",
+        nodes: [{
+          nodeId: toolName,
           name: toolName,
           tool: toolName,
-          args: input,
-          status: "pending"
+          args: input
         }],
         targetRuntimeId: effectiveRuntimeId
       };
@@ -24964,7 +25397,7 @@ app.post("/api/tasks", async (req, res) => {
   try {
     const taskConfig = req.body;
     console.log("[Relay] \u6536\u5230HTTP\u4EFB\u52A1\u63D0\u4EA4:", taskConfig);
-    const task = await submitTaskSubmission(taskConfig, "sidepanel");
+    const task = await submitTaskSubmission(taskConfig, "api");
     const taskId = task.taskId;
     console.log(`[Relay] \u4EFB\u52A1\u5DF2\u521B\u5EFA: ${taskId}\uFF0C\u5305\u542B ${task.assets.length} \u4E2A\u6587\u4EF6`);
     res.json({ success: true, taskId, channel: "http" });
@@ -25068,12 +25501,14 @@ function startOrchestrator(taskId) {
     console.error(`[Relay] \u4EFB\u52A1\u4E0D\u5B58\u5728: ${taskId}`);
     return;
   }
-  if (!task.payload?.steps) {
-    console.error(`[Relay] \u4EFB\u52A1\u6CA1\u6709 steps: ${taskId}`);
+  const orchestrator = createTaskOrchestrator(task);
+  if (!orchestrator) {
+    console.error(`[Relay] \u4EFB\u52A1\u6CA1\u6709\u53EF\u6267\u884C\u8282\u70B9/\u6B65\u9AA4: ${taskId}`);
     return;
   }
-  console.log(`[Relay] \u4EFB\u52A1\u6709 ${task.payload.steps.length} \u4E2A\u6B65\u9AA4`);
-  orchestrators.set(taskId, { currentStepIndex: 0 });
+  const executionLength = getTaskExecutionLength(task);
+  console.log(`[Relay] \u4EFB\u52A1\u6309 nodes \u6267\u884C\uFF0C\u5171 ${executionLength} \u4E2A\u8282\u70B9`);
+  orchestrators.set(taskId, orchestrator);
   void sendNextStep(taskId);
 }
 async function sendNextStep(taskId) {
@@ -25088,17 +25523,17 @@ async function sendNextStep(taskId) {
     console.error(`[Relay] \u7F16\u6392\u5668\u4E0D\u5B58\u5728: ${taskId}`);
     return;
   }
-  if (!task.payload?.steps) {
-    console.error(`[Relay] \u4EFB\u52A1\u6CA1\u6709 steps`);
+  const executionLength = getTaskExecutionLength(task);
+  if (executionLength === 0) {
+    console.error(`[Relay] \u4EFB\u52A1\u6CA1\u6709\u53EF\u6267\u884C\u8282\u70B9`);
     return;
   }
-  const steps = task.payload.steps;
-  console.log(`[Relay] \u5F53\u524D\u6B65\u9AA4\u7D22\u5F15: ${orch.currentStepIndex}, \u603B\u6B65\u9AA4\u6570: ${steps.length}`);
-  if (orch.currentStepIndex >= steps.length) {
+  console.log(`[Relay] \u5F53\u524D\u8282\u70B9\u7D22\u5F15: ${orch.currentStepIndex}, \u603B\u8282\u70B9\u6570: ${executionLength}`);
+  if (orch.currentStepIndex >= executionLength) {
     task.status = "completed";
     task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     updateTaskStatusView(task, {
-      currentStepId: task.currentStepId
+      currentNodeId: task.currentNodeId
     });
     orchestrators.delete(taskId);
     console.log(`[Relay] Task ${taskId} completed`);
@@ -25106,20 +25541,30 @@ async function sendNextStep(taskId) {
     void handleBatchTaskTerminal(taskId, "completed", null);
     return;
   }
-  const step = steps[orch.currentStepIndex];
-  task.status = "running";
-  task.currentStepId = step.stepId;
-  task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const step = markTaskExecutionDispatch(task, orch);
+  if (!step) {
+    task.status = "failed";
+    task.lastError = {
+      code: ERROR_CODES.ERR_INVALID_TASK,
+      message: `Unable to resolve executable node at index ${orch.currentStepIndex}`
+    };
+    task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    updateTaskStatusView(task);
+    orchestrators.delete(taskId);
+    notifyRuntimeTaskFinalized(task, "failed");
+    void handleBatchTaskTerminal(taskId, "failed", task.lastError);
+    return;
+  }
   updateTaskStatusView(task, {
-    currentStepId: step.stepId,
-    currentStepTool: step.tool,
-    currentStepName: step.name
+    currentNodeId: task.currentNodeId ?? step.nodeId,
+    currentNodeTool: step.tool,
+    currentNodeName: step.name
   });
   const stepMessage = {
-    type: "step.submit",
-    requestId: `step_${taskId}_${orch.currentStepIndex}`,
+    type: "node.submit",
+    requestId: `node_${taskId}_${orch.currentStepIndex}`,
     timestamp: Date.now(),
-    payload: { taskId, step }
+    payload: { taskId, node: step }
   };
   let targetRuntimeId;
   try {
@@ -25153,17 +25598,17 @@ async function sendNextStep(taskId) {
     void handleBatchTaskTerminal(taskId, "failed", task.lastError);
     return;
   }
-  console.log(`[Relay] Sent step ${orch.currentStepIndex + 1}/${steps.length} for task ${taskId}`);
+  console.log(`[Relay] Sent node ${orch.currentStepIndex + 1}/${executionLength} for task ${taskId}`);
 }
-function continueOrchestrator(taskId, completedStepId) {
-  console.log(`[Relay] continueOrchestrator \u88AB\u8C03\u7528: ${taskId}, stepId: ${completedStepId}`);
+function continueOrchestrator(taskId, completedNodeId, nextStepIndex) {
+  console.log(`[Relay] continueOrchestrator \u88AB\u8C03\u7528: ${taskId}, nodeId: ${completedNodeId}`);
   const orch = orchestrators.get(taskId);
   if (!orch) {
     console.error(`[Relay] \u7F16\u6392\u5668\u4E0D\u5B58\u5728: ${taskId}`);
     return;
   }
-  orch.currentStepIndex++;
-  console.log(`[Relay] \u6B65\u9AA4\u7D22\u5F15\u9012\u589E\u81F3: ${orch.currentStepIndex}`);
+  advanceTaskOrchestrator(orch, nextStepIndex);
+  console.log(`[Relay] \u8282\u70B9\u7D22\u5F15\u9012\u589E\u81F3: ${orch.currentStepIndex}`);
   setTimeout(() => {
     void sendNextStep(taskId);
   }, STEP_DISPATCH_INTERVAL_MS);