@fieldwangai/agentflow 0.1.26 → 0.1.28

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

@@ -26,11 +26,9 @@ import { updateModelLists } from "./model-lists.mjs";
 import {
   startComposerAgent,
   startComposerMultiStep,
-  shouldUseMultiStep,
   runComposerPostFlowValidationAndRepair,
   buildScriptContentBlockForInstances,
 } from "./composer-agent.mjs";
-import { buildNodeSchemaCompactSection } from "./composer-node-schema.mjs";
 import { t } from "./i18n.mjs";
 import {
   PACKAGE_ROOT,
@@ -42,6 +40,8 @@ import { RUN_INTERRUPTED_FILENAME } from "./recent-runs.mjs";
 import {
   detectIntents,
   loadResourcesForIntents,
+  loadResourcesForSkillKeys,
+  listComposerSkills,
   buildSkillInjectionBlock,
   buildSkillCompactInjectionBlock,
 } from "./composer-skill-router.mjs";
@@ -64,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",
@@ -276,10 +277,6 @@ function buildComposerPromptWithFlowContext(p) {
   const flowDirAbs = path.dirname(p.flowYamlAbs);
   const idsLine =
     p.instanceIds.length > 0 ? p.instanceIds.map(String).join(", ") : "（无，可能为全局修改或新增节点）";
-  const syncFs = p.editorSyncFlowSource ?? p.flowSource;
-  const syncBody = { flowId: p.flowId, flowSource: syncFs };
-  if (p.flowArchived) syncBody.flowArchived = true;
-  const syncJsonArg = JSON.stringify(JSON.stringify(syncBody));
   const builtinExtra =
     p.flowSource === "builtin" && p.workspaceWriteDirAbs
       ? [
@@ -288,23 +285,6 @@ function buildComposerPromptWithFlowContext(p) {
         ]
       : [];
 
-  // 基于用户意图动态注入 skill 和 reference 内容
-  const intents = detectIntents(p.userPrompt);
-  const resources = loadResourcesForIntents(intents, PACKAGE_ROOT);
-  const skillBlock = resources.hasContext
-    ? buildSkillInjectionBlock(resources.skills, resources.references)
-    : "";
-
-  // 无意图匹配时使用通用 skill 路径引用作为兜底
-  const skillPathHints = resources.hasContext
-    ? []
-    : [
-        "- 新增实例与边：遵循 skill `skills/agentflow-flow-add-instances/SKILL.md`（或 `.cursor/skills/.../SKILL.md`）。",
-        "- 仅改已有实例文案/占位等：遵循 `skills/agentflow-flow-edit-node-fields/SKILL.md`，勿改 definitionId、instanceId、IO 结构与边拓扑。",
-      ];
-
-  const nodeSchemaSection = buildNodeSchemaCompactSection();
-
   const prefix = [
     "## AgentFlow Composer 上下文",
     `- 流水线目录（flowId=${p.flowId}）：${flowDirAbs}`,
@@ -313,33 +293,15 @@ function buildComposerPromptWithFlowContext(p) {
     `- flowSource：${p.flowSource}`,
     ...builtinExtra,
     `- 当前关联的节点实例 ID（顺序：画布选中优先，再输入框 @提及）：${idsLine}`,
-    "- 请根据用户需求自行判断：如果是在问问题，只回答；如果是在要求新增、修改、完善或修复流程，请直接修改对应文件。",
-    "- 一旦修改 flow.yaml、脚本或相关文件，必须按下方方式刷新 Web 画布。",
-    ...skillPathHints,
-    "",
-    "### 节点能力选择",
-    "**判据**：确定性任务优先 `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 写期望执行的逻辑**",
-    "- 如果无法写出完整可执行的 script（需要 AI 理解/判断），**必须改用 agent_subAgent**，不要用 tool_nodejs",
-    "- script 支持多行（YAML `|`）和管道，可写复杂的 curl + node 组合",
-    "- **禁止**：tool_nodejs 只有 body 没有 script（body 中的自然语言不会被执行，节点会失败）",
-    "",
-    // 动态注入的 skill 和 reference 内容
-    ...(skillBlock ? [skillBlock, ""] : []),
-    "- **保存 flow.yaml 后必须刷新 Web 画布**：遵循 `skills/agentflow-flow-sync-ui/SKILL.md`；在终端执行（将 JSON 与上方 flowId、flowSource" +
-      (p.flowArchived ? "、flowArchived" : "") +
-      " 保持一致）：",
-    `  curl -sS -X POST http://127.0.0.1:${p.uiPort}/api/flow-editor-sync -H 'Content-Type: application/json' -d ${syncJsonArg}`,
+    "- 像普通 agent 请求一样处理用户说明：可能只是问问题，也可能要求编辑文件。不要因为存在 flowId 就默认修改 flow.yaml。",
+    "- 按需使用当前环境可用的 skills；如果用户点名某个 skill，遵循该 skill 的 SKILL.md。",
+    "- 如果你判断需要编辑 AgentFlow 流程，可按需读取这些本地 skills：",
+    "  - `skills/agentflow-flow-add-instances/SKILL.md`：新增实例、边和布局",
+    "  - `skills/agentflow-flow-edit-node-fields/SKILL.md`：只改已有节点字段",
+    "  - `skills/agentflow-flow-sync-ui/SKILL.md`：保存 flow.yaml 后刷新画布",
+    "- 如果只是回答问题，不要修改文件。",
     "",
+    ...(p.selectedSkillBlock ? [p.selectedSkillBlock, ""] : []),
     ...(p.thread && p.thread.length > 0
       ? [formatThreadHistory(p.thread), ""]
       : []),
@@ -351,6 +313,15 @@ function buildComposerPromptWithFlowContext(p) {
   return prefix;
 }
 
+function flowYamlChangedSince(flowYamlAbs, beforeText) {
+  if (!flowYamlAbs || beforeText == null) return false;
+  try {
+    return fs.readFileSync(flowYamlAbs, "utf-8") !== beforeText;
+  } catch {
+    return false;
+  }
+}
+
 function normalizeContextInstanceIds(raw) {
   if (raw == null) return [];
   if (!Array.isArray(raw)) return [];
@@ -885,6 +856,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";
@@ -1637,6 +1679,11 @@ finishedAt: "${new Date().toISOString()}"
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/skills") {
+      json(res, 200, { skills: listComposerSkills(PACKAGE_ROOT, root) });
+      return;
+    }
+
     if (req.method === "POST" && url.pathname === "/api/composer-agent") {
       let payload;
       try {
@@ -1656,6 +1703,9 @@ finishedAt: "${new Date().toISOString()}"
         json(res, 400, { error: "Invalid model" });
         return;
       }
+      const selectedSkillKeys = Array.isArray(payload.selectedSkills)
+        ? payload.selectedSkills.map((x) => String(x || "").trim()).filter(Boolean).slice(0, 20)
+        : [];
 
       const flowIdRaw = payload.flowId;
       const flowSourceRaw = payload.flowSource;
@@ -1678,6 +1728,8 @@ finishedAt: "${new Date().toISOString()}"
       let flowSource = null;
       let instanceIds = [];
       let flowContextForMultiStep = null;
+      let flowYamlBefore = null;
+      const hasPhaseContext = payload.phaseContext && typeof payload.phaseContext === "object" && typeof payload.phaseContext.phaseIndex === "number";
 
       if (hasFlowId) {
         flowId = String(flowIdRaw).trim();
@@ -1693,6 +1745,7 @@ finishedAt: "${new Date().toISOString()}"
           return;
         }
         flowYamlAbs = yamlRes.path;
+        try { flowYamlBefore = fs.readFileSync(flowYamlAbs, "utf-8"); } catch { flowYamlBefore = null; }
         let workspaceWriteDirAbs;
         let editorSyncFlowSource = flowSource;
         let flowDirForCli = path.dirname(flowYamlAbs);
@@ -1713,10 +1766,18 @@ finishedAt: "${new Date().toISOString()}"
         if (flowArchived) syncBody.flowArchived = true;
         const syncJsonArg = JSON.stringify(JSON.stringify(syncBody));
 
-        // 基于用户意图动态加载 skill 上下文
+        // 多步分阶段仍需要技能上下文；普通 Composer 请求直接交给 agent + skills 自行判断。
         const multiStepIntents = detectIntents(prompt);
-        const multiStepResources = loadResourcesForIntents(multiStepIntents, PACKAGE_ROOT);
+        const selectedSkillResources = selectedSkillKeys.length > 0
+          ? loadResourcesForSkillKeys(selectedSkillKeys, PACKAGE_ROOT, root)
+          : { skills: [], references: [], skillsHint: "", hasContext: false };
+        const multiStepResources = selectedSkillResources.hasContext
+          ? selectedSkillResources
+          : loadResourcesForIntents(multiStepIntents, PACKAGE_ROOT);
         const flowPipelineDir = flowYamlAbs ? path.dirname(flowYamlAbs) : "";
+        const selectedSkillBlock = selectedSkillResources.hasContext
+          ? buildSkillInjectionBlock(selectedSkillResources.skills, selectedSkillResources.references)
+          : "";
 
         flowContextForMultiStep = {
           flowYamlAbs,
@@ -1746,6 +1807,7 @@ finishedAt: "${new Date().toISOString()}"
           flowArchived,
           thread,
           scriptContentBlock,
+          selectedSkillBlock,
         });
         cliWorkspace = composerCliWorkspaceForFlowDir(root, flowDirForCli);
       }
@@ -1837,10 +1899,9 @@ finishedAt: "${new Date().toISOString()}"
       onStreamEvent({ type: "status", line: t("composer.analyzing_task") });
       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";
       let useMultiStep;
       try {
-        useMultiStep = hasPhaseContext || ((await shouldUseMultiStep({ flowYamlAbs, userPrompt: prompt.trim(), cliWorkspace })) && !payload.singleStep);
+        useMultiStep = hasPhaseContext && !payload.singleStep;
       } catch (classifyErr) {
         log.debug(`[ui] composer classify error: ${classifyErr.message}`);
         logComposerEvent(composerLogPath, "composer-done", {
@@ -1937,7 +1998,8 @@ finishedAt: "${new Date().toISOString()}"
                 endSafe();
                 return;
               }
-              if (flowYamlAbs && flowContextForMultiStep) {
+              const flowYamlChanged = flowYamlChangedSince(flowYamlAbs, flowYamlBefore);
+              if (flowYamlChanged && flowYamlAbs && flowContextForMultiStep) {
                 try {
                   await runComposerPostFlowValidationAndRepair({
                     uiWorkspaceRoot: root,
@@ -1966,7 +2028,7 @@ finishedAt: "${new Date().toISOString()}"
                   flowId: flowId || null,
                   flowSource: flowSource || null,
                 });
-                if (flowId && flowSource) {
+                if (flowYamlChanged && flowId && flowSource) {
                   broadcastFlowEditorSync(flowId, flowSource, Boolean(payload.flowArchived));
                 }
                 try { res.write(JSON.stringify({ type: "done" }) + "\n"); } catch (_) {}

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;