@fieldwangai/agentflow 0.1.25

package/bin/lib/paths.mjs

@@ -0,0 +1,216 @@
+/**
+ * 包路径与 CLI 常量（供 bin/agentflow 与各 lib 模块使用）。
+ */
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/** bin/ 目录（含 pipeline 子目录） */
+export const BIN_DIR = path.resolve(__dirname, "..");
+export const PACKAGE_ROOT = path.resolve(BIN_DIR, "..");
+
+/** 节点执行区域分割线（开始/结束标识用） */
+export const NODE_SEP = "════════════════════════════════════════════════════════════════";
+
+/** agentflow 包根目录（CLI 所在包的 node_modules 用于解析脚本依赖，如 js-yaml） */
+export const PACKAGE_AGENTS_DIR = path.join(PACKAGE_ROOT, "agents");
+/** 包内 agents 元数据 JSON */
+export const PACKAGE_AGENTS_JSON = path.join(PACKAGE_AGENTS_DIR, "agents.json");
+
+/**
+ * 用户级 AgentFlow 数据根目录：`AGENTFLOW_HOME` 或 `~/agentflow`。
+ * 与项目根 workspaceRoot 分离；run、pipelines、agents 等均落盘于此。
+ */
+export function getAgentflowDataRoot() {
+  const env = process.env.AGENTFLOW_HOME;
+  if (env != null && String(env).trim() !== "") {
+    let raw = String(env).trim();
+    if (raw === "~") raw = os.homedir();
+    else if (raw.startsWith("~/")) raw = path.join(os.homedir(), raw.slice(2));
+    return path.resolve(raw);
+  }
+  return path.join(os.homedir(), "agentflow");
+}
+
+/** 项目内 runBuild 根目录：`<workspaceRoot>/.workspace/agentflow/runBuild`（legacy：写入路径已迁至 `<flowDir>/runBuild`，仅用于兼容读取） */
+export function getWorkspaceRunBuildRoot(workspaceRoot) {
+  const root =
+    workspaceRoot != null && String(workspaceRoot).trim() !== ""
+      ? path.resolve(String(workspaceRoot))
+      : process.cwd();
+  return path.join(root, ".workspace/agentflow/runBuild");
+}
+
+/** 旧版用户目录 runBuild 根目录：`~/agentflow/runBuild`（legacy：仅用于历史兼容读取） */
+export function getLegacyUserRunBuildRoot() {
+  return path.join(getAgentflowDataRoot(), "runBuild");
+}
+
+/**
+ * 统一 runtime root：每个 flow 的 pipeline 源、scripts、runBuild 共用一个根目录。
+ * - 若 `~/agentflow/pipelines/<name>/flow.yaml` 存在 → user-scope：`~/agentflow/pipelines/<name>`
+ * - 若 `<ws>/.workspace/agentflow/pipelines/<name>/flow.yaml` 存在 → workspace-scope：`<ws>/.workspace/agentflow/pipelines/<name>`
+ * - archived（`_archived/<name>`）按对应 scope 返回
+ * - 其他（builtin 只读 / 不存在）→ 默认 user-scope 路径（首次 run 时自动创建，builtin 源仍从包内读取但 runBuild 落到用户目录）
+ */
+export function getFlowRuntimeRoot(workspaceRoot, flowName) {
+  const root =
+    workspaceRoot != null && String(workspaceRoot).trim() !== ""
+      ? path.resolve(String(workspaceRoot))
+      : process.cwd();
+  const userRoot = getUserPipelinesRoot();
+  const userDir = path.join(userRoot, flowName);
+  if (fs.existsSync(path.join(userDir, "flow.yaml"))) return userDir;
+  const userArchived = path.join(userRoot, ARCHIVED_PIPELINES_DIR_NAME, flowName);
+  if (fs.existsSync(path.join(userArchived, "flow.yaml"))) return userArchived;
+  const wsDir = path.join(root, PIPELINES_DIR, flowName);
+  if (fs.existsSync(path.join(wsDir, "flow.yaml"))) return wsDir;
+  const wsArchived = path.join(root, PIPELINES_DIR, ARCHIVED_PIPELINES_DIR_NAME, flowName);
+  if (fs.existsSync(path.join(wsArchived, "flow.yaml"))) return wsArchived;
+  // builtin / legacy / 尚未落盘 → 默认 user 目录，runBuild 首次写入时创建
+  return userDir;
+}
+
+/**
+ * 单次 run 目录。
+ * 新运行走 `<flowRuntimeRoot>/runBuild/<uuid>`；
+ * 若该 uuid 在旧位置（legacy workspace/user runBuild 根）已存在，则返回旧位置，保留 resume 兼容。
+ */
+export function getRunDir(workspaceRoot, flowName, uuid) {
+  const candidates = getRunDirCandidates(workspaceRoot, flowName, uuid);
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return candidates[0];
+}
+
+/**
+ * 枚举候选 run 目录（新/旧位置）供 UI 读取历史 run。
+ * 返回数组按"最优先 → 最兜底"排序：
+ *   1. 新 per-flow：<flowRuntimeRoot>/runBuild/<uuid>
+ *   2. 旧 workspace：<ws>/.workspace/agentflow/runBuild/<flow>/<uuid>
+ *   3. 旧 user：~/agentflow/runBuild/<flow>/<uuid>
+ */
+export function getRunDirCandidates(workspaceRoot, flowName, uuid) {
+  const candidates = [
+    path.join(getFlowRuntimeRoot(workspaceRoot, flowName), "runBuild", uuid),
+    path.join(getWorkspaceRunBuildRoot(workspaceRoot), flowName, uuid),
+    path.join(getLegacyUserRunBuildRoot(), flowName, uuid),
+  ];
+  const seen = new Set();
+  const out = [];
+  for (const c of candidates) {
+    const r = path.resolve(c);
+    if (seen.has(r)) continue;
+    seen.add(r);
+    out.push(r);
+  }
+  return out;
+}
+
+export function getUserPipelinesRoot() {
+  return path.join(getAgentflowDataRoot(), "pipelines");
+}
+
+export function getReferenceRootAbs() {
+  return path.join(getAgentflowDataRoot(), "reference");
+}
+
+export function getUserAgentsDirAbs() {
+  return path.join(getAgentflowDataRoot(), "agents");
+}
+
+export function getUserAgentsJsonAbs() {
+  return path.join(getAgentflowDataRoot(), "agents.json");
+}
+
+export function getModelListsAbs() {
+  return path.join(getAgentflowDataRoot(), "model-lists.json");
+}
+
+export function getAgentflowUserConfigAbs() {
+  return path.join(getAgentflowDataRoot(), "config.json");
+}
+
+/** CLI / UI 文案用 */
+export const USER_AGENTFLOW_DIR_LABEL = "~/agentflow";
+export const USER_AGENTFLOW_PIPELINES_LABEL = "~/agentflow/pipelines";
+export const USER_AGENTFLOW_AGENTS_LABEL = "~/agentflow/agents";
+
+/** agents.json 中 user 角色 filepath 展示前缀（相对数据根） */
+export const USER_AGENTS_FILEPATH_PREFIX = "agentflow/agents";
+
+/** apply/replay 流水线脚本目录（随包发布） */
+export const PIPELINE_SCRIPTS_DIR = path.join(BIN_DIR, "pipeline");
+/** apply -ai 允许调用的单步脚本名（不含 .mjs） */
+export const APPLY_AI_STEPS = [
+  "ensure-run-dir",
+  "parse-flow",
+  "get-ready-nodes",
+  "pre-process-node",
+  "post-process-node",
+  "write-result",
+  "run-tool-nodejs",
+  "get-env",
+  "validate-flow",
+  "collect-nodes",
+  "gc",
+  "extract-thinking",
+];
+/** 项目内流水线根目录（写入与主读取路径） */
+export const PIPELINES_DIR = ".workspace/agentflow/pipelines";
+/** 用户目录或工作区 pipelines 下存放已归档流水线的子目录名 */
+export const ARCHIVED_PIPELINES_DIR_NAME = "_archived";
+/** 旧版项目内路径；仅用于读取回退 */
+export const LEGACY_PIPELINES_DIR = ".cursor/agentflow/pipelines";
+
+/** 项目内 AgentFlow 根目录（相对 workspaceRoot） */
+export const WORKSPACE_AGENTFLOW_ROOT = ".workspace/agentflow";
+/** 项目内自定义节点 .md 目录（主路径；与包内 builtin/nodes 区分） */
+export const PROJECT_NODES_DIR = ".workspace/agentflow/nodes";
+/** 旧版项目内节点目录；仅用于读取回退 */
+export const LEGACY_NODES_DIR = ".cursor/agentflow/nodes";
+/** Web UI 模型映射等项目内配置（主路径） */
+export const MODEL_CONFIG_REL = ".workspace/agentflow/models.json";
+/** 旧版 models.json；仅用于读取回退 */
+export const LEGACY_MODEL_CONFIG_REL = ".cursor/agentflow/models.json";
+
+export const RUN_LOG_REL = "logs/log.txt";
+
+/** 包内 reference 目录 */
+export const PACKAGE_REFERENCE_DIR = path.join(PACKAGE_ROOT, "reference");
+/** 包内内置节点与流水线 */
+export const PACKAGE_BUILTIN_NODES_DIR = path.join(PACKAGE_ROOT, "builtin", "nodes");
+export const PACKAGE_BUILTIN_PIPELINES_DIR = path.join(PACKAGE_ROOT, "builtin", "pipelines");
+
+export const MAX_LOOP_ROUNDS = 10000;
+
+/** 去掉 ANSI 转义码，便于解析 Cursor/OpenCode models 输出 */
+export const CURSOR_NON_MODEL_PATTERNS = [
+  /^loading\s+models/i,
+  /^available\s+models$/i,
+  /^tip:\s*use\s+--model/i,
+];
+
+/** 仅 pre+post、不执行任何命令的节点类型 */
+export const LOCAL_ONLY_DEFINITION_IDS = new Set([
+  "control_if",
+  "control_start",
+  "control_end",
+  "tool_print",
+  "tool_user_check",
+  "tool_user_ask",
+  "provide_str",
+  "provide_file",
+]);
+
+/** 仅 pre+post 且由 CLI 负责写终态的节点 */
+export const LOCAL_ONLY_TERMINAL_SUCCESS_IDS = new Set([
+  "control_start",
+  "control_end",
+  "tool_print",
+  "provide_str",
+  "provide_file",
+]);

package/bin/lib/pipeline-scripts.mjs

@@ -0,0 +1,41 @@
+import { spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { PIPELINE_SCRIPTS_DIR } from "./paths.mjs";
+
+/** 脚本路径：从 agentflow 包内 bin/pipeline 目录加载 */
+export function getScriptPath(_workspaceRoot, name) {
+  return path.join(PIPELINE_SCRIPTS_DIR, name);
+}
+
+export function runNodeScript(workspaceRoot, scriptName, args, options = {}) {
+  const scriptPath = getScriptPath(workspaceRoot, scriptName);
+  if (!fs.existsSync(scriptPath)) {
+    throw new Error(`Script not found: ${scriptPath}. Reinstall the agentflow package.`);
+  }
+  const result = spawnSync(process.execPath, [scriptPath, ...args], {
+    cwd: workspaceRoot,
+    encoding: "utf-8",
+    stdio: options.captureStdout ? ["inherit", "pipe", "inherit"] : ["inherit", "inherit", "inherit"],
+    ...options,
+  });
+  return result;
+}
+
+export function parseJsonStdout(result) {
+  if (result.status !== 0) {
+    const err = (result.stdout || "").trim() || result.stderr || "unknown";
+    throw new Error(`Script failed: ${err}`);
+  }
+  const out = (result.stdout || "").trim();
+  if (!out) throw new Error("Script produced no stdout");
+  try {
+    return JSON.parse(out);
+  } catch (e) {
+    throw new Error(`Invalid JSON from script: ${out.slice(0, 200)}`);
+  }
+}
+
+export function isValidUuid(value) {
+  return typeof value === "string" && /^\d{14}$/.test(value);
+}

package/bin/lib/recent-runs.mjs

@@ -0,0 +1,173 @@
+/**
+ * 扫描 runBuild 目录，供 UI 展示「最近运行」。
+ */
+import fs from "fs";
+import path from "path";
+import { listAllRunDirs } from "./workspace.mjs";
+import { isApplyProcessAlive } from "./run-apply-active-lock.mjs";
+
+/** Web UI 调用 /api/flow/run/stop 时写入，用于与「未跑完但未标记」区分 */
+export const RUN_INTERRUPTED_FILENAME = "run-interrupted.json";
+
+/** @param {string} filePath */
+function parseResultStatusFromFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const m = raw.match(/^\s*status:\s*["']?(\w+)["']?/m);
+    return m ? m[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+/** 读取 result.md 里的 finishedAt（ISO 字符串），返回 ms 时间戳或 null */
+function parseResultFinishedAtFromFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const m = raw.match(/^\s*finishedAt:\s*["']?([^"'\n]+?)["']?\s*$/m);
+    if (!m) return null;
+    const t = Date.parse(m[1]);
+    return Number.isFinite(t) ? t : null;
+  } catch {
+    return null;
+  }
+}
+
+/** 扫 run 目录所有 result.md，返回最大的 finishedAt。回退到 runDir mtime */
+function computeEndedAt(runDir) {
+  const interRoot = path.join(runDir, "intermediate");
+  let maxAt = 0;
+  if (fs.existsSync(interRoot) && fs.statSync(interRoot).isDirectory()) {
+    try {
+      const dirs = fs.readdirSync(interRoot, { withFileTypes: true }).filter((e) => e.isDirectory());
+      for (const d of dirs) {
+        const rp = path.join(interRoot, d.name, `${d.name}.result.md`);
+        if (!fs.existsSync(rp)) continue;
+        const t = parseResultFinishedAtFromFile(rp);
+        if (t != null && t > maxAt) maxAt = t;
+      }
+    } catch {
+      /* ignore */
+    }
+  }
+  if (maxAt > 0) return maxAt;
+  try {
+    return fs.statSync(runDir).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 根据 intermediate 下各节点 result 与 control_end 推断单次运行状态。
+ * @returns {'success'|'failed'|'running'|'stopped'|'interrupted'|'unknown'}
+ */
+function inferRunStatusFromRunDir(runDir) {
+  const interruptedPath = path.join(runDir, RUN_INTERRUPTED_FILENAME);
+  if (fs.existsSync(interruptedPath)) return "stopped";
+
+  const interRoot = path.join(runDir, "intermediate");
+  if (!fs.existsSync(interRoot) || !fs.statSync(interRoot).isDirectory()) return "unknown";
+
+  let anyFailed = false;
+  let anyResult = false;
+  try {
+    const dirs = fs.readdirSync(interRoot, { withFileTypes: true }).filter((e) => e.isDirectory());
+    for (const d of dirs) {
+      const instanceId = d.name;
+      const rp = path.join(interRoot, instanceId, `${instanceId}.result.md`);
+      if (!fs.existsSync(rp)) continue;
+      anyResult = true;
+      const st = parseResultStatusFromFile(rp);
+      if (st === "failed") anyFailed = true;
+    }
+  } catch {
+    return "unknown";
+  }
+
+  if (anyFailed) return "failed";
+
+  const flowJsonPath = path.join(interRoot, "flow.json");
+  let endId = null;
+  if (fs.existsSync(flowJsonPath)) {
+    try {
+      const flow = JSON.parse(fs.readFileSync(flowJsonPath, "utf-8"));
+      const nd = flow.nodeDefinitions || {};
+      for (const [iid, def] of Object.entries(nd)) {
+        if (def === "control_end") {
+          endId = iid;
+          break;
+        }
+      }
+    } catch {
+      /* ignore */
+    }
+  }
+
+  if (endId) {
+    const endPath = path.join(interRoot, endId, `${endId}.result.md`);
+    const endSt = parseResultStatusFromFile(endPath);
+    if (endSt === "success") return "success";
+  }
+
+  if (anyResult || fs.existsSync(flowJsonPath)) {
+    if (isApplyProcessAlive(runDir)) return "running";
+    return "interrupted";
+  }
+  return "unknown";
+}
+
+function readKeyFromMemory(runDir, key) {
+  const memoryPath = path.join(runDir, "memory.md");
+  if (!fs.existsSync(memoryPath)) return null;
+  try {
+    const content = fs.readFileSync(memoryPath, "utf-8");
+    for (const line of (content || "").split(/\r?\n/)) {
+      const idx = line.indexOf(": ");
+      if (idx <= 0) continue;
+      const k = line.slice(0, idx).trim();
+      if (k !== key) continue;
+      const v = line.slice(idx + 2).trim();
+      const n = parseInt(String(v), 10);
+      return Number.isFinite(n) && n >= 0 ? n : null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+/** listAllRunDirs 的 source 映射到 UI 里的 flowSource 字段 */
+function mapFlowSource(src) {
+  if (src === "user") return "user";
+  if (src === "workspace") return "workspace";
+  // legacy 位置仍归到它物理所在的 scope
+  if (src === "legacyWorkspaceRoot") return "workspace";
+  if (src === "legacyUserRoot") return "user";
+  return "workspace";
+}
+
+/**
+ * @param {string} workspaceRoot
+ * @returns {Array<{ flowId: string, flowSource: 'workspace'|'user', runId: string, at: number, durationMs: number, endedAt: number|null, status: 'success'|'failed'|'running'|'stopped'|'interrupted'|'unknown' }>}
+ */
+export function listRecentRunsFromDisk(workspaceRoot) {
+  const out = [];
+  for (const { flowName, uuid, runDir, source } of listAllRunDirs(workspaceRoot)) {
+    let at = readKeyFromMemory(runDir, "runStartTime");
+    if (at == null) {
+      try {
+        at = fs.statSync(runDir).mtimeMs;
+      } catch {
+        continue;
+      }
+    }
+    const durationMs = readKeyFromMemory(runDir, "totalExecutedMs") ?? 0;
+    const status = inferRunStatusFromRunDir(runDir);
+    const endedAt = status === "running" ? null : computeEndedAt(runDir);
+    out.push({ flowId: flowName, flowSource: mapFlowSource(source), runId: uuid, at, durationMs, endedAt, status });
+  }
+
+  out.sort((a, b) => b.at - a.at);
+  return out;
+}

package/bin/lib/run-apply-active-lock.mjs

@@ -0,0 +1,82 @@
+/**
+ * apply 运行期间在 run 目录写入 PID 锁，供「最近运行」严格区分 running / interrupted。
+ */
+import fs from "fs";
+import path from "path";
+import { getRunDir } from "./paths.mjs";
+
+export const RUN_APPLY_ACTIVE_FILENAME = "run-apply-active.json";
+
+/**
+ * @param {string} workspaceRoot
+ * @param {string} flowName
+ * @param {string} uuid
+ */
+export function writeApplyActiveLock(workspaceRoot, flowName, uuid) {
+  const runDir = getRunDir(workspaceRoot, flowName, uuid);
+  fs.mkdirSync(runDir, { recursive: true });
+  const payload = {
+    pid: process.pid,
+    flowName,
+    uuid,
+    workspaceRoot: path.resolve(String(workspaceRoot)),
+    startedAt: Date.now(),
+  };
+  fs.writeFileSync(path.join(runDir, RUN_APPLY_ACTIVE_FILENAME), JSON.stringify(payload, null, 2), "utf-8");
+}
+
+/**
+ * @param {string} workspaceRoot
+ * @param {string} flowName
+ * @param {string} uuid
+ */
+export function clearApplyActiveLock(workspaceRoot, flowName, uuid) {
+  try {
+    const lockPath = path.join(getRunDir(workspaceRoot, flowName, uuid), RUN_APPLY_ACTIVE_FILENAME);
+    if (fs.existsSync(lockPath)) fs.unlinkSync(lockPath);
+  } catch {
+    /* ignore */
+  }
+}
+
+/**
+ * 锁存在且 PID 仍存活 → apply 主进程仍在跑。
+ * 锁存在但 PID 已死 → 删除陈旧锁并返回 false。
+ * @param {string} runDir
+ * @returns {boolean}
+ */
+export function isApplyProcessAlive(runDir) {
+  const lockPath = path.join(runDir, RUN_APPLY_ACTIVE_FILENAME);
+  if (!fs.existsSync(lockPath)) return false;
+  let pid;
+  try {
+    const j = JSON.parse(fs.readFileSync(lockPath, "utf-8"));
+    pid = typeof j.pid === "number" ? j.pid : parseInt(String(j.pid), 10);
+  } catch {
+    try {
+      fs.unlinkSync(lockPath);
+    } catch {
+      /* ignore */
+    }
+    return false;
+  }
+  if (!Number.isFinite(pid) || pid <= 0) {
+    try {
+      fs.unlinkSync(lockPath);
+    } catch {
+      /* ignore */
+    }
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    try {
+      fs.unlinkSync(lockPath);
+    } catch {
+      /* ignore */
+    }
+    return false;
+  }
+}

package/bin/lib/run-events.mjs

@@ -0,0 +1,85 @@
+import fs from "fs";
+import path from "path";
+import { machineReadable } from "./log.mjs";
+import { RUN_LOG_REL } from "./paths.mjs";
+import { runNodeScript } from "./pipeline-scripts.mjs";
+import { getRunDir } from "./workspace.mjs";
+
+/**
+ * 将 CLI 侧的关键信息也落盘到 run 目录的 logs/log.txt。
+ */
+export function appendRunLogLine(workspaceRoot, flowName, uuid, tag, message) {
+  if (!workspaceRoot || !flowName || !uuid) return;
+  try {
+    const runDir = getRunDir(workspaceRoot, flowName, uuid);
+    const logPath = path.join(runDir, RUN_LOG_REL);
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    const text = typeof message === "string" ? message : JSON.stringify(message);
+    const line = `[${new Date().toISOString()}] [${tag}] ${text}\n`;
+    fs.appendFileSync(logPath, line, "utf-8");
+  } catch (_) {}
+}
+
+/** 发送 CLI 事件：写 run log，且 machineReadable 时向 stdout 输出一行 JSON */
+export function emitEvent(workspaceRoot, flowName, uuid, payload) {
+  appendRunLogLine(workspaceRoot, flowName, uuid, "cli", payload);
+  if (machineReadable && workspaceRoot && flowName && uuid) {
+    const line = JSON.stringify({ ...payload, ts: new Date().toISOString() }) + "\n";
+    /* 同步写入，减少 pipe 缓冲导致 UI 长时间收不到首行 */
+    try {
+      fs.writeSync(1, Buffer.from(line, "utf8"));
+    } catch {
+      process.stdout.write(line);
+    }
+  }
+}
+
+/** 从 run 的 memory.md 读取 runStartTime */
+export function readRunStartTime(workspaceRoot, flowName, uuid) {
+  const memoryPath = path.join(getRunDir(workspaceRoot, flowName, uuid), "memory.md");
+  if (!fs.existsSync(memoryPath)) return null;
+  const content = fs.readFileSync(memoryPath, "utf-8");
+  for (const line of (content || "").split(/\r?\n/)) {
+    const idx = line.indexOf(": ");
+    if (idx <= 0) continue;
+    const k = line.slice(0, idx).trim();
+    if (k !== "runStartTime") continue;
+    const v = line.slice(idx + 2).trim();
+    const n = parseInt(String(v), 10);
+    return Number.isFinite(n) && n > 0 ? n : null;
+  }
+  return null;
+}
+
+/** 从 run 的 memory.md 读取 totalExecutedMs */
+export function readTotalExecutedMs(workspaceRoot, flowName, uuid) {
+  const memoryPath = path.join(getRunDir(workspaceRoot, flowName, uuid), "memory.md");
+  if (!fs.existsSync(memoryPath)) return 0;
+  const content = fs.readFileSync(memoryPath, "utf-8");
+  for (const line of (content || "").split(/\r?\n/)) {
+    const idx = line.indexOf(": ");
+    if (idx <= 0) continue;
+    const k = line.slice(0, idx).trim();
+    if (k !== "totalExecutedMs") continue;
+    const v = line.slice(idx + 2).trim();
+    const n = parseInt(String(v), 10);
+    return Number.isFinite(n) && n >= 0 ? n : 0;
+  }
+  return 0;
+}
+
+export function saveTotalExecutedMs(workspaceRoot, flowName, uuid, totalExecutedMs) {
+  runNodeScript(workspaceRoot, "save-key.mjs", [workspaceRoot, flowName, uuid, "totalExecutedMs", String(totalExecutedMs)], {
+    captureStdout: true,
+  });
+}
+
+export function ensureRunStartTime(workspaceRoot, flowName, uuid) {
+  const existing = readRunStartTime(workspaceRoot, flowName, uuid);
+  if (existing != null) return existing;
+  const runStartTime = Date.now();
+  runNodeScript(workspaceRoot, "save-key.mjs", [workspaceRoot, flowName, uuid, "runStartTime", String(runStartTime)], {
+    captureStdout: true,
+  });
+  return runStartTime;
+}

package/bin/lib/run-node-statuses-from-disk.mjs

@@ -0,0 +1,85 @@
+/**
+ * 从某次 run 的 intermediate 读取各节点最新 result 状态，供 UI 从历史进入时还原画布角标。
+ */
+import fs from "fs";
+import path from "path";
+import { getRunDir } from "./paths.mjs";
+import { formatDuration } from "./terminal.mjs";
+import { loadAllExecIds, latestResultExecId, intermediateResultBasename } from "../pipeline/get-exec-id.mjs";
+
+function parseResultStatus(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const m = raw.match(/^\s*status:\s*["']?(\w+)["']?/m);
+    return m ? m[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+/** @param {string} filePath @returns {number | null} */
+function parseElapsedMsLine(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const m = raw.match(/^\s*elapsedMs:\s*(\d+)/m);
+    if (!m) return null;
+    const n = parseInt(m[1], 10);
+    return Number.isFinite(n) && n >= 0 ? n : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} workspaceRoot
+ * @param {string} flowName
+ * @param {string} uuid
+ * @returns {Record<string, { status: string, elapsed?: string }>}
+ */
+export function getRunNodeStatusesFromDisk(workspaceRoot, flowName, uuid) {
+  const runDir = getRunDir(workspaceRoot, flowName, uuid);
+  const flowJsonPath = path.join(runDir, "intermediate", "flow.json");
+  if (!fs.existsSync(flowJsonPath)) return {};
+
+  let flow;
+  try {
+    flow = JSON.parse(fs.readFileSync(flowJsonPath, "utf-8"));
+  } catch {
+    return {};
+  }
+  if (!flow || !flow.ok) return {};
+
+  const order = Array.isArray(flow.order) ? flow.order : [];
+  const nodeDefinitions = flow.nodeDefinitions && typeof flow.nodeDefinitions === "object" ? flow.nodeDefinitions : {};
+  const execIdMap = loadAllExecIds(workspaceRoot, flowName, uuid, order);
+  const intermediateDir = path.join(runDir, "intermediate");
+  /** @type {Record<string, { status: string, elapsed?: string }>} */
+  const out = {};
+
+  for (const instanceId of order) {
+    const defId = nodeDefinitions[instanceId] || "";
+    const execId = execIdMap[instanceId] ?? 1;
+    const latestE = latestResultExecId(execId);
+    const resultPath = path.join(intermediateDir, instanceId, intermediateResultBasename(instanceId, latestE));
+    let status = fs.existsSync(resultPath) ? parseResultStatus(resultPath) : null;
+    if (!status && defId.startsWith("provide_")) status = "success";
+    if (!status && defId === "control_start") status = "success";
+    if (!status) continue;
+
+    let uiStatus = status;
+    const low = String(status).toLowerCase();
+    if (low === "completed" || low === "done") uiStatus = "success";
+
+    /** @type {{ status: string, elapsed?: string }} */
+    const row = { status: uiStatus };
+    if (uiStatus === "success" && fs.existsSync(resultPath)) {
+      const ms = parseElapsedMsLine(resultPath);
+      if (ms != null && ms > 0) {
+        row.elapsed = formatDuration(ms);
+      }
+    }
+    out[instanceId] = row;
+  }
+
+  return out;
+}