taskmeld 0.1.1 → 0.1.41

package/dist/src/cli/server-runtime-client.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPipelineRuntimeApiClient = exports.createServerLifecycleClient = void 0;
+exports.createPipelineRuntimeApiClientWs = exports.createServerLifecycleClient = exports.resolveRuntimePipelineSelector = void 0;
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
@@ -11,6 +11,7 @@ const node_child_process_1 = require("node:child_process");
 const ws_1 = __importDefault(require("ws"));
 const app_context_env_1 = require("../app/app-context-env");
 const data_dir_1 = require("../app/data-dir");
+const ws_runtime_client_1 = require("./ws-runtime-client");
 const errors_1 = require("./errors");
 const STARTUP_LOCK_STALE_MS = 15_000;
 const STARTUP_LOCK_WAIT_MS = 250;
@@ -18,24 +19,12 @@ const STARTUP_TIMEOUT_MS = 15_000;
 const STOP_TIMEOUT_MS = 10_000;
 const buildApiBaseUrl = () => {
     const config = (0, app_context_env_1.resolveAppContextConfig)();
-    // CLI 访问本地常驻后端时固定走 loopback，避免 0.0.0.0 作为 client 目标地址不可直连。
     return `http://127.0.0.1:${config.apiPort}`;
 };
 const buildWsBaseUrl = () => {
     const config = (0, app_context_env_1.resolveAppContextConfig)();
     return `ws://127.0.0.1:${config.apiPort}`;
 };
-const buildPipelineApiUrl = (pipelineId, suffix) => `${buildApiBaseUrl()}/api/pipelines/${encodeURIComponent(pipelineId)}${suffix}`;
-const buildPipelineApiUrlWithIdentity = (pipelineId, suffix, target) => {
-    const url = new URL(buildPipelineApiUrl(pipelineId, suffix));
-    if (typeof target?.runId === "string" && target.runId.trim()) {
-        url.searchParams.set("runId", target.runId.trim());
-    }
-    if (typeof target?.batchRunId === "string" && target.batchRunId.trim()) {
-        url.searchParams.set("batchRunId", target.batchRunId.trim());
-    }
-    return url.toString();
-};
 const resolveRuntimePipelineSelector = (selector) => {
     if (typeof selector === "string" && selector.trim()) {
         return { pipelineId: selector.trim() };
@@ -52,7 +41,7 @@ const resolveRuntimePipelineSelector = (selector) => {
     }
     const pipelineId = typeof selector.pipelineId === "string" ? selector.pipelineId.trim() : "";
     if (!pipelineId) {
-        // runtime API 的 status/stop 路由仍是 /api/pipelines/:pipelineId/*，runId/batchRunId 仅用于“精确命中当前 pipeline 运行”。
+        // runtime API status/stop routes are still /api/pipelines/:pipelineId/*; runId/batchRunId are only used for "precisely hitting the current pipeline run".
         throw new errors_1.CliError("Missing pipelineId for runtime API selector", {
             code: "INVALID_ARGUMENT",
             exitCode: 2,
@@ -70,6 +59,7 @@ const resolveRuntimePipelineSelector = (selector) => {
         },
     };
 };
+exports.resolveRuntimePipelineSelector = resolveRuntimePipelineSelector;
 const waitForPipelineWatchSignal = async (selector, timeoutMs) => {
     const wsUrl = `${buildWsBaseUrl()}/api/ws`;
     const eventType = await new Promise((resolve, reject) => {
@@ -104,8 +94,8 @@ const waitForPipelineWatchSignal = async (selector, timeoutMs) => {
             if (selector.runId) {
                 return selector.runId === eventRunId || selector.runId === runIdFromRun;
             }
-            // batchRunId 在 pipeline.updated 中没有稳定字段；这里把更新当作“状态可能变化”的唤醒信号，
-            // 实际终态判断仍由后续 status 请求完成，避免因为事件字段缺失误判终态。
+            // batchRunId has no stable field in pipeline.updated; treat the update as a "state may have changed" wake-up signal,
+            // while the actual terminal-state judgment is still done by a subsequent status request, to avoid misjudging terminal state due to missing event fields.
             if (selector.batchRunId)
                 return true;
             return Boolean(selector.pipelineId);
@@ -294,7 +284,7 @@ const metadataMatchesHealth = (metadata, health) => {
     if (metadata.serverId && health.serverId) {
         return metadata.serverId === health.serverId;
     }
-    // 兼容旧 metadata：早期 runtime.json 不含 serverId，此时退回 pid/port/endpoint 交叉校验。
+    // Compatibility with old metadata: early runtime.json didn't include serverId; fall back to pid/port/endpoint cross-validation.
     return true;
 };
 const buildMetadataFromHealth = (health) => ({
@@ -354,7 +344,7 @@ const cleanupStaleRuntimeArtifacts = async (probe) => {
     if (probe.metadataStale) {
         await (0, promises_1.rm)(getServerRuntimeMetadataPath(), { force: true });
     }
-    // startup.lock 是“开始拉起”的互斥标记，不是 owner 证据；只有健康实例不存在且锁超时才允许清理。
+    // startup.lock is a mutual-exclusion marker for "starting up", not owner evidence; only clean up when no healthy instance exists and the lock is stale.
     if (!probe.ready && probe.lockStale) {
         await (0, promises_1.rm)(getServerStartupLockPath(), { force: true });
     }
@@ -364,8 +354,8 @@ const reconcileRuntimeMetadataWithHealth = async (probe) => {
         return probe.metadata;
     const nextMetadata = buildMetadataFromHealth(probe.health);
     if (!metadataMatchesHealth(probe.metadata, probe.health)) {
-        // health 请求已经命中了当前 CLI 期望的 endpoint；只要这份 owner 信息完整，就应该回填 metadata，
-        // 否则 metadata_missing / metadata_mismatch 会在后续 ensure/status/stop 中反复被误判为异常状态。
+        // The health request already matched the endpoint the CLI expects; if this owner info is complete, it should be written back to metadata,
+        // otherwise metadata_missing / metadata_mismatch would repeatedly be misjudged as an abnormal state in subsequent ensure/status/stop calls.
         await writeRuntimeMetadata(nextMetadata);
         return nextMetadata;
     }
@@ -382,47 +372,6 @@ const isPidRunning = (pid) => {
         return false;
     }
 };
-const normalizeServerError = async (response) => {
-    let payload = null;
-    try {
-        payload = await response.json();
-    }
-    catch {
-        payload = null;
-    }
-    const code = typeof payload?.error === "string" && payload.error.trim() ? payload.error.trim().toUpperCase() : "SERVER_REQUEST_FAILED";
-    const message = typeof payload?.error === "string" && payload.error.trim()
-        ? payload.error.trim()
-        : `server request failed: ${response.status}`;
-    throw new errors_1.CliError(message, {
-        code,
-        exitCode: response.status === 404 ? 3 : response.status === 400 ? 2 : 4,
-        details: {
-            status: response.status,
-            payload,
-        },
-    });
-};
-const requestJson = async (url, init) => {
-    let response;
-    try {
-        response = await fetch(url, init);
-    }
-    catch (error) {
-        throw new errors_1.CliError("Local API server is unavailable", {
-            code: "LOCAL_API_UNAVAILABLE",
-            exitCode: 5,
-            details: {
-                url,
-                detail: error instanceof Error ? error.message : "unknown_error",
-            },
-        });
-    }
-    if (!response.ok) {
-        await normalizeServerError(response);
-    }
-    return response.json();
-};
 const isServerHealthy = async () => {
     return (await readServerHealth()) !== null;
 };
@@ -561,7 +510,7 @@ const startLocalApiServer = async () => {
             };
         }
         const launchSpec = await resolveServerLaunchSpec();
-        // 后台 daemon 必须脱离当前 CLI 生命周期运行，否则 watch/start 等命令一结束就会把宿主一并带死。
+        // The background daemon must run detached from the CLI lifecycle; otherwise commands like watch/start would kill the host when they exit.
         const child = (0, node_child_process_1.spawn)(launchSpec.command, launchSpec.args, {
             cwd: launchSpec.cwd,
             detached: true,
@@ -745,36 +694,46 @@ const createServerLifecycleClient = () => ({
     stopServer: stopLocalApiServer,
 });
 exports.createServerLifecycleClient = createServerLifecycleClient;
-const createPipelineRuntimeApiClient = () => ({
-    ensureServerReady,
-    startPipeline: async (pipelineId) => requestJson(buildPipelineApiUrl(pipelineId, "/run"), {
-        method: "POST",
-    }),
-    getPipelineStatus: async (selector) => {
-        const resolved = resolveRuntimePipelineSelector(selector);
-        return requestJson(buildPipelineApiUrlWithIdentity(resolved.pipelineId, "/status", resolved.target));
-    },
-    stopPipeline: async (selector) => {
-        const resolved = resolveRuntimePipelineSelector(selector);
-        return requestJson(buildPipelineApiUrlWithIdentity(resolved.pipelineId, "/stop", resolved.target), {
-            method: "POST",
-        });
-    },
-    waitForPipelineWatchSignal,
-    diagnoseNode: async (pipelineId, nodeId, itemKey) => {
-        const url = new URL(buildPipelineApiUrl(pipelineId, `/nodes/${encodeURIComponent(nodeId)}/diagnostics`));
-        if (itemKey)
-            url.searchParams.set("itemKey", itemKey);
-        return requestJson(url.toString());
-    },
-    getOutput: async (pipelineId, runId) => {
-        const url = new URL(buildPipelineApiUrl(pipelineId, "/outputs"));
-        if (runId)
-            url.searchParams.set("runId", runId);
-        return requestJson(url.toString());
-    },
-    listOutputs: async (pipelineId) => requestJson(buildPipelineApiUrl(pipelineId, "/outputs")),
-    listLinks: async () => requestJson("/api/pipeline-links"),
-    getQueue: async (pipelineId) => requestJson(buildPipelineApiUrl(pipelineId, "/queue")),
-});
-exports.createPipelineRuntimeApiClient = createPipelineRuntimeApiClient;
+const createPipelineRuntimeApiClientWs = () => {
+    const wsUrl = `${buildWsBaseUrl()}/api/ws`;
+    const wsClient = (0, ws_runtime_client_1.createWsRuntimeClient)(wsUrl);
+    return {
+        ensureServerReady,
+        startPipeline: async (pipelineId) => wsClient.sendReq("pipeline.run", { pipelineId }),
+        getPipelineStatus: async (selector) => {
+            const resolved = (0, exports.resolveRuntimePipelineSelector)(selector);
+            const params = { pipelineId: resolved.pipelineId };
+            if (resolved.target?.runId)
+                params.runId = resolved.target.runId;
+            if (resolved.target?.batchRunId)
+                params.batchRunId = resolved.target.batchRunId;
+            return wsClient.sendReq("pipeline.status", params);
+        },
+        stopPipeline: async (selector) => {
+            const resolved = (0, exports.resolveRuntimePipelineSelector)(selector);
+            const params = { pipelineId: resolved.pipelineId };
+            if (resolved.target?.runId)
+                params.runId = resolved.target.runId;
+            if (resolved.target?.batchRunId)
+                params.batchRunId = resolved.target.batchRunId;
+            return wsClient.sendReq("pipeline.stop", params);
+        },
+        waitForPipelineWatchSignal,
+        diagnoseNode: async (pipelineId, nodeId, itemKey) => {
+            const params = { pipelineId, nodeId };
+            if (itemKey)
+                params.itemKey = itemKey;
+            return wsClient.sendReq("pipeline.node.diagnostics", params);
+        },
+        getOutput: async (pipelineId, runId) => {
+            const params = { pipelineId };
+            if (runId)
+                params.runId = runId;
+            return wsClient.sendReq("pipeline.output.list", params);
+        },
+        listOutputs: async (pipelineId) => wsClient.sendReq("pipeline.output.list", { pipelineId }),
+        listLinks: async () => wsClient.sendReq("pipeline.link.list"),
+        getQueue: async (pipelineId) => wsClient.sendReq("pipeline.queue.list", { pipelineId }),
+    };
+};
+exports.createPipelineRuntimeApiClientWs = createPipelineRuntimeApiClientWs;

package/dist/src/cli/ui-prompts.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectPrompt = exports.fieldPrompt = exports.hr = void 0;
+const c = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    white: "\x1b[37m",
+    black: "\x1b[30m",
+    bgCyan: "\x1b[46m",
+    bgGreen: "\x1b[42m",
+};
+/** Render a horizontal rule line */
+const hr = () => {
+    process.stdout.write(`\n  ${c.dim}${"─".repeat(50)}${c.reset}\n\n`);
+};
+exports.hr = hr;
+/** Simple text-input prompt using readline */
+const fieldPrompt = (rl, label, hint, prefill) => {
+    return new Promise((resolve) => {
+        process.stdout.write(`  ${c.bold}${c.white}${label}${c.reset}\n`);
+        process.stdout.write(`  ${c.dim}${hint}${c.reset}\n\n`);
+        rl.question(`  ${c.green}${c.bold}>${c.reset} `, (answer) => {
+            resolve(answer.trim());
+        });
+        if (prefill) {
+            rl.write(prefill);
+        }
+    });
+};
+exports.fieldPrompt = fieldPrompt;
+/** Interactive arrow-key select prompt using raw TTY mode */
+const selectPrompt = (label, options) => {
+    return new Promise((resolve) => {
+        let selected = 0;
+        process.stdout.write(`  ${c.bold}${c.white}${label}${c.reset}\n\n`);
+        const render = () => {
+            for (let i = 0; i < options.length; i++) {
+                const opt = options[i];
+                if (i === selected) {
+                    process.stdout.write(`    ${c.bgCyan}${c.black}${c.bold} ${opt.label} ${c.reset}\n`);
+                }
+                else {
+                    process.stdout.write(`    ${c.dim}${opt.label}${c.reset}\n`);
+                }
+            }
+        };
+        render();
+        const onData = (key) => {
+            const str = key.toString();
+            // up arrow or k
+            if (str === "\x1b[A" || str === "k") {
+                selected = selected > 0 ? selected - 1 : options.length - 1;
+                // down arrow or j
+            }
+            else if (str === "\x1b[B" || str === "j") {
+                selected = selected < options.length - 1 ? selected + 1 : 0;
+                // enter
+            }
+            else if (str === "\r" || str === "\n") {
+                cleanup();
+                process.stdout.write("\n");
+                resolve(options[selected].value);
+                return;
+                // ctrl+c
+            }
+            else if (str === "\x03") {
+                cleanup();
+                process.stdout.write("\n");
+                process.exit(0);
+            }
+            else {
+                return;
+            }
+            // Move cursor up to re-render
+            process.stdout.write(`\x1b[${options.length}A`);
+            process.stdout.write("\x1b[J");
+            render();
+        };
+        const cleanup = () => {
+            process.stdin.removeListener("data", onData);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+            process.stdin.pause();
+        };
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.on("data", onData);
+    });
+};
+exports.selectPrompt = selectPrompt;

package/dist/src/cli/ws-runtime-client.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWsRuntimeClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const createWsRuntimeClient = (wsUrl) => {
+    let socket;
+    let ready = false;
+    const pending = new Map();
+    let reqCounter = 0;
+    const connect = (timeoutMs = 10_000) => {
+        return new Promise((resolve, reject) => {
+            socket = new ws_1.default(wsUrl);
+            const timeout = setTimeout(() => reject(new Error("ws_connect_timeout")), timeoutMs);
+            socket.on("open", () => { clearTimeout(timeout); });
+            socket.on("message", (raw) => {
+                const frame = JSON.parse(raw.toString());
+                if (frame.type === "bootstrap") {
+                    ready = true;
+                    resolve();
+                    return;
+                }
+                if (frame.type === "res" && frame.id && pending.has(frame.id)) {
+                    const entry = pending.get(frame.id);
+                    clearTimeout(entry.timer);
+                    pending.delete(frame.id);
+                    if (frame.ok)
+                        entry.resolve(frame.payload);
+                    else
+                        entry.reject(new Error(String(frame.error ?? "request_failed")));
+                }
+            });
+            socket.on("error", (err) => { clearTimeout(timeout); reject(err); });
+        });
+    };
+    const sendReq = async (method, params = {}, timeoutMs = 15_000) => {
+        if (!ready)
+            await connect();
+        const id = `cli-${++reqCounter}`;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { pending.delete(id); reject(new Error(`timeout:${method}`)); }, timeoutMs);
+            pending.set(id, { resolve: resolve, reject, timer });
+            socket.send(JSON.stringify({ type: "req", id, method, params }));
+        });
+    };
+    const close = () => { socket?.close(); };
+    return { sendReq, close, connect };
+};
+exports.createWsRuntimeClient = createWsRuntimeClient;

package/dist/src/gateway/gateway-client.js

@@ -337,7 +337,7 @@ const createGatewayClient = (options) => {
     const openSocket = async () => {
         clearTimer(reconnectTimer);
         reconnectTimer = null;
-        // S7 fix: 旧 socket 必须显式解绑 listener + close，避免重连时旧实例和监听器闭包滞留
+        // S7 fix: the old socket must have its listeners explicitly removed and be closed, to prevent stale instances and listener closures from lingering during reconnects.
         if (socket) {
             try {
                 socket.removeAllListeners();
@@ -380,9 +380,9 @@ const createGatewayClient = (options) => {
                 updateStatus(isManualClose ? "closed" : "failed_transport", `closed:${code}`);
             }
             options.onClose?.(code, reason.toString());
-            // 握手阶段如果已经判定为鉴权/协议错误，close 只是前面主动断开的收尾动作。
-            // 这里不能再按 failed_transport 继续重连，否则 pairing required / scope-upgrade
-            // 会触发本地无限重连，持续打 127.0.0.1:18789。
+            // If auth/protocol errors were already determined during the handshake phase, the close is just the tail-end of a preceding proactive disconnect.
+            // We must not continue reconnect as failed_transport here, otherwise pairing required / scope-upgrade
+            // would trigger infinite local reconnects, repeatedly hitting 127.0.0.1:18789.
             if (!isManualClose && status !== "failed_auth" && status !== "failed_protocol") {
                 scheduleReconnect("failed_transport", `closed:${code}`);
             }

package/dist/src/index.js

@@ -10,9 +10,14 @@ const gateway_1 = require("./gateway");
 Object.defineProperty(exports, "createGatewayClient", { enumerable: true, get: function () { return gateway_1.createGatewayClient; } });
 const create_app_context_1 = require("./app/create-app-context");
 const user_config_1 = require("./app/user-config");
-const api_handler_1 = require("./server/api-handler");
+const http_handler_1 = require("./server/http-handler");
 const ws_broker_1 = require("./transport/ws-broker");
+const ws_handler_1 = require("./transport/ws-handler");
+const register_all_1 = require("./transport/ws-methods/register-all");
 const data_dir_1 = require("./app/data-dir");
+const pipeline_service_1 = require("./services/pipeline-service");
+const scheduler_service_1 = require("./services/scheduler-service");
+const run_log_service_1 = require("./logs/run-log-service");
 const serverRuntimeIdentity = {
     serverId: (0, node_crypto_1.randomUUID)(),
     startedAt: new Date().toISOString(),
@@ -54,7 +59,27 @@ if (require.main === module) {
                 console.error("gateway-error", error);
             },
         });
-        const apiServer = (0, node_http_1.createServer)((0, api_handler_1.createApiHandler)({
+        // Create shared services (used by both HTTP routes and WS handler)
+        const pipelineService = (0, pipeline_service_1.createPipelineService)(app);
+        const schedulerService = (0, scheduler_service_1.createSchedulerService)(app);
+        const runLogService = (0, run_log_service_1.createRunLogService)({
+            rootDir: (0, data_dir_1.resolveTaskMeldDataPath)("logs", "runs"),
+        });
+        const wsHandler = (0, ws_handler_1.createWsRequestHandler)(app, {
+            pipelineService,
+            schedulerService,
+            runLogService,
+            client: app.gateway.client,
+            getLatestStatus: app.gateway.getLatestStatus,
+            getLatestHello: app.gateway.getLatestHello,
+            getLastFrame: app.gateway.getLastFrame,
+            getTimeline: app.runtime.getCombinedTimeline,
+            pickArray: app.gateway.pickArray,
+            refreshSessionsFromGateway: app.gateway.refreshSessionsFromGateway,
+            getSessionCache: app.gateway.getSessionCache,
+        });
+        (0, register_all_1.registerAllWsMethods)(wsHandler.registry);
+        const apiServer = (0, node_http_1.createServer)((0, http_handler_1.createApiHandler)({
             apiPort: appContext.api.port,
             webOrigin: appContext.api.webOrigin,
             app,
@@ -70,6 +95,7 @@ if (require.main === module) {
             server: apiServer,
             path: "/api/ws",
             getBootstrapPayload: app.getBootstrapPayload,
+            handleRequest: wsHandler.handleMessage,
         });
         app.runtime.setBroadcast(wsBroker.broadcast);
         void appContext.initialize();

package/dist/src/logs/run-log-reader.js

@@ -7,7 +7,7 @@ const guards_1 = require("../utils/guards");
 const MAX_LIMIT = 300;
 const isRunLogLevel = (value) => value === "info" || value === "warn" || value === "error";
 const normalizeLimit = (value) => {
-    // 服务端必须兜底分页，避免前端漏传 limit 时把大型日志一次性读入 V8 堆。
+    // Server must enforce pagination as a safety net, to avoid loading huge logs into the V8 heap when the frontend omits the limit parameter.
     if (value === undefined)
         return MAX_LIMIT;
     if (!Number.isFinite(value))

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

@@ -67,10 +67,10 @@ const createAgentActivityTracker = (deps) => {
             stateVersion: frame.stateVersion ?? null,
         };
         if (lifecycle === "start") {
-            deps.pushTimeline(`Agent ${agentId} 开始工作 (${runLabel(runId)}, ${source})`, "info", detail);
+            deps.pushTimeline(`Agent ${agentId} started (${runLabel(runId)}, ${source})`, "info", detail);
             return;
         }
-        deps.pushTimeline(`Agent ${agentId} 结束工作 (${runLabel(runId)}, ${source})`, "info", detail);
+        deps.pushTimeline(`Agent ${agentId} finished (${runLabel(runId)}, ${source})`, "info", detail);
     };
     const refreshAgentActivity = (agentId, source, runId, frame) => {
         const activityKey = toActivityKey(agentId, runId);

package/dist/src/pipeline/artifact-storage.js

@@ -8,8 +8,8 @@ const artifact_index_1 = require("../artifacts/artifact-index");
 const pad2 = (value) => String(value).padStart(2, "0");
 const formatLocalDateBucket = (at) => `${at.getFullYear()}-${pad2(at.getMonth() + 1)}-${pad2(at.getDate())}`;
 const buildArtifactStorageDirs = (rootDir, runId, status, savedAt = new Date(), batchRunId) => {
-    // 运行产物需要按"结果状态/日期/runId"归档，避免目录长期平铺后难以按日排障或批量清理。
-    // envelopes 与 artifacts 分桶存放，是为了把节点回执和实际产物内容分开，减少误读与误删风险。
+    // Run artifacts are archived by "result status / date / runId" so flat directories don't become hard to troubleshoot by date or batch-clean.
+    // Envelopes and artifacts are bucketed separately to keep node receipts apart from actual artifact content, reducing misread/misdelete risk.
     const dateBucket = formatLocalDateBucket(savedAt);
     const runDir = batchRunId
         ? (0, node_path_1.join)(rootDir, status, dateBucket, batchRunId, runId)
@@ -31,14 +31,14 @@ const sanitizeFileSegment = (value) => {
     return normalized || "unnamed";
 };
 /**
- * 产物文件统一写入入口。
- * 负责：目录创建、原子写入（临时文件 + rename）、真实 SHA-256 哈希计算、索引追加、ArtifactManifest 构造。
+ * Unified artifact file write entry point.
+ * Responsibilities: directory creation, atomic write (temp file + rename), real SHA-256 hash computation, index append, ArtifactManifest construction.
  */
 const persistArtifactFile = async (rootDir, status, ctx, artifact, opts) => {
     const savedAt = opts?.savedAt ?? new Date();
     const persistDirs = (0, exports.buildArtifactStorageDirs)(rootDir, ctx.runId, status, savedAt, ctx.batchRunId);
     await (0, promises_1.mkdir)(persistDirs.artifactsDir, { recursive: true });
-    // 统一的文件序列化格式，kind 字段供读取端分发
+    // Unified file serialization format; the kind field is used by readers to dispatch
     const fileContent = {
         schemaVersion: 1,
         runId: ctx.runId,
@@ -55,7 +55,7 @@ const persistArtifactFile = async (rootDir, status, ctx, artifact, opts) => {
     if (opts?.fileNameSuffix)
         fileNameSegments.push(sanitizeFileSegment(opts.fileNameSuffix));
     const fileName = `${fileNameSegments.join("-")}.json`;
-    // 原子写入: 先写临时文件，计算 hash，再 rename 到最终路径
+    // Atomic write: write to temp file first, compute hash, then rename to final path
     const tmpFileName = `.tmp-${(0, node_crypto_1.randomUUID)()}.json`;
     const tmpPath = (0, node_path_1.join)(persistDirs.artifactsDir, tmpFileName);
     const json = JSON.stringify(fileContent, null, 2);
@@ -68,7 +68,7 @@ const persistArtifactFile = async (rootDir, status, ctx, artifact, opts) => {
     const createdAt = new Date().toISOString();
     const updatedAt = fileStat.mtime.toISOString();
     const relativePath = (0, node_path_1.relative)(rootDir, finalPath).replaceAll("\\", "/");
-    // 追加索引记录（best-effort，失败不阻断产物写入）
+    // Append index record (best-effort; a failure here must not block the artifact write)
     const pipelineId = ctx.pipelineId;
     const indexRecord = {
         schemaVersion: 1,
@@ -92,7 +92,7 @@ const persistArtifactFile = async (rootDir, status, ctx, artifact, opts) => {
         createdAt,
         updatedAt,
     };
-    // 追加索引记录：文件已通过 tmp+rename 原子写入磁盘，索引追加失败不丢失产物文件
+    // Append index record: the file is already atomically written (tmp+rename); index append failure does not lose the artifact file
     const _ir = await (0, artifact_index_1.appendIndexRecord)(rootDir, indexRecord);
     void _ir;
     return {
@@ -107,7 +107,7 @@ const persistArtifactFile = async (rootDir, status, ctx, artifact, opts) => {
     };
 };
 exports.persistArtifactFile = persistArtifactFile;
-/** 产物移动（如 rejected 归档）后补记索引，使查询端通过 artifactId 去重拿到最新位置。 */
+/** After moving an artifact (e.g. rejected archiving), append an index record so queries can use artifactId deduplication to get the latest location. */
 const appendMovedArtifactIndexRecord = async (rootDir, input) => {
     const targetPath = (0, node_path_1.resolve)(rootDir, input.relativePath);
     const fileStat = await (0, promises_1.stat)(targetPath);
@@ -140,7 +140,7 @@ const appendMovedArtifactIndexRecord = async (rootDir, input) => {
     });
 };
 exports.appendMovedArtifactIndexRecord = appendMovedArtifactIndexRecord;
-/** 保存 envelope 回执文件到 envelopes 子目录并追加索引，使 kind=envelope 可在列表中查询。 */
+/** Save envelope receipt file to the envelopes sub-directory and append index, so kind=envelope is queryable in the list. */
 const persistEnvelopeFile = async (rootDir, status, ctx, envelope, opts) => {
     const savedAt = opts?.savedAt ?? new Date();
     const persistDirs = (0, exports.buildArtifactStorageDirs)(rootDir, ctx.runId, status, savedAt, ctx.batchRunId);
@@ -191,7 +191,7 @@ const persistEnvelopeFile = async (rootDir, status, ctx, envelope, opts) => {
         createdAt,
         updatedAt,
     };
-    // 追加索引记录：文件已通过 tmp+rename 原子写入磁盘，索引追加失败不丢失产物文件
+    // Append index record: the file is already atomically written (tmp+rename); index append failure does not lose the artifact file
     const _ir = await (0, artifact_index_1.appendIndexRecord)(rootDir, indexRecord);
     void _ir;
     return {

package/dist/src/pipeline/diagnostics/dependency-diagnostic.js

@@ -3,17 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.diagnoseNodeDependency = exports.REASON_MESSAGES = void 0;
 const dependency_check_1 = require("../execution/dependency-check");
 exports.REASON_MESSAGES = {
-    dependency_satisfied: "依赖已满足",
-    source_not_success: "上游节点未成功（当前状态不满足依赖）",
-    source_failed: "上游节点执行失败",
-    source_skipped: "上游节点已跳过",
-    route_mismatch: "路由不匹配（上游路由值与边要求不一致）",
-    cross_branch_edge_blocked: "跨支线边已被阻断",
-    group_not_success: "上游并行组未成功",
-    source_disabled_dependency_satisfied: "上游节点已禁用（视为依赖满足）",
-    source_disabled_route_impossible: "上游节点已禁用但路由边无法满足",
-    missing_source_item_run: "缺少上游节点条目运行记录",
-    missing_group_item_run: "缺少上游并行组条目运行记录",
+    dependency_satisfied: "Dependency satisfied",
+    source_not_success: "Upstream node not successful (dependency not met)",
+    source_failed: "Upstream node execution failed",
+    source_skipped: "Upstream node was skipped",
+    route_mismatch: "Route mismatch (upstream route value does not match edge requirement)",
+    cross_branch_edge_blocked: "Cross-branch edge is blocked",
+    group_not_success: "Upstream parallel group not successful",
+    source_disabled_dependency_satisfied: "Upstream node is disabled (dependency treated as satisfied)",
+    source_disabled_route_impossible: "Upstream node is disabled but route edge cannot be satisfied",
+    missing_source_item_run: "Missing upstream node item run record",
+    missing_group_item_run: "Missing upstream parallel group item run record",
 };
 const resolveOutcome = (satisfiedCount, impossibleCount, totalIncoming, policy) => {
     if (policy === "any") {

package/dist/src/pipeline/dispatch/pipeline-inbound-queue.js

@@ -43,8 +43,8 @@ const createPipelineInboundQueue = () => {
         catch {
             // File not found, start empty
         }
-        // 重放后自动回收"running"状态的 job：这些 job 属于上次进程崩溃前已启动但未完成的任务，
-        // 恢复为 pending 并清空 targetRunId，让 drainer 重新调度执行。
+        // After replay, auto-reclaim jobs stuck in "running" status: these jobs were started but not completed before the last process crash,
+        // restore them to pending and clear targetRunId so the drainer can re-schedule execution.
         for (const [jobId, job] of newSnapshot) {
             if (job.status === "running") {
                 newSnapshot.set(jobId, {

package/dist/src/pipeline/execution/group-item-executor.js

@@ -110,7 +110,7 @@ const createGroupItemExecutor = (deps) => {
         }
         (0, state_1.markGroupItemRunning)(item, ctx("group_start"));
         (0, state_1.markGroupRunning)(runGroup, ctx("group_start"));
-        deps.runtimeStore.pushTimeline(`并行组执行已触发: ${group.id}#${item.itemKey}`);
+        deps.runtimeStore.pushTimeline(`Parallel group execution triggered: ${group.id}#${item.itemKey}`);
         deps.runtimeStore.emitPipeline();
         const { results, memberItems } = await executeGroupMembers(item, group);
         if (results.some((result) => !result.ok)) {

package/dist/src/pipeline/execution/node-item-executor.js

@@ -19,7 +19,7 @@ const createNodeItemExecutor = (deps) => {
         const maxAttempts = Math.max(1, workflowNode?.retryPolicy.maxAttempts ?? 1);
         if (item.attempt >= maxAttempts) {
             (0, state_1.markItemFailed)(item, ctx("max_attempts_exceeded", { error: `max_attempts_exceeded:${maxAttempts}` }));
-            deps.runtimeStore.pushTimeline(`节点项超过重试上限: ${item.nodeId}#${item.itemKey} (${maxAttempts})`, "error");
+            deps.runtimeStore.pushTimeline(`Node item exceeded max retry attempts: ${item.nodeId}#${item.itemKey} (${maxAttempts})`, "error");
             deps.runtimeStore.emitPipeline();
             return { ok: false, error: item.lastError ?? undefined, finalStatus: "failed" };
         }
@@ -28,7 +28,7 @@ const createNodeItemExecutor = (deps) => {
             await new Promise(resolve => setTimeout(resolve, retryBackoffMs));
         }
         (0, state_1.markItemRunning)(item, ctx("exec_start"));
-        deps.runtimeStore.pushTimeline(`节点项执行已触发: ${item.nodeId}#${item.itemKey}`);
+        deps.runtimeStore.pushTimeline(`Node item execution triggered: ${item.nodeId}#${item.itemKey}`);
         deps.runtimeStore.emitPipeline();
         const exec = await deps.nodeRunner.executeNode(node, {
             itemKey: item.itemKey,
@@ -36,7 +36,7 @@ const createNodeItemExecutor = (deps) => {
         });
         if (!exec.ok) {
             if (exec.finalStatus === "stopped") {
-                // 用户中止时节点项已被标记为 stopped，不覆盖
+                // When the user aborts, the node item is already marked as stopped — do not overwrite
             }
             else if (exec.finalStatus === "rejected") {
                 (0, state_1.markItemRejected)(item, ctx("node_rejected", { error: exec.error ?? null }));