@fieldwangai/agentflow 0.1.62 → 0.1.63

package/bin/lib/ui-server.mjs

@@ -1948,13 +1948,23 @@ function workspaceExtractLooseResult(raw) {
   return "";
 }
 
+function workspaceNormalizeAgentflowEnvelopeBody(body) {
+  let text = String(body || "").replace(/\r\n/g, "\n").trim();
+  if (!text.includes("\n")) {
+    text = text
+      .replace(/\s+(resultFile|result|outParams|outParams\.[A-Za-z_][A-Za-z0-9_-]*)\s*:/g, "\n$1:")
+      .replace(/(^|\n)outParams:\s+([A-Za-z_][A-Za-z0-9_-]*\s*:)/g, "$1outParams:\n  $2");
+  }
+  return text;
+}
+
 function workspaceExtractAgentflowEnvelope(raw) {
   const text = String(raw || "");
-  const match = text.match(/(?:^|\n)---agentflow\s*\n([\s\S]*?)\n---end(?:\n|$)/i);
+  const match = text.match(/---agentflow\b([\s\S]*?)---end/i);
   if (!match) return null;
-  const envelope = match[1] || "";
+  const envelope = workspaceNormalizeAgentflowEnvelopeBody(match[1] || "");
   const outside = `${text.slice(0, match.index || 0)}\n${text.slice((match.index || 0) + match[0].length)}`.trim();
-  const lines = envelope.replace(/\r\n/g, "\n").split("\n");
+  const lines = envelope.split("\n");
   const outParams = {};
   let result = "";
   let resultFile = "";
@@ -1986,7 +1996,7 @@ function workspaceExtractAgentflowEnvelope(raw) {
       i += 1;
       continue;
     }
-    const top = line.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/);
+    const top = line.match(/^([A-Za-z_][A-Za-z0-9_.-]*)\s*:\s*(.*)$/);
     if (!top) {
       i += 1;
       continue;
@@ -2002,7 +2012,7 @@ function workspaceExtractAgentflowEnvelope(raw) {
           continue;
         }
         if (lineIndent(childLine) === 0) break;
-        const child = childLine.match(/^\s+([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/);
+        const child = childLine.match(/^\s+([A-Za-z_][A-Za-z0-9_.-]*)\s*:\s*(.*)$/);
         if (!child) {
           i += 1;
           continue;
@@ -2017,6 +2027,7 @@ function workspaceExtractAgentflowEnvelope(raw) {
     const parsed = parseValue(rawValue, i, 0);
     if (key === "result") result = String(parsed.value || "");
     else if (key === "resultFile") resultFile = String(parsed.value || "").trim();
+    else if (key.startsWith("outParams.")) outParams[key.slice("outParams.".length)] = String(parsed.value || "").trim();
     else if (key) outParams[key] = String(parsed.value || "").trim();
     i = parsed.nextIndex;
   }
@@ -2031,8 +2042,8 @@ function workspaceExtractAgentflowEnvelope(raw) {
 
 function workspaceCanonicalAgentOutput(content) {
   const raw = String(content || "").trim();
-  const match = raw.match(/(?:^|\n)(---agentflow\s*\n[\s\S]*?\n---end)(?:\n|$)/i);
-  if (match?.[1]) return match[1].trim();
+  const match = raw.match(/---agentflow\b[\s\S]*?---end/i);
+  if (match?.[0]) return match[0].trim();
   return raw;
 }
 
@@ -2055,6 +2066,7 @@ function workspaceStructuredAgentOutput(content) {
     return { result: raw, outParams: {}, structured: false, parsed: null };
   }
   const hasEnvelope = Object.prototype.hasOwnProperty.call(parsed, "result") ||
+    Object.prototype.hasOwnProperty.call(parsed, "resultFile") ||
     Object.prototype.hasOwnProperty.call(parsed, "outParams");
   if (!hasEnvelope) return { result: raw, outParams: {}, structured: false, parsed };
   const outParamsRaw = parsed.outParams && typeof parsed.outParams === "object" && !Array.isArray(parsed.outParams)
@@ -2195,6 +2207,57 @@ function workspaceDisplayTextFilePath(value, kind = "") {
   return allowed.has(ext) ? clean : "";
 }
 
+function workspaceSafeNodeOutputRelPath(value) {
+  const text = String(value || "").trim().replace(/^["']|["']$/g, "");
+  if (!text || text.length > 260) return "";
+  if (/[\r\n<>]/.test(text)) return "";
+  if (/^(?:https?:|data:|blob:|file:|javascript:|mailto:|tel:)/i.test(text)) return "";
+  const clean = text.replace(/^\/+/, "");
+  if (clean.includes("..") || clean.startsWith(".") || path.isAbsolute(clean)) return "";
+  if (!clean.startsWith("outputs/")) return "";
+  return clean;
+}
+
+function workspacePublishNodeOutputFile(runPackage, relPath) {
+  if (!String(relPath || "").trim()) return "";
+  const clean = workspaceSafeNodeOutputRelPath(relPath);
+  if (!clean) throw new Error(`Agent returned an invalid output file path: ${String(relPath || "").trim()}`);
+  const nodeRunDir = path.resolve(runPackage?.nodeRunDir || "");
+  const workspaceOutputsDir = path.resolve(runPackage?.workspaceOutputsDir || "");
+  if (!nodeRunDir || !workspaceOutputsDir) return clean;
+  const src = path.resolve(nodeRunDir, clean);
+  const nodeRootWithSep = nodeRunDir.endsWith(path.sep) ? nodeRunDir : `${nodeRunDir}${path.sep}`;
+  if (src !== nodeRunDir && !src.startsWith(nodeRootWithSep)) {
+    throw new Error(`Invalid node output path: ${clean}`);
+  }
+  if (!fs.existsSync(src) || !fs.statSync(src).isFile()) {
+    throw new Error(`Agent returned resultFile but did not create it under node outputs: ${clean}`);
+  }
+  const destRel = clean.slice("outputs/".length);
+  const dest = path.resolve(workspaceOutputsDir, destRel);
+  const workspaceOutputsWithSep = workspaceOutputsDir.endsWith(path.sep) ? workspaceOutputsDir : `${workspaceOutputsDir}${path.sep}`;
+  if (dest !== workspaceOutputsDir && !dest.startsWith(workspaceOutputsWithSep)) {
+    throw new Error(`Invalid workspace output path: ${clean}`);
+  }
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+  return clean;
+}
+
+function workspacePublishAgentOutputFiles(structured, runPackage) {
+  if (!structured?.structured || !runPackage) return structured;
+  const resultFile = workspacePublishNodeOutputFile(runPackage, structured.resultFile);
+  const outParams = { ...(structured.outParams || {}) };
+  for (const [key, value] of Object.entries(outParams)) {
+    if (!String(key || "").endsWith("File")) continue;
+    const published = workspacePublishNodeOutputFile(runPackage, value);
+    if (published) outParams[key] = published;
+  }
+  return resultFile || Object.keys(outParams).length
+    ? { ...structured, result: resultFile || structured.result, resultFile: resultFile || structured.resultFile, outParams }
+    : structured;
+}
+
 function workspaceOutputFieldForSlot(slot, index = 0) {
   const name = String(slot?.name || "").trim();
   if (!name || name === "result" || name === "content" || index === 0) return "result";
@@ -2212,19 +2275,6 @@ function workspaceDisplayKindExample(kind, field) {
   return `<${field} 的值>`;
 }
 
-function workspaceDisplayFieldRule(kind, field, slotName = "") {
-  const slotText = field === "result" ? "`result` 或 `resultFile`" : `\`${field}\` 或 \`${field}File\``;
-  const prefix = slotName ? `- 输出引脚 \`${slotName}\` 连接了 ${kind} 展示节点：` : `- 下游连接了 ${kind} 展示节点：`;
-  if (kind === "html") return `${prefix}将可直接放入 iframe 渲染的 HTML 放在 ${slotText} 中；内容较长时优先写入 outputs/*.html 并返回文件路径。不要使用 Markdown 代码围栏。`;
-  if (kind === "markdown") return `${prefix}将 Markdown 正文放在 ${slotText} 中；内容较长时优先写入 outputs/*.md 并返回文件路径。除非正文确实需要代码块，否则不要额外包裹代码围栏。`;
-  if (kind === "mermaid") return `${prefix}将 Mermaid 图表代码放在 ${slotText} 中，例如 flowchart/sequenceDiagram；不要使用 Markdown 代码围栏。`;
-  if (kind === "ascii") return `${prefix}将纯文本/ASCII 图或表格放在 ${slotText} 中；不要输出 HTML 或 Markdown 装饰。`;
-  if (kind === "image") return `${prefix}将可作为 img src 使用的图片地址、data URL 或 base64 data URL 放在 ${slotText} 中；不要输出 Markdown 图片语法。`;
-  if (kind === "chart") return `${prefix}将 ChartSpec JSON 对象放在 ${slotText} 中。ChartSpec 必须包含 "type":"chart"、"version":"1.0"、"renderer":"echarts"、"option"；option.series[].type 只使用 line/bar/pie/scatter/radar/heatmap/tree/treemap/sunburst/sankey/graph/gauge/funnel；不要输出 HTML、script、iframe 或 JS 函数。`;
-  if (kind === "table") return `${prefix}将表格数据放在 ${slotText} 中。推荐格式：{"columns":["列名1","列名2"],"rows":[["值1","值2"]]}；也可使用对象数组、Markdown 表格、CSV 或 TSV。不要输出 HTML。`;
-  return `${prefix}将展示内容放在 ${slotText} 中。`;
-}
-
 function workspaceDownstreamOutputDisplayBindings(graph, nodeId) {
   const instances = graph?.instances && typeof graph.instances === "object" ? graph.instances : {};
   const edges = Array.isArray(graph?.edges) ? graph.edges : [];
@@ -2284,45 +2334,24 @@ function normalizeHtmlDisplayContent(content) {
   return text;
 }
 
-function workspaceDownstreamDisplayRequirements(graph, nodeId) {
-  const bindings = workspaceDownstreamOutputDisplayBindings(graph, nodeId);
-  if (bindings.length === 0) return "";
-  const seen = new Set();
-  const rules = [];
-  for (const binding of bindings) {
-    const key = `${binding.field}:${binding.kind}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    rules.push(workspaceDisplayFieldRule(binding.kind, binding.field, binding.name));
-  }
-  return [
-    "## 下游输出要求",
-    "",
-    ...rules,
-    "",
-    "这些要求按输出引脚分别生效：不要把非 `result` 引脚连接的展示内容误写到 `result`；具名引脚应写入 `outParams.<引脚名>`。",
-    "如果用户任务与下游展示格式没有冲突，优先满足上述格式要求；如果用户明确指定了其他格式，以用户任务为准。",
-  ].join("\n");
+function workspaceBodyPlaceholderNames(body) {
+  const names = new Set();
+  const raw = String(body || "");
+  raw.replace(/\$\{([A-Za-z_][A-Za-z0-9_-]*)\}/g, (_match, name) => {
+    if (name) names.add(String(name));
+    return _match;
+  });
+  return names;
 }
 
-function workspaceNodeScopeGuardrails(graph, nodeId, inputValues = {}) {
-  const edges = Array.isArray(graph?.edges) ? graph.edges : [];
-  const directInputEdges = edges
-    .filter((edge) => String(edge?.target || "") === String(nodeId))
-    .filter((edge) => !isWorkspaceSemanticInputSlot(workspaceTargetSlotForEdge(graph, edge)));
-  const upstreamNodeIds = Array.from(new Set(directInputEdges.map((edge) => String(edge?.source || "").trim()).filter(Boolean)));
-  const inputNames = Object.keys(inputValues || {}).filter(Boolean);
-  return [
-    "## 当前节点上下文边界",
-    "",
-    "你只负责执行当前节点；`上游上下文`、已解析输入槽和节点任务就是本节点的业务上下文边界。",
-    upstreamNodeIds.length ? `当前直接上游节点：${upstreamNodeIds.map((id) => `\`${id}\``).join("、")}。` : "当前没有直接业务上游节点。",
-    inputNames.length ? `当前已解析输入槽：${inputNames.map((name) => `\`${name}\``).join("、")}。` : "当前没有已解析的具名业务输入槽。",
-    "不要为了理解本节点而读取或搜索整张 workspace、`workspace.graph.json`、正式 `flow.yaml`、历史 run/log 或其它未连接节点。",
-    "不要把下游展示节点已有内容、下游错误信息、其它分支节点内容当作本节点输入；下游输出要求只用于决定输出字段和格式。",
-    "只有当当前节点任务文本或上游输入明确要求读取/修改 `workspace.graph.json`、`flow.yaml` 或某个具体文件路径时，才可以打开对应文件。",
-    "如果完成任务所需信息不在当前节点任务、输入槽或上游上下文中，应明确说明缺少哪个上游输入，而不是扫描整张 workspace 猜测。",
-  ].join("\n");
+function workspaceRelevantInputValues(body, inputValues = {}) {
+  const placeholders = workspaceBodyPlaceholderNames(body);
+  if (!placeholders.size) return { values: inputValues || {}, placeholders };
+  const values = {};
+  for (const [name, value] of Object.entries(inputValues || {})) {
+    if (placeholders.has(name)) values[name] = value;
+  }
+  return { values, placeholders };
 }
 
 function workspaceOutputProtocolRequirements(graph, nodeId) {
@@ -2340,39 +2369,46 @@ function workspaceOutputProtocolRequirements(graph, nodeId) {
       return name && type !== "node" && name !== "next" && name !== "result" && name !== "content";
     })
     .map((slot) => String(slot.name).trim());
-  const outParamsExample = slots.length
-    ? Object.fromEntries(slots.map((name) => [name, workspaceDisplayKindExample(displayByField.get(`outParams.${name}`) || "", name)]))
-    : {};
-  const resultExample = workspaceDisplayKindExample(displayByField.get("result") || "markdown", "result");
-  const slotDisplayRules = displayBindings
-    .map((binding) => `- 输出引脚 \`${binding.name}\` -> ${binding.kind} 展示节点：写入 \`${binding.field}\`。`)
-    .filter((line, index, arr) => arr.indexOf(line) === index);
+  const resultKind = displayByField.get("result") || "";
+  const resultExtByKind = {
+    html: "html",
+    markdown: "md",
+    mermaid: "mmd",
+    ascii: "txt",
+    chart: "json",
+    table: "json",
+  };
+  const resultExt = resultExtByKind[resultKind] || "txt";
+  const resultFile = `outputs/result.${resultExt}`;
+  const resultKindText = resultKind ? ` ${resultKind}` : "";
+  const resultGuidance = {
+    html: "内容必须是可直接放入 iframe 渲染的 HTML；不要使用 Markdown 代码围栏。",
+    markdown: "内容必须是 Markdown 正文；除非正文确实需要代码块，否则不要额外包裹代码围栏。",
+    mermaid: "内容必须是 Mermaid 图表代码，例如 flowchart/sequenceDiagram；不要使用 Markdown 代码围栏。",
+    ascii: "内容必须是纯文本/ASCII 图或表格；不要输出 HTML 或 Markdown 装饰。",
+    image: "内容必须是可作为 img src 使用的图片地址、data URL 或 base64 data URL；不要输出 Markdown 图片语法。",
+    chart: "内容必须是 ChartSpec JSON 对象，包含 type/version/renderer/option；不要输出 HTML、script、iframe 或 JS 函数。",
+    table: "内容必须是表格数据，推荐 JSON：{\"columns\":[...],\"rows\":[...]}；不要输出 HTML。",
+  }[resultKind] || "内容应满足任务要求。";
   const envelopeExample = [
     "---agentflow",
-    "resultFile: outputs/result.html",
+    `resultFile: ${resultFile}`,
     slots.length ? "outParams:" : "",
-    ...slots.slice(0, 3).map((name) => `  ${name}: <${name} 的短值>`),
+    ...slots.slice(0, 3).map((name) => {
+      const kind = displayByField.get(`outParams.${name}`) || "";
+      const ext = resultExtByKind[kind] || "txt";
+      return kind ? `  ${name}File: outputs/${name}.${ext}` : `  ${name}: <${name} 的短值>`;
+    }),
     "---end",
   ].filter(Boolean).join("\n");
   return [
-    "## Workspace 输出协议",
+    "## 输出",
     "",
-    "如果只有一个默认输出，直接输出正文即可，系统会写入 `result` / `content` 输出口。",
-    "如果需要多个输出，或需要返回文件路径，最后输出一个轻量 envelope；不要把大段 HTML/Markdown/SQL 包进 JSON 字符串。",
-    "长内容、HTML、Markdown、SQL、CSV、图片等 artifact 优先写入当前 workspace 的 `outputs/` 目录，然后在 `resultFile` 或 `outParams.<name>File` 返回相对路径。",
-    "普通 assistant 文本会被当作本节点输出内容；执行过程中不要发送进度说明、解释或寒暄，例如“正在读取/正在生成/准备输出”。需要思考时只使用内部 thinking，最终只发送正文或 envelope。",
-    "envelope 格式：",
+    `请把${resultKindText}结果写入 \`${resultFile}\`。${resultGuidance}`,
+    ...(slots.length ? [`额外输出：${slots.map((name) => `\`${name}\``).join("、")}。短值可写在 \`outParams\`，文件值写成 \`outParams.<name>File\`。`] : []),
+    "最终只输出下面的 agentflow envelope，不要输出解释、进度或其它文字：",
     "",
     envelopeExample,
-    "",
-    "- `result`：默认输出正文；`resultFile`：默认输出对应的 workspace 相对文件路径。",
-    "- `outParams`：具名输出参数；`outParams.<name>File`：具名输出对应的 workspace 相对文件路径。",
-    "- 旧格式 `{ \"result\": ..., \"outParams\": ... }` 仍兼容，但新输出优先使用正文或 envelope。",
-    ...(slotDisplayRules.length ? ["- 当前输出引脚与展示节点映射：", ...slotDisplayRules] : []),
-    ...(slots.length
-      ? [`- 当前节点具名输出槽：${slots.map((name) => `\`${name}\``).join("、")}。例如任务要求写入 \`${slots[0]}\` 时，放到 \`outParams.${slots[0]}\`；如果写成文件，放到 \`outParams.${slots[0]}File\`。`]
-      : ["- 当前节点没有额外具名输出槽；只有默认输出时不需要 envelope。"]),
-    "- 如果 `result` 需要承载表格、ChartSpec 等短结构化内容，可以直接输出对象或正文；系统会转换给下游展示节点。",
   ].join("\n");
 }
 
@@ -2458,79 +2494,44 @@ function isWorkspaceSemanticInputSlot(slot) {
   return type === "node" || name === "prev" || name === "next" || name === "skillsContext" || name === "mcpContext" || name === "workspaceContext" || name === "gitContext";
 }
 
-function workspaceNodeBrief(graph, nodeId) {
-  const instance = graph?.instances?.[String(nodeId || "")] || {};
-  const label = String(instance?.label || nodeId || "").trim();
-  const defId = String(instance?.definitionId || "").trim();
-  return defId && defId !== label ? `${label || nodeId} (${defId})` : (label || nodeId);
-}
-
-function workspaceSlotBrief(slot, fallback) {
-  const name = String(slot?.name || "").trim();
-  const type = String(slot?.type || "").trim();
-  return `${name || fallback}${type ? `:${type}` : ""}`;
-}
-
-function workspaceNodeConnectionContextBlock(graph, nodeId) {
-  const edges = Array.isArray(graph?.edges) ? graph.edges : [];
-  const incoming = edges.filter((edge) => String(edge?.target || "") === String(nodeId));
-  const outgoing = edges.filter((edge) => String(edge?.source || "") === String(nodeId));
-  const inputLines = incoming.map((edge) => {
-    const sourceSlot = workspaceSourceSlotForEdge(graph, edge);
-    const targetSlot = workspaceTargetSlotForEdge(graph, edge);
-    const targetName = String(targetSlot?.name || "").trim();
-    const semantic = isWorkspaceSemanticInputSlot(targetSlot) ? "上下文输入" : "业务输入";
-    return `- ${workspaceNodeBrief(graph, edge.source)} \`${workspaceSlotBrief(sourceSlot, edge.sourceHandle || "output")}\` -> 当前 \`${workspaceSlotBrief(targetSlot, edge.targetHandle || "input")}\`（${semantic}${targetName ? `：${targetName}` : ""}）`;
-  });
-  const outputLines = outgoing.map((edge) => {
-    const sourceSlot = workspaceSourceSlotForEdge(graph, edge);
-    const targetSlot = workspaceTargetSlotForEdge(graph, edge);
-    const targetKind = workspaceDisplayKind(graph?.instances?.[String(edge?.target || "")]?.definitionId);
-    return `- 当前 \`${workspaceSlotBrief(sourceSlot, edge.sourceHandle || "output")}\` -> ${workspaceNodeBrief(graph, edge.target)} \`${workspaceSlotBrief(targetSlot, edge.targetHandle || "input")}\`${targetKind ? `（${targetKind} 展示）` : ""}`;
-  });
-  if (!inputLines.length && !outputLines.length) return "";
-  return [
-    "## 当前节点连线",
-    "",
-    inputLines.length ? "### 直接上游" : "",
-    ...inputLines,
-    outputLines.length ? "\n### 直接下游" : "",
-    ...outputLines,
-    "",
-    "只把直接上游的业务输入和上下文输入当作本节点依据；直接下游只用于确定输出字段和格式。",
-  ].filter(Boolean).join("\n");
-}
-
-function workspaceResolvedInputValuesBlock(inputValues = {}) {
+function workspaceAgentInputBlock(inputValues = {}) {
   const entries = Object.entries(inputValues || {}).filter(([name, value]) => String(name || "").trim() && String(value || "").trim());
-  if (!entries.length) return "";
+  if (!entries.length) return "## 输入\n\n无。";
   const lines = entries.map(([name, value]) => {
     const text = String(value || "");
     const clipped = text.length > 6000 ? `${text.slice(0, 6000)}\n...[已截断 ${text.length - 6000} 字]` : text;
     return `### ${name}\n\n${clipped}`;
   });
-  return ["## 已解析业务输入槽", "", ...lines].join("\n");
+  return ["## 输入", "", ...lines].join("\n");
 }
 
-function workspaceNodeTmpDirectoryBlock(nodeTmpDir) {
-  const dir = String(nodeTmpDir || "").trim();
-  if (!dir) return "";
+function workspaceNodeFileBoundaryBlock(runPackage = {}) {
+  const nodeRunDir = String(runPackage?.nodeRunDir || "").trim();
+  const nodeTmpDir = String(runPackage?.nodeTmpDir || "").trim();
+  const outputsRel = String(runPackage?.outputsRel || "outputs").trim() || "outputs";
+  if (!nodeRunDir && !nodeTmpDir) return "";
   return [
-    "## 临时文件目录",
+    "## 文件边界",
     "",
-    `- 本节点专用临时目录：\`${dir}\``,
-    "- 如果确实需要创建中间文件，只能写入该目录，路径也可通过环境变量 `AGENTFLOW_NODE_TMP_DIR` 获取。",
-    "- 不要在 workspace 根目录、业务仓库根目录或当前 cwd 下创建 `temp_*`、`_out.json`、`tmp.html` 等临时产物。",
-    "- 不要自行删除该目录或其中的最终待读文件；AgentFlow 会在节点运行结束后统一清理。",
-    "- 短文本结果可直接输出；长 HTML/Markdown/SQL 等正式 artifact 应写入 workspace 的 `outputs/` 目录并返回相对路径，不要为了输出而写临时文件、cat 文件再粘贴。",
-  ].join("\n");
+    nodeRunDir ? `- 当前执行目录：\`${nodeRunDir}\`。` : "",
+    nodeTmpDir ? `- 临时文件只能写入：\`${nodeTmpDir}\`，也可通过环境变量 \`AGENTFLOW_NODE_TMP_DIR\` 获取。` : "",
+    `- 正式产物写入本任务 \`${outputsRel}/\`，例如 \`${outputsRel}/result.html\`、\`${outputsRel}/result.md\`；返回时仍使用 \`${outputsRel}/...\` 相对路径。`,
+    "- 不要在执行目录根部创建 `temp_*`、`_out.json`、`tmp.html` 等临时产物。",
+    "- 不要自行删除 run package；AgentFlow 会在运行结束后统一清理。",
+  ].filter(Boolean).join("\n");
 }
 
-function workspaceTaskUpstreamText(graph, nodeId, outputs) {
+function workspaceTaskUpstreamText(graph, nodeId, outputs, relevantInputNames = null) {
   const edges = Array.isArray(graph?.edges) ? graph.edges : [];
   const instances = graph?.instances && typeof graph.instances === "object" ? graph.instances : {};
   const incoming = edges.filter((edge) => String(edge?.target || "") === String(nodeId));
-  const contentEdges = incoming.filter((edge) => !isWorkspaceSemanticInputSlot(workspaceTargetSlotForEdge(graph, edge)));
+  let contentEdges = incoming.filter((edge) => !isWorkspaceSemanticInputSlot(workspaceTargetSlotForEdge(graph, edge)));
+  if (relevantInputNames && relevantInputNames.size) {
+    contentEdges = contentEdges.filter((edge) => {
+      const slot = workspaceTargetSlotForEdge(graph, edge);
+      return relevantInputNames.has(String(slot?.name || "").trim());
+    });
+  }
   const contentEdge = contentEdges.find((edge) => String(edge?.targetHandle || "") === "input-1") || contentEdges[0];
   if (!contentEdge) return "";
   return workspaceOutputSlotValueForEdge(graph, outputs, contentEdge);
@@ -2744,28 +2745,21 @@ function workspaceUpdateDirectDisplays(graph, sourceId, content, outputs = null)
 function workspaceNodePrompt(graph, nodeId, upstreamText, skillsBlock, mcpBlock = "", inputValues = {}, nodeTmpDir = "") {
   const instance = graph.instances[nodeId] || {};
   const body = workspaceResolveBodyPlaceholders(instance.body || "", inputValues).trim();
-  const label = String(instance.label || nodeId).trim();
-  const scopeGuardrails = workspaceNodeScopeGuardrails(graph, nodeId, inputValues);
-  const connectionContext = workspaceNodeConnectionContextBlock(graph, nodeId);
-  const resolvedInputs = workspaceResolvedInputValuesBlock(inputValues);
-  const tmpDirectory = workspaceNodeTmpDirectoryBlock(nodeTmpDir);
-  const downstreamRequirements = workspaceDownstreamDisplayRequirements(graph, nodeId);
+  const { values: relevantInputValues, placeholders } = workspaceRelevantInputValues(instance.body || "", inputValues);
+  const runPackage = typeof nodeTmpDir === "object" && nodeTmpDir ? nodeTmpDir : { nodeTmpDir: String(nodeTmpDir || "") };
+  const inputBlock = workspaceAgentInputBlock(relevantInputValues);
+  const fileBoundary = workspaceNodeFileBoundaryBlock(runPackage);
   const outputProtocolRequirements = workspaceOutputProtocolRequirements(graph, nodeId);
   return [
-    "你正在执行 AgentFlow Workspace 画布中的一个临时节点。",
-    "按 Workspace 输出协议返回该节点要传给下游展示/后续节点的数据。",
-    scopeGuardrails,
-    connectionContext ? `\n${connectionContext}` : "",
-    tmpDirectory ? `\n${tmpDirectory}` : "",
-    workspaceSearchGuardrailsBlock(),
-    resolvedInputs ? `\n${resolvedInputs}` : "",
-    skillsBlock ? `\n## 上游已加载 Skills\n\n${skillsBlock}` : "",
-    mcpBlock ? `\n## 上游已加载 MCP\n\n${mcpBlock}` : "",
-    upstreamText ? `\n## 上游上下文\n\n${upstreamText}` : "",
-    downstreamRequirements ? `\n${downstreamRequirements}` : "",
+    "你正在执行一个独立任务。只使用本提示中的任务、输入、可用能力和文件边界。",
+    fileBoundary ? `\n${fileBoundary}` : "",
+    inputBlock ? `\n${inputBlock}` : "",
+    placeholders.size ? "\n任务只显式引用了上面的输入槽；其它未被 `${...}` 引用的已连接业务输入不要作为分析依据。" : "",
+    skillsBlock ? `\n## 可用能力\n\n${skillsBlock}` : "",
+    mcpBlock ? `\n## 可用 MCP\n\n${mcpBlock}` : "",
+    upstreamText ? `\n## 上游正文\n\n${upstreamText}` : "",
     outputProtocolRequirements ? `\n${outputProtocolRequirements}` : "",
-    `\n## 当前节点\n\n- id: ${nodeId}\n- label: ${label}\n- definitionId: ${instance.definitionId || ""}`,
-    `\n## 节点任务\n\n${body || upstreamText}`,
+    `\n## 任务\n\n${body || upstreamText}`,
   ].filter(Boolean).join("\n");
 }
 
@@ -2857,6 +2851,40 @@ function workspaceCreateNodeTmpDir(runTmpRoot, nodeId) {
   return dir;
 }
 
+function workspaceCreateNodeRunPackage(runTmpRoot, nodeId, { scopedRoot, task = "", inputValues = {}, skillsBlock = "", mcpBlock = "" } = {}) {
+  const nodeRunDir = workspaceCreateNodeTmpDir(runTmpRoot, nodeId);
+  const nodeTmpDir = path.join(nodeRunDir, "tmp");
+  const outputsDir = path.join(nodeRunDir, "outputs");
+  const workspaceOutputsDir = path.join(path.resolve(scopedRoot), "outputs");
+  fs.mkdirSync(nodeTmpDir, { recursive: true });
+  fs.mkdirSync(outputsDir, { recursive: true });
+  fs.mkdirSync(workspaceOutputsDir, { recursive: true });
+  const manifest = {
+    version: 1,
+    nodeId: String(nodeId || ""),
+    nodeRunDir,
+    nodeTmpDir,
+    outputsDir,
+    createdAt: new Date().toISOString(),
+  };
+  try {
+    fs.writeFileSync(path.join(nodeRunDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+    fs.writeFileSync(path.join(nodeRunDir, "task.md"), String(task || "").trimEnd() + "\n", "utf-8");
+    if (Object.keys(inputValues || {}).length) {
+      fs.writeFileSync(path.join(nodeRunDir, "inputs.json"), JSON.stringify(inputValues, null, 2) + "\n", "utf-8");
+    }
+    if (skillsBlock) fs.writeFileSync(path.join(nodeRunDir, "skills.md"), String(skillsBlock).trimEnd() + "\n", "utf-8");
+    if (mcpBlock) fs.writeFileSync(path.join(nodeRunDir, "mcp.md"), String(mcpBlock).trimEnd() + "\n", "utf-8");
+  } catch {
+    // Runtime metadata is best-effort and should not block node execution.
+  }
+  return {
+    ...manifest,
+    workspaceOutputsDir,
+    outputsRel: "outputs",
+  };
+}
+
 function workspaceShouldKeepTmp(userCtx = {}) {
   const env = { ...process.env, ...readMergedEnvObject(userCtx.userId) };
   const value = String(env.AGENTFLOW_KEEP_TMP || env.AGENTFLOW_KEEP_WORKSPACE_TMP || "").trim().toLowerCase();
@@ -2921,9 +2949,16 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
   };
   const outputs = new Map();
   const events = [];
+  const runStartedAt = Date.now();
   const emit = (event) => {
-    events.push(event);
-    if (typeof opts.onEvent === "function") opts.onEvent(event);
+    const now = Date.now();
+    const enriched = {
+      ...event,
+      ts: Number(event?.ts) || now,
+      runElapsedMs: Number.isFinite(event?.runElapsedMs) ? event.runElapsedMs : Math.max(0, now - runStartedAt),
+    };
+    events.push(enriched);
+    if (typeof opts.onEvent === "function") opts.onEvent(enriched);
   };
   const emitTiming = (nodeId, label, startedAt, extra = {}) => {
     const elapsedMs = Math.max(0, Date.now() - startedAt);
@@ -3233,8 +3268,9 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
     }
 
     const prepareStartedAt = Date.now();
-    const upstreamText = workspaceTaskUpstreamText(graph, nodeId, outputs);
     const inputValues = workspaceInputValues(graph, nodeId, outputs);
+    const relevantInputs = workspaceRelevantInputValues(instance.body || "", inputValues);
+    const upstreamText = workspaceTaskUpstreamText(graph, nodeId, outputs, relevantInputs.placeholders);
     const body = workspaceResolveBodyPlaceholders(instance.body || "", inputValues).trim();
     if (defId === "agent_subAgent" && !body && !String(upstreamText || "").trim()) {
       throw new Error(`Workspace node ${nodeId} has no task. Fill the node body or connect upstream text.`);
@@ -3242,9 +3278,27 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
     const upstreamSkillBlocks = workspaceUpstreamSkillBlocks(graph, nodeId, outputs);
     const promptSkillsBlock = mergeWorkspaceSkillBlocks(upstreamSkillBlocks);
     const promptMcpBlock = workspaceUpstreamMcpBlocks(graph, nodeId, outputs);
-    const nodeTmpDir = workspaceCreateNodeTmpDir(runTmpRoot, nodeId);
-    const prompt = workspaceNodePrompt(graph, nodeId, upstreamText, promptSkillsBlock, promptMcpBlock, inputValues, nodeTmpDir);
-    emitTiming(nodeId, "prepare-agent-prompt", prepareStartedAt, { promptChars: prompt.length, upstreamChars: String(upstreamText || "").length, skillsChars: promptSkillsBlock.length, mcpChars: promptMcpBlock.length });
+    const runPackage = workspaceCreateNodeRunPackage(runTmpRoot, nodeId, {
+      scopedRoot,
+      cwd,
+      task: body || upstreamText,
+      inputValues: relevantInputs.values,
+      skillsBlock: promptSkillsBlock,
+      mcpBlock: promptMcpBlock,
+    });
+    const prompt = workspaceNodePrompt(graph, nodeId, upstreamText, promptSkillsBlock, promptMcpBlock, inputValues, runPackage);
+    try {
+      fs.writeFileSync(path.join(runPackage.nodeRunDir, "prompt.md"), prompt.trimEnd() + "\n", "utf-8");
+    } catch {
+      // Best-effort debug artifact only.
+    }
+    emitTiming(nodeId, "prepare-agent-prompt", prepareStartedAt, {
+      promptChars: prompt.length,
+      upstreamChars: String(upstreamText || "").length,
+      skillsChars: promptSkillsBlock.length,
+      mcpChars: promptMcpBlock.length,
+      nodeRunDir: runPackage.nodeRunDir,
+    });
     emit({ type: "natural", kind: "prompt", nodeId, text: prompt });
     let content = "";
     const maxAttempts = 3;
@@ -3253,15 +3307,19 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       try {
         const spawnStartedAt = Date.now();
         let firstAgentEventSeen = false;
+        let attemptResultContent = "";
+        let attemptLastAssistantContent = "";
         const handle = startComposerAgent({
           uiWorkspaceRoot: scopedRoot,
-          cliWorkspace: cwd,
+          cliWorkspace: runPackage.nodeRunDir,
           prompt,
           modelKey,
           agentflowUserId: userCtx.userId || "",
           extraEnv: {
             AGENTFLOW_WORKSPACE_TMP_ROOT: runTmpRoot,
-            AGENTFLOW_NODE_TMP_DIR: nodeTmpDir,
+            AGENTFLOW_NODE_RUN_DIR: runPackage.nodeRunDir,
+            AGENTFLOW_NODE_TMP_DIR: runPackage.nodeTmpDir,
+            AGENTFLOW_OUTPUTS_DIR: runPackage.outputsDir,
           },
           onStreamEvent: (ev) => {
             if (!firstAgentEventSeen) {
@@ -3273,7 +3331,10 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
               : { ...ev, nodeId };
             emit(eventToEmit);
             if (ev?.type === "natural" && ev.kind === "assistant" && typeof ev.text === "string") {
+              attemptLastAssistantContent = ev.text;
               attemptContent += (attemptContent ? "\n" : "") + ev.text;
+            } else if (ev?.type === "natural" && ev.kind === "result" && typeof ev.text === "string") {
+              attemptResultContent = ev.text;
             }
           },
           onToolCall: (subtype, toolName) => {
@@ -3290,7 +3351,11 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
           if (typeof opts.onActiveChild === "function") opts.onActiveChild(null);
         }
         throwIfAborted();
-        content = workspaceCanonicalAgentOutput(attemptContent);
+        const resultStructured = attemptResultContent ? workspaceStructuredAgentOutput(attemptResultContent) : null;
+        const assistantStructured = attemptLastAssistantContent ? workspaceStructuredAgentOutput(attemptLastAssistantContent) : null;
+        if (resultStructured?.structured) content = workspaceCanonicalAgentOutput(attemptResultContent);
+        else if (assistantStructured?.structured) content = workspaceCanonicalAgentOutput(attemptLastAssistantContent);
+        else content = workspaceCanonicalAgentOutput(attemptLastAssistantContent || attemptContent);
         break;
       } catch (e) {
         if (signal?.aborted || e?.code === "WORKSPACE_RUN_ABORTED") throwIfAborted();
@@ -3302,7 +3367,7 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
         throw e;
       }
     }
-    const normalizedAgentOutput = workspaceStructuredAgentOutput(content);
+    const normalizedAgentOutput = workspacePublishAgentOutputFiles(workspaceStructuredAgentOutput(content), runPackage);
     const resultContent = normalizedAgentOutput.result || content;
     outputs.set(nodeId, resultContent);
     const slotUpdate = workspaceApplyAgentOutputSlots(instance, content);