taskmeld 0.1.1 → 0.1.41

package/dist/src/pipeline/scheduler-service.js

@@ -8,9 +8,9 @@ const run_state_helpers_1 = require("./execution/run-state-helpers");
 const state_1 = require("./state");
 const identity_1 = require("./identity");
 /**
- * 流水线调度器。
- * 负责：决定何时执行节点、管理并发、控制调度模式。
- * 不负责：节点的具体执行逻辑。
+ * Pipeline scheduler.
+ * Responsible for: deciding when to execute nodes, managing concurrency, controlling scheduling mode.
+ * Not responsible for: the specific execution logic of nodes.
  */
 const createSchedulerService = (deps) => {
     const isSchedulerPluginEnabled = () => deps.graph.getWorkflow().plugins.scheduler.enabled;
@@ -96,8 +96,8 @@ const createSchedulerService = (deps) => {
             currentGroupItem.attempt = 0;
             currentGroupItem.artifacts = [];
         }
-        // 手动重试模式下，目标节点可能已经满足依赖但被 reset 成 blocked。
-        // 这里先重新评估依赖，再决定是否立刻执行首个节点，避免稳定复现 node_retry_blocked。
+        // In manual retry mode, the target node may already have its dependencies met but was reset to blocked.
+        // Re-evaluate dependencies first, then decide whether to execute the first node immediately, to avoid reliably reproducing node_retry_blocked.
         markReadyItemsFromDependencies();
         markReadyGroupsFromDependencies();
         deps.runtimeStore.emitPipeline();
@@ -121,10 +121,10 @@ const createSchedulerService = (deps) => {
         return { ok: true, node, drained };
     };
     /**
-     * 核心调度循环。遍历就绪节点并执行。这是调度器的核心职责。
+     * Core scheduling loop. Iterates over ready nodes and executes them. This is the scheduler's core responsibility.
      *
-     * 传入的 AbortSignal 仅用于提前退出本地排水循环；
-     * 远端 agent 的停止由 executionService.abortRunControllers 通过 "/stop" 命令处理。
+     * The passed AbortSignal is only used to exit the local drain loop early;
+     * remote agent stopping is handled by executionService.abortRunControllers via the "/stop" command.
      */
     const drainPipeline = async (reason, signal) => {
         const manualTick = reason.startsWith("manual_tick");
@@ -141,7 +141,7 @@ const createSchedulerService = (deps) => {
                 return { executed: 0, hardFailed: false };
         }
         if (drainInFlight) {
-            deps.runtimeStore.pushTimeline(`[调度排水锁] 调用方=${reason} 触发排水，但已有 ${drainInFlightReason} 排水正在执行，本次调用合并至现有排水`, "info");
+            deps.runtimeStore.pushTimeline(`[Scheduling drain lock] caller=${reason} triggered drain, but ${drainInFlightReason} drain is already in progress, merged into existing drain`, "info");
             return drainInFlight;
         }
         drainInFlight = (async () => {
@@ -161,13 +161,13 @@ const createSchedulerService = (deps) => {
                 active.add(task);
             };
             while (true) {
-                // 客户端侧中止：外部调用 abortRunControllers 后，signal 变为 aborted，
-                // 排水循环提前退出，不再等待活跃节点自然完成。
+                // Client-side abort: after external call to abortRunControllers, the signal becomes aborted,
+                // the drain loop exits early and no longer waits for active nodes to finish naturally.
                 if (signal?.aborted) {
                     stopScheduling = true;
                 }
                 if (executed >= maxIterations) {
-                    deps.runtimeStore.pushTimeline(`调度达到全局迭代上限: ${maxIterations}`, "warn");
+                    deps.runtimeStore.pushTimeline(`Scheduling reached global iteration limit: ${maxIterations}`, "warn");
                     break;
                 }
                 while (!stopScheduling && !signal?.aborted && active.size < maxConcurrency && executed < maxIterations) {
@@ -179,7 +179,7 @@ const createSchedulerService = (deps) => {
                     const batchLabel = batch
                         .map((item) => ("nodeId" in item ? `${item.nodeId}#${item.itemKey}` : `group:${item.groupId}#${item.itemKey}`))
                         .join(", ");
-                    deps.runtimeStore.pushTimeline(`流水线自动调度: ${batchLabel} (${reason})`);
+                    deps.runtimeStore.pushTimeline(`Pipeline auto-scheduled: ${batchLabel} (${reason})`);
                     for (const item of batch) {
                         launchItem(item);
                     }
@@ -219,8 +219,8 @@ const createSchedulerService = (deps) => {
         return drainInFlight;
     };
     /**
-     * 批量运行控制器。管理关键词池的分批执行生命周期（启动、停止、取消、状态查询）。
-     * 属于调度器职责——控制何时及如何分批执行。
+     * Batch run controller. Manages the lifecycle of keyword-pool batch execution (start, stop, cancel, status query).
+     * Belongs to the scheduler's responsibility — controls when and how to execute batches.
      */
     const itemBatchController = (0, item_batch_controller_1.createItemBatchController)({
         pipelineId: deps.pipelineId,
@@ -231,7 +231,7 @@ const createSchedulerService = (deps) => {
             deps.executionService.setActiveBatchKeywordItems([...batchItems]);
             deps.graph.syncRunGroupsFromWorkflow(nextRun);
             deps.runtimeStore.emitPipeline();
-            deps.runtimeStore.pushTimeline(`批量运行开始: 第 ${batchIndex}/${totalBatches} 批, 关键词 ${batchItems.length}/${totalItems}`);
+            deps.runtimeStore.pushTimeline(`Batch run started: batch ${batchIndex}/${totalBatches}, keywords ${batchItems.length}/${totalItems}`);
             let drained;
             try {
                 const drainSignal = deps.executionService.getOrCreateDrainSignal(getRun().id);
@@ -243,7 +243,7 @@ const createSchedulerService = (deps) => {
                 deps.executionService.setActiveBatchKeywordItems(null);
             }
             if (getRun().status === "running") {
-                deps.runtimeStore.pushTimeline(`批量运行结束: 第 ${batchIndex} 批无后续可执行节点，直接进入下一批`, "warn", {
+                deps.runtimeStore.pushTimeline(`Batch run ended: batch ${batchIndex} has no further executable nodes, proceeding to next batch`, "warn", {
                     batchIndex,
                     totalBatches,
                     drained,
@@ -251,9 +251,9 @@ const createSchedulerService = (deps) => {
                 });
                 return { ok: true };
             }
-            // 仅在硬失败场景停止后续批次；业务型 failed(status=failed) 允许继续下一批。
+            // Only stop subsequent batches on hard-failure scenarios; business-type failed (status=failed) allows continuing to the next batch.
             if (drained.hardFailed) {
-                deps.runtimeStore.pushTimeline(`批量运行失败: 第 ${batchIndex} 批, 已停止后续批次`, "error", {
+                deps.runtimeStore.pushTimeline(`Batch run failed: batch ${batchIndex}, subsequent batches stopped`, "error", {
                     batchIndex,
                     totalBatches,
                     drained,
@@ -261,14 +261,14 @@ const createSchedulerService = (deps) => {
                 });
                 return { ok: false, error: `batch_${batchIndex}_failed`, hardStop: true };
             }
-            deps.runtimeStore.pushTimeline(`批量运行完成: 第 ${batchIndex}/${totalBatches} 批, run=${getRun().id}`);
+            deps.runtimeStore.pushTimeline(`Batch run completed: batch ${batchIndex}/${totalBatches}, run=${getRun().id}`);
             return { ok: true };
         },
     });
     return {
         getSchedulerState: () => ({
             ...schedulerState,
-            // 调度器插件关闭时，对外统一表现为 disabled，避免界面和运行时状态不一致。
+            // When the scheduler plugin is disabled, externally present as disabled to avoid UI/runtime state inconsistency.
             enabled: isSchedulerPluginEnabled() && schedulerState.enabled,
         }),
         setSchedulerEnabled: (enabled) => {
@@ -285,21 +285,21 @@ const createSchedulerService = (deps) => {
         startBatchRun: (items, batchSize, options) => {
             const started = itemBatchController.start(items, batchSize, options);
             if (started.ok) {
-                deps.runtimeStore.pushTimeline(`已启动关键词池批量运行: 共 ${started.snapshot.totalItems} 个, 每批 ${started.snapshot.batchSize} 个`);
+                deps.runtimeStore.pushTimeline(`Batch run started: ${started.snapshot.totalItems} total items, ${started.snapshot.batchSize} per batch`);
             }
             return started;
         },
         stopBatchRun: () => {
             const stopped = itemBatchController.stop();
             if (stopped.ok) {
-                deps.runtimeStore.pushTimeline("已请求停止关键词池批量运行（当前批次结束后生效）", "warn");
+                deps.runtimeStore.pushTimeline("Batch run stop requested (takes effect after current batch completes)", "warn");
             }
             return stopped;
         },
         cancelBatchRun: () => {
             const canceled = itemBatchController.cancel();
             if (canceled.ok) {
-                deps.runtimeStore.pushTimeline("已立即停止关键词池批量运行（插件已关闭）", "warn");
+                deps.runtimeStore.pushTimeline("Batch run cancelled immediately (plugin disabled)", "warn");
             }
             return canceled;
         },

package/dist/src/pipeline/state-machine.js

@@ -83,8 +83,8 @@ const transitionStatus = (current, next, command) => {
     if (current === next)
         return current;
     const allowedByCommand = exports.VALID_TRANSITIONS[current];
-    // 未指定 command 时仅允许 execute + dependency 权限（安全默认值），
-    // 特殊权限（route_backfill/retry_reset/reject_reset/sleep/group_aggregate）必须显式传 command。
+    // When no command is specified, only execute + dependency permissions are allowed (safe default),
+    // special permissions (route_backfill/retry_reset/reject_reset/sleep/group_aggregate) require an explicit command.
     const allowed = command
         ? (allowedByCommand[command] ?? [])
         : [

package/dist/src/pipeline/structured-output/contract.js

@@ -12,7 +12,7 @@ const normalizeSchemaVersion = (value) => {
     if (typeof value !== "string")
         return null;
     const trimmed = value.trim();
-    // 兼容模型把 schemaVersion 输出成字符串数字（例如 "1"）的场景。
+    // Accommodate models that output schemaVersion as a numeric string (e.g. "1").
     if (!/^\d+$/.test(trimmed))
         return null;
     const parsed = Number(trimmed);
@@ -33,7 +33,7 @@ const normalizeAllowedRoute = (rawRoute, allowedRoutes) => {
     if (direct)
         return direct;
     const lower = trimmed.toLowerCase();
-    // 允许大小写不一致，统一纠正为工作流里声明的 route，避免无意义失败。
+    // Allow case-insensitive matches, normalizing to the declared workflow route to avoid pointless failures.
     const insensitive = allowedRoutes.find((route) => route.toLowerCase() === lower);
     return insensitive ?? null;
 };
@@ -96,7 +96,7 @@ const validateEnvelope = (envelope, ctx) => {
             return { ok: false, code: "artifact_spec_mismatch" };
         }
     }
-    // 兼容历史/冗余字段：顶层 route、decisions 不再作为硬失败条件，忽略即可。
+    // Backward-compat with legacy/redundant fields: top-level route and decisions are no longer hard-failure conditions — simply ignore.
     if (envelope.control !== undefined) {
         if (!(0, guards_1.isRecord)(envelope.control))
             return { ok: false, code: "hold_control_invalid" };
@@ -113,7 +113,7 @@ const validateEnvelope = (envelope, ctx) => {
             return { ok: false, code: "route_content_invalid" };
         }
         if (!Array.isArray(primaryArtifact.content) && (0, guards_1.isRecord)(primaryArtifact.content)) {
-            // 兼容单对象输出，统一纠正为数组，后续分流逻辑保持一致。
+            // Accommodate single-object output by normalizing to an array so downstream routing logic stays consistent.
             primaryArtifact.content = [primaryArtifact.content];
         }
         if (!Array.isArray(primaryArtifact.content) || primaryArtifact.content.length === 0) {

package/dist/src/pipeline/structured-output/index.js

@@ -14,8 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// 目录出口：调用方继续从 structured-output 子模块导入，内部文件按职责拆分。
-// 统一从这里 re-export，避免后续再次拆分时把外部 import 路径扩散到实现细节。
+// Directory barrel export: callers continue importing from structured-output sub-modules; internal files are split by responsibility.
+// Re-export uniformly from here to avoid spreading external import paths to implementation details upon future re-splits.
 __exportStar(require("./contract"), exports);
 __exportStar(require("./parser"), exports);
 __exportStar(require("./prompt"), exports);

package/dist/src/pipeline/structured-output/parser.js

@@ -31,8 +31,8 @@ exports.detectFenceLanguage = detectFenceLanguage;
 const extractBalancedJsonObjectCandidates = (text) => {
     const candidates = [];
     const seen = new Set();
-    // 流式输出常出现“说明文字 + JSON”拼接在同一段文本中的情况。
-    // 这里通过括号平衡扫描抽取内嵌 JSON 对象，避免整段 JSON.parse 直接失败。
+    // Streaming output often has "explanatory text + JSON" concatenated in the same text segment.
+    // Use bracket-balanced scanning to extract embedded JSON objects, avoiding direct JSON.parse failure on the whole segment.
     for (let start = text.indexOf("{"); start >= 0; start = text.indexOf("{", start + 1)) {
         let depth = 0;
         let inString = false;
@@ -130,7 +130,7 @@ const tryParseEnvelopeObject = (value) => {
             continue;
         const normalized = (0, contract_1.normalizeSchemaVersion)(rawArtifact.schemaVersion);
         if (normalized !== null) {
-            // 解析阶段先做宽松纠正，后续统一走 number 语义校验与持久化。
+            // Loosely correct at parse stage; subsequent processing uniformly uses number semantic validation and persistence.
             rawArtifact.schemaVersion = normalized;
         }
     }
@@ -147,7 +147,7 @@ const tryParseEnvelopeText = (text) => {
     if (text.length > ENVELOPE_TEXT_SCAN_TAIL_CHARS) {
         const headLen = text.length - ENVELOPE_TEXT_SCAN_TAIL_CHARS;
         const headPart = text.slice(0, headLen);
-        // 向前回溯到最近的 {，防止 JSON 起始被窗口切断
+        // Backtrack to the nearest { to prevent the JSON start from being cut off by the window
         const lastBrace = headPart.lastIndexOf("{");
         scanText = lastBrace >= 0 ? text.slice(lastBrace) : text.slice(-ENVELOPE_TEXT_SCAN_TAIL_CHARS);
     }
@@ -167,7 +167,7 @@ const tryParseEnvelopeText = (text) => {
                     return envelope;
             }
             catch {
-                // 继续尝试后续候选
+                // Continue trying subsequent candidates
             }
         }
         return null;

package/dist/src/pipeline/structured-output/prompt.js

@@ -106,16 +106,16 @@ const createNodeExecutionPrompt = (ctx) => {
         return Array.from(grouped.values());
     })();
     const lines = [
-        "# 流水线节点执行指令",
+        "# Pipeline Node Execution Instructions",
         "",
-        "## 输出要求",
-        "- 只能返回一个合法 JSON 对象（ResultEnvelope）。",
-        "- 不要输出任何额外解释、前后缀、Markdown 之外的文本。",
-        "- `status=success` 时，`artifacts` 必须至少 1 条。",
-        "- `artifacts[].content` 支持任意 JSON 值（例如：`\"text\"`、`{\"k\":\"v\"}`、`[{\"k\":\"v1\"},{\"k\":\"v2\"}]`）。",
-        ...(isRouteNode ? ["- 分流节点的 `artifacts[0].content` 必须是数组，数组内每个对象都要包含 `route` 字段。"] : []),
+        "## Output Requirements",
+        "- Return only a valid JSON object (ResultEnvelope).",
+        "- Do not output any extra explanations, prefixes, suffixes, or text outside of Markdown.",
+        "- When `status=success`, `artifacts` must contain at least 1 item.",
+        "- `artifacts[].content` accepts any JSON value (e.g., `\"text\"`, `{\"k\":\"v\"}`, `[{\"k\":\"v1\"},{\"k\":\"v2\"}]`).",
+        ...(isRouteNode ? ["- For routing nodes, `artifacts[0].content` must be an array, and each object in the array must include a `route` field."] : []),
         "",
-        "## ResultEnvelope 固定字段",
+        "## ResultEnvelope Fixed Fields",
         `- version: \`2.0\``,
         `- runId: \`${ctx.runId}\``,
         `- nodeId: \`${ctx.nodeId}\``,
@@ -124,27 +124,27 @@ const createNodeExecutionPrompt = (ctx) => {
         "- status: `success | failed`",
         "- artifacts: `array`",
         "",
-        "## 节点上下文",
-        `- 当前节点: \`${ctx.nodeId}\`（${ctx.nodeTitle}）`,
-        `- 依赖节点: ${ctx.dependencies.length > 0 ? ctx.dependencies.map((id) => `\`${id}\``).join(", ") : "`none`"}`,
+        "## Node Context",
+        `- Current node: \`${ctx.nodeId}\` (${ctx.nodeTitle})`,
+        `- Dependencies: ${ctx.dependencies.length > 0 ? ctx.dependencies.map((id) => `\`${id}\``).join(", ") : "`none`"}`,
     ];
-    lines.push("", "## 产物规格", `- type: \`${spec.type}\``, `- schemaVersion: \`${spec.schemaVersion}\``);
-    // 仅在节点明确开启分流时，才注入分流相关说明，避免无配置时污染提示词。
+    lines.push("", "## Artifact Specification", `- type: \`${spec.type}\``, `- schemaVersion: \`${spec.schemaVersion}\``);
+    // Only inject routing instructions when the node explicitly enables routing, to avoid polluting the prompt when no routing is configured.
     if (ctx.allowedRoutes.length > 0) {
-        lines.push("", "## 分流规则", `- 允许的 route 仅能是: ${ctx.allowedRoutes.map((route) => `\`${route}\``).join(", ")}`, `- \`${MAINLINE_ROUTE_VALUE}\` 表示继续主线，不需要配置分流目标。`, "- `artifacts[0].content` 必须输出为数组。", "- 数组中的每个对象都必须包含 `route` 字段。", "- 每个对象的 `route` 必须命中上述取值。", "- 系统会按 `content[*].route` 自动分组、汇总并推送到对应分支。");
+        lines.push("", "## Routing Rules", `- Allowed routes are: ${ctx.allowedRoutes.map((route) => `\`${route}\``).join(", ")}`, `- \`${MAINLINE_ROUTE_VALUE}\` indicates continuing on the mainline; no routing target configuration needed.`, "- `artifacts[0].content` must be an array.", "- Each object in the array must include a `route` field.", "- Each object's `route` must match one of the allowed values above.", "- The system will automatically group and dispatch items by `content[*].route` to the corresponding branches.");
         if (ctx.routeTargets.length > 0) {
-            lines.push("- 当前配置的 route 目标如下:");
+            lines.push("- The configured route targets are:");
             for (const target of ctx.routeTargets) {
                 lines.push(`  - \`${target.route}\` -> \`${target.targetNodeId}\` (${target.targetNodeTitle}, agent:${target.targetAgentId}, lane:${target.lane})`);
             }
         }
     }
-    // 仅在节点明确开启打回且存在上游依赖时，才注入打回相关说明，避免无配置时污染提示词。
+    // Only inject rejection instructions when the node explicitly enables rejection and has upstream dependencies, to avoid polluting the prompt when no rejection is configured.
     if (ctx.allowReject && ctx.dependencies.length > 0) {
-        lines.push("", "## 打回配置", `- allowReject: \`${ctx.allowReject ? "true" : "false"}\``, `- maxRejectCount: \`${ctx.maxRejectCount}\``, "", "### 打回规则", "- 仅当上游内容不符合你的校验规范时，才允许打回。", "- 打回时必须返回 `status=failed`，且 `error.code=upstream_reject`。", "- 如需指定目标上游，可提供 `error.targets=[\"nodeId\"]`。", "- 不提供 `targets` 时，系统默认打回上一个直接上游节点。", "", "```json", "{\"code\":\"upstream_reject\",\"message\":\"打回原因\"}", "```");
+        lines.push("", "## Rejection Configuration", `- allowReject: \`${ctx.allowReject ? "true" : "false"}\``, `- maxRejectCount: \`${ctx.maxRejectCount}\``, "", "### Rejection Rules", "- Rejection is only allowed when upstream content does not meet your validation criteria.", "- When rejecting, you must return `status=failed` with `error.code=upstream_reject`.", "- To specify target upstream nodes, provide `error.targets=[\"nodeId\"]`.", "- When `targets` is not provided, the system defaults to rejecting the most recent direct upstream node.", "", "```json", "{\"code\":\"upstream_reject\",\"message\":\"rejection reason\"}", "```");
     }
     if (isRouteNode) {
-        lines.push("", "## 分流节点 JSON 示例", "```json", JSON.stringify({
+        lines.push("", "## Routing Node JSON Example", "```json", JSON.stringify({
             version: "2.0",
             runId: "__RUN_ID__",
             nodeId: "__NODE_ID__",
@@ -173,7 +173,7 @@ const createNodeExecutionPrompt = (ctx) => {
         }, null, 2), "```");
     }
     else {
-        lines.push("", "## JSON 输出示例", "```json", JSON.stringify({
+        lines.push("", "## JSON Output Example", "```json", JSON.stringify({
             version: "2.0",
             runId: "__RUN_ID__",
             nodeId: "__NODE_ID__",
@@ -202,22 +202,22 @@ const createNodeExecutionPrompt = (ctx) => {
     if (ctx.externalPipelineArtifact) {
         const artifact = ctx.externalPipelineArtifact;
         const fence = (0, parser_1.detectFenceLanguage)(artifact.content);
-        lines.push("## 外部流水线上游产物", "", `来源: 流水线 ${artifact.sourcePipelineId} 的最终输出`, "", "内容:", `\`\`\`${fence}`, artifact.content, "```");
+        lines.push("## External Pipeline Upstream Artifacts", "", `Source: final output of pipeline ${artifact.sourcePipelineId}`, "", "Content:", `\`\`\`${fence}`, artifact.content, "```");
     }
     if (groupedDependencies.length > 0) {
-        lines.push("## 上游输输出结构：");
+        lines.push("## Upstream Output Structure:");
         for (const dep of groupedDependencies) {
             const merged = dep.contents.join("\n");
             const fence = (0, parser_1.detectFenceLanguage)(merged);
-            lines.push(`### 节点 \`${dep.sourceNodeId}\`（${dep.sourceNodeTitle}）- agent \`${dep.sourceAgentId}\``, `\`\`\`${fence}`, merged, "```");
+            lines.push(`### Node \`${dep.sourceNodeId}\` (${dep.sourceNodeTitle}) - agent \`${dep.sourceAgentId}\``, `\`\`\`${fence}`, merged, "```");
         }
         lines.push("");
     }
-    // 节点目标是执行 prompt 的核心约束，不能因为存在打回反馈或分流说明而被覆盖掉。
-    // 这里固定保留“节点目标”段，再额外追加反馈，避免分流节点提示词缺少主任务目标。
-    lines.push("## 节点目标", ctx.instruction || "请按节点职责完成任务");
+    // The node objective is the core constraint of the execution prompt and must not be overwritten by rejection feedback or routing instructions.
+    // Always keep the "Node Objective" section here, then append feedback separately, to avoid routing-node prompts missing the main task objective.
+    lines.push("## Node Objective", ctx.instruction || "Complete the task according to the node's responsibilities");
     if (ctx.rejectFeedbacks.length > 0) {
-        lines.push("", "## 下游打回反馈（请优先修正）");
+        lines.push("", "## Downstream Rejection Feedback (please prioritize fixes)");
         for (const item of ctx.rejectFeedbacks) {
             lines.push(`- ${item}`);
         }
@@ -226,28 +226,28 @@ const createNodeExecutionPrompt = (ctx) => {
 };
 exports.createNodeExecutionPrompt = createNodeExecutionPrompt;
 const createNodeCorrectionPrompt = (ctx, lastViolation) => [
-    `结构校验未通过，错误码: ${lastViolation}`,
-    "请严格基于本次请求的固定字段重发完整 ResultEnvelope，不要沿用旧请求的顶层字段。",
-    `固定字段必须为: version="2.0", runId="${ctx.runId}", nodeId="${ctx.nodeId}", requestId="${ctx.requestId}", sessionId="${ctx.sessionId}"`,
-    `产物规格必须为: type="${ctx.outputSpec.type}", schemaVersion=${ctx.outputSpec.schemaVersion}`,
+    `Structural validation failed, error code: ${lastViolation}`,
+    "Resend a complete ResultEnvelope strictly based on the fixed fields of this request. Do not reuse top-level fields from previous requests.",
+    `Fixed fields must be: version="2.0", runId="${ctx.runId}", nodeId="${ctx.nodeId}", requestId="${ctx.requestId}", sessionId="${ctx.sessionId}"`,
+    `Artifact specification must be: type="${ctx.outputSpec.type}", schemaVersion=${ctx.outputSpec.schemaVersion}`,
     ctx.allowedRoutes && ctx.allowedRoutes.length > 0
-        ? `这是分流节点。允许的 route 只有: ${ctx.allowedRoutes.map((route) => `"${route}"`).join(", ")}。请把 route 写进 artifacts[0].content 的每个对象里。`
+        ? `This is a routing node. The only allowed routes are: ${ctx.allowedRoutes.map((route) => `"${route}"`).join(", ")}. Include the route field in each object within artifacts[0].content.`
         : ctx.externalPipelineArtifact
-            ? `本次请求包含来自流水线 ${ctx.externalPipelineArtifact.sourcePipelineId} 的外部上游产物。请继续基于该上游产物修正。`
-            : "请按当前结构输出结果。",
-    "请先把完整 ResultEnvelope 保存为当前工作目录下的 result.json，然后自行运行下面的校验命令，确认 JSON valid 后再继续：",
+            ? `This request contains an external upstream artifact from pipeline ${ctx.externalPipelineArtifact.sourcePipelineId}. Continue corrections based on this upstream artifact.`
+            : "Output the result in the current structure.",
+    "First save the complete ResultEnvelope as result.json in the current working directory, then run the following validation command and confirm JSON valid before continuing:",
     "```bash",
     "cat result.json | python3 -m json.tool > /dev/null && echo \"JSON valid\" || echo \"JSON invalid\"",
     "```",
-    "如果校验结果不是 JSON valid，请继续修正 result.json，直到通过为止。",
-    "必须输出完整 JSON 对象，不要只输出 artifacts 片段。",
-    "只输出修正后的合法 JSON ResultEnvelope，不要输出任何解释。",
+    "If the validation result is not JSON valid, continue fixing result.json until it passes.",
+    "You must output the complete JSON object, not just the artifacts fragment.",
+    "Output only the corrected valid JSON ResultEnvelope. Do not output any explanations.",
 ].join("\n");
 exports.createNodeCorrectionPrompt = createNodeCorrectionPrompt;
 const buildExternalPipelineArtifactInput = async (output) => {
     try {
         const { absolutePath } = output.artifactRef;
-        // Verify path is within artifact directory (basic path traversal check)
+        // Normalize path to resolve relative segments (e.g. '..', '.')
         const normalizedPath = (0, node_path_1.resolve)(absolutePath);
         if (!normalizedPath)
             return null;

package/dist/src/pipeline/structured-output/waiter.js

@@ -54,8 +54,8 @@ const evaluateObservedEnvelopeWindow = (observed, ctx, options) => {
     const forRequestId = observed.filter((entry) => entry.envelope.requestId === ctx.requestId);
     if (forRequestId.length > 0) {
         if (!confirmFinal) {
-            // agent 会话未结束前，只记录“已见到候选”，不能提前认定成功/失败。
-            // 否则中途调试 JSON、半成品 envelope 都可能被过早消费。
+            // Before the agent session ends, only record "candidate seen" — cannot prematurely declare success/failure.
+            // Otherwise intermediate debug JSON or half-finished envelopes could be consumed too early.
             return { seenCandidate: true };
         }
         let latestFailure = null;
@@ -80,12 +80,12 @@ const evaluateObservedEnvelopeWindow = (observed, ctx, options) => {
 };
 exports.evaluateObservedEnvelopeWindow = evaluateObservedEnvelopeWindow;
 /**
- * 等待结构化回执。
+ * Wait for a structured receipt.
  *
- * 当传入 AbortSignal 且被触发时，提前退出本地轮询循环。
- * 远端 agent 的停止由上游 executionService 通过 "/stop" 命令处理。
+ * When an AbortSignal is passed and triggered, exit the local polling loop early.
+ * Remote agent stopping is handled by the upstream executionService via the "/stop" command.
  *
- * @param signal 可选的中止信号，用于流水线 stop/retry 时提前退出轮询。
+ * @param signal Optional abort signal, used to exit polling early during pipeline stop/retry.
  */
 const waitForStructuredEnvelope = async (emitter, ctx, initialViolation, hasSessionCompleted, signal) => {
     const deadline = Date.now() + STRUCTURED_RESULT_TIMEOUT_MS;

package/dist/src/pipeline/template.js

@@ -69,30 +69,30 @@ exports.readTemplateNodesFromRaw = readTemplateNodesFromRaw;
 // ====== Migration ======
 const migrateWorkflowDefinitionV2RawToV3 = (value) => {
     if (!(0, guards_1.isRecord)(value) || value.version !== "2.0") {
-        return { ok: false, error: "invalid_workflow_definition", detail: "仅支持从 workflow v2.0 迁移" };
+        return { ok: false, error: "invalid_workflow_definition", detail: "Migration is only supported from workflow v2.0" };
     }
     if (!Array.isArray(value.nodes) || !Array.isArray(value.edges) || !Array.isArray(value.groups)) {
-        return { ok: false, error: "invalid_workflow_definition", detail: "workflow.nodes/edges/groups 必须为数组" };
+        return { ok: false, error: "invalid_workflow_definition", detail: "workflow.nodes/edges/groups must be arrays" };
     }
     const nodes = [];
     for (const item of value.nodes) {
         const normalized = (0, normalize_1.normalizeWorkflowNode)(item);
         if (!normalized)
-            return { ok: false, error: "invalid_workflow_definition", detail: "workflow.nodes 存在非法节点结构" };
+            return { ok: false, error: "invalid_workflow_definition", detail: "workflow.nodes contains an invalid node structure" };
         nodes.push(normalized);
     }
     const edges = [];
     for (const item of value.edges) {
         const normalized = (0, normalize_1.normalizeWorkflowEdge)(item);
         if (!normalized)
-            return { ok: false, error: "invalid_workflow_definition", detail: "workflow.edges 存在非法边结构" };
+            return { ok: false, error: "invalid_workflow_definition", detail: "workflow.edges contains an invalid edge structure" };
         edges.push(normalized);
     }
     const groups = [];
     for (const item of value.groups) {
         const normalized = (0, normalize_1.normalizeWorkflowGroup)(item);
         if (!normalized)
-            return { ok: false, error: "invalid_workflow_definition", detail: "workflow.groups 存在非法并行组结构" };
+            return { ok: false, error: "invalid_workflow_definition", detail: "workflow.groups contains an invalid parallel group structure" };
         groups.push(normalized);
     }
     const workflow = {

package/dist/src/pipeline/timeline-log-store.js

@@ -7,8 +7,8 @@ const LOG_FILE_NAME = "timeline.log";
 const stringifyTimelineEntry = (entry) => {
     const seen = new WeakSet();
     return JSON.stringify(entry, (_key, value) => {
-        // 允许完整保留 detail 内容，但循环引用对象本身无法直接 JSON 化，
-        // 这里仅做兜底，避免日志持久化因为异常对象而中断主流程。
+        // Allow keeping the full detail content, but cyclic-referencing objects themselves can't be directly JSON-serialized;
+        // this is purely a safety net to prevent log persistence from being interrupted by an anomalous object in the main flow.
         if (typeof value !== "object" || value === null)
             return value;
         if (seen.has(value))
@@ -30,7 +30,7 @@ const createTimelineLogStore = (options) => {
             text: item.text,
             ...(item.detail === undefined ? {} : { detail: item.detail }),
         })}\n`;
-        // 单行大小兜底，防止超大 detail 撑爆日志文件
+        // Per-line size safety net to prevent oversized details from blowing up the log file
         const MAX_LOG_LINE_BYTES = 512 * 1024;
         if (Buffer.byteLength(line, "utf8") > MAX_LOG_LINE_BYTES) {
             const truncated = line.slice(0, MAX_LOG_LINE_BYTES);
@@ -40,14 +40,14 @@ const createTimelineLogStore = (options) => {
         }
         writeChain = writeChain
             .catch(() => {
-            // 前一次写盘失败后继续后续写入，避免整个队列永久卡死。
+            // Continue subsequent writes after a previous flush failure to avoid permanently deadlocking the entire queue.
         })
             .then(async () => {
             await (0, promises_1.mkdir)((0, node_path_1.dirname)(logFile), { recursive: true });
             await (0, promises_1.appendFile)(logFile, line, "utf8");
         });
         return writeChain.catch(() => {
-            // 日志持久化失败不能影响流水线运行，这里吞掉异常交给调用方按需记录。
+            // Log persistence failure must not affect pipeline execution; swallow the exception here and let the caller record it as needed.
         });
     };
     return {

package/dist/src/pipeline/tool-activity.js

@@ -77,15 +77,15 @@ const createToolActivityLogger = (deps) => {
         if (!markSeen(dedupeKey))
             return;
         if (phase === "start") {
-            deps.pushTimeline(`Agent ${agentId} 工具开始: ${toolName} (run:${runId})`);
+            deps.pushTimeline(`Agent ${agentId} tool started: ${toolName} (run:${runId})`);
             return;
         }
         if (phase === "result" || phase === "end") {
             const isError = data.isError === true;
-            deps.pushTimeline(`Agent ${agentId} 工具结束: ${toolName} (run:${runId}${isError ? ", error" : ""})`, isError ? "warn" : "info");
+            deps.pushTimeline(`Agent ${agentId} tool finished: ${toolName} (run:${runId}${isError ? ", error" : ""})`, isError ? "warn" : "info");
             return;
         }
-        deps.pushTimeline(`Agent ${agentId} 工具事件: ${toolName}/${phase || "unknown"} (run:${runId})`);
+        deps.pushTimeline(`Agent ${agentId} tool event: ${toolName}/${phase || "unknown"} (run:${runId})`);
     };
     return {
         handleFrame,

package/dist/src/pipeline/types/pipeline-output.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildOutputId = void 0;
 const node_crypto_1 = require("node:crypto");
-/** 用去重键计算短哈希，稳定去重且长度可控。 */
+/** Compute a short hash from a deduplication key; stable dedup with manageable length. */
 const buildOutputId = (pipelineId, runId, batchRunId, itemKey, outputNodeId, artifactId, hash) => {
     const key = `${pipelineId}|${runId}|${batchRunId ?? ""}|${itemKey ?? ""}|${outputNodeId}|${artifactId}|${hash}`;
     const digest = (0, node_crypto_1.createHash)("sha256").update(key).digest("hex").slice(0, 16);