taskmeld 0.1.1 → 0.1.41

package/dist/src/pipeline/workflow/branch-rules.js

@@ -1,23 +1,23 @@
 "use strict";
 /**
- * 支线判定纯规则函数。
- * 无外部依赖，只接受数据参数，供 workflow/validate 和 execution/dependency-check 共同使用。
+ * Pure-functional branch determination rules.
+ * No external dependencies, accepts only data parameters. Shared by workflow/validate and execution/dependency-check.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBranchScope = exports.isCrossBranchEdgeByScope = exports.computeNodeScopes = void 0;
-// ====== Phase 2: 基于显式 branchScopeId 的支线规则 ======
+// ====== Phase 2: Branch rules based on explicit branchScopeId ======
 /**
- * 从 workflow 的 route 边推导每个节点的 branch scope。
- * scope 标识 = routerNodeId:routeValue，如 "router:a"。
- * 主线节点 scope 为 null。
+ * Derive each node's branch scope from the workflow's route edges.
+ * Scope identifier = routerNodeId:routeValue, e.g. "router:a".
+ * Mainline nodes have null scope.
  */
 const computeNodeScopes = (nodes, edges, explicitScopes) => {
     const scopes = new Map();
-    // 初始化：有显式 scope 的用显式，否则为 null
+    // Initialize: use explicit scope if provided, otherwise null
     for (const node of nodes) {
         scopes.set(node.id, explicitScopes?.get(node.id) ?? null);
     }
-    // 从 route 边推导 scope：路由边 from 的 scope 已知时，to 的 scope = fromScope != null ? fromScope : "from:when"
+    // Derive scope from route edges: when from's scope is known, to's scope = fromScope != null ? fromScope : "from:when"
     for (const edge of edges) {
         if (edge.when === null)
             continue;
@@ -28,17 +28,17 @@ const computeNodeScopes = (nodes, edges, explicitScopes) => {
             scopes.set(edge.to, targetScope);
         }
     }
-    // 传播 scope 沿普通依赖边：BFS 确保同一分支内的下游节点继承上游 scope。
-    // 多条路径到达节点时，若 scope 一致则合并；若冲突则保留首次设置的 scope。
+    // Propagate scope along unconditional dependency edges: BFS ensures downstream nodes within the same branch inherit the upstream scope.
+    // When multiple paths reach a node, merge if scopes agree; on conflict preserve the first-set scope.
     let changed = true;
     while (changed) {
         changed = false;
         for (const edge of edges) {
             if (edge.when !== null)
-                continue; // 只传播普通依赖边
+                continue; // Only propagate unconditional dependency edges
             const fromScope = scopes.get(edge.from);
             if (fromScope == null)
-                continue; // 上游无 scope 则不传播
+                continue; // Don't propagate if upstream has no scope
             const toScope = scopes.get(edge.to);
             if (toScope == null) {
                 scopes.set(edge.to, fromScope);
@@ -50,25 +50,25 @@ const computeNodeScopes = (nodes, edges, explicitScopes) => {
 };
 exports.computeNodeScopes = computeNodeScopes;
 /**
- * 基于 scope 判断边是否为跨支线普通边。
- * 跨支线：when 为 null 且 from 和 to 在不同的 scope 中。
+ * Determine whether an edge is a cross-branch unconditional edge based on scope.
+ * Cross-branch: when is null and from and to are in different scopes.
  */
 const isCrossBranchEdgeByScope = (edge, nodeScopes) => {
     if (edge.when !== null)
         return false;
     const fromScope = nodeScopes.get(edge.from) ?? null;
     const toScope = nodeScopes.get(edge.to) ?? null;
-    // 同 scope → 同一分支内，允许
+    // Same scope → within the same branch, allowed
     if (fromScope === toScope)
         return false;
-    // from 有 scope，to 无 scope → 支线结点向主线传播，不阻断（scope 沿依赖边继承）
+    // from has scope, to has no scope → branch node propagating to mainline, don't block (scope inherits along dependency edges)
     if (fromScope != null && toScope == null)
         return false;
-    // from 无 scope（主线），to 有 scope（支线）→ 禁止：主线不能无条件依赖支线内部节点
-    // from 和 to 都有 scope 但不同 → 禁止：不同支线之间的跨分支依赖
+    // from has no scope (mainline), to has scope (branch) → forbidden: mainline cannot unconditionally depend on branch-internal nodes
+    // from and to both have scope but different → forbidden: cross-branch dependency between different branches
     return fromScope !== toScope;
 };
 exports.isCrossBranchEdgeByScope = isCrossBranchEdgeByScope;
-/** 基于 scope 获取节点的支线身份。null scope = 主线。 */
+/** Get a node's branch identity based on scope. null scope = mainline. */
 const getBranchScope = (nodeId, nodeScopes) => nodeScopes.get(nodeId) ?? null;
 exports.getBranchScope = getBranchScope;

package/dist/src/pipeline/workflow/io.js

@@ -33,7 +33,7 @@ const loadWorkflowDefinitionWithStorage = (options) => {
             throw error;
         }
         const wrapped = new Error("invalid_persisted_workflow_definition");
-        wrapped.detail = "workflow 文件解析失败，请检查 JSON 格式";
+        wrapped.detail = "Failed to parse workflow file, please check JSON format";
         throw wrapped;
     }
 };

package/dist/src/pipeline/workflow/normalize.js

@@ -57,7 +57,7 @@ const normalizeRemoteBatchPlugin = (value) => {
         enabled: record.enabled === true,
         url: normalizeNonEmptyString(record.url) ?? DEFAULT_REMOTE_BATCH_URL,
         startBatch: normalizeIntegerInRange(record.startBatch, 1, 1, 1_000_000),
-        // 批大小与取数来源都属于低频配置，统一并入插件配置，避免主面板堆叠过多参数。
+        // Batch size and data source are low-frequency configuration; consolidate into plugin config to avoid too many params piling up on the main panel.
         batchSize: normalizeIntegerInRange(record.batchSize, 5, 1, 1_000),
         sourceField: normalizeNonEmptyString(record.sourceField) ?? "list30",
     };
@@ -65,14 +65,14 @@ const normalizeRemoteBatchPlugin = (value) => {
 const normalizeSchedulerPlugin = (value) => {
     const record = (0, guards_1.isRecord)(value) ? value : {};
     return {
-        // 调度器历史上默认对所有流水线开启；插件化后继续保持默认开启，避免升级后界面和行为突然消失。
+        // The scheduler was historically enabled for all pipelines by default; after plugin-ification, keep it enabled by default so the UI and behavior don't suddenly disappear after upgrade.
         enabled: record.enabled !== false,
     };
 };
 const normalizeWorkflowPlugins = (value) => {
     const record = (0, guards_1.isRecord)(value) ? value : {};
     return {
-        // 插件能力对所有流水线一致，这里只记录每条流水线自己的启用与参数配置。
+        // Plugin capabilities are consistent across all pipelines; only record each pipeline's own enabled + parameter configuration here.
         remoteBatch: normalizeRemoteBatchPlugin(record.remoteBatch),
         scheduler: normalizeSchedulerPlugin(record.scheduler),
     };
@@ -193,7 +193,7 @@ const normalizeWorkflowNode = (value) => {
         allowReject: value.allowReject === true,
         maxRejectCount: normalizeIntegerInRange(value.maxRejectCount, 3, 0, 10),
     };
-    // 仅在显式提供时写入 branch scope 字段，避免 null 值污染 JSON 输出
+    // Only write branch scope fields when explicitly provided to avoid null values polluting JSON output
     if (branchScopeId)
         node.branchScopeId = branchScopeId;
     if (routeSourceNodeId)
@@ -224,8 +224,8 @@ const normalizeWorkflowEdgeV3 = (value) => {
     const to = normalizeNonEmptyString(value.to);
     if (!from || !to)
         return null;
-    // v3 API 闭环要求：读取接口返回运行时 when 形状时，写回 /workflow 也必须可直接接受。
-    // 这里仅在 version=3.0 契约下做"同版本双形状"归一化，不允许 version=2.0 旁路写入。
+    // v3 API closed-loop requirement: when the read API returns runtime when shapes, writing back to /workflow must also be directly accepted.
+    // Here, only do "same-version dual-shape" normalization under the version=3.0 contract; do not allow version=2.0 bypass writes.
     if ("when" in value) {
         return {
             from,
@@ -258,10 +258,10 @@ const normalizeWorkflowGroup = (value) => {
     if (!type)
         return null;
     const joinPolicy = "all";
-    // 历史 any/quorum 降级：运行时仅支持 all，读取历史数据时静默降级为 all。
-    // 保存新 workflow 时 validate 会显式拒绝 any/quorum。
+    // Historical any/quorum downgrade: runtime only supports all; silently downgrade to all when reading historical data.
+    // When saving a new workflow, validate will explicitly reject any/quorum.
     if (value.joinPolicy === "any" || value.joinPolicy === "quorum") {
-        // 静默降级 — 历史数据兼容，新保存会被 validate 拦截
+        // Silently downgrade — historical data compatibility; new saves will be intercepted by validate
     }
     return {
         id,
@@ -286,48 +286,48 @@ const readWorkflowDefinitionFromRaw = (value) => {
 exports.readWorkflowDefinitionFromRaw = readWorkflowDefinitionFromRaw;
 const readWorkflowDefinitionFromRawDetailed = (value) => {
     if (!(0, guards_1.isRecord)(value)) {
-        return { ok: false, error: "invalid_workflow_definition", detail: "workflow 根对象格式非法" };
+        return { ok: false, error: "invalid_workflow_definition", detail: "Workflow root object has an invalid format" };
     }
     if (value.version === "2.0") {
         return {
             ok: false,
             error: "workflow_migration_required",
-            detail: "检测到 workflow v2.0，请先执行迁移脚本再写入",
+            detail: "Workflow v2.0 detected, please run the migration script before writing",
         };
     }
     if (value.version !== "3.0") {
-        return { ok: false, error: "invalid_workflow_definition", detail: `workflow.version 非法: ${String(value.version ?? "")}` };
+        return { ok: false, error: "invalid_workflow_definition", detail: `Invalid workflow.version: ${String(value.version ?? "")}` };
     }
     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, exports.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 = normalizeWorkflowEdgeV3(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) {
-        // 预检：在 normalize 静默降级之前显式拒绝不支持的 joinPolicy
+        // Pre-check: explicitly reject unsupported joinPolicy before normalize silently downgrades it
         if ((0, guards_1.isRecord)(item) && (item.joinPolicy === "any" || item.joinPolicy === "quorum")) {
             return {
                 ok: false,
                 error: "join_policy_not_supported",
-                detail: `并行组 "${String(item.id ?? "?")}" 的 joinPolicy "${String(item.joinPolicy)}" 未支持，当前仅支持 "all"`,
+                detail: `Parallel group "${String(item.id ?? "?")}" has unsupported joinPolicy "${String(item.joinPolicy)}", only "all" is currently supported`,
             };
         }
         const normalized = (0, exports.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/workflow/template-mapper.js

@@ -5,13 +5,13 @@ const validate_1 = require("./validate");
 const toUniqueList = (items) => [...new Set(items)];
 // ====== Workflow → Template nodes (unified, with dedup) ======
 /**
- * 从 WorkflowDefinitionRuntime 提取模板节点（仅 dependency 类型的出边）。
- * 这是 workflow → template 映射的唯一权威实现。
+ * Extract template nodes from WorkflowDefinitionRuntime (dependency-type outgoing edges only).
+ * This is the single authoritative implementation of the workflow → template mapping.
  */
 const workflowToTemplateNodes = (workflow) => {
     const incomingByNodeId = new Map();
     for (const edge of workflow.edges) {
-        // template.dependsOn 只表达依赖边；路由边属于分流语义，不能回写成普通依赖。
+        // template.dependsOn only expresses dependency edges; route edges belong to routing semantics and cannot be written back as ordinary dependencies.
         if (edge.when !== null)
             continue;
         const prev = incomingByNodeId.get(edge.to) ?? [];

package/dist/src/pipeline/workflow/validate.js

@@ -8,11 +8,11 @@ const validateWorkflowGraph = (workflow) => {
     if (workflow.nodes.length === 0) {
         return workflow.edges.length === 0 && workflow.groups.length === 0
             ? { ok: true }
-            : { ok: false, error: "invalid_workflow_definition", detail: "空 workflow 不能包含 edges 或 groups" };
+            : { ok: false, error: "invalid_workflow_definition", detail: "Empty workflow cannot contain edges or groups" };
     }
     const nodeIds = new Set(workflow.nodes.map((node) => node.id));
     if (nodeIds.size !== workflow.nodes.length) {
-        return { ok: false, error: "invalid_workflow_definition", detail: "workflow.nodes 存在重复 id" };
+        return { ok: false, error: "invalid_workflow_definition", detail: "workflow.nodes contains duplicate IDs" };
     }
     const groupIds = new Set(workflow.groups.map((group) => group.id));
     const entityIds = new Set([...nodeIds, ...groupIds]);
@@ -29,14 +29,14 @@ const validateWorkflowGraph = (workflow) => {
     const edgeDedupe = new Set();
     for (const edge of workflow.edges) {
         if (!entityIds.has(edge.from) || !entityIds.has(edge.to)) {
-            return { ok: false, error: "invalid_workflow_definition", detail: `边引用了不存在实体: ${edge.from} -> ${edge.to}` };
+            return { ok: false, error: "invalid_workflow_definition", detail: `Edge references non-existent entity: ${edge.from} -> ${edge.to}` };
         }
         if (edge.from === edge.to) {
-            return { ok: false, error: "invalid_workflow_definition", detail: `检测到自环边: ${edge.from} -> ${edge.to}` };
+            return { ok: false, error: "invalid_workflow_definition", detail: `Self-loop edge detected: ${edge.from} -> ${edge.to}` };
         }
         const key = `${edge.from}|${edge.when ?? ""}|${edge.to}`;
         if (edgeDedupe.has(key)) {
-            return { ok: false, error: "invalid_workflow_definition", detail: `检测到重复边: ${edge.from} -> ${edge.to}` };
+            return { ok: false, error: "invalid_workflow_definition", detail: `Duplicate edge detected: ${edge.from} -> ${edge.to}` };
         }
         edgeDedupe.add(key);
         outgoing.set(edge.from, [...(outgoing.get(edge.from) ?? []), edge.to]);
@@ -57,15 +57,15 @@ const validateWorkflowGraph = (workflow) => {
         const sourceNode = workflow.nodes.find((node) => node.id === sourceId);
         if (sourceNode?.routePolicy)
             continue;
-        // 非分流节点仍禁止同一节点混合依赖边和路由边，避免无条件放行导致重复执行。
+        // Non-routing nodes are still forbidden from mixing dependency and route edges on the same node, to prevent unconditional passthrough leading to double execution.
         return {
             ok: false,
             error: "mixed_outgoing_edge_kinds_forbidden",
-            detail: `节点 ${sourceId} 同时存在 dependency 与 route 出边，已禁止保存`,
+            detail: `Node ${sourceId} has both dependency and route outgoing edges, which is not allowed`,
         };
     }
-    // Phase 2: 基于显式 scope 的跨支线边检测。
-    // computeNodeScopes + isCrossBranchEdgeByScope 使用显式 branchScopeId（缺失时从 route 边推导）。
+    // Phase 2: Cross-branch edge detection based on explicit scope.
+    // computeNodeScopes + isCrossBranchEdgeByScope use explicit branchScopeId (derived from route edges when missing).
     {
         const explicitScopes = new Map();
         const mergeNodeIds = new Set();
@@ -73,13 +73,13 @@ const validateWorkflowGraph = (workflow) => {
             if (node.branchScopeId != null) {
                 explicitScopes.set(node.id, node.branchScopeId);
             }
-            // merge 节点（dependencyPolicy !== "all"）是显式分支汇聚点，接受来自不同 scope 的依赖边
+            // merge nodes (dependencyPolicy !== "all") are explicit branch convergence points, accepting dependency edges from different scopes
             if (node.dependencyPolicy && node.dependencyPolicy !== "all") {
                 mergeNodeIds.add(node.id);
             }
         }
         const nodeScopes = (0, branch_rules_1.computeNodeScopes)(workflow.nodes, workflow.edges, explicitScopes);
-        // 对 merge 节点清除 scope，避免其被误判为跨支线（与 workflow-graph.ts 的 buildIndices 保持一致）
+        // Clear scope for merge nodes to avoid them being misjudged as cross-branch (consistent with buildIndices in workflow-graph.ts)
         for (const nodeId of mergeNodeIds) {
             nodeScopes.set(nodeId, null);
         }
@@ -88,7 +88,7 @@ const validateWorkflowGraph = (workflow) => {
             return {
                 ok: false,
                 error: "cross_branch_edge_forbidden",
-                detail: `禁止跨支线无条件边: ${scopeCrossEdges[0].from} -> ${scopeCrossEdges[0].to}（from 分支 ${nodeScopes.get(scopeCrossEdges[0].from) ?? "main"} -> to 分支 ${nodeScopes.get(scopeCrossEdges[0].to) ?? "main"}，跨支线依赖边需要显式 merge 节点）`,
+                detail: `Cross-branch unconditional edge is not allowed: ${scopeCrossEdges[0].from} -> ${scopeCrossEdges[0].to} (from branch ${nodeScopes.get(scopeCrossEdges[0].from) ?? "main"} -> to branch ${nodeScopes.get(scopeCrossEdges[0].to) ?? "main"}, cross-branch dependency edges require an explicit merge node)`,
             };
         }
     }
@@ -96,12 +96,12 @@ const validateWorkflowGraph = (workflow) => {
     const explicitGroupById = new Map(workflow.groups.map((group) => [group.id, group]));
     for (const group of workflow.groups) {
         if (uniqueGroupIds.has(group.id)) {
-            return { ok: false, error: "invalid_workflow_definition", detail: `并行组 id 重复: ${group.id}` };
+            return { ok: false, error: "invalid_workflow_definition", detail: `Duplicate parallel group ID: ${group.id}` };
         }
         uniqueGroupIds.add(group.id);
         for (const member of group.members) {
             if (!nodeIds.has(member)) {
-                return { ok: false, error: "invalid_workflow_definition", detail: `并行组 ${group.id} 引用了不存在成员 ${member}` };
+                return { ok: false, error: "invalid_workflow_definition", detail: `Parallel group ${group.id} references non-existent member ${member}` };
             }
         }
     }
@@ -111,9 +111,9 @@ const validateWorkflowGraph = (workflow) => {
             continue;
         const group = explicitGroupById.get(groupId);
         if (!group)
-            return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 引用了不存在并行组 ${groupId}` };
+            return { ok: false, error: "invalid_workflow_definition", detail: `Node ${node.id} references non-existent parallel group ${groupId}` };
         if (!group.members.includes(node.id)) {
-            return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 未加入其声明的并行组 ${groupId}` };
+            return { ok: false, error: "invalid_workflow_definition", detail: `Node ${node.id} is not a member of its declared parallel group ${groupId}` };
         }
     }
     for (const group of workflow.groups) {
@@ -129,20 +129,20 @@ const validateWorkflowGraph = (workflow) => {
             if (edge.to === group.id)
                 continue;
             if (edge.from === group.id)
-                return { ok: false, error: "invalid_workflow_definition", detail: `并行组 ${group.id} 不能直接连入成员节点` };
+                return { ok: false, error: "invalid_workflow_definition", detail: `Parallel group ${group.id} cannot directly connect to member nodes` };
             if (memberSet.has(edge.from))
-                return { ok: false, error: "invalid_workflow_definition", detail: `并行组 ${group.id} 成员之间禁止直接依赖` };
+                return { ok: false, error: "invalid_workflow_definition", detail: `Direct dependencies between members of parallel group ${group.id} are not allowed` };
             if (groupIncoming.has(edge.from))
-                return { ok: false, error: "invalid_workflow_definition", detail: `并行组 ${group.id} 的入口节点不能直连成员` };
+                return { ok: false, error: "invalid_workflow_definition", detail: `The entry node of parallel group ${group.id} cannot directly connect to members` };
         }
     }
     for (const group of workflow.groups) {
-        // joinPolicy 仅支持 "all"；any/quorum 运行时未实现，保存时显式拒绝
+        // joinPolicy only supports "all"; any/quorum are not implemented at runtime, explicitly reject on save
         if (group.joinPolicy !== "all") {
             return {
                 ok: false,
                 error: "join_policy_not_supported",
-                detail: `并行组 ${group.id} 的 joinPolicy "${group.joinPolicy}" 未支持，当前仅支持 "all"`,
+                detail: `Parallel group ${group.id} has unsupported joinPolicy "${group.joinPolicy}", only "all" is currently supported`,
             };
         }
     }
@@ -150,24 +150,24 @@ const validateWorkflowGraph = (workflow) => {
         if (node.routePolicy) {
             const { allowed } = node.routePolicy;
             if (allowed.length < 2 || allowed.length > 5) {
-                return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 的路由集合长度非法` };
+                return { ok: false, error: "invalid_workflow_definition", detail: `Node ${node.id} has an invalid route set size` };
             }
             if (!allowed.includes(routes_1.MAINLINE_ROUTE_VALUE) || !allowed.includes(routes_1.DEFAULT_BRANCH_ROUTE_VALUE)) {
-                return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 开启分流后必须包含 yes 和 no` };
+                return { ok: false, error: "invalid_workflow_definition", detail: `Node ${node.id} must include "yes" and "no" routes when routing is enabled` };
             }
             const outgoingEdges = edgesBySource.get(node.id) ?? [];
             const dependencyEdges = outgoingEdges.filter((edge) => edge.when === null);
             if (dependencyEdges.length > 1) {
-                return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 的 yes 主线依赖边最多只能有 1 条` };
+                return { ok: false, error: "invalid_workflow_definition", detail: `Node ${node.id} can have at most 1 "yes" mainline dependency edge` };
             }
             const routeEdgeCounts = new Map();
             for (const edge of outgoingEdges.filter((item) => item.when !== null)) {
                 routeEdgeCounts.set(edge.when ?? "", (routeEdgeCounts.get(edge.when ?? "") ?? 0) + 1);
                 if (edge.when === routes_1.MAINLINE_ROUTE_VALUE) {
-                    return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 的 yes 不能保存为路由边` };
+                    return { ok: false, error: "invalid_workflow_definition", detail: `Node ${node.id} cannot save "yes" as a route edge` };
                 }
                 if (!allowed.includes(edge.when ?? "")) {
-                    return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 存在未声明的路由边: ${edge.when}` };
+                    return { ok: false, error: "invalid_workflow_definition", detail: `Node ${node.id} has an undeclared route edge: ${edge.when}` };
                 }
                 const targetNode = workflow.nodes.find((candidate) => candidate.id === edge.to);
                 const targetGroup = workflow.groups.find((group) => group.id === edge.to);
@@ -176,17 +176,17 @@ const validateWorkflowGraph = (workflow) => {
                     : [];
                 const isBranchTarget = targetNode?.lane === "branch" || (targetGroupMembers.length > 0 && targetGroupMembers.every((member) => member?.lane === "branch"));
                 if (!isBranchTarget) {
-                    return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 的路由 ${edge.when} 只能指向支线节点或支线并行组` };
+                    return { ok: false, error: "invalid_workflow_definition", detail: `Node ${node.id} route "${edge.when}" can only target branch nodes or branch parallel groups` };
                 }
             }
             for (const route of allowed.filter((item) => item !== routes_1.MAINLINE_ROUTE_VALUE)) {
                 if ((routeEdgeCounts.get(route) ?? 0) !== 1) {
-                    return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 的路由 ${route} 必须配置且只能配置 1 个支线目标` };
+                    return { ok: false, error: "invalid_workflow_definition", detail: `Node ${node.id} route "${route}" must have exactly 1 branch target` };
                 }
             }
         }
         if (node.dependencyPolicy !== undefined && node.dependencyPolicy !== "all" && node.dependencyPolicy !== "any") {
-            return { ok: false, error: "invalid_workflow_definition", detail: `节点 ${node.id} 的 dependencyPolicy 非法` };
+            return { ok: false, error: "invalid_workflow_definition", detail: `Node ${node.id} has an invalid dependencyPolicy` };
         }
     }
     const queue = [...[...entityIds].filter((id) => (indegree.get(id) ?? 0) === 0)];
@@ -203,7 +203,7 @@ const validateWorkflowGraph = (workflow) => {
         }
     }
     if (visited !== entityIds.size) {
-        return { ok: false, error: "invalid_workflow_definition", detail: "工作流存在环路，无法拓扑排序" };
+        return { ok: false, error: "invalid_workflow_definition", detail: "Workflow contains a cycle, cannot perform topological sort" };
     }
     return { ok: true };
 };
@@ -212,25 +212,25 @@ const validateWorkflowOutputConfig = (workflow) => {
     const output = workflow.output ?? { mode: "mainline_last", nodeId: null };
     if (workflow.nodes.length === 0) {
         return output.mode === "explicit" && output.nodeId
-            ? { ok: false, error: "invalid_workflow_output_config", detail: "空 workflow 不能指定输出节点" }
+            ? { ok: false, error: "invalid_workflow_output_config", detail: "Empty workflow cannot specify an output node" }
             : { ok: true };
     }
     if (output.mode === "explicit") {
         if (!output.nodeId) {
-            return { ok: false, error: "invalid_workflow_output_config", detail: "mode=explicit 时 nodeId 必填" };
+            return { ok: false, error: "invalid_workflow_output_config", detail: "nodeId is required when mode=explicit" };
         }
         const node = workflow.nodes.find((n) => n.id === output.nodeId);
         if (!node) {
-            return { ok: false, error: "invalid_workflow_output_config", detail: `输出节点 ${output.nodeId} 不存在` };
+            return { ok: false, error: "invalid_workflow_output_config", detail: `Output node ${output.nodeId} does not exist` };
         }
         if (!node.enabled) {
-            return { ok: false, error: "invalid_workflow_output_config", detail: `输出节点 ${output.nodeId} 必须 enabled` };
+            return { ok: false, error: "invalid_workflow_output_config", detail: `Output node ${output.nodeId} must be enabled` };
         }
         if (node.lane !== "main") {
-            return { ok: false, error: "invalid_workflow_output_config", detail: `输出节点 ${output.nodeId} 必须是主线节点` };
+            return { ok: false, error: "invalid_workflow_output_config", detail: `Output node ${output.nodeId} must be a mainline node` };
         }
         if (node.branchScopeId) {
-            return { ok: false, error: "invalid_workflow_output_config", detail: `输出节点 ${output.nodeId} 不能属于支线 scope` };
+            return { ok: false, error: "invalid_workflow_output_config", detail: `Output node ${output.nodeId} cannot belong to a branch scope` };
         }
         return { ok: true };
     }
@@ -239,7 +239,7 @@ const validateWorkflowOutputConfig = (workflow) => {
         .filter((n) => n.enabled && n.lane === "main" && !n.branchScopeId && !n.routeSourceNodeId && !n.routeValue)
         .map((n) => n.id));
     if (mainlineNodeIds.size === 0) {
-        return { ok: false, error: "invalid_workflow_output_config", detail: "没有可用的主线节点" };
+        return { ok: false, error: "invalid_workflow_output_config", detail: "No available mainline nodes" };
     }
     // Build full adjacency (all nodes, all edges) for reachability DFS
     const allNodeIds = new Set(workflow.nodes.map((n) => n.id));
@@ -296,13 +296,13 @@ const validateWorkflowOutputConfig = (workflow) => {
         ? sinkNodes // all candidates are orphans, keep as-is
         : sinkNodes.filter((id) => !orphanIds.has(id)); // exclude orphans
     if (effectiveSinks.length === 0) {
-        return { ok: false, error: "invalid_workflow_output_config", detail: "无法推导唯一主线 sink 节点" };
+        return { ok: false, error: "invalid_workflow_output_config", detail: "Cannot derive a unique mainline sink node" };
     }
     if (effectiveSinks.length > 1) {
         return {
             ok: false,
             error: "invalid_workflow_output_config",
-            detail: `存在多个主线 sink 节点: ${effectiveSinks.join(", ")}，请切换到 mode=explicit 并指定 nodeId`,
+            detail: `Multiple mainline sink nodes found: ${effectiveSinks.join(", ")}, switch to mode=explicit and specify nodeId`,
         };
     }
     return { ok: true };

package/dist/src/pipeline/workflow-graph.js

@@ -21,8 +21,8 @@ const buildIndices = (workflow) => {
         outgoing.push(edge);
         outgoingEdgesBySource.set(edge.from, outgoing);
     }
-    // 计算节点 branch scope：优先使用显式 branchScopeId，缺失时从 route 边推导。
-    // 将 nodes 和 groups 都纳入 scope 计算，确保 group 的 scope 被正确传播。
+    // Compute node branch scope: prefer explicit branchScopeId, derive from route edges when missing.
+    // Include both nodes and groups in scope computation so group scopes are correctly propagated.
     const explicitScopes = new Map();
     for (const node of workflow.nodes) {
         if (node.branchScopeId != null) {
@@ -34,9 +34,9 @@ const buildIndices = (workflow) => {
         ...workflow.groups.map((g) => ({ id: g.id })),
     ];
     const nodeScopes = (0, branch_rules_1.computeNodeScopes)(allEntities, workflow.edges, explicitScopes);
-    // explicitScopeIds: 显式声明了非默认 merge 策略的节点（dependencyPolicy != "all"），
-    // 是多个分支的显式汇聚点，应接受来自不同 scope 的依赖边。
-    // 将其 scope 重置为 null，避免跨支线误判阻断合法的分支合并。
+    // explicitScopeIds: nodes that explicitly declare a non-default merge strategy (dependencyPolicy != "all"),
+    // they are explicit convergence points for multiple branches and should accept dependency edges from different scopes.
+    // Reset their scope to null to avoid cross-branch false positives blocking valid branch merges.
     for (const node of workflow.nodes) {
         if (node.dependencyPolicy && node.dependencyPolicy !== "all") {
             nodeScopes.set(node.id, null);
@@ -103,14 +103,14 @@ const createWorkflowGraph = (initialWorkflow, initialTemplateNodes) => {
     const getParallelGroupByMemberNodeId = (nodeId) => indices.parallelGroupByMemberNodeId.get(nodeId) ?? null;
     const isWorkflowNodeEnabled = (nodeId) => getWorkflowNodeById(nodeId)?.enabled !== false;
     const isGroupId = (id) => indices.groupById.has(id);
-    // Phase 2: 基于 scope 判断支线身份，替代入边形状推断。
-    // scope 为 null → 主线节点；scope 非 null → 支线节点。
+    // Phase 2: determine branch identity based on scope, replacing incoming-edge shape inference.
+    // scope is null → mainline node; scope is non-null → branch node.
     const isBranchNode = (nodeId) => {
         const scope = indices.nodeScopes.get(nodeId);
         return scope != null;
     };
-    // Phase 2: 基于 scope 判断跨支线边，替代入边形状推断。
-    // 旧版在存在 B1→B2 普通边时会因 B2 不再"纯支线"而漏判，新版不受此影响。
+    // Phase 2: determine cross-branch edges based on scope, replacing incoming-edge shape inference.
+    // The old version would miss detection when B1→B2 unconditional edges exist because B2 was no longer "purely branch"; the new version is unaffected.
     const isCrossBranchEdge = (edge) => (0, branch_rules_1.isCrossBranchEdgeByScope)(edge, indices.nodeScopes);
     const getNodeScope = (nodeId) => indices.nodeScopes.get(nodeId) ?? null;
     const getNodesWithWorkflowMeta = (nodes) => nodes.map((node) => {
@@ -126,7 +126,7 @@ const createWorkflowGraph = (initialWorkflow, initialTemplateNodes) => {
         const current = new Map((run.groups ?? []).map((group) => [group.id, group]));
         run.groups = indices.groups.map((group) => ({
             id: group.id,
-            title: `并行组 ${group.id}`,
+            title: `Group ${group.id}`,
             status: current.get(group.id)?.status ?? "blocked",
             members: group.members,
             joinPolicy: group.joinPolicy,

package/dist/src/server/http-handler.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiHandler = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+// Static file MIME type map
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+};
+// Resolve the web static assets directory
+const resolveWebDist = () => (0, node_path_1.join)(__dirname, "..", "..", "..", "web", "dist");
+const webDistRoot = resolveWebDist();
+// Static file serving (SPA falls back to index.html)
+const serveStatic = (req, res) => {
+    if (!(0, node_fs_1.existsSync)(webDistRoot))
+        return false;
+    const url = new URL(req.url ?? "/", "http://localhost");
+    let filePath = (0, node_path_1.join)(webDistRoot, url.pathname === "/" ? "index.html" : url.pathname);
+    if (!(0, node_fs_1.existsSync)(filePath) || !filePath.startsWith(webDistRoot)) {
+        filePath = (0, node_path_1.join)(webDistRoot, "index.html");
+    }
+    if (!(0, node_fs_1.existsSync)(filePath))
+        return false;
+    const ext = (0, node_path_1.extname)(filePath);
+    const contentType = MIME[ext] ?? "application/octet-stream";
+    res.writeHead(200, {
+        "Content-Type": contentType,
+        "Cache-Control": ext === ".html" ? "no-cache" : "public, max-age=3600",
+    });
+    (0, node_fs_1.createReadStream)(filePath).pipe(res);
+    return true;
+};
+// Create HTTP request handler (health check + CORS + static files)
+const createApiHandler = (options) => {
+    return (req, res) => {
+        const url = req.url ?? "/";
+        // /api/health — CLI server lifecycle check
+        if (req.method === "GET" && url === "/api/health") {
+            res.writeHead(200, {
+                "Content-Type": "application/json; charset=utf-8",
+                "Access-Control-Allow-Origin": options.webOrigin,
+            });
+            res.end(JSON.stringify({ ok: true, ...options.serverRuntimeIdentity }));
+            return;
+        }
+        // OPTIONS — CORS preflight
+        if (req.method === "OPTIONS") {
+            res.writeHead(204, {
+                "Access-Control-Allow-Origin": options.webOrigin,
+                "Access-Control-Allow-Methods": "GET,POST,PATCH,DELETE,OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type",
+            });
+            res.end();
+            return;
+        }
+        // Static SPA files (falls back to index.html)
+        if (serveStatic(req, res))
+            return;
+        res.writeHead(404, {
+            "Content-Type": "application/json; charset=utf-8",
+            "Access-Control-Allow-Origin": options.webOrigin,
+        });
+        res.end(JSON.stringify({ error: "not_found" }));
+    };
+};
+exports.createApiHandler = createApiHandler;

package/dist/src/services/agent-service.js

@@ -38,14 +38,14 @@ const createAgentService = (app) => {
         await (0, gateway_read_helpers_1.ensureGatewayReadyForReadonly)(app);
         const payload = await app.gateway.client.sendReq("agents.list");
         const rawItems = app.gateway.pickArray(payload);
-        // 会话活动时间优先尝试刷新；刷新失败时回退缓存，保证只读查询可用性。
+        // Try refreshing session activity first; fall back to cache on failure to keep read-only queries available.
         let sessionItems = app.gateway.getSessionCache();
         try {
             const refreshed = await app.gateway.refreshSessionsFromGateway();
             sessionItems = refreshed.items;
         }
         catch {
-            // 只读查询容错：会话刷新失败不应阻断 agents.list 输出。
+            // Read-only query resilience: session refresh failure must not block agents.list output.
         }
         const lastActiveByAgentId = new Map();
         for (const session of sessionItems) {