@fieldwangai/agentflow 0.1.25 → 0.1.27

package/bin/lib/scheduler.mjs

@@ -12,9 +12,12 @@ import {
 import { getRunDir, PACKAGE_ROOT } from "./paths.mjs";
 import { isApplyProcessAlive } from "./run-apply-active-lock.mjs";
 import { log } from "./log.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));
@@ -108,6 +111,104 @@ function getLatestRunUuidForFlow(workspaceRoot, flowId) {
   }
 }
 
+function listRunDirsForFlow(flow) {
+  const flowDir = flow.path || "";
+  const runRoot = flowDir ? path.join(flowDir, "runBuild") : "";
+  if (!runRoot || !fs.existsSync(runRoot)) return [];
+  try {
+    return fs.readdirSync(runRoot, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && /^\d{14}$/.test(e.name))
+      .map((e) => ({ uuid: e.name, runDir: path.join(runRoot, e.name) }));
+  } catch {
+    return [];
+  }
+}
+
+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.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 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 key = waitStateKey(persisted);
+
+  const registry = readJsonObject(registryPath);
+  if (registry && Array.isArray(registry.waits)) {
+    const waits = registry.waits.filter((w) => waitStateKey(w) !== key);
+    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) {
   const candidates = [];
   if (state && typeof state.lastRunUuid === "string") candidates.push(state.lastRunUuid);
@@ -206,6 +307,110 @@ function startScheduledRun(workspaceRoot, flow, schedule, state) {
   return child;
 }
 
+function startWaitingRunResume(workspaceRoot, flow, waitState) {
+  const agentflowBin = path.join(PACKAGE_ROOT, "bin", "agentflow.mjs");
+  const uuid = String(waitState.uuid || "");
+  const instanceId = String(waitState.instanceId || "");
+  const args = [
+    agentflowBin,
+    "resume",
+    flow.id,
+    uuid,
+    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, FORCE_COLOR: "0" },
+    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(flow) {
+  let count = 0;
+  for (const run of listRunDirsForFlow(flow)) {
+    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) {
+  const flow = listFlowsJson(workspaceRoot).find((f) => f.id === flowId && !f.archived && f.source !== "builtin");
+  if (!flow) return { ok: false, error: `flow not found: ${flowId}` };
+  const runDir = getRunDir(workspaceRoot, flow.id, uuid);
+  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;
+    if (canPropagate) {
+      writeResult(
+        workspaceRoot,
+        flow.id,
+        uuid,
+        instanceId,
+        { status: "success", message: "已取消", branch: "cancelled" },
+        { execId: Number(waitState.execId) || undefined, preserveBody: false },
+      );
+      const child = startWaitingRunResume(workspaceRoot, flow, { ...waitState, uuid, runDir, branch: "cancelled" });
+      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) {
   const rows = [];
   for (const flow of listFlowsJson(workspaceRoot)) {
@@ -232,6 +437,7 @@ export function listScheduleStatuses(workspaceRoot) {
         ? "workspace flow is shadowed by a user flow with the same id"
         : state.lastError || "",
       running: isFlowCurrentlyRunning(workspaceRoot, flow.id, state),
+      waiting: countActiveWaitsForFlow(flow),
     });
   }
   rows.sort((a, b) => {
@@ -251,6 +457,46 @@ export async function startScheduler(workspaceRoot, opts = {}) {
     for (const flow of listFlowsJson(workspaceRoot)) {
       if (flow.archived || flow.source === "builtin") continue;
       const flowSource = flow.source || "user";
+      let resumedWaitingRun = false;
+      for (const run of listRunDirsForFlow(flow)) {
+        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 })) {
+            const nodeStatus = readNodeResultStatus(run.runDir, String(waitState.instanceId));
+            writeWaitState(waitState, {
+              status: nodeStatus === "pending" ? "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 })) 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 });
+            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)}`);
+          }
+        }
+      }
+
       const scheduleRes = readFlowSchedule(workspaceRoot, flow.id, flowSource);
       if (!scheduleRes.success) {
         log.debug(`[scheduler] ${flow.id}: ${scheduleRes.error}`);

package/bin/lib/ui-server.mjs

@@ -29,8 +29,8 @@ import {
   shouldUseMultiStep,
   runComposerPostFlowValidationAndRepair,
   buildScriptContentBlockForInstances,
-  buildQueryContextBlock,
 } from "./composer-agent.mjs";
+import { buildNodeSchemaCompactSection } from "./composer-node-schema.mjs";
 import { t } from "./i18n.mjs";
 import {
   PACKAGE_ROOT,
@@ -41,7 +41,6 @@ import {
 import { RUN_INTERRUPTED_FILENAME } from "./recent-runs.mjs";
 import {
   detectIntents,
-  classifyIntentCategory,
   loadResourcesForIntents,
   buildSkillInjectionBlock,
   buildSkillCompactInjectionBlock,
@@ -65,6 +64,7 @@ import {
 import { runNodeScript } from "./pipeline-scripts.mjs";
 import { readFlowSchedule, writeFlowSchedule } from "./schedule-config.mjs";
 import { listScheduleStatuses } from "./scheduler.mjs";
+import { installFlowDependency, listMarketplacePackages, publishNodeFromInstance } from "./marketplace.mjs";
 
 const MIME = {
   ".html": "text/html; charset=utf-8",
@@ -274,33 +274,7 @@ function formatThreadHistory(thread) {
 }
 
 function buildComposerPromptWithFlowContext(p) {
-  const intentCategory = p.intentCategory || "generic";
   const flowDirAbs = path.dirname(p.flowYamlAbs);
-
-  // ── query 轻量路径：只注入节点上下文 + 问题，跳过全部编辑规则 ──
-  if (intentCategory === "query") {
-    const queryCtx = buildQueryContextBlock(p.flowYamlAbs, p.instanceIds);
-    const parts = [
-      "## AgentFlow 问答上下文",
-      `- 流水线（flowId=${p.flowId}）：${flowDirAbs}`,
-      `- 图定义文件：${p.flowYamlAbs}`,
-      "",
-    ];
-    if (queryCtx) {
-      parts.push(queryCtx, "");
-    }
-    parts.push(
-      "请基于上方注入的节点 YAML 与脚本内容回答用户的问题。**不要修改任何文件。**",
-      ""
-    );
-    if (p.thread && p.thread.length > 0) {
-      parts.push(formatThreadHistory(p.thread), "");
-    }
-    parts.push("## 用户说明", "", p.userPrompt.trim());
-    return parts.join("\n");
-  }
-
-  // ── 编辑路径（edit-node / add-node / add-flow / edit-flow / generic） ──
   const idsLine =
     p.instanceIds.length > 0 ? p.instanceIds.map(String).join(", ") : "（无，可能为全局修改或新增节点）";
   const syncFs = p.editorSyncFlowSource ?? p.flowSource;
@@ -330,48 +304,29 @@ function buildComposerPromptWithFlowContext(p) {
         "- 仅改已有实例文案/占位等：遵循 `skills/agentflow-flow-edit-node-fields/SKILL.md`，勿改 definitionId、instanceId、IO 结构与边拓扑。",
       ];
 
-  // edit-node: 不需要重型节点类型选择规则和 tool_nodejs 区分
-  const needsNodeTypeRules = intentCategory !== "edit-node";
+  const nodeSchemaSection = buildNodeSchemaCompactSection();
 
   const prefix = [
-    "## AgentFlow 编辑上下文",
+    "## AgentFlow Composer 上下文",
     `- 流水线目录（flowId=${p.flowId}）：${flowDirAbs}`,
-    `- 图定义文件（必读/必改此文件）：${p.flowYamlAbs}`,
+    `- 图定义文件：${p.flowYamlAbs}`,
     `- flowId：${p.flowId}`,
     `- flowSource：${p.flowSource}`,
     ...builtinExtra,
     `- 当前关联的节点实例 ID（顺序：画布选中优先，再输入框 @提及）：${idsLine}`,
+    "- 请根据用户需求自行判断：如果是在问问题，只回答；如果是在要求新增、修改、完善或修复流程，请直接修改对应文件。",
+    "- 一旦修改 flow.yaml、脚本或相关文件，必须按下方方式刷新 Web 画布。",
     ...skillPathHints,
     "",
-    ...(needsNodeTypeRules ? [
-      "### 节点类型选择（必须遵守）",
-      "**判据**：**确定性任务 → `tool_nodejs`；非确定性任务 → `agent_subAgent`**。",
-      "- **确定性**：相同输入永远产出相同输出，可用普通代码完整描述（CLI/npm 调用、读写文件、JSON/路径转换、调现成 API 解析固定格式、跑脚手架等）",
-      "- **非确定性**：需要语义理解或创造（代码翻译/生成、源码/文本解析改写、多步推理决策、创意写作）",
-      "| 场景 | 推荐节点 |",
-      "|------|----------|",
-      "| 确定性逻辑（跑命令、读写文件、转换格式、调 API） | **tool_nodejs** + `script` |",
-      "| 醒目输出 | **tool_print** |",
-      "| 代码翻译/生成、源码/文本理解、多步决策、创意写作 | **agent_subAgent** |",
-      "**反例**：「Android 转 RN/TS」「分析代码生成测试」「代码 review」必须 agent——做成 tool_nodejs 必然失败。",
-      "",
-      "tool_nodejs + script 示例（打印文本）：",
-      "```yaml",
-      "print_hello:",
-      "  definitionId: tool_nodejs",
-      "  label: 打印Hello",
-      '  script: node -e "console.log(${value})"',
-      "  input:",
-      "    - { type: 节点, name: prev, value: '' }",
-      "    - { type: 文本, name: value, value: '' }",
-      "  output:",
-      "    - { type: 节点, name: next, value: '' }",
-      "    - { type: 文本, name: result, value: '' }",
-      "```",
-      "script 成败以 exit code 为准（0=success），stdout 直接作为 result 槽位内容（纯文本即可，如 console.log）。",
-      "常见误用：用 agent_subAgent 做「打印一段文字」「执行已有脚本」→ 应改用 tool_nodejs + script 或 tool_print。",
-      "",
-    ] : []),
+    "### 节点能力选择",
+    "**判据**：确定性任务优先 `tool_nodejs`；需要语义理解、生成、判断或多步推理时使用 `agent_subAgent`。",
+    "- **确定性**：相同输入永远产出相同输出，可用普通代码完整描述（CLI/npm 调用、读写文件、JSON/路径转换、调现成 API 解析固定格式、跑脚手架等）。",
+    "- **非确定性**：需要语义理解或创造（代码翻译/生成、源码/文本解析改写、多步推理决策、创意写作）。",
+    "- 分支/循环使用 `control_toBool` / `control_agent_toBool` + `control_if` + `control_anyOne` 组合。",
+    "- 常量输入使用 `provide_str` / `provide_file`；读取环境变量使用 `tool_get_env`；终端展示使用 `tool_print`。",
+    "",
+    nodeSchemaSection,
+    "",
     "### tool_nodejs 的 script 与 body 关键区分",
     "- **`script` 字段**：实际执行的命令代码，流水线直接 spawn 执行；**tool_nodejs 必须写 script**",
     "- **`body` 字段**：纯文档注释，有 script 时完全不执行；**禁止在 body 写期望执行的逻辑**",
@@ -931,6 +886,77 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/marketplace/nodes") {
+      try {
+        json(res, 200, listMarketplacePackages(root));
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/marketplace/install-node") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      const flowId = payload?.flowId;
+      const flowSource = payload?.flowSource || "user";
+      const flowArchived = payload?.archived === true;
+      const nodeSpec = payload?.nodeSpec || payload?.definitionId || payload?.id;
+      if (!flowId) {
+        json(res, 400, { error: "Missing flowId" });
+        return;
+      }
+      if (!nodeSpec) {
+        json(res, 400, { error: "Missing nodeSpec" });
+        return;
+      }
+      if (flowArchived || !isValidFlowSourceWrite(flowSource)) {
+        json(res, 400, { error: "Cannot install marketplace nodes into builtin or archived flow" });
+        return;
+      }
+      try {
+        const resolved = resolveFlowDirForWrite(root, flowId, flowSource);
+        if (resolved.error || !resolved.flowDir) {
+          json(res, 400, { error: resolved.error || "Could not resolve flow directory" });
+          return;
+        }
+        const result = installFlowDependency(root, resolved.flowDir, nodeSpec);
+        json(res, result.ok ? 200 : 400, result);
+      } catch (e) {
+        json(res, 500, { ok: false, error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/marketplace/publish-node-from-instance") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const flowId = payload?.flowId;
+        const flowSource = payload?.flowSource || "user";
+        let flowDir = "";
+        if (flowId && isValidFlowSourceWrite(flowSource)) {
+          const resolved = resolveFlowDirForWrite(root, flowId, flowSource);
+          if (!resolved.error && resolved.flowDir) flowDir = resolved.flowDir;
+        }
+        const result = publishNodeFromInstance(root, payload || {}, { flowDir });
+        json(res, result.ok ? 200 : 400, result);
+      } catch (e) {
+        json(res, 500, { ok: false, error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/flow") {
       const flowId = url.searchParams.get("flowId");
       const flowSource = url.searchParams.get("flowSource") || "user";
@@ -1761,7 +1787,6 @@ finishedAt: "${new Date().toISOString()}"
 
         // 基于用户意图动态加载 skill 上下文
         const multiStepIntents = detectIntents(prompt);
-        const intentCategory = classifyIntentCategory(multiStepIntents);
         const multiStepResources = loadResourcesForIntents(multiStepIntents, PACKAGE_ROOT);
         const flowPipelineDir = flowYamlAbs ? path.dirname(flowYamlAbs) : "";
 
@@ -1770,7 +1795,6 @@ finishedAt: "${new Date().toISOString()}"
           flowId,
           flowSource,
           intents: multiStepIntents,
-          intentCategory,
           canvasInstanceIds: instanceIds,
           skillsHint: multiStepResources.skillsHint,
           skillInjectionBlock: multiStepResources.hasContext
@@ -1794,7 +1818,6 @@ finishedAt: "${new Date().toISOString()}"
           flowArchived,
           thread,
           scriptContentBlock,
-          intentCategory,
         });
         cliWorkspace = composerCliWorkspaceForFlowDir(root, flowDirForCli);
       }
@@ -1887,13 +1910,9 @@ finishedAt: "${new Date().toISOString()}"
       log.debug(`[ui] composer-agent: flowId=${flowId || "(none)"} model=${model || "default"} promptLen=${finalPrompt.length}`);
 
       const hasPhaseContext = payload.phaseContext && typeof payload.phaseContext === "object" && typeof payload.phaseContext.phaseIndex === "number";
-      // query 意图：跳过 planner，直接走单步轻量路径
-      const resolvedIntentCategory = flowContextForMultiStep?.intentCategory || "generic";
       let useMultiStep;
       try {
-        useMultiStep = resolvedIntentCategory === "query"
-          ? false
-          : (hasPhaseContext || ((await shouldUseMultiStep({ flowYamlAbs, userPrompt: prompt.trim(), cliWorkspace })) && !payload.singleStep));
+        useMultiStep = hasPhaseContext || ((await shouldUseMultiStep({ flowYamlAbs, userPrompt: prompt.trim(), cliWorkspace })) && !payload.singleStep);
       } catch (classifyErr) {
         log.debug(`[ui] composer classify error: ${classifyErr.message}`);
         logComposerEvent(composerLogPath, "composer-done", {

package/bin/pipeline/build-node-prompt.mjs

@@ -11,6 +11,7 @@ import { fileURLToPath } from "url";
 
 import { getRunDir, PIPELINES_DIR } from "../lib/paths.mjs";
 import { getFlowDir } from "../lib/workspace.mjs";
+import { isMarketplaceDefinitionId, resolveMarketplaceNodePackage } from "../lib/marketplace.mjs";
 import { loadFlowDefinition } from "./parse-flow.mjs";
 import { getResolvedValues, getOutputPathForSlot } from "./get-resolved-values.mjs";
 import { loadExecId } from "./get-exec-id.mjs";
@@ -22,7 +23,8 @@ function shellQuote(s) {
 }
 
 function resolvePlaceholder(k, resolvedInputs, resolvedOutputs, opts) {
-  const { instanceId, currentExecId, runDir } = opts;
+  const { instanceId, currentExecId, runDir, extra = {} } = opts;
+  if (Object.prototype.hasOwnProperty.call(extra, k)) return extra[k];
   const execId = currentExecId ?? 1;
   const toAbs = (rel) => (runDir && rel ? path.join(runDir, rel) : rel);
   if (k.startsWith("input.")) {
@@ -76,6 +78,39 @@ function resolveScriptCommand(
   });
 }
 
+function marketplaceRuntimeCommand(marketplaceNode, resolvedInputs, resolvedOutputs, opts) {
+  if (!marketplaceNode || !marketplaceNode.runtime) return "";
+  const runtime = marketplaceNode.runtime;
+  const packageDir = marketplaceNode.packageDir;
+  const entry = runtime.entry ? path.join(packageDir, String(runtime.entry)) : "";
+  const language = String(runtime.language || "").trim();
+  const runner =
+    language === "python"
+      ? "python3"
+      : language === "bash"
+        ? "bash"
+        : language === "nodejs" || entry
+          ? "node"
+          : "";
+  const args = Array.isArray(runtime.args) ? runtime.args.map((x) => String(x)).join(" ") : "";
+  const command = runtime.command
+    ? String(runtime.command)
+    : entry
+      ? [runner, "${entry}", args].filter(Boolean).join(" ")
+      : "";
+  if (!command) return "";
+  return resolveScriptCommand(command, resolvedInputs, resolvedOutputs, {
+    ...opts,
+    extra: {
+      ...(opts.extra || {}),
+      entry,
+      packageDir,
+      workspaceRoot: opts.workspaceRoot || "",
+      runDir: opts.runDir || "",
+    },
+  });
+}
+
 /**
  * 执行占位符替换，组装 prompt 并写入 intermediate 文件（文件名带 _execId）。
  * @param {number} [execId] - 本轮 execId，缺省则从 memory 读取
@@ -105,6 +140,10 @@ export function buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, execI
 
   const flowData = loadFlowDefinition(flowDir);
   const inst = flowData?.instances?.[instanceId];
+  const marketplaceNode =
+    inst?.definitionId && isMarketplaceDefinitionId(inst.definitionId)
+      ? resolveMarketplaceNodePackage(workspaceRoot, flowDir, inst.definitionId, flowData)
+      : null;
   const instanceBody =
     inst?.body != null
       ? String(inst.body || "").trim()
@@ -115,7 +154,7 @@ export function buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, execI
       : "";
 
   const { resolvedInputs = {}, resolvedOutputs = {}, systemPrompt = "" } = data;
-  const resolveOpts = { instanceId, currentExecId: e, runDir };
+  const resolveOpts = { instanceId, currentExecId: e, runDir, workspaceRoot };
   const taskBody = resolvePlaceholdersInText(
     instanceBody,
     resolvedInputs,
@@ -125,6 +164,8 @@ export function buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, execI
 
   const resolvedScript = instanceScript
     ? resolveScriptCommand(instanceScript, resolvedInputs, resolvedOutputs, resolveOpts)
+    : marketplaceNode
+      ? marketplaceRuntimeCommand(marketplaceNode, resolvedInputs, resolvedOutputs, resolveOpts)
     : "";
 
   const content = `## 节点上下文

package/bin/pipeline/get-ready-nodes.mjs

@@ -248,7 +248,7 @@ function main() {
     for (const id of pendingInstances) {
       if (instanceStatus[id] !== "success") continue;
       nextPending.delete(id);
-      if (nodeDefinitions[id] === "control_if" || nodeDefinitions[id] === "tool_user_ask") {
+      if (nodeDefinitions[id] === "control_if" || nodeDefinitions[id] === "tool_user_ask" || nodeDefinitions[id] === "control_interval_loop") {
         const predLatestE = latestResultExecId(execIdMap[id] ?? 1);
         const resultPath = predLatestE
           ? path.join(intermediateDir, id, intermediateResultBasename(id, predLatestE))
@@ -309,7 +309,7 @@ function main() {
     /** 判断 predecessor P 对 target N 是否算「就绪」：普通节点看 status；control_if / tool_user_ask 看 branch 与出边 sourceHandle */
     const isPredecessorReadyFor = (predSource, predDefId, targetId) => {
       if (instanceStatus[predSource] !== "success") return false;
-      if (predDefId !== "control_if" && predDefId !== "tool_user_ask") return true;
+      if (predDefId !== "control_if" && predDefId !== "tool_user_ask" && predDefId !== "control_interval_loop") return true;
       const inEdges = inEdgesByTarget[targetId] || [];
       const edge = inEdges.find((ie) => ie.source === predSource);
       if (!edge) return true;

package/bin/pipeline/get-resolved-values.mjs

@@ -10,6 +10,7 @@ import fs from "fs";
 import path from "path";
 
 import { getRunDir, LEGACY_NODES_DIR, PIPELINES_DIR, PROJECT_NODES_DIR } from "../lib/paths.mjs";
+import { isMarketplaceDefinitionId, resolveMarketplaceNodePackage } from "../lib/marketplace.mjs";
 import { getFlowDir } from "../lib/workspace.mjs";
 import { fileURLToPath } from "url";
 
@@ -102,6 +103,11 @@ function extractDescriptionFromFrontmatter(frontmatter) {
 }
 
 function readNodeDescription(workspaceRoot, flowDir, definitionId) {
+  if (isMarketplaceDefinitionId(definitionId)) {
+    const flowData = loadFlowDefinition(flowDir);
+    const resolved = resolveMarketplaceNodePackage(workspaceRoot, flowDir, definitionId, flowData);
+    if (resolved?.description) return resolved.description;
+  }
   const fileName = definitionId.endsWith(".md") ? definitionId : `${definitionId}.md`;
   const flowNodesPath = path.join(flowDir, "nodes", fileName);
   const projectNodesNew = path.join(workspaceRoot, PROJECT_NODES_DIR, fileName);