@fieldwangai/agentflow 0.1.153 → 0.1.156

package/bin/lib/scheduler.mjs

@@ -1,601 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { spawn } from "child_process";
-import yaml from "js-yaml";
-import { listFlowsJson } from "./catalog-flows.mjs";
-import {
-  computeNextRunAtFromSchedule,
-  readFlowSchedule,
-  readScheduleState,
-  writeScheduleState,
-} from "./schedule-config.mjs";
-import { getAgentflowUserContexts, getFlowRuntimeRoot, getRunDir, PACKAGE_ROOT } from "./paths.mjs";
-import { isApplyProcessAlive } from "./run-apply-active-lock.mjs";
-import { log } from "./log.mjs";
-import { readMergedEnvObject } from "./user-env.mjs";
-import { writeResult } from "../pipeline/write-result.mjs";
-
-const DEFAULT_POLL_MS = 30_000;
-const RUN_CONFIG_FILENAME = "run-config.json";
-const WAIT_STATE_FILENAME = "wait-state.json";
-const WAIT_STATES_FILENAME = "wait-states.json";
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function scheduleIdentity(schedule) {
-  return [
-    schedule.enabled ? "1" : "0",
-    schedule.cron || "",
-    schedule.timezone || "",
-    schedule.preset || "",
-    schedule.overlapPolicy || "skip",
-    schedule.misfirePolicy || "skip",
-  ].join("\t");
-}
-
-function readRunConfig(flowDir) {
-  const configPath = path.join(flowDir, RUN_CONFIG_FILENAME);
-  if (!fs.existsSync(configPath)) return { presets: {}, activePreset: null };
-  try {
-    const data = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-    return {
-      presets: data.presets && typeof data.presets === "object" ? data.presets : {},
-      activePreset: typeof data.activePreset === "string" ? data.activePreset : null,
-    };
-  } catch {
-    return { presets: {}, activePreset: null };
-  }
-}
-
-function buildCliInputArgs(flowDir, presetName) {
-  const cfg = readRunConfig(flowDir);
-  const name = presetName || cfg.activePreset || "";
-  const preset = name && cfg.presets && typeof cfg.presets[name] === "object" ? cfg.presets[name] : null;
-  if (!preset) return [];
-  let flow;
-  try {
-    flow = yaml.load(fs.readFileSync(path.join(flowDir, "flow.yaml"), "utf-8"));
-  } catch {
-    flow = null;
-  }
-  const instances = flow && typeof flow === "object" && flow.instances && typeof flow.instances === "object" ? flow.instances : {};
-  const edges = flow && typeof flow === "object" && Array.isArray(flow.edges) ? flow.edges : [];
-  const provideToInputName = {};
-  for (const e of edges) {
-    if (!e || !e.source || !e.target) continue;
-    const source = String(e.source);
-    const target = String(e.target);
-    if (!preset.hasOwnProperty(source)) continue;
-    const sourceInst = instances[source] || {};
-    const sourceDef = String(sourceInst.definitionId || "");
-    if (!sourceDef.startsWith("provide_")) continue;
-    const m = /^input-(\d+)$/.exec(String(e.targetHandle || ""));
-    if (!m) continue;
-    const targetInst = instances[target] || {};
-    const inputs = Array.isArray(targetInst.input) ? targetInst.input : [];
-    const slot = inputs[parseInt(m[1], 10)];
-    if (slot && typeof slot.name === "string" && slot.name.trim()) {
-      provideToInputName[source] = {
-        name: slot.name.trim(),
-        isFile: sourceDef.startsWith("provide_file"),
-      };
-    }
-  }
-  const args = [];
-  for (const [inputName, value] of Object.entries(preset)) {
-    if (!inputName || typeof inputName !== "string") continue;
-    const mapped = provideToInputName[inputName];
-    if (!mapped) continue;
-    args.push("--input", `${mapped.name}=${mapped.isFile ? "file:" : ""}${String(value ?? "")}`);
-  }
-  return args;
-}
-
-function hasHigherPriorityDuplicate(workspaceRoot, flow, opts = {}) {
-  if ((flow.source || "user") !== "workspace") return false;
-  return listFlowsJson(workspaceRoot, opts).some((f) => f.id === flow.id && !f.archived && (f.source || "user") === "user");
-}
-
-function getLatestRunUuidForFlow(workspaceRoot, flowId, opts = {}) {
-  const runRoot = path.dirname(getRunDir(workspaceRoot, flowId, "00000000000000", opts));
-  if (!fs.existsSync(runRoot)) return null;
-  try {
-    const dirs = fs.readdirSync(runRoot, { withFileTypes: true })
-      .filter((e) => e.isDirectory() && /^\d{14}$/.test(e.name))
-      .map((e) => e.name)
-      .sort();
-    return dirs[dirs.length - 1] || null;
-  } catch {
-    return null;
-  }
-}
-
-function listRunDirsForFlow(workspaceRoot, flow, opts = {}) {
-  const roots = [
-    flow.path ? path.join(flow.path, "runBuild") : "",
-    path.join(getFlowRuntimeRoot(workspaceRoot, flow.id, opts), "runBuild"),
-  ].filter(Boolean);
-  const seen = new Set();
-  const runs = [];
-  for (const runRoot of roots) {
-    const resolved = path.resolve(runRoot);
-    if (seen.has(resolved) || !fs.existsSync(resolved)) continue;
-    seen.add(resolved);
-    try {
-      for (const entry of fs.readdirSync(resolved, { withFileTypes: true })) {
-        if (entry.isDirectory() && /^\d{14}$/.test(entry.name)) {
-          runs.push({ uuid: entry.name, runDir: path.join(resolved, entry.name) });
-        }
-      }
-    } catch {
-      /* ignore unreadable run roots */
-    }
-  }
-  return runs.sort((a, b) => b.uuid.localeCompare(a.uuid));
-}
-
-function readJsonObject(filePath) {
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    const state = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-    return state && typeof state === "object" ? state : null;
-  } catch {
-    return null;
-  }
-}
-
-function waitStateKey(state) {
-  return String((state && (state.waitId || state.id || state.instanceId)) || "");
-}
-
-function persistedWaitState(state) {
-  const {
-    waitPath: _waitPath,
-    legacyPath: _legacyPath,
-    registryPath: _registryPath,
-    runDir: _runDir,
-    ...persisted
-  } = state && typeof state === "object" ? state : {};
-  return persisted;
-}
-
-function readWaitStates(runDir) {
-  const legacyPath = path.join(runDir, WAIT_STATE_FILENAME);
-  const registryPath = path.join(runDir, WAIT_STATES_FILENAME);
-  const states = [];
-  const seen = new Set();
-  const registry = readJsonObject(registryPath);
-  if (registry && Array.isArray(registry.waits)) {
-    for (const raw of registry.waits) {
-      if (!raw || typeof raw !== "object") continue;
-      const state = { ...raw, runDir, legacyPath, registryPath };
-      const key = waitStateKey(state);
-      if (!key || seen.has(key)) continue;
-      seen.add(key);
-      states.push(state);
-    }
-  }
-  const legacy = readJsonObject(legacyPath);
-  if (legacy) {
-    const state = { ...legacy, runDir, waitPath: legacyPath, legacyPath, registryPath: fs.existsSync(registryPath) ? registryPath : null };
-    const key = waitStateKey(state);
-    if (key && !seen.has(key)) states.push(state);
-  }
-  return states;
-}
-
-function writeWaitState(waitState, patch = {}) {
-  const next = {
-    ...(waitState && typeof waitState === "object" ? waitState : {}),
-    ...(patch && typeof patch === "object" ? patch : {}),
-    updatedAt: new Date().toISOString(),
-  };
-  const key = waitStateKey(next);
-  if (key) {
-    next.waitId = String(next.waitId || key);
-    next.id = String(next.id || next.waitId);
-  }
-  const runDir = next.runDir || (next.waitPath ? path.dirname(next.waitPath) : "");
-  if (!runDir) return;
-
-  const legacyPath = next.legacyPath || next.waitPath || path.join(runDir, WAIT_STATE_FILENAME);
-  const registryPath = next.registryPath || path.join(runDir, WAIT_STATES_FILENAME);
-  const persisted = persistedWaitState(next);
-  const persistedKey = waitStateKey(persisted);
-
-  const registry = readJsonObject(registryPath);
-  if (registry && Array.isArray(registry.waits)) {
-    const waits = registry.waits.filter((w) => waitStateKey(w) !== persistedKey);
-    waits.push(persisted);
-    fs.writeFileSync(registryPath, JSON.stringify({ ...registry, updatedAt: new Date().toISOString(), waits }, null, 2) + "\n", "utf-8");
-  }
-  fs.writeFileSync(legacyPath, JSON.stringify(persisted, null, 2) + "\n", "utf-8");
-}
-
-function readNodeResultStatus(runDir, instanceId) {
-  const resultPath = path.join(runDir, "intermediate", instanceId, `${instanceId}.result.md`);
-  if (!fs.existsSync(resultPath)) return null;
-  try {
-    const raw = fs.readFileSync(resultPath, "utf-8");
-    const m = raw.match(/^\s*status:\s*["']?([^"'\s]+)["']?/m);
-    return m ? m[1] : null;
-  } catch {
-    return null;
-  }
-}
-
-function isFlowCurrentlyRunning(workspaceRoot, flowId, state, opts = {}) {
-  const candidates = [];
-  if (state && typeof state.lastRunUuid === "string") candidates.push(state.lastRunUuid);
-  const latest = getLatestRunUuidForFlow(workspaceRoot, flowId, opts);
-  if (latest) candidates.push(latest);
-  for (const uuid of candidates) {
-    const runDir = getRunDir(workspaceRoot, flowId, uuid, opts);
-    if (isApplyProcessAlive(runDir)) return true;
-  }
-  return false;
-}
-
-function baseState(flow, schedule, previousState) {
-  return {
-    ...(previousState && typeof previousState === "object" ? previousState : {}),
-    flowId: flow.id,
-    flowSource: flow.source || "user",
-    scheduleIdentity: scheduleIdentity(schedule),
-    updatedAt: new Date().toISOString(),
-  };
-}
-
-function ensureNextRunAt(workspaceRoot, flow, schedule, state, opts = {}) {
-  const identity = scheduleIdentity(schedule);
-  if (state.scheduleIdentity === identity && state.nextRunAt) return state;
-  const nextRunAt = schedule.enabled && schedule.cron ? computeNextRunAtFromSchedule(schedule) : null;
-  const next = {
-    ...baseState(flow, schedule, state),
-    nextRunAt,
-    lastError: "",
-  };
-  writeScheduleState(workspaceRoot, flow.id, flow.source || "user", next, opts);
-  return next;
-}
-
-function startScheduledRun(workspaceRoot, flow, schedule, state, opts = {}) {
-  const flowDir = flow.path || "";
-  const agentflowBin = path.join(PACKAGE_ROOT, "bin", "agentflow.mjs");
-  const args = [agentflowBin, "apply", flow.id, "--machine-readable", "--workspace-root", path.resolve(workspaceRoot), "--force"];
-  args.push(...buildCliInputArgs(flowDir, schedule.preset));
-  const child = spawn(process.execPath, args, {
-    cwd: path.resolve(workspaceRoot),
-    stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env, ...readMergedEnvObject(opts.userId), FORCE_COLOR: "0", AGENTFLOW_USER_ID: opts.userId || "" },
-    detached: true,
-  });
-
-  const startedAt = new Date().toISOString();
-  let lastRunUuid = null;
-  let stdoutBuf = "";
-  child.stdout.on("data", (chunk) => {
-    stdoutBuf += chunk.toString("utf8");
-    const lines = stdoutBuf.split("\n");
-    stdoutBuf = lines.pop() || "";
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const evt = JSON.parse(line);
-        if (evt && evt.event === "apply-start" && typeof evt.uuid === "string") {
-          lastRunUuid = evt.uuid;
-          writeScheduleState(workspaceRoot, flow.id, flow.source || "user", {
-            ...baseState(flow, schedule, state),
-            nextRunAt: computeNextRunAtFromSchedule(schedule),
-            lastTriggeredAt: startedAt,
-            lastRunUuid,
-            lastPid: child.pid || null,
-            lastError: "",
-          }, opts);
-        }
-      } catch {
-        /* ignore non-json lines */
-      }
-    }
-  });
-
-  child.stderr.on("data", (chunk) => {
-    const text = chunk.toString("utf8").trim();
-    if (text) log.debug(`[scheduler] ${flow.id}: ${text.slice(0, 1000)}`);
-  });
-
-  child.on("exit", (code, signal) => {
-    const prev = readScheduleState(workspaceRoot, flow.id, flow.source || "user", opts).state || state;
-    writeScheduleState(workspaceRoot, flow.id, flow.source || "user", {
-      ...baseState(flow, schedule, prev),
-      nextRunAt: prev.nextRunAt || computeNextRunAtFromSchedule(schedule),
-      lastTriggeredAt: prev.lastTriggeredAt || startedAt,
-      lastRunUuid: lastRunUuid || prev.lastRunUuid || null,
-      lastExitCode: code,
-      lastExitSignal: signal || "",
-      lastFinishedAt: new Date().toISOString(),
-      lastError: code === 0 ? "" : `scheduled run exited with code ${code}${signal ? ` signal ${signal}` : ""}`,
-    }, opts);
-  });
-
-  child.unref();
-  return child;
-}
-
-function startWaitingRunResume(workspaceRoot, flow, waitState, opts = {}) {
-  const agentflowBin = path.join(PACKAGE_ROOT, "bin", "agentflow.mjs");
-  const uuid = String(waitState.uuid || "");
-  const instanceId = String(waitState.instanceId || "");
-  const rerunCurrentNode = waitState.resumeMode === "rerun";
-  if (rerunCurrentNode) {
-    writeResult(
-      workspaceRoot,
-      flow.id,
-      uuid,
-      instanceId,
-      { status: "cache_not_met", message: "后台任务到期，重新检查外部状态" },
-      { execId: Number(waitState.execId) || undefined, preserveBody: true, runDir: waitState.runDir },
-    );
-  }
-  const args = [
-    agentflowBin,
-    rerunCurrentNode ? "apply" : "resume",
-    flow.id,
-    uuid,
-    ...(rerunCurrentNode ? [] : [instanceId]),
-    "--machine-readable",
-    "--workspace-root",
-    path.resolve(workspaceRoot),
-    "--force",
-  ];
-  const child = spawn(process.execPath, args, {
-    cwd: path.resolve(workspaceRoot),
-    stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env, ...readMergedEnvObject(opts.userId), FORCE_COLOR: "0", AGENTFLOW_USER_ID: opts.userId || "" },
-    detached: true,
-  });
-  child.stdout.on("data", () => {});
-  child.stderr.on("data", (chunk) => {
-    const text = chunk.toString("utf8").trim();
-    if (text) log.debug(`[scheduler] resume ${flow.id}/${uuid}: ${text.slice(0, 1000)}`);
-  });
-  child.on("exit", (code, signal) => {
-    const runDir = waitState.runDir || (waitState.waitPath ? path.dirname(waitState.waitPath) : "");
-    if (!runDir) return;
-    const latest = readWaitStates(runDir).find((s) => waitStateKey(s) === waitStateKey(waitState));
-    if (!latest || latest.wakeAt !== waitState.wakeAt || latest.instanceId !== waitState.instanceId) return;
-    writeWaitState(latest, {
-      status: code === 0 ? "resumed" : "waiting",
-      lastResumeExitCode: code,
-      lastResumeExitSignal: signal || "",
-      lastResumeFinishedAt: new Date().toISOString(),
-      ...(code === 0 ? {} : { lastError: `resume exited with code ${code}${signal ? ` signal ${signal}` : ""}` }),
-    });
-  });
-  child.unref();
-  return child;
-}
-
-function countActiveWaitsForFlow(workspaceRoot, flow, opts = {}) {
-  let count = 0;
-  for (const run of listRunDirsForFlow(workspaceRoot, flow, opts)) {
-    for (const waitState of readWaitStates(run.runDir)) {
-      if (waitState && (waitState.status === "waiting" || waitState.status === "resuming")) count += 1;
-    }
-  }
-  return count;
-}
-
-function hasNodeBranchEdge(runDir, instanceId, branchName) {
-  const flowJsonPath = path.join(runDir, "intermediate", "flow.json");
-  const flow = readJsonObject(flowJsonPath);
-  if (!flow || !Array.isArray(flow.edges)) return false;
-  const outputSlotTypes = flow.outputSlotTypes && flow.outputSlotTypes[instanceId];
-  if (!outputSlotTypes || typeof outputSlotTypes !== "object") return false;
-  const idx = Object.keys(outputSlotTypes).indexOf(branchName);
-  if (idx < 0) return false;
-  const sourceHandle = `output-${idx}`;
-  return flow.edges.some((e) => e && e.source === instanceId && (e.sourceHandle || "output-0") === sourceHandle);
-}
-
-export function cancelScheduledRun(workspaceRoot, flowId, uuid, opts = {}) {
-  const flow = listFlowsJson(workspaceRoot, opts).find((f) => f.id === flowId && !f.archived);
-  if (!flow) return { ok: false, error: `flow not found: ${flowId}` };
-  const runDir = getRunDir(workspaceRoot, flow.id, uuid, opts);
-  if (!fs.existsSync(runDir)) return { ok: false, error: `run not found: ${flowId}/${uuid}` };
-  const cancelledAt = new Date().toISOString();
-  fs.writeFileSync(path.join(runDir, "cancelled.json"), JSON.stringify({ cancelled: true, cancelledAt }, null, 2) + "\n", "utf-8");
-  let updated = 0;
-  let propagated = 0;
-  let resumePid = null;
-  for (const waitState of readWaitStates(runDir)) {
-    if (waitState.status !== "waiting" && waitState.status !== "resuming") continue;
-    const instanceId = String(waitState.instanceId || "");
-    const canPropagate =
-      waitState.reason === "control_interval_loop" &&
-      instanceId &&
-      hasNodeBranchEdge(runDir, instanceId, "cancelled") &&
-      !resumePid;
-    const canRerunForCancellation = waitState.resumeMode === "rerun" && instanceId && !resumePid;
-    if (canRerunForCancellation) {
-      const child = startWaitingRunResume(workspaceRoot, flow, { ...waitState, uuid, runDir, branch: "cancelled" }, opts);
-      resumePid = child.pid || null;
-      writeWaitState(waitState, { status: "resuming", branch: "cancelled", cancelledAt, resumePid, resumeStartedAt: cancelledAt });
-      propagated += 1;
-    } else if (canPropagate) {
-      writeResult(
-        workspaceRoot,
-        flow.id,
-        uuid,
-        instanceId,
-        { status: "success", message: "已取消", branch: "cancelled" },
-        { execId: Number(waitState.execId) || undefined, preserveBody: false, runDir },
-      );
-      const child = startWaitingRunResume(workspaceRoot, flow, { ...waitState, uuid, runDir, branch: "cancelled" }, opts);
-      resumePid = child.pid || null;
-      writeWaitState(waitState, { status: "resuming", branch: "cancelled", cancelledAt, resumePid, resumeStartedAt: cancelledAt });
-      propagated += 1;
-    } else {
-      writeWaitState(waitState, { status: "cancelled", cancelledAt });
-    }
-    updated += 1;
-  }
-  return { ok: true, flowId, uuid, cancelledAt, updatedWaits: updated, propagatedWaits: propagated, resumePid };
-}
-
-export function listScheduleStatuses(workspaceRoot, opts = {}) {
-  const rows = [];
-  for (const flow of listFlowsJson(workspaceRoot, opts)) {
-    if (flow.archived || flow.source === "builtin") continue;
-    const scheduleRes = readFlowSchedule(workspaceRoot, flow.id, flow.source || "user", opts);
-    if (!scheduleRes.success) {
-      rows.push({ flowId: flow.id, flowSource: flow.source || "user", enabled: false, error: scheduleRes.error });
-      continue;
-    }
-    const schedule = scheduleRes.schedule;
-    const stateRes = readScheduleState(workspaceRoot, flow.id, flow.source || "user", opts);
-    const state = stateRes.success ? stateRes.state : {};
-    rows.push({
-      flowId: flow.id,
-      flowSource: flow.source || "user",
-      enabled: Boolean(schedule.enabled),
-      cron: schedule.cron || "",
-      timezone: schedule.timezone || "",
-      preset: schedule.preset || "",
-      nextRunAt: state.nextRunAt || schedule.nextRunAt || null,
-      lastTriggeredAt: state.lastTriggeredAt || null,
-      lastRunUuid: state.lastRunUuid || null,
-      lastError: hasHigherPriorityDuplicate(workspaceRoot, flow, opts)
-        ? "workspace flow is shadowed by a user flow with the same id"
-        : state.lastError || "",
-      running: isFlowCurrentlyRunning(workspaceRoot, flow.id, state, opts),
-      waiting: countActiveWaitsForFlow(workspaceRoot, flow, opts),
-    });
-  }
-  rows.sort((a, b) => {
-    const ea = a.enabled ? 0 : 1;
-    const eb = b.enabled ? 0 : 1;
-    return ea - eb || String(a.nextRunAt || "").localeCompare(String(b.nextRunAt || "")) || a.flowId.localeCompare(b.flowId);
-  });
-  return rows;
-}
-
-export async function startScheduler(workspaceRoot, opts = {}) {
-  const pollMs = Math.max(1000, Number(opts.pollMs) || DEFAULT_POLL_MS);
-  const once = Boolean(opts.once);
-  log.info(`AgentFlow scheduler started. workspace=${path.resolve(workspaceRoot)} poll=${pollMs}ms`);
-  while (true) {
-    const now = Date.now();
-    const contexts = opts.userId ? [{ userId: opts.userId }] : getAgentflowUserContexts();
-    for (const scheduleCtx of contexts) {
-    for (const flow of listFlowsJson(workspaceRoot, scheduleCtx)) {
-      if (flow.archived) continue;
-      const flowSource = flow.source || "user";
-      let resumedWaitingRun = false;
-      for (const run of listRunDirsForFlow(workspaceRoot, flow, scheduleCtx)) {
-        if (resumedWaitingRun) break;
-        for (const waitState of readWaitStates(run.runDir)) {
-          if (!waitState || !waitState.wakeAt || !waitState.instanceId) continue;
-          if (waitState.status === "resuming" && !isFlowCurrentlyRunning(workspaceRoot, flow.id, { lastRunUuid: run.uuid }, scheduleCtx)) {
-            const nodeStatus = readNodeResultStatus(run.runDir, String(waitState.instanceId));
-            writeWaitState(waitState, {
-              status:
-                nodeStatus === "pending" ||
-                (waitState.resumeMode === "rerun" && nodeStatus !== "success" && nodeStatus !== "failed")
-                  ? "waiting"
-                  : "resumed",
-              reconciledAt: new Date().toISOString(),
-            });
-            continue;
-          }
-          if (waitState.status !== "waiting") continue;
-          if (Date.parse(waitState.wakeAt) > now) continue;
-          if (isFlowCurrentlyRunning(workspaceRoot, flow.id, { lastRunUuid: run.uuid }, scheduleCtx)) continue;
-          const nextState = {
-            ...waitState,
-            status: "resuming",
-            resumePid: null,
-            resumeStartedAt: new Date().toISOString(),
-          };
-          try {
-            const child = startWaitingRunResume(workspaceRoot, flow, { ...waitState, uuid: run.uuid, runDir: run.runDir }, scheduleCtx);
-            nextState.resumePid = child.pid || null;
-            writeWaitState(waitState, nextState);
-            resumedWaitingRun = true;
-            log.info(`[scheduler] resume ${flow.id}/${run.uuid} at ${waitState.instanceId}; pid=${child.pid || "?"}`);
-            break;
-          } catch (e) {
-            writeWaitState(waitState, {
-              status: "waiting",
-              lastError: e && e.message ? e.message : String(e),
-              lastErrorAt: new Date().toISOString(),
-            });
-            log.info(`[scheduler] resume failed ${flow.id}/${run.uuid}: ${e && e.message ? e.message : String(e)}`);
-          }
-        }
-      }
-
-      if (flow.source === "builtin") continue;
-
-      const scheduleRes = readFlowSchedule(workspaceRoot, flow.id, flowSource, scheduleCtx);
-      if (!scheduleRes.success) {
-        log.debug(`[scheduler] ${flow.id}: ${scheduleRes.error}`);
-        continue;
-      }
-      const schedule = scheduleRes.schedule;
-      if (!schedule.enabled || !schedule.cron) continue;
-      if (hasHigherPriorityDuplicate(workspaceRoot, flow, scheduleCtx)) {
-        const stateRes = readScheduleState(workspaceRoot, flow.id, flowSource, scheduleCtx);
-        writeScheduleState(workspaceRoot, flow.id, flowSource, {
-          ...baseState(flow, schedule, stateRes.success ? stateRes.state : {}),
-          nextRunAt: null,
-          lastError: "workspace flow is shadowed by a user flow with the same id; scheduled run skipped",
-          lastErrorAt: new Date().toISOString(),
-        }, scheduleCtx);
-        continue;
-      }
-      const stateRes = readScheduleState(workspaceRoot, flow.id, flowSource, scheduleCtx);
-      let state = ensureNextRunAt(workspaceRoot, flow, schedule, stateRes.success ? stateRes.state : {}, scheduleCtx);
-      if (!state.nextRunAt || Date.parse(state.nextRunAt) > now) continue;
-
-      if (isFlowCurrentlyRunning(workspaceRoot, flow.id, state, scheduleCtx)) {
-        const nextRunAt = computeNextRunAtFromSchedule(schedule);
-        writeScheduleState(workspaceRoot, flow.id, flowSource, {
-          ...baseState(flow, schedule, state),
-          nextRunAt,
-          lastSkippedAt: new Date().toISOString(),
-          lastSkipReason: "running",
-        }, scheduleCtx);
-        log.info(`[scheduler] skip ${flow.id}: already running; next=${nextRunAt}`);
-        continue;
-      }
-
-      try {
-        const child = startScheduledRun(workspaceRoot, flow, schedule, state, scheduleCtx);
-        const nextRunAt = computeNextRunAtFromSchedule(schedule);
-        writeScheduleState(workspaceRoot, flow.id, flowSource, {
-          ...baseState(flow, schedule, state),
-          nextRunAt,
-          lastTriggeredAt: new Date().toISOString(),
-          lastPid: child.pid || null,
-          lastError: "",
-        }, scheduleCtx);
-        log.info(`[scheduler] triggered ${flow.id}; pid=${child.pid || "?"}; next=${nextRunAt}`);
-      } catch (e) {
-        const nextRunAt = computeNextRunAtFromSchedule(schedule);
-        writeScheduleState(workspaceRoot, flow.id, flowSource, {
-          ...baseState(flow, schedule, state),
-          nextRunAt,
-          lastError: e && e.message ? e.message : String(e),
-          lastErrorAt: new Date().toISOString(),
-        }, scheduleCtx);
-        log.info(`[scheduler] failed ${flow.id}: ${e && e.message ? e.message : String(e)}`);
-      }
-    }
-    }
-    if (once) return;
-    await sleep(pollMs);
-  }
-}

package/bin/lib/ui-print.mjs

@@ -1,94 +0,0 @@
-import chalk from "chalk";
-import { log } from "./log.mjs";
-import { runNodeScript } from "./pipeline-scripts.mjs";
-import { Table } from "./table.mjs";
-
-/** 开始时：入口信息（仅流程名称与 uuid） */
-export function printEntryAndFlowFiles(workspaceRoot, flowName, uuid) {
-  const entryTable = new Table({
-    head: [chalk.cyan("项目"), chalk.cyan("值")],
-    colWidths: [18, 24],
-    style: { head: [], border: ["grey"] },
-  });
-  entryTable.push(["流程名称", flowName], ["本次运行 uuid", uuid]);
-  log.info("\n" + chalk.bold("入口信息"));
-  log.info(entryTable.toString());
-}
-
-export function styleStatus(s) {
-  if (s === "success") return chalk.green("success");
-  if (s === "pending") return chalk.yellow("pending");
-  if (s === "running") return chalk.cyan("running");
-  if (s === "condition_not_met") return chalk.dim("condition_not_met");
-  return chalk.dim(s || "-");
-}
-
-/** 仅打印全量节点状态表（应用进入时展示一次用）。输出到 stderr。 */
-export function printNodeStatusTable(instanceStatus, nodes, execIdMap = {}) {
-  const idToLabel = new Map();
-  const idToType = new Map();
-  if (Array.isArray(nodes)) {
-    for (const n of nodes) {
-      idToLabel.set(n.id, n.label || n.id);
-      idToType.set(n.id, n.type || "-");
-    }
-  }
-  const order = Array.isArray(nodes) ? nodes.map((n) => n.id) : Object.keys(instanceStatus || {});
-  if (order.length === 0) return;
-  const statusTable = new Table({
-    head: [chalk.cyan("标签"), chalk.cyan("类型"), chalk.cyan("状态"), chalk.cyan("execId")],
-    colWidths: [20, 10, 16, 8],
-    style: { head: [], border: ["grey"] },
-  });
-  for (const id of order) {
-    const label = idToLabel.get(id) || id;
-    const type = idToType.get(id) || "-";
-    const status = (instanceStatus && instanceStatus[id]) || "-";
-    const execId = execIdMap[id] != null ? String(execIdMap[id]) : "-";
-    statusTable.push([label, type, styleStatus(status), execId]);
-  }
-  process.stderr.write("\n" + chalk.bold("节点状态") + "\n");
-  process.stderr.write(statusTable.toString() + "\n");
-}
-
-/**
- * apply 启动时执行 validate-flow（统一校验）；errors 则退出，仅 warnings 则提示后继续。
- */
-export function runValidateFlowAndExitIfInvalid(workspaceRoot, flowName, flowDir) {
-  const result = runNodeScript(workspaceRoot, "validate-flow.mjs", [workspaceRoot, flowName, flowDir], {
-    captureStdout: true,
-  });
-  const stdout = (result.stdout || "").trim();
-  if (!stdout) return;
-  let data;
-  try {
-    data = JSON.parse(stdout);
-  } catch {
-    return;
-  }
-  const errors = Array.isArray(data.errors) ? data.errors : [];
-  const warnings = Array.isArray(data.warnings) ? data.warnings : [];
-
-  if (errors.length > 0) {
-    process.stderr.write("\n" + chalk.bold.red("流程校验未通过，请修正后再执行 apply：") + "\n\n");
-    for (const err of errors) {
-      process.stderr.write("  " + chalk.red("• ") + err + "\n");
-    }
-    if (warnings.length > 0) {
-      process.stderr.write("\n" + chalk.yellow("警告：") + "\n");
-      for (const w of warnings) {
-        process.stderr.write("  " + chalk.yellow("• ") + w + "\n");
-      }
-    }
-    process.stderr.write("\n" + chalk.dim("校验命令: agentflow validate " + flowName) + "\n");
-    process.exit(1);
-  }
-
-  if (warnings.length > 0) {
-    process.stderr.write("\n" + chalk.yellow("校验警告：") + "\n");
-    for (const w of warnings) {
-      process.stderr.write("  " + chalk.yellow("• ") + w + "\n");
-    }
-    process.stderr.write("\n");
-  }
-}