taskmeld 0.1.2 → 0.1.41

package/dist/src/pipeline/execution/node-runner.js

@@ -41,7 +41,7 @@ const createNodeRunner = (deps) => {
             node.rejectCount = 0;
             node.rejectFeedbacks = [];
             succeeded = true;
-            deps.runtimeStore.pushTimeline(`节点执行完成(结构化): ${node.id} <- ${usedAgentId}`);
+            deps.runtimeStore.pushTimeline(`Node executed (structured): ${node.id} <- ${usedAgentId}`);
         }
         else if (envelopeErrorCode === "upstream_reject" && node.allowReject) {
             node.artifacts = [];
@@ -72,7 +72,7 @@ const createNodeRunner = (deps) => {
             finalStatus = "failed";
             node.artifacts = result.artifacts;
             execError = "upstream_reject_not_allowed: node_allowReject_false";
-            deps.runtimeStore.pushTimeline(`节点执行失败(结构化): ${node.id} <- ${usedAgentId} upstream_reject_not_allowed: node_allowReject_false`, "error");
+            deps.runtimeStore.pushTimeline(`Node execution failed (structured): ${node.id} <- ${usedAgentId} upstream_reject_not_allowed: node_allowReject_false`, "error");
         }
         else {
             const structuredFailError = JSON.stringify(result.envelope.error ?? "node_failed");
@@ -84,14 +84,14 @@ const createNodeRunner = (deps) => {
             const detailText = envelopeError.message
                 ? `${envelopeError.code ? `${envelopeError.code}: ` : ""}${envelopeError.message}`
                 : envelopeError.code || "node_failed";
-            deps.runtimeStore.pushTimeline(`节点执行失败(结构化): ${node.id} <- ${usedAgentId} ${detailText}`, "error");
+            deps.runtimeStore.pushTimeline(`Node execution failed (structured): ${node.id} <- ${usedAgentId} ${detailText}`, "error");
         }
         return { succeeded, finalStatus, execError, haltPipeline };
     };
     const executeNode = async (node, opts) => {
         const resolved = await deps.sessionRegistry.resolveExecutorSession(node);
         if (!resolved) {
-            deps.runtimeStore.pushTimeline(`节点 ${node.id} 执行失败: 找不到执行者会话(${node.executor.agentId})`, "error");
+            deps.runtimeStore.pushTimeline(`Node ${node.id} execution failed: executor session not found (${node.executor.agentId})`, "error");
             (0, state_1.markNodeFailed)(node, ctx("executor_session_not_found", { error: "executor_session_not_found" }));
             deps.runtimeStore.emitPipeline();
             return {
@@ -105,7 +105,7 @@ const createNodeRunner = (deps) => {
         const sessionId = resolved.sessionId;
         const usedAgentId = resolved.agentId;
         (0, state_1.markNodeRunning)(node, ctx("exec_start"));
-        deps.runtimeStore.pushTimeline(`节点执行已触发: ${node.id} -> ${usedAgentId}`);
+        deps.runtimeStore.pushTimeline(`Node execution triggered: ${node.id} -> ${usedAgentId}`);
         deps.runtimeStore.emitPipeline();
         const effectiveDependencyIds = opts?.dependencyIds?.length
             ? Array.from(new Set(opts.dependencyIds.map((id) => id.trim()).filter(Boolean)))
@@ -134,11 +134,11 @@ const createNodeRunner = (deps) => {
             const classification = isAborted
                 ? { reason: "pipeline_aborted", haltPipeline: true }
                 : classifyNodeFailure(error);
-            // 用户中止时节点已被标记为 stopped，不应再覆盖为 failed
+            // When the user aborts, the node is already marked as stopped — should not be overwritten to failed
             if (!isAborted) {
                 (0, state_1.markNodeFailed)(node, ctx(classification.reason, { error: String(error) }));
             }
-            deps.runtimeStore.pushTimeline(`节点执行中断(结构化): ${node.id} <- ${usedAgentId} ${String(error)}`, "warn");
+            deps.runtimeStore.pushTimeline(`Node execution interrupted (structured): ${node.id} <- ${usedAgentId} ${String(error)}`, "warn");
             deps.runtimeStore.emitPipeline();
             return {
                 ok: false,

package/dist/src/pipeline/execution/readiness-state.js

@@ -5,6 +5,6 @@ const isSleepWaitingState = (candidate) => candidate.status === "waiting" && typ
 exports.isSleepWaitingState = isSleepWaitingState;
 const canPromoteToQueuedByDependency = (candidate) => candidate.status === "blocked" ||
     candidate.status === "skipped" ||
-    // 仅允许“依赖未满足”造成的 waiting 被重新入队；sleep waiting 仍需等到 wakeAt 到期。
+    // Only "waiting" caused by unmet dependencies is allowed to be re-enqueued; sleep waiting must still wait until wakeAt expires.
     (candidate.status === "waiting" && !(0, exports.isSleepWaitingState)(candidate));
 exports.canPromoteToQueuedByDependency = canPromoteToQueuedByDependency;

package/dist/src/pipeline/execution/reject-handler.js

@@ -50,7 +50,7 @@ const handleNodeReject = async (params) => {
     node.rejectCount = (node.rejectCount ?? 0) + 1;
     if (node.rejectCount > limit) {
         (0, state_1.markNodeFailed)(node, ctx("reject_limit_exceeded", { error: JSON.stringify(envelope.error ?? "reject_limit_exceeded") }));
-        pushTimeline(`节点 ${node.id} 打回超过 ${limit} 次，标记失败`, "error");
+        pushTimeline(`Node ${node.id} rejected ${limit} times, marked as failed`, "error");
         return;
     }
     const effectiveDependencyIds = dependencyIds?.length ? dependencyIds : node.dependsOn;
@@ -61,10 +61,10 @@ const handleNodeReject = async (params) => {
         : defaultTarget
             ? [defaultTarget]
             : [];
-    const rejectMessage = (0, exports.extractEnvelopeErrorMessage)(envelope.error) || "下游校验不通过，请修正后重新提交。";
+    const rejectMessage = (0, exports.extractEnvelopeErrorMessage)(envelope.error) || "Downstream validation failed, please correct and resubmit.";
     if (rejectTargetIds.length === 0) {
         (0, state_1.markNodeFailed)(node, ctx("reject_target_missing", { error: JSON.stringify(envelope.error ?? "reject_target_missing") }));
-        pushTimeline(`节点 ${node.id} 请求打回但未找到可用上游节点，标记失败`, "error");
+        pushTimeline(`Node ${node.id} requested reject but no available upstream node found, marked as failed`, "error");
         return;
     }
     (0, state_1.markNodeRejected)(node, ctx("upstream_reject", { error: JSON.stringify(envelope.error ?? "upstream_reject") }));
@@ -72,7 +72,7 @@ const handleNodeReject = async (params) => {
         const targetNode = nodes.find((current) => current.id === targetId);
         if (!targetNode)
             continue;
-        const feedback = `${node.id}(${node.title})打回原因: ${rejectMessage}`;
+        const feedback = `${node.id}(${node.title}) reject reason: ${rejectMessage}`;
         targetNode.rejectFeedbacks = [...(targetNode.rejectFeedbacks ?? []), feedback].slice(-5);
         const movedCount = await (0, rejected_artifact_archiver_1.archiveRejectedArtifacts)({
             node: targetNode,
@@ -88,7 +88,7 @@ const handleNodeReject = async (params) => {
             itemKey,
             skipNodeIds: [node.id],
         });
-        pushTimeline(`节点 ${node.id} 打回 ${targetNode.id}，原因: ${rejectMessage}；重置 ${affectedNodeCount} 个节点/${affectedGroupCount} 个并行组，归档产物 ${movedCount} 条`, "warn");
+        pushTimeline(`Node ${node.id} rejected ${targetNode.id}, reason: ${rejectMessage}; reset ${affectedNodeCount} nodes/${affectedGroupCount} parallel groups, archived ${movedCount} artifacts`, "warn");
     }
 };
 exports.handleNodeReject = handleNodeReject;

package/dist/src/pipeline/execution/rejected-artifact-archiver.js

@@ -37,7 +37,7 @@ const archiveRejectedArtifacts = async (params) => {
             moved += 1;
         }
         catch (error) {
-            pushTimeline(`归档被驳回产物失败 (节点 ${node.id}): ${error instanceof Error ? error.message : String(error)}`, "warn");
+            pushTimeline(`Failed to archive rejected artifact (node ${node.id}): ${error instanceof Error ? error.message : String(error)}`, "warn");
         }
     }
     return moved;

package/dist/src/pipeline/execution/route-item-manager.js

@@ -20,7 +20,7 @@ const normalizeAllowedRoute = (rawRoute, allowedRoutes) => {
     if (direct)
         return direct;
     const lower = trimmed.toLowerCase();
-    // 与结构化校验保持一致：大小写不一致时使用工作流声明值，避免命中丢失。
+    // Consistent with structured validation: when case differs, use the workflow-declared value to avoid missed matches.
     return allowedRoutes.find((route) => route.toLowerCase() === lower) ?? null;
 };
 const collectRouteBuckets = (content, allowedRoutes) => {
@@ -86,7 +86,7 @@ const createRouteItemManager = (options) => {
         const outgoingEdges = options.graph.getOutgoingEdges(sourceItem.nodeId);
         const isRouteNode = (options.graph.getWorkflowNodeById(sourceItem.nodeId)?.routePolicy?.allowed.length ?? 0) > 0;
         const startTargets = outgoingEdges
-            // 分流节点中 yes 是主线语义：只沿普通依赖边初始化；no/自定义值只沿路由边初始化。
+            // In routing nodes, yes is mainline semantics: only follow unconditional dependency edges; no/custom values only follow route edges.
             .filter((edge) => (isRouteNode ? (route === routes_1.MAINLINE_ROUTE_VALUE ? edge.when === null : edge.when === route) : !edge.when))
             .map((edge) => edge.to);
         const reachable = options.state.collectReachableEntities(startTargets);
@@ -192,7 +192,7 @@ const createRouteItemManager = (options) => {
                     for (const edge of options.graph.getOutgoingEdges(item.nodeId)) {
                         if (bucket.route === routes_1.MAINLINE_ROUTE_VALUE)
                             continue;
-                        // 路由节点只按命中的 route 边推进，普通边在此一律忽略，避免主线被隐式直通。
+                        // Routing nodes only advance along the matched route edge; unconditional edges are unconditionally ignored here to prevent implicit mainline passthrough.
                         if (edge.when !== bucket.route)
                             continue;
                         if (options.graph.isGroupId(edge.to)) {
@@ -211,7 +211,7 @@ const createRouteItemManager = (options) => {
                         }
                     }
                 }
-                options.runtimeStore.pushTimeline(`分流命中: ${item.nodeId}#${item.itemKey} -> ${bucket.route} (${bucket.count} 条)`);
+                options.runtimeStore.pushTimeline(`Route hit: ${item.nodeId}#${item.itemKey} -> ${bucket.route} (${bucket.count} items)`);
             }
         }
         const sleepUntil = envelope.control?.sleepUntil;

package/dist/src/pipeline/execution/run-abort-controller.js

@@ -25,9 +25,9 @@ const createRunAbortController = () => {
         entry.ac.abort();
     };
     /**
-     * 中止指定流水线运行的所有节点执行。
-     * 1. 向每个活跃节点的远端 agent 会话发送 "/stop" 命令（fire-and-forget）
-     * 2. 触发本地 AbortController 中断轮询/排水循环
+     * Abort all node executions for a given pipeline run.
+     * 1. Send "/stop" to each active node's remote agent session (fire-and-forget)
+     * 2. Trigger local AbortController to interrupt polling/drain loop
      */
     const abortRunControllers = (runId, client) => {
         const controllers = nodeExecutionControllers.get(runId);
@@ -50,8 +50,8 @@ const createRunAbortController = () => {
         }
     };
     /**
-     * 获取或创建用于 drainPipeline 的中止信号。
-     * 每次新 run 会创建新的 AbortController，确保 stop/retry 只中断当前运行。
+     * Get or create the abort signal for drainPipeline.
+     * Each new run creates a new AbortController so stop/retry only interrupt the current run.
      */
     const getOrCreateDrainSignal = (runId) => {
         let dc = drainControllers.get(runId);

package/dist/src/pipeline/execution/run-state-helpers.js

@@ -134,8 +134,8 @@ const createRunStateHelpers = (options) => {
             if (options.graph.isGroupId(current)) {
                 groupIds.add(current);
                 const group = options.graph.getWorkflowGroupById(current);
-                // 并行组本身不是执行节点，但它控制成员节点与后续 join 分支的状态。
-                // 回放/打回时必须穿透 group，把成员和 group 后面的节点一起纳入重置范围。
+                // A parallel group is not an execution node itself, but it controls the state of its member nodes and subsequent join branches.
+                // Replay/reject must penetrate the group to include members and nodes downstream of the group in the reset scope.
                 for (const memberId of group?.members ?? []) {
                     queue.push(memberId);
                 }

package/dist/src/pipeline/execution/service.js

@@ -13,9 +13,9 @@ const group_item_executor_1 = require("./group-item-executor");
 const node_item_executor_1 = require("./node-item-executor");
 const ctx = (reason, extra) => ({ reason, ...extra });
 /**
- * 流水线执行器。
- * 负责：节点的具体执行逻辑、状态转换、产物管理。
- * 不负责：调度决策、并发控制。
+ * Pipeline executor.
+ * Responsible for: specific execution logic of nodes, state transitions, artifact management.
+ * Not responsible for: scheduling decisions, concurrency control.
  */
 const createExecutionService = (deps) => {
     let activeBatchKeywordItems = null;
@@ -56,7 +56,7 @@ const createExecutionService = (deps) => {
             return ids;
         },
     });
-    // ====== Helper: 重置受影响的 downstream ======
+    // ====== Helper: Reset affected downstream ======
     const resetAffectedDownstreamNodes = (params) => {
         const run = getRun();
         const affected = collectDownstreamSubgraph(params.targetNodeId);

package/dist/src/pipeline/execution/structured-node-runner.js

@@ -20,11 +20,11 @@ const injectRuntimeKeywordsToInstruction = (instruction, keywords) => {
     if (matchedArray && matchedArray.length > 0) {
         return instruction.replace(arrayPattern, keywordJson);
     }
-    return `${instruction}\n\n本批次关键词(JSON数组)：\n${keywordJson}`;
+    return `${instruction}\n\nKeywords for this batch (JSON array):\n${keywordJson}`;
 };
 const resolveActiveBatchKeywordsForInstruction = (activeBatchKeywordItems, isSourceEntryNode) => {
-    // 只有真正处于批跑中的入口节点，才允许把关键词池注入到提示词。
-    // 普通单运行虽然默认 itemKey 可能是 global，但它只是运行项标识，不应被当成批次关键词展示。
+    // Only the entry node that is actually in a batch run may inject the keyword pool into the prompt.
+    // In a regular single run the default itemKey may be "global", but that's just a run-item identifier — it should not be shown as a batch keyword.
     if (!isSourceEntryNode || !activeBatchKeywordItems || activeBatchKeywordItems.length === 0) {
         return [];
     }
@@ -72,8 +72,8 @@ const shouldParseFrameForEnvelope = (frame) => {
 const createStructuredNodeRunner = (options) => {
     const emitter = new node_events_1.EventEmitter();
     emitter.setMaxListeners(32);
-    // 同一个 agent session 会复用多轮对话。
-    // 这里按 sessionId + agent runId 记录生命周期，避免上一轮尾部的 end/error 事件误伤下一轮新请求。
+    // The same agent session reuses multiple rounds of conversation.
+    // Track lifecycle by sessionId + agent runId to prevent stray end/error events from the previous round's tail from hitting the next round's new request.
     const sessionRuns = new Map();
     const findStringByKeys = (value, keys, depth = 0) => {
         if (depth > 5 || value === null || value === undefined)
@@ -145,9 +145,9 @@ const createStructuredNodeRunner = (options) => {
             current.completedAt = null;
         }
         runMap.set(runId, current);
-        // 每个 session 只保留最近少量 run 记录，避免长跑时无界增长。
-        // 驱逐前跳过仍在等待确认的活跃 run (completedAt 为 null)，
-        // 防止 resolveCompletedAtForRequest 锁定的 runId 被误删导致超时。
+        // Keep only the most recent few run records per session to avoid unbounded growth during long runs.
+        // Skip active runs still awaiting confirmation (completedAt is null) before eviction,
+        // to prevent runId locked by resolveCompletedAtForRequest from being mistakenly deleted and causing a timeout.
         const MAX_RUNS_PER_SESSION = 48;
         if (runMap.size > MAX_RUNS_PER_SESSION) {
             const now = Date.now();
@@ -171,8 +171,8 @@ const createStructuredNodeRunner = (options) => {
         if (!runMap || runMap.size === 0)
             return null;
         if (!watch.lockedRunId) {
-            // 优先锁定"首次出现时间晚于本次请求发出时间"的 runId。
-            // 这样可以避免上一轮请求的尾部 end/error 在新请求刚开始时被错认成当前轮次结束。
+            // Prefer locking the runId whose "first seen time" is later than this request's start time.
+            // This avoids the previous request's tail end/error being misidentified as the current round's completion when a new request just starts.
             const currentRun = [...runMap.entries()]
                 .filter(([, snapshot]) => snapshot.firstSeenAt >= requestStartedAt)
                 .sort((a, b) => a[1].firstSeenAt - b[1].firstSeenAt)[0];
@@ -210,8 +210,8 @@ const createStructuredNodeRunner = (options) => {
                 rememberSessionRunEvent(sessionId, runId, inferLifecycle(payload.data));
                 return;
             }
-            // assistant/tool/item 等流虽然不代表完成，但能提供当前轮次的 runId。
-            // 这里只做"看见过该 run"的记录，完成仍以 lifecycle/chat.final 为准。
+            // assistant/tool/item streams don't represent completion, but they provide the current round's runId.
+            // This only records "this run was seen"; completion is still determined by lifecycle/chat.final.
             rememberSessionRunEvent(sessionId, runId, "unknown");
             return;
         }
@@ -232,8 +232,8 @@ const createStructuredNodeRunner = (options) => {
         const workflowNode = options.graph.getWorkflowNodeById(node.id);
         const retryBackoffMs = workflowNode?.retryPolicy.backoffMs ?? 0;
         const parallelGroup = options.graph.getParallelGroupByMemberNodeId(node.id);
-        // 批处理关键词只应注入真正的入口节点。并行组成员虽然通常没有 direct incoming edge，
-        // 但它们的依赖挂在 group 上，只看 node 自身入边会把 group 成员误判为 source entry。
+        // Batch keywords should only be injected into the true entry node. Parallel-group members typically have no direct incoming edge,
+        // but their dependencies are attached to the group; looking only at the node's own incoming edges would misclassify group members as source entries.
         const isSourceEntryNode = options.graph.getIncomingEdges(node.id).length === 0 &&
             (!parallelGroup || options.graph.getIncomingEdges(parallelGroup.id).length === 0);
         const effectiveRuntimeKeywordItems = (0, exports.resolveActiveBatchKeywordsForInstruction)(options.getActiveBatchKeywordItems(), isSourceEntryNode);
@@ -250,7 +250,7 @@ const createStructuredNodeRunner = (options) => {
             }
         }
         if (effectiveDependencyIds.length > 0) {
-            options.runtimeStore.pushTimeline(`节点 ${node.id} 已加载上游产物 ${dependencyArtifacts.length} 条（来自: ${effectiveDependencyIds.join(",")}）`);
+            options.runtimeStore.pushTimeline(`Node ${node.id} loaded ${dependencyArtifacts.length} upstream artifacts (from: ${effectiveDependencyIds.join(",")})`);
         }
         const allowedRoutes = workflowNode?.routePolicy?.allowed ?? [];
         const routeTargets = options.graph.getOutgoingEdges(node.id)
@@ -263,7 +263,7 @@ const createStructuredNodeRunner = (options) => {
                 route: edge.when ?? "",
                 targetNodeId: edge.to,
                 targetNodeTitle: targetWorkflowGroup
-                    ? `并行组 ${targetWorkflowGroup.id}`
+                    ? `Parallel group ${targetWorkflowGroup.id}`
                     : targetNode?.title ?? targetWorkflowNode?.name ?? edge.to,
                 targetAgentId: targetWorkflowGroup
                     ? targetWorkflowGroup.id
@@ -287,7 +287,7 @@ const createStructuredNodeRunner = (options) => {
         return { requestId, ctx, effectiveDependencyIds, dependencyArtifacts, allowedRoutes, routeTargets, retryBackoffMs };
     };
     const sendAndWaitForEnvelope = async (prompt, sessionId, nodeId, validationCtx, lastViolation, requestStartedAt, requestRunWatch, signal) => {
-        // DAG 节点发送只保留 chat.send 单一路径，避免不同发送 API 的兼容补发把同一 requestId 投递两次。
+        // DAG node send only uses the chat.send single path to avoid compatibility fallback sends from different APIs delivering the same requestId twice.
         const idempotencyKey = (0, node_crypto_1.randomUUID)();
         let payload;
         try {
@@ -298,10 +298,10 @@ const createStructuredNodeRunner = (options) => {
             });
         }
         catch (error) {
-            options.runtimeStore.pushTimeline(`节点 ${nodeId} 发送失败(chat.send): ${String(error)}`, "error");
+            options.runtimeStore.pushTimeline(`Node ${nodeId} send failed (chat.send): ${String(error)}`, "error");
             throw new Error(`openclaw_send_failed:chat.send:${String(error)}`);
         }
-        options.runtimeStore.pushTimeline(`节点 ${nodeId} 已发送请求，等待结构化回执...`);
+        options.runtimeStore.pushTimeline(`Node ${nodeId} request sent, waiting for structured receipt...`);
         const envelope = await (0, structured_output_1.waitForStructuredEnvelope)(emitter, validationCtx, lastViolation, () => resolveCompletedAtForRequest(sessionId, requestStartedAt, requestRunWatch), signal);
         return envelope;
     };
@@ -316,8 +316,8 @@ const createStructuredNodeRunner = (options) => {
             requireRouteContent: allowedRoutes.length > 0,
         };
         let lastViolation = null;
-        // 纠错重试属于同一次节点请求的补正，不应更换 requestId。
-        // 否则模型即使按上一轮上下文修正成功，也会因为顶层 requestId 变化被误判为 mismatch。
+        // Error-correction retries are corrections of the same node request; the requestId should not be changed.
+        // Otherwise the model would be wrongly flagged as a mismatch due to a changed top-level requestId, even after a successful context-based correction.
         for (let attemptIndex = 0; attemptIndex < 2; attemptIndex += 1) {
             if (attemptIndex > 0 && retryBackoffMs > 0) {
                 await new Promise(resolve => setTimeout(resolve, retryBackoffMs));
@@ -336,10 +336,10 @@ const createStructuredNodeRunner = (options) => {
                 if (violation) {
                     lastViolation = violation;
                     if (attemptIndex === 0) {
-                        options.runtimeStore.pushTimeline(`节点 ${node.id} 回执校验失败(${violation})，自动纠正重试中...`, "warn");
+                        options.runtimeStore.pushTimeline(`Node ${node.id} receipt validation failed (${violation}), auto-correcting...`, "warn");
                         continue;
                     }
-                    options.runtimeStore.pushTimeline(`节点 ${node.id} 回执校验失败(${violation})，纠正后仍未通过，标记失败`, "error");
+                    options.runtimeStore.pushTimeline(`Node ${node.id} receipt validation failed (${violation}), correction still failed, marked as failed`, "error");
                 }
                 throw error;
             }
@@ -350,7 +350,7 @@ const createStructuredNodeRunner = (options) => {
         const savedAt = new Date();
         const status = envelope.status === "failed" ? "failed" : "success";
         const batchRunId = options.getBatchRunId?.();
-        // envelope 文件通过 persistEnvelopeFile 写入并追加索引
+        // Envelope files are written and indexed via persistEnvelopeFile
         await (0, artifact_storage_1.persistEnvelopeFile)(options.artifactDir, status, { runId, batchRunId, nodeId, requestId, pipelineId: options.pipelineId }, envelope, { savedAt });
         const normalizedArtifacts = [];
         for (let i = 0; i < envelope.artifacts.length; i += 1) {

package/dist/src/pipeline/execution-timeout.js

@@ -10,12 +10,12 @@ const normalizeTimeout = (value, fallback, min) => {
         return fallback;
     return Math.max(min, Math.trunc(parsed));
 };
-// 统一维护 DAG 节点执行超时，避免发送请求与等待回执使用不同默认值。
+// Centrally maintain DAG node execution timeout so send-request and wait-receipt don't use different defaults.
 const getPipelineNodeExecutionTimeoutMs = () => normalizeTimeout(process.env.PIPELINE_NODE_EXECUTION_TIMEOUT_MS, DEFAULT_PIPELINE_NODE_TIMEOUT_MS, MIN_TIMEOUT_MS);
 exports.getPipelineNodeExecutionTimeoutMs = getPipelineNodeExecutionTimeoutMs;
-// 兼容历史环境变量名，未设置新变量时继续读取旧变量。
+// Compatible with legacy env var name; fall back to the old var when the new one is not set.
 const getStructuredResultTimeoutMs = () => normalizeTimeout(process.env.STRUCTURED_RESULT_TIMEOUT_MS ?? process.env.PIPELINE_NODE_EXECUTION_TIMEOUT_MS, DEFAULT_PIPELINE_NODE_TIMEOUT_MS, MIN_TIMEOUT_MS);
 exports.getStructuredResultTimeoutMs = getStructuredResultTimeoutMs;
-// 轮询间隔保持短周期，仅负责观察回执，不参与失败判定。
+// Polling interval stays short; it only observes receipts and does not participate in failure judgment.
 const getStructuredResultPollMs = () => normalizeTimeout(process.env.STRUCTURED_RESULT_POLL_MS, DEFAULT_STRUCTURED_RESULT_POLL_MS, 100);
 exports.getStructuredResultPollMs = getStructuredResultPollMs;

package/dist/src/pipeline/identity/index.js

@@ -15,17 +15,17 @@ const buildRequestId = (nodeId) => `node-${nodeId}-${(0, node_crypto_1.randomUUI
 exports.buildRequestId = buildRequestId;
 const buildItemKeyFromKeywords = (keywords) => [...new Set(keywords.map((item) => item.trim()).filter(Boolean))];
 exports.buildItemKeyFromKeywords = buildItemKeyFromKeywords;
-/** 从 Run 和 pipelineId 构造身份快照 */
+/** Build an identity snapshot from a Run and pipelineId */
 const toRunIdentity = (pipelineId, run) => ({
     pipelineId,
     runId: run.id,
     batchRunId: null,
 });
 exports.toRunIdentity = toRunIdentity;
-/** 格式化身份为可读字符串 */
+/** Format an identity into a human-readable string */
 const formatIdentity = (id) => `pipeline=${id.pipelineId} run=${id.runId}${id.batchRunId ? ` batch=${id.batchRunId}` : ""}`;
 exports.formatIdentity = formatIdentity;
-/** 校验身份匹配：pipelineId 必须相等，runId 必须相等，batchRunId 任一方为 null 时放行 */
+/** Verify identity match: pipelineId must be equal, runId must be equal, allow when either batchRunId is null */
 const matchIdentity = (target, candidate) => target.pipelineId === candidate.pipelineId &&
     target.runId === candidate.runId &&
     (target.batchRunId === null || candidate.batchRunId === null || target.batchRunId === candidate.batchRunId);

package/dist/src/pipeline/item-batch-controller.js

@@ -44,7 +44,7 @@ const normalizePoolItems = (value) => {
         }
     }
     else if (typeof value === "string") {
-        // 支持逗号与换行混输，方便直接粘贴关键词池。
+        // Support mixed comma and newline input for easy pasting of keyword pools.
         rawList.push(...value.split(/[\n,]/g));
     }
     const unique = new Set();
@@ -93,8 +93,8 @@ const createItemBatchController = (deps) => {
                 });
             }
             catch (error) {
-                // 批跑控制器运行在 HTTP 请求之外；这里若让异常逃逸，快照会永久停留在 running，
-                // 后续 start() 都会误判为已有批跑进行中。必须在控制器内兜底收口状态。
+                // The batch-run controller runs outside HTTP requests; if an exception escapes here, the snapshot would permanently stay at running,
+                // and subsequent start() calls would falsely detect an existing batch run in progress. Must guard the state inside the controller.
                 if (token !== runToken)
                     return;
                 hasBatchErrors = true;
@@ -184,7 +184,7 @@ const createItemBatchController = (deps) => {
             stopRequested: false,
             batchRunId,
         };
-        // 异步后台运行，避免占住 HTTP 请求。
+        // Run asynchronously in the background to avoid blocking the HTTP request.
         void runLoop(runToken, [...queuedItems]);
         return { ok: true, snapshot: cloneSnapshot(snapshot) };
     };
@@ -192,7 +192,7 @@ const createItemBatchController = (deps) => {
         if (snapshot.status !== "running") {
             return { ok: false, error: "batch_run_not_running", snapshot: cloneSnapshot(snapshot) };
         }
-        // 仅请求停止，当前批次跑完后会安全退出。
+        // Only request stop; the current batch will exit safely after completion.
         snapshot = {
             ...snapshot,
             stopRequested: true,
@@ -203,7 +203,7 @@ const createItemBatchController = (deps) => {
         if (snapshot.status !== "running") {
             return { ok: false, error: "batch_run_not_running", snapshot: cloneSnapshot(snapshot) };
         }
-        // 插件关闭后不应继续保留运行中的批跑控制器；切换 runToken 让旧循环结果失效。
+        // When the plugin is disabled, the running batch controller should not be retained; switch runToken to invalidate old loop results.
         runToken += 1;
         snapshot = {
             ...snapshot,

package/dist/src/pipeline/scheduler/dependency-state.js

@@ -23,9 +23,9 @@ const createDependencyState = (options) => {
                 impossibleCount += 1;
             }
         }
-        // all/any 执行差异：
-        // - all: 只有全部依赖满足才入队；若剩余依赖都已不可能满足则跳过。
-        // - any: 任一依赖满足即可入队；仅当所有依赖都不可能满足时才跳过。
+        // all/any execution difference:
+        // - all: only enqueue when all dependencies are satisfied; skip when remaining dependencies are all impossible.
+        // - any: enqueue when any single dependency is satisfied; only skip when all dependencies are impossible.
         if (policy === "any") {
             if (satisfiedCount > 0)
                 return "queued";
@@ -56,7 +56,7 @@ const createDependencyState = (options) => {
             if (!Number.isFinite(wakeTs) || wakeTs > now)
                 continue;
             (0, state_1.markItemWakeSuccess)(item, { reason: "sleep_expired" });
-            options.runtimeStore.pushTimeline(`等待节点已唤醒: ${item.nodeId}#${item.itemKey}`);
+            options.runtimeStore.pushTimeline(`Waiting node woken: ${item.nodeId}#${item.itemKey}`);
         }
     };
     const markReadyItemsFromDependencies = () => {
@@ -115,7 +115,7 @@ const createDependencyState = (options) => {
             const related = (getRun().groupItemRuns ?? []).filter((item) => item.groupId === group.id);
             if (related.length === 0)
                 continue;
-            // joinPolicy 仅支持 "all"：全部 group item 成功才标记 group 成功，任一失败即失败
+            // joinPolicy only supports "all": mark group success only when all group items succeed, fail if any fails
             if (related.some((item) => item.status === "failed")) {
                 (0, state_1.markGroupFailed)(group, { reason: "member_failed", command: "group_aggregate", error: related.find((item) => item.status === "failed")?.lastError });
             }