@fieldwangai/agentflow 0.1.84 → 0.1.86

package/bin/lib/ui-server.mjs

@@ -102,6 +102,7 @@ import {
   buildClearSessionCookie,
   buildSessionCookie,
   getAuthUserFromRequest,
+  getSessionTokenFromRequest,
   isAuthUserAllowed,
   loginOrCreateUser,
   logoutRequest,
@@ -120,6 +121,13 @@ import {
   readRunLedgerEvents,
   runLedgerId,
 } from "./run-ledger.mjs";
+import {
+  appendWorkspaceRunLogEvent,
+  createWorkspaceRunLogSession,
+  finishWorkspaceRunLogSession,
+  listWorkspaceRunLogs,
+  readWorkspaceRunLogEvents,
+} from "./workspace-run-logs.mjs";
 
 const MIME = {
   ".html": "text/html; charset=utf-8",
@@ -612,6 +620,125 @@ function normalizeMcpServerConfig(value) {
   return next;
 }
 
+function mcpHeadersInfo(headers = {}) {
+  const entries = Object.entries(headers && typeof headers === "object" && !Array.isArray(headers) ? headers : {})
+    .filter(([key]) => String(key || "").trim());
+  const unsupported = [];
+  let bearer = false;
+  for (const [key, value] of entries) {
+    const name = String(key || "").trim();
+    if (name.toLowerCase() !== "authorization") {
+      unsupported.push(name);
+      continue;
+    }
+    if (/^Bearer\s+.+/i.test(String(value ?? "").trim())) bearer = true;
+    else unsupported.push(name);
+  }
+  return { count: entries.length, bearer, unsupported };
+}
+
+function codexMcpCompatibility(server) {
+  const raw = server?.raw && typeof server.raw === "object" && !Array.isArray(server.raw) ? server.raw : {};
+  const reasons = [];
+  const supported = [];
+  const unsupported = [];
+  const type = raw.url || server?.url ? "url" : raw.command || server?.command ? "command" : "";
+  if (raw.disabled === true) {
+    return {
+      status: "unsupported",
+      label: "Codex disabled",
+      reasons: ["该 MCP 已 disabled，Codex 不会启用。"],
+      supported,
+      unsupported: ["disabled"],
+    };
+  }
+  if (!type) {
+    return {
+      status: "unsupported",
+      label: "Codex unsupported",
+      reasons: ["缺少 url 或 command。"],
+      supported,
+      unsupported: ["transport"],
+    };
+  }
+
+  if (type === "command") {
+    supported.push("command", "args");
+    const envKeys = Object.keys(raw.env && typeof raw.env === "object" && !Array.isArray(raw.env) ? raw.env : {});
+    if (envKeys.length) supported.push("env");
+    if (raw.cwd) supported.push("cwd");
+    const headers = raw.headers && typeof raw.headers === "object" && !Array.isArray(raw.headers) ? raw.headers : {};
+    if (Object.keys(headers).length) {
+      unsupported.push("headers");
+      reasons.push("Codex stdio MCP 不支持 headers。");
+    }
+  }
+
+  if (type === "url") {
+    supported.push("url");
+    const headers = mcpHeadersInfo(raw.headers);
+    if (headers.bearer) supported.push("Authorization Bearer");
+    if (headers.unsupported.length) {
+      unsupported.push(...headers.unsupported.map((name) => `header:${name}`));
+      reasons.push(`Codex URL MCP 仅能等价支持 Authorization: Bearer；不支持自定义 header：${headers.unsupported.join(", ")}。`);
+    }
+    const envKeys = Object.keys(raw.env && typeof raw.env === "object" && !Array.isArray(raw.env) ? raw.env : {});
+    if (envKeys.length) {
+      unsupported.push("env");
+      reasons.push("Codex URL MCP 不支持 env；如需鉴权请使用 Authorization: Bearer 或 bearer_token_env_var。");
+    }
+    if (raw.bearer_token_env_var) supported.push("bearer_token_env_var");
+    if (raw.oauth_client_id) supported.push("oauth_client_id");
+    if (raw.oauth_resource) supported.push("oauth_resource");
+  }
+
+  const known = new Set([
+    "url",
+    "command",
+    "args",
+    "env",
+    "headers",
+    "description",
+    "cwd",
+    "disabled",
+    "bearer_token_env_var",
+    "oauth_client_id",
+    "oauth_resource",
+    "__agentflowPrivateKeys",
+  ]);
+  const unknownKeys = Object.keys(raw).filter((key) => !known.has(key));
+  if (unknownKeys.length) {
+    unsupported.push(...unknownKeys.map((key) => `field:${key}`));
+    reasons.push(`存在 Codex 未确认支持的额外字段：${unknownKeys.join(", ")}。`);
+  }
+
+  const status = unsupported.length ? "partial" : "ok";
+  return {
+    status,
+    label: status === "ok" ? "Codex OK" : "Codex partial",
+    reasons,
+    supported,
+    unsupported,
+  };
+}
+
+function cursorMcpCompatibility(server) {
+  if (server?.raw?.disabled === true) {
+    return { status: "unsupported", label: "Cursor disabled", reasons: ["该 MCP 已 disabled。"] };
+  }
+  return { status: "ok", label: "Cursor OK", reasons: [] };
+}
+
+function withMcpBackendCompatibility(server) {
+  return {
+    ...server,
+    backends: {
+      cursor: cursorMcpCompatibility(server),
+      codex: codexMcpCompatibility(server),
+    },
+  };
+}
+
 function readCursorMcpServers(userCtx = {}) {
   const config = readCursorMcpConfig();
   const privateConfig = readUserMcpPrivate(userCtx);
@@ -644,7 +771,7 @@ function readCursorMcpServers(userCtx = {}) {
       privateEnvKeys,
       privateHeaderKeys,
     };
-  }).sort((a, b) => a.name.localeCompare(b.name));
+  }).map(withMcpBackendCompatibility).sort((a, b) => a.name.localeCompare(b.name));
   return { path: cursorMcpConfigPath(), servers };
 }
 
@@ -951,9 +1078,11 @@ function readModelListsFromDisk(workspaceRoot) {
     cursor: [],
     opencode: [],
     claudeCode: [],
+    codex: [],
     cursorFetchedAt: null,
     opencodeFetchedAt: null,
     claudeCodeFetchedAt: null,
+    codexFetchedAt: null,
   };
   try {
     if (!fs.existsSync(p)) return empty;
@@ -962,9 +1091,11 @@ function readModelListsFromDisk(workspaceRoot) {
       cursor: Array.isArray(data.cursor) ? data.cursor.map(String) : [],
       opencode: Array.isArray(data.opencode) ? data.opencode.map(String) : [],
       claudeCode: Array.isArray(data.claudeCode) ? data.claudeCode.map(String) : [],
+      codex: Array.isArray(data.codex) ? data.codex.map(String) : [],
       cursorFetchedAt: data.cursorFetchedAt ?? null,
       opencodeFetchedAt: data.opencodeFetchedAt ?? null,
       claudeCodeFetchedAt: data.claudeCodeFetchedAt ?? null,
+      codexFetchedAt: data.codexFetchedAt ?? null,
     };
   } catch {
     return empty;
@@ -1482,6 +1613,195 @@ function readWorkspaceGraph(workspaceRoot) {
 
 const DISPLAY_SHARE_FILENAME = "display-shares.json";
 const DISPLAY_SHARE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+const DISPLAY_SHARE_ALLOWED_EXPIRY_DAYS = new Set([1, 7, 30, 90, 365]);
+const NODE_STUDIO_DRAFTS_DIRNAME = "node-studio/drafts";
+const USER_WORKSPACES_FILENAME = "workspaces.json";
+
+function userWorkspacesPath(userCtx = {}) {
+  return path.join(getAgentflowUserDataRoot(userCtx.userId || ""), USER_WORKSPACES_FILENAME);
+}
+
+function normalizeWorkspaceEntry(entry = {}, index = 0, userCtx = {}) {
+  const label = String(entry?.label || entry?.name || "").trim();
+  const kindRaw = String(entry?.kind || entry?.source || "").trim().toLowerCase();
+  const repoUrl = String(entry?.repoUrl || entry?.gitUrl || entry?.url || "").trim();
+  const kind = kindRaw === "git" || repoUrl ? "git" : "local";
+  const branch = String(entry?.branch || "master").trim() || "master";
+  const mountPathRaw = String(entry?.mountPath || "").trim();
+  const rawPath = String(entry?.path || entry?.cwd || "").trim();
+  if (!rawPath && kind !== "git") return null;
+  const idRaw = String(entry?.id || label || mountPathRaw || repoUrl || rawPath || `workspace_${index + 1}`).trim().toLowerCase();
+  const id = idRaw.replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 64) || `workspace_${index + 1}`;
+  const mountPath = (mountPathRaw || id).replace(/^\/+/, "").replace(/\.\.(\/|\\|$)/g, "").trim() || id;
+  const defaultGitPath = path.join(getAgentflowUserDataRoot(userCtx.userId || ""), "workspaces", "repos", id);
+  const absPath = path.resolve((rawPath || defaultGitPath).replace(/^~(?=$|\/|\\)/, os.homedir()));
+  const exists = fs.existsSync(absPath) && fs.statSync(absPath).isDirectory();
+  return {
+    id,
+    label: label || path.basename(absPath) || id,
+    kind,
+    path: absPath,
+    repoUrl,
+    branch,
+    mountPath,
+    credentialRef: String(entry?.credentialRef || "").trim(),
+    type: String(entry?.type || (kind === "git" ? "code" : "local")).trim() || (kind === "git" ? "code" : "local"),
+    description: String(entry?.description || "").trim(),
+    visibility: String(entry?.visibility || "personal").trim() || "personal",
+    enabled: entry?.enabled !== false,
+    exists,
+  };
+}
+
+function readUserWorkspaces(userCtx = {}) {
+  const p = userWorkspacesPath(userCtx);
+  if (!fs.existsSync(p)) return [];
+  try {
+    const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+    const list = Array.isArray(data?.workspaces) ? data.workspaces : Array.isArray(data) ? data : [];
+    return list.map((entry, index) => normalizeWorkspaceEntry(entry, index, userCtx)).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function writeUserWorkspaces(userCtx = {}, entries = []) {
+  const seen = new Set();
+  const workspaces = (Array.isArray(entries) ? entries : [])
+    .map((entry, index) => normalizeWorkspaceEntry(entry, index, userCtx))
+    .filter(Boolean)
+    .filter((entry) => {
+      const key = entry.id || entry.path;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  const p = userWorkspacesPath(userCtx);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify({ version: 1, workspaces }, null, 2) + "\n", "utf-8");
+  return workspaces;
+}
+
+function listConfiguredWorkspaces(root, scopedRoot, userCtx = {}) {
+  const currentRoot = path.resolve(scopedRoot || root);
+  const homeRoot = path.resolve(os.homedir());
+  const builtins = [
+    { id: "current", label: "当前流程工作区", kind: "local", path: currentRoot, builtin: true, exists: fs.existsSync(currentRoot) && fs.statSync(currentRoot).isDirectory(), type: "flow", enabled: true },
+    { id: "home", label: "用户 Home", kind: "local", path: homeRoot, builtin: true, exists: fs.existsSync(homeRoot) && fs.statSync(homeRoot).isDirectory(), type: "local", enabled: true },
+  ];
+  const custom = readUserWorkspaces(userCtx).filter((entry) => entry.enabled !== false).map((entry) => ({ ...entry, builtin: false }));
+  const seen = new Set();
+  return [...builtins, ...custom].filter((entry) => {
+    const key = path.resolve(entry.path);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function nodeStudioDraftsRoot(userCtx = {}) {
+  return path.join(getAgentflowUserDataRoot(userCtx.userId || ""), NODE_STUDIO_DRAFTS_DIRNAME);
+}
+
+function normalizeNodeStudioDraftId(value) {
+  const raw = String(value || "").trim().toLowerCase();
+  const safe = raw.replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 64);
+  return safe || `draft_${Date.now().toString(36)}_${crypto.randomBytes(3).toString("hex")}`;
+}
+
+function nodeStudioDraftPath(userCtx = {}, draftId = "") {
+  return path.join(nodeStudioDraftsRoot(userCtx), normalizeNodeStudioDraftId(draftId), "draft.json");
+}
+
+function emptyNodeStudioDraft(userCtx = {}, draftId = "") {
+  const now = new Date().toISOString();
+  const id = normalizeNodeStudioDraftId(draftId || "untitled_node");
+  return {
+    id,
+    title: "Untitled Node",
+    definitionId: "",
+    createdAt: now,
+    updatedAt: now,
+    ownerUserId: String(userCtx.userId || ""),
+    agentMessages: [],
+    promptDraft: "",
+    manifest: {
+      id,
+      version: "1.0.0",
+      name: "Untitled Node",
+      description: "",
+      baseDefinitionId: "agent_subAgent",
+      runtime: { type: "agent_subAgent" },
+      inputs: [],
+      outputs: [],
+      configSchema: { fields: [] },
+      ui: { card: { icon: "extension", variant: "default", actions: [] } },
+    },
+    config: {},
+    test: { inputs: {}, log: [], status: "not run" },
+    files: {},
+  };
+}
+
+function isLegacyNodeStudioDemoDraft(draft) {
+  return (
+    String(draft?.id || "") === "daily_report_demo" &&
+    String(draft?.definitionId || "") === "marketplace:daily_report@1.0.0"
+  );
+}
+
+function readNodeStudioDraft(userCtx = {}, draftId = "") {
+  const id = normalizeNodeStudioDraftId(draftId || "");
+  const filePath = nodeStudioDraftPath(userCtx, id);
+  if (!fs.existsSync(filePath)) return null;
+  const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  return parsed && typeof parsed === "object" ? parsed : null;
+}
+
+function writeNodeStudioDraft(userCtx = {}, draft = {}) {
+  const id = normalizeNodeStudioDraftId(draft.id || "untitled_node");
+  const filePath = nodeStudioDraftPath(userCtx, id);
+  const previous = fs.existsSync(filePath)
+    ? JSON.parse(fs.readFileSync(filePath, "utf-8"))
+    : {};
+  const now = new Date().toISOString();
+  const next = {
+    ...previous,
+    ...draft,
+    id,
+    createdAt: previous.createdAt || draft.createdAt || now,
+    updatedAt: now,
+    ownerUserId: String(userCtx.userId || draft.ownerUserId || ""),
+  };
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n", "utf-8");
+  return next;
+}
+
+function listNodeStudioDrafts(userCtx = {}) {
+  const rootDir = nodeStudioDraftsRoot(userCtx);
+  if (!fs.existsSync(rootDir)) return [];
+  const rows = [];
+  for (const entry of fs.readdirSync(rootDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const filePath = path.join(rootDir, entry.name, "draft.json");
+    if (!fs.existsSync(filePath)) continue;
+    try {
+      const draft = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      if (isLegacyNodeStudioDemoDraft(draft)) continue;
+      rows.push({
+        id: String(draft.id || entry.name),
+        title: String(draft.title || draft.manifest?.name || entry.name),
+        definitionId: String(draft.definitionId || `marketplace:${draft.manifest?.id || entry.name}@${draft.manifest?.version || "1.0.0"}`),
+        updatedAt: String(draft.updatedAt || ""),
+      });
+    } catch {
+      /* ignore corrupt drafts */
+    }
+  }
+  rows.sort((a, b) => String(b.updatedAt || "").localeCompare(String(a.updatedAt || "")) || a.id.localeCompare(b.id));
+  return rows;
+}
 
 function displaySharesPath() {
   return path.join(getAgentflowDataRoot(), DISPLAY_SHARE_FILENAME);
@@ -1931,9 +2251,30 @@ function createDisplayShareId() {
   return crypto.randomBytes(12).toString("base64url");
 }
 
-function displayShareExpiresAt(now = new Date()) {
+function normalizeDisplayShareExpiry(input = {}, now = new Date()) {
+  const mode = String(input?.expiresMode || input?.expiryMode || "").trim().toLowerCase();
+  const rawDays = Number(input?.expiresInDays ?? input?.expiryDays ?? input?.ttlDays);
+  if (
+    mode === "permanent" ||
+    mode === "forever" ||
+    input?.permanent === true ||
+    input?.expiresAt === null ||
+    String(input?.expiresAt || "").trim().toLowerCase() === "permanent"
+  ) {
+    return { expiresAt: "", expiresMode: "permanent", expiresInDays: null };
+  }
+  let days = Number.isFinite(rawDays) ? Math.round(rawDays) : 30;
+  if (!DISPLAY_SHARE_ALLOWED_EXPIRY_DAYS.has(days)) days = 30;
   const time = now instanceof Date ? now.getTime() : Date.now();
-  return new Date(time + DISPLAY_SHARE_TTL_MS).toISOString();
+  return {
+    expiresAt: new Date(time + days * 24 * 60 * 60 * 1000).toISOString(),
+    expiresMode: "days",
+    expiresInDays: days,
+  };
+}
+
+function displayShareExpiresAt(now = new Date()) {
+  return normalizeDisplayShareExpiry({ expiresInDays: 30 }, now).expiresAt;
 }
 
 function isDisplayShareExpired(share) {
@@ -1971,12 +2312,13 @@ function normalizeDisplayShareLayout(layout, fallback = "canvas") {
   return ["canvas", "gallery", "slides", "document", "single"].includes(text) ? text : fallback;
 }
 
-function createDisplayShareRecord({ userId, flowId, flowSource, archived, title, layout, nodeIds }) {
+function createDisplayShareRecord({ userId, flowId, flowSource, archived, title, layout, nodeIds, expiresMode, expiresInDays, permanent, expiresAt }) {
   const shares = readDisplayShares();
   let id = createDisplayShareId();
   while (shares[id]) id = createDisplayShareId();
   const nowDate = new Date();
   const now = nowDate.toISOString();
+  const expiry = normalizeDisplayShareExpiry({ expiresMode, expiresInDays, permanent, expiresAt }, nowDate);
   const share = {
     id,
     userId: String(userId || ""),
@@ -1988,13 +2330,84 @@ function createDisplayShareRecord({ userId, flowId, flowSource, archived, title,
     nodeIds: Array.isArray(nodeIds) ? nodeIds : [],
     createdAt: now,
     updatedAt: now,
-    expiresAt: displayShareExpiresAt(nowDate),
+    expiresAt: expiry.expiresAt,
+    expiresMode: expiry.expiresMode,
+    expiresInDays: expiry.expiresInDays,
   };
   shares[id] = share;
   writeDisplayShares(shares);
   return share;
 }
 
+function displayShareSummary(share, baseUrl = "") {
+  return {
+    id: String(share?.id || ""),
+    userId: String(share?.userId || ""),
+    flowId: String(share?.flowId || ""),
+    flowSource: String(share?.flowSource || "user"),
+    archived: share?.archived === true,
+    title: String(share?.title || "AgentFlow Display"),
+    layout: String(share?.layout || "gallery"),
+    nodeIds: Array.isArray(share?.nodeIds) ? share.nodeIds : [],
+    createdAt: String(share?.createdAt || ""),
+    updatedAt: String(share?.updatedAt || ""),
+    expiresAt: String(share?.expiresAt || ""),
+    expiresMode: String(share?.expiresMode || (share?.expiresAt ? "days" : "permanent")),
+    expiresInDays: share?.expiresInDays == null ? null : Number(share.expiresInDays),
+    url: displayShareOutputUrl(share?.id || "", baseUrl),
+  };
+}
+
+function listDisplaySharesForUser(userCtx = {}, baseUrl = "") {
+  const userId = String(userCtx?.userId || "");
+  const isAdmin = userCtx?.isAdmin === true;
+  const shares = readDisplayShares();
+  let changed = false;
+  const rows = [];
+  for (const [id, share] of Object.entries(shares)) {
+    if (isDisplayShareExpired(share)) {
+      delete shares[id];
+      changed = true;
+      continue;
+    }
+    if (!isAdmin && String(share?.userId || "") !== userId) continue;
+    rows.push(displayShareSummary(share, baseUrl));
+  }
+  if (changed) writeDisplayShares(shares);
+  rows.sort((a, b) => Date.parse(b.createdAt || "") - Date.parse(a.createdAt || ""));
+  return rows;
+}
+
+function updateDisplayShareExpiryForUser(id, userCtx = {}, patch = {}) {
+  const shares = readDisplayShares();
+  const share = shares[id];
+  if (!share) return { status: 404, error: "Display share not found" };
+  const userId = String(userCtx?.userId || "");
+  if (userCtx?.isAdmin !== true && String(share.userId || "") !== userId) return { status: 403, error: "Forbidden" };
+  const expiry = normalizeDisplayShareExpiry(patch, new Date());
+  const updated = {
+    ...share,
+    expiresAt: expiry.expiresAt,
+    expiresMode: expiry.expiresMode,
+    expiresInDays: expiry.expiresInDays,
+    updatedAt: new Date().toISOString(),
+  };
+  shares[id] = updated;
+  writeDisplayShares(shares);
+  return { status: 200, share: updated };
+}
+
+function deleteDisplayShareForUser(id, userCtx = {}) {
+  const shares = readDisplayShares();
+  const share = shares[id];
+  if (!share) return { status: 404, error: "Display share not found" };
+  const userId = String(userCtx?.userId || "");
+  if (userCtx?.isAdmin !== true && String(share.userId || "") !== userId) return { status: 403, error: "Forbidden" };
+  delete shares[id];
+  writeDisplayShares(shares);
+  return { status: 200 };
+}
+
 function parseDisplayShareNodeIdInput(value) {
   return String(value || "")
     .split(/[\s,，]+/g)
@@ -2146,6 +2559,8 @@ function publicDisplayPayloadFromShare(root, share) {
       createdAt: share.createdAt || "",
       updatedAt: share.updatedAt || "",
       expiresAt: share.expiresAt || "",
+      expiresMode: share.expiresMode || (share.expiresAt ? "days" : "permanent"),
+      expiresInDays: share.expiresInDays == null ? null : Number(share.expiresInDays),
     },
     nodes,
   };
@@ -2422,6 +2837,14 @@ function buildWorkspaceGeneratePrompt(payload) {
             "只输出 ASCII 图正文，不要解释，不要包裹 Markdown 代码围栏。",
             "使用 +-|/\\<> 等字符表达结构，尽量保持对齐。",
           ].join("\n")
+        : outputKind === "react"
+          ? [
+              "你是 workspace React 工程节点的内容生成器。",
+              "请根据用户 prompt 和上游节点/文件上下文生成一个可预览的小型 React 工程 JSON。",
+              "只输出 JSON，不要解释，不要包裹 Markdown 代码围栏。",
+              "JSON 必须包含 title、entry、files；files 至少包含 src/App.jsx，可包含 src/styles.css。",
+              "src/App.jsx 里定义或 export default 一个 App 组件；不要依赖未声明的外部包。",
+            ].join("\n")
         : [
             "你是 AgentFlow Workspace Composer。",
             "默认以用户当前选择的 workspace 节点作为上下文范围；选中节点不是让你重建整张画布的授权。",
@@ -2475,6 +2898,8 @@ function buildWorkspaceNodeChatPrompt(payload) {
       ].join("\n")
     : nodeKind === "html"
       ? "只输出完整或片段 HTML，不要解释，不要包裹 Markdown 代码围栏。"
+      : nodeKind === "react"
+        ? "只输出 React 工程 JSON，不要解释，不要包裹 Markdown 代码围栏。JSON 必须包含 title、entry、files；files 至少包含 src/App.jsx。"
       : nodeKind === "image"
         ? "只输出新的图片 src，可以是 URL、data URL 或文件路径，不要解释。"
         : nodeKind === "mermaid"
@@ -3030,6 +3455,7 @@ function workspaceDisplayKind(definitionId) {
   if (id === "display_mermaid") return "mermaid";
   if (id === "display_ascii") return "ascii";
   if (id === "display_html") return "html";
+  if (id === "display_react_app") return "react";
   if (id === "display_image") return "image";
   if (id === "display_chart") return "chart";
   if (id === "display_table") return "table";
@@ -3046,6 +3472,7 @@ function workspaceDisplayTextFilePath(value, kind = "") {
   const ext = clean.split("?")[0].split("#")[0].toLowerCase().split(".").pop() || "";
   const allowedByKind = {
     html: new Set(["html", "htm"]),
+    react: new Set(["json", "jsx", "tsx", "js", "txt"]),
     markdown: new Set(["md", "markdown", "txt"]),
     mermaid: new Set(["mmd", "mermaid", "txt"]),
     ascii: new Set(["txt", "log"]),
@@ -3119,6 +3546,7 @@ function workspaceDisplayKindExample(kind, field) {
   if (kind === "table") return { columns: ["列名1", "列名2"], rows: [["值1", "值2"]] };
   if (kind === "chart") return { type: "chart", version: "1.0", renderer: "echarts", option: { xAxis: { type: "category", data: [] }, yAxis: { type: "value" }, series: [{ type: "bar", data: [] }] } };
   if (kind === "html") return "<可直接渲染的 HTML>";
+  if (kind === "react") return { title: "React App", entry: "src/App.jsx", files: { "src/App.jsx": "export default function App() { return <main>...</main>; }", "src/styles.css": "body { margin: 0; }" }, inputs: {} };
   if (kind === "mermaid") return "flowchart TD\n  A[开始] --> B[结束]";
   if (kind === "ascii") return "+---+\n|   |\n+---+";
   if (kind === "image") return "<图片 URL 或 data URL>";
@@ -3254,12 +3682,16 @@ function workspaceOutputProtocolRequirements(graph, nodeId) {
     .filter((slot) => {
       const name = String(slot?.name || "").trim();
       const type = String(slot?.type || "");
-      return name && type !== "node" && name !== "next" && name !== "result" && name !== "content";
+      return name && type !== "node" && name !== "next" && name !== "result" && name !== "content" && name !== "displayType";
     })
     .map((slot) => String(slot.name).trim());
-  const resultKind = displayByField.get("result") || workspaceDownstreamOutputKindForField(graph, nodeId, "result") || "";
+  const configuredResultKind = isWorkspaceOneClickTaskDefinitionId(instance.definitionId)
+    ? workspaceContextRunDisplayKind(instance)
+    : "";
+  const resultKind = displayByField.get("result") || workspaceDownstreamOutputKindForField(graph, nodeId, "result") || configuredResultKind || "";
   const resultExtByKind = {
     html: "html",
+    react: "json",
     markdown: "md",
     mermaid: "mmd",
     ascii: "txt",
@@ -3271,6 +3703,7 @@ function workspaceOutputProtocolRequirements(graph, nodeId) {
   const resultKindText = resultKind ? ` ${resultKind}` : "";
   const resultGuidance = {
     html: "内容必须是可直接放入 iframe 渲染的 HTML；不要使用 Markdown 代码围栏。",
+    react: "内容必须是 React 工程 JSON，包含 title、entry、files；files 至少包含 src/App.jsx，可包含 CSS 文件。",
     markdown: "内容必须是 Markdown 正文；除非正文确实需要代码块，否则不要额外包裹代码围栏。",
     mermaid: "内容必须是 Mermaid 图表代码，例如 flowchart/sequenceDiagram；不要使用 Markdown 代码围栏。",
     ascii: "内容必须是纯文本/ASCII 图或表格；不要输出 HTML 或 Markdown 装饰。",
@@ -3377,8 +3810,11 @@ function workspaceRunPlan(graph, runNodeId, scopedRoot = "") {
       if (needed.size !== before) visitControlDownstream(next);
     }
   };
+  const targetDefId = String(instances[target]?.definitionId || "");
+  const targetIsRunController = targetDefId === "workspace_run" || targetDefId === "workspace_scheduled_run";
+  if (!targetIsRunController) needed.add(target);
   visitControlDownstream(target);
-  needed.delete(target);
+  if (targetIsRunController) needed.delete(target);
   const dependencyQueue = Array.from(needed);
   for (let i = 0; i < dependencyQueue.length; i++) {
     const id = dependencyQueue[i];
@@ -3832,6 +4268,135 @@ function workspaceBuildImplementationPrompt(instance, nodeId, opts = {}) {
   ].filter((line) => line !== "").join("\n");
 }
 
+function workspaceImplementationPlanNeighbors(graph, nodeId) {
+  const instances = graph?.instances && typeof graph.instances === "object" ? graph.instances : {};
+  const edges = Array.isArray(graph?.edges) ? graph.edges : [];
+  const incoming = [];
+  const outgoing = [];
+  for (const edge of edges) {
+    if (String(edge?.target || "") === String(nodeId)) {
+      const sourceId = String(edge?.source || "");
+      if (sourceId) incoming.push(`${sourceId} (${instances[sourceId]?.label || instances[sourceId]?.definitionId || "node"})`);
+    }
+    if (String(edge?.source || "") === String(nodeId)) {
+      const targetId = String(edge?.target || "");
+      if (targetId) outgoing.push(`${targetId} (${instances[targetId]?.label || instances[targetId]?.definitionId || "node"})`);
+    }
+  }
+  return {
+    incoming: workspaceUniqueImplementationList(incoming, 20),
+    outgoing: workspaceUniqueImplementationList(outgoing, 20),
+  };
+}
+
+function workspaceBuildPlannedImplementationPrompt(graph, nodeId, opts = {}) {
+  const instance = graph?.instances?.[nodeId] || {};
+  const defId = String(instance?.definitionId || "").trim();
+  const label = String(instance?.label || nodeId || "node").trim();
+  const mode = workspaceImplementationModeForInstance(instance);
+  const inputValues = opts.inputValues || {};
+  const task = workspaceResolveBodyPlaceholders(instance?.body || "", inputValues).trim();
+  const scriptRef = String(instance?.scriptRef || "").trim();
+  const inlineScript = String(instance?.script || "").trim();
+  const previousImplementation = opts.previousImplementation
+    ? workspaceClipImplementationText(opts.previousImplementation, 12000)
+    : "";
+  const neighbors = workspaceImplementationPlanNeighbors(graph, nodeId);
+  return [
+    "你要为 AgentFlow Workspace 的一个重复执行节点提前写“实现方案”Markdown。",
+    "这个 implementation.md 会在后续 Scheduled Run 执行同一节点前作为参考上下文，目标是减少重复推理、提前固定执行路径和脚本约定。",
+    "",
+    "要求：",
+    "- 基于当前节点任务、输入槽、上下游关系，写一份可复用的执行方案。",
+    "- 写清楚下次运行应优先采用的步骤、文件路径、输入输出协议、错误处理和可复用约定。",
+    "- 如果是脚本类节点，重点写清楚脚本入口、环境变量、输入 JSON/输出文件协议、幂等性和失败重试策略。",
+    "- 不要假装已经执行过；这是执行前优化计划，不要引用不存在的实际结果。",
+    "- 只输出 Markdown 正文，不要输出代码围栏包裹整篇。",
+    "",
+    "## 节点信息",
+    "",
+    `nodeId: ${nodeId}`,
+    `label: ${label}`,
+    `definitionId: ${defId || "(unknown)"}`,
+    `mode: ${mode}`,
+    scriptRef ? `scriptRef: ${scriptRef}` : "",
+    inlineScript ? `inlineScript: ${workspaceClipImplementationText(inlineScript, 2400)}` : "",
+    "",
+    "## 当前任务",
+    "",
+    workspaceClipImplementationText(task || instance?.body || scriptRef || inlineScript || "(无显式任务)", 8000),
+    "",
+    "## 可见输入",
+    "",
+    JSON.stringify(inputValues || {}, null, 2),
+    "",
+    "## 上下游",
+    "",
+    `incoming: ${neighbors.incoming.length ? neighbors.incoming.join(", ") : "(none)"}`,
+    `outgoing: ${neighbors.outgoing.length ? neighbors.outgoing.join(", ") : "(none)"}`,
+    "",
+    previousImplementation ? "## 上一版实现方案" : "",
+    previousImplementation || "",
+  ].filter((line) => line !== "").join("\n");
+}
+
+async function workspaceGeneratePlannedImplementationMarkdown({
+  scopedRoot,
+  graph,
+  nodeId,
+  inputValues,
+  implementationPath,
+  previousImplementation,
+  runPackage,
+  modelKey,
+  userCtx,
+  emit,
+  onActiveChild,
+}) {
+  const prompt = workspaceBuildPlannedImplementationPrompt(graph, nodeId, {
+    inputValues,
+    previousImplementation,
+  });
+  let content = "";
+  let lastAssistant = "";
+  let resultText = "";
+  emit?.({ type: "status", nodeId, line: `Generate implementation plan: ${nodeId}` });
+  const handle = startComposerAgent({
+    uiWorkspaceRoot: scopedRoot,
+    cliWorkspace: runPackage?.nodeRunDir || scopedRoot,
+    prompt,
+    modelKey,
+    agentflowUserId: userCtx?.userId || "",
+    extraEnv: runtimeEnvForUser(userCtx, {
+      AGENTFLOW_IMPLEMENTATION_REF: implementationPath || "",
+      AGENTFLOW_NODE_RUN_DIR: runPackage?.nodeRunDir || "",
+      AGENTFLOW_NODE_TMP_DIR: runPackage?.nodeTmpDir || "",
+      AGENTFLOW_OUTPUTS_DIR: runPackage?.outputsDir || "",
+    }),
+    onStreamEvent: (ev) => {
+      if (ev?.type === "natural" && ev.kind === "assistant" && typeof ev.text === "string") {
+        lastAssistant = ev.text;
+        content += (content ? "\n" : "") + ev.text;
+      } else if (ev?.type === "natural" && ev.kind === "result" && typeof ev.text === "string") {
+        resultText = ev.text;
+      }
+    },
+    onToolCall: (subtype, toolName) => {
+      const sub = subtype ? String(subtype) : "";
+      const tool = toolName ? String(toolName) : "";
+      emit?.({ type: "status", nodeId, line: `优化工具 ${tool || "thinking"}${sub ? ` (${sub})` : ""}` });
+    },
+  });
+  if (typeof onActiveChild === "function") onActiveChild(handle.child || null);
+  try {
+    await handle.finished;
+  } finally {
+    if (typeof onActiveChild === "function") onActiveChild(null);
+  }
+  const markdown = String(resultText || lastAssistant || content || "").trim();
+  return markdown.replace(/^```(?:markdown|md)?\s*/i, "").replace(/```\s*$/i, "").trim();
+}
+
 async function workspaceGenerateImplementationMarkdown({
   scopedRoot,
   nodeId,
@@ -4033,39 +4598,125 @@ async function workspaceTryPersistNodeImplementation(scopedRoot, graph, nodeId,
   }
 }
 
-function parseWorkspaceSkillKeys(raw) {
-  const text = String(raw || "").trim();
-  if (!text) return [];
-  try {
-    const parsed = JSON.parse(text);
-    if (Array.isArray(parsed)) return parsed.map((item) => String(item || "").trim()).filter(Boolean);
-  } catch {
-    /* plain list fallback */
-  }
-  return text.split(/[\n,]+/).map((item) => item.trim()).filter(Boolean);
-}
-
-function selectedSkillKeysFromInstance(instance) {
-  const bodyKeys = parseWorkspaceSkillKeys(instance?.body || "");
-  if (bodyKeys.length > 0) return bodyKeys;
-  const slots = [...(Array.isArray(instance?.input) ? instance.input : []), ...(Array.isArray(instance?.output) ? instance.output : [])];
-  const slot = slots.find((item) => item?.name === "skillsContext") || slots.find((item) => item?.name === "skillKeys");
-  return parseWorkspaceSkillKeys(workspaceSlotValue(slot) || "");
-}
-
-function selectedMcpServerNamesFromInstance(instance) {
-  const bodyNames = parseWorkspaceSkillKeys(instance?.body || "");
-  if (bodyNames.length > 0) return bodyNames;
-  const slots = [...(Array.isArray(instance?.input) ? instance.input : []), ...(Array.isArray(instance?.output) ? instance.output : [])];
-  const slot = slots.find((item) => item?.name === "mcpContext") || slots.find((item) => item?.name === "serverNames");
-  return parseWorkspaceSkillKeys(workspaceSlotValue(slot) || "");
+function workspaceShouldOptimizeNodeImplementation(instance) {
+  const defId = String(instance?.definitionId || "").trim();
+  if (!defId) return false;
+  if (defId === "workspace_run" || defId === "workspace_scheduled_run") return false;
+  if (defId.startsWith("display_") || defId.startsWith("provide_") || defId.startsWith("control_")) return false;
+  return defId === "agent_subAgent" || defId === "tool_nodejs" || defId.startsWith("tool_");
 }
 
-function workspaceUpstreamSkillBlocks(graph, nodeId, outputs) {
-  const edges = Array.isArray(graph?.edges) ? graph.edges : [];
-  const blocks = edges
-    .filter((edge) => String(edge?.target || "") === String(nodeId))
-    .filter((edge) => {
+async function workspaceOptimizeNodeImplementation(scopedRoot, graph, nodeId, opts = {}) {
+  const current = graph?.instances?.[nodeId];
+  if (!current || !workspaceShouldOptimizeNodeImplementation(current)) {
+    return { optimized: false, skipped: true, nodeId, reason: "not optimizable" };
+  }
+  const implementationRef = String(current.implementationRef || "").trim() || workspaceDefaultImplementationRef(nodeId);
+  const abs = workspaceResolveFlowFile(scopedRoot, implementationRef, "implementationRef");
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  const previousImplementation = fs.existsSync(abs) && fs.statSync(abs).isFile()
+    ? workspaceReadTextFileIfExists(abs, 60000)
+    : "";
+  const inputValues = workspaceInputValues(graph, nodeId, new Map(), scopedRoot);
+  const runPackage = workspaceCreateNodeRunPackage(opts.runTmpRoot || workspaceCreateRunTmpRoot(scopedRoot, "optimize"), nodeId, {
+    scopedRoot,
+    cwd: scopedRoot,
+    task: workspaceResolveBodyPlaceholders(current.body || current.script || current.scriptRef || "", inputValues),
+    inputValues,
+  });
+  const markdown = await workspaceGeneratePlannedImplementationMarkdown({
+    scopedRoot,
+    graph,
+    nodeId,
+    inputValues: { ...inputValues, ...(runPackage.inputValues || {}) },
+    implementationPath: implementationRef,
+    previousImplementation,
+    runPackage,
+    modelKey: opts.modelKey || "",
+    userCtx: opts.userCtx || {},
+    emit: opts.emit,
+    onActiveChild: opts.onActiveChild,
+  });
+  if (!markdown.trim()) throw new Error(`Implementation plan is empty for node ${nodeId}`);
+  fs.writeFileSync(abs, markdown.trimEnd() + "\n", "utf-8");
+  const explicitMode = String(current.implementationMode || "").trim();
+  graph.instances[nodeId] = {
+    ...current,
+    implementationRef,
+    implementationMode: explicitMode || workspaceImplementationModeForInstance(current),
+  };
+  return { optimized: true, nodeId, implementationRef };
+}
+
+async function workspaceOptimizeRunImplementations(root, scopedRoot, payload, userCtx = {}, opts = {}) {
+  const graph = hydrateWorkspaceGraphForRuntime(root, {
+    root: scopedRoot,
+    flowId: payload.flowId || "",
+    flowSource: payload.flowSource || "user",
+    archived: payload.archived === true || payload.flowArchived === true,
+  }, payload.graph || {}, userCtx);
+  const runNodeId = String(payload?.runNodeId || "").trim();
+  const plan = workspaceRunPlan(graph, runNodeId, scopedRoot);
+  const runTmpRoot = workspaceCreateRunTmpRoot(scopedRoot, `${runNodeId || "run"}-optimize`);
+  const optimized = [];
+  const skipped = [];
+  for (const nodeId of plan.order) {
+    const instance = graph.instances?.[nodeId];
+    if (!workspaceShouldOptimizeNodeImplementation(instance)) {
+      skipped.push({ nodeId, reason: "not optimizable" });
+      continue;
+    }
+    opts.emit?.({ type: "node-start", nodeId, definitionId: instance.definitionId, phase: "optimize" });
+    const result = await workspaceOptimizeNodeImplementation(scopedRoot, graph, nodeId, {
+      runTmpRoot,
+      modelKey: payload.model || "",
+      userCtx,
+      emit: opts.emit,
+      onActiveChild: opts.onActiveChild,
+    });
+    optimized.push(result);
+    opts.emit?.({ type: "node-done", nodeId, definitionId: instance.definitionId, phase: "optimize", implementationRef: result.implementationRef });
+  }
+  return { ok: true, graph, order: plan.order, optimized, skipped };
+}
+
+function parseWorkspaceSkillKeys(raw) {
+  const text = String(raw || "").trim();
+  if (!text) return [];
+  try {
+    const parsed = JSON.parse(text);
+    if (Array.isArray(parsed)) return parsed.map((item) => String(item || "").trim()).filter(Boolean);
+  } catch {
+    /* plain list fallback */
+  }
+  return text.split(/[\n,]+/).map((item) => item.trim()).filter(Boolean);
+}
+
+function selectedSkillKeysFromInstance(instance) {
+  const bodyKeys = parseWorkspaceSkillKeys(instance?.body || "");
+  if (bodyKeys.length > 0) return bodyKeys;
+  return selectedSkillKeysFromConfigSlots(instance);
+}
+
+function selectedSkillKeysFromConfigSlots(instance) {
+  const slots = [...(Array.isArray(instance?.input) ? instance.input : []), ...(Array.isArray(instance?.output) ? instance.output : [])];
+  const slot = slots.find((item) => item?.name === "skillsContext") || slots.find((item) => item?.name === "skillKeys");
+  return parseWorkspaceSkillKeys(workspaceSlotValue(slot) || "");
+}
+
+function selectedMcpServerNamesFromInstance(instance) {
+  const bodyNames = parseWorkspaceSkillKeys(instance?.body || "");
+  if (bodyNames.length > 0) return bodyNames;
+  const slots = [...(Array.isArray(instance?.input) ? instance.input : []), ...(Array.isArray(instance?.output) ? instance.output : [])];
+  const slot = slots.find((item) => item?.name === "mcpContext") || slots.find((item) => item?.name === "serverNames");
+  return parseWorkspaceSkillKeys(workspaceSlotValue(slot) || "");
+}
+
+function workspaceUpstreamSkillBlocks(graph, nodeId, outputs) {
+  const edges = Array.isArray(graph?.edges) ? graph.edges : [];
+  const blocks = edges
+    .filter((edge) => String(edge?.target || "") === String(nodeId))
+    .filter((edge) => {
       const slot = workspaceTargetSlotForEdge(graph, edge);
       return String(slot?.name || "") === "skillsContext";
     })
@@ -4161,6 +4812,34 @@ function workspaceNodeWorkspaceContextBlock(graph, nodeId, outputs, scopedRoot =
   return lines.join("\n");
 }
 
+function workspaceDefaultWorkspaceContextBlock(scopedRoot = "", logicalCwd = "") {
+  const root = scopedRoot ? path.resolve(scopedRoot) : "";
+  const cwd = logicalCwd ? path.resolve(logicalCwd) : root;
+  if (!root && !cwd) return "";
+  return [
+    "## Workspace 上下文",
+    "",
+    "当前 Agent 仍在独立节点目录中运行，文件边界以“文件边界”章节为准。",
+    cwd ? `- 当前工作目录上下文：\`${cwd}\`` : "",
+    root ? `- 流程目录：\`${root}\`` : "",
+    "",
+    "使用要求：",
+    "- 读取、搜索、分析当前项目或资料时，优先从“当前工作目录上下文”开始；不要把节点的“当前执行目录”误认为项目根目录。",
+    "- 临时文件和正式产物仍必须按“文件边界”写入本节点的 `tmp/` 与 `outputs/`。",
+  ].filter((line) => line !== "").join("\n");
+}
+
+function isWorkspaceOneClickTaskDefinitionId(definitionId) {
+  const id = String(definitionId || "");
+  return id === "workspace_one_click_task" || id === "workspace_context_run";
+}
+
+function workspaceContextRunDisplayKind(instance) {
+  const raw = workspaceSlotValue(workspaceSlotByName(instance, "displayType")).trim().toLowerCase();
+  if (["markdown", "html", "react", "table", "chart", "ascii", "mermaid"].includes(raw)) return raw;
+  return "markdown";
+}
+
 function mergeWorkspaceSkillBlocks(...values) {
   const blocks = values
     .map((value) => String(value || ""))
@@ -4669,6 +5348,12 @@ async function workspaceRunToolNodejsScript({
   });
 }
 
+function workspaceNodeModelKey(instance, fallback = "") {
+  const own = String(instance?.model || "").trim();
+  if (own && own !== "default") return own;
+  return String(fallback || "").trim();
+}
+
 async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts = {}) {
   const graph = hydrateWorkspaceGraphForRuntime(root, {
     root: scopedRoot,
@@ -4911,17 +5596,49 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       const inputSlots = Array.isArray(instance.input) ? instance.input : [];
       const pathSlot = inputSlots.find((slot) => String(slot?.name || "") === "path") ||
         inputSlots.find((slot) => String(slot?.name || "") === "target");
+      const labelSlot = inputSlots.find((slot) => String(slot?.name || "") === "label");
+      const contextSlot = inputSlots.find((slot) => String(slot?.name || "") === "workspaceContext");
       const candidate = workspaceSlotValue(pathSlot) || workspaceInstanceText(instance) || inputText;
       const abs = candidate ? path.resolve(scopedRoot, candidate) : scopedRoot;
-      if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) cwd = abs;
-      publishNodeOutput(nodeId, cwd, { emitGraph: true });
+      if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
+        throw new Error(`Load Workspace path does not exist or is not a directory: ${abs}`);
+      }
+      cwd = abs;
+      const parsedContext = parseJsonText(workspaceSlotValue(contextSlot), {});
+      const configuredContext = parsedContext && typeof parsedContext === "object" && !Array.isArray(parsedContext) ? parsedContext : {};
+      const workspaceContext = {
+        ...configuredContext,
+        version: 1,
+        label: workspaceSlotValue(labelSlot) || path.basename(cwd) || "workspace",
+        cwd,
+        workspaceRoot: cwd,
+        pipelineWorkspace: path.resolve(scopedRoot),
+        previous: null,
+      };
+      let nextInstance = workspaceSetOutputSlot(instance, "workspaceContext", JSON.stringify(workspaceContext));
+      nextInstance = workspaceSetOutputSlot(nextInstance, "cwd", cwd);
+      graph.instances[nodeId] = nextInstance;
+      publishNodeOutput(nodeId, JSON.stringify(workspaceContext), { emitGraph: true });
+      emit({ type: "graph", nodeId, graph });
       emit({ type: "node-done", nodeId, definitionId: defId });
       continue;
     }
 
     if (defId === "control_user_workspace") {
       cwd = path.resolve(os.homedir());
-      publishNodeOutput(nodeId, cwd, { emitGraph: true });
+      const workspaceContext = {
+        version: 1,
+        label: "home",
+        cwd,
+        workspaceRoot: cwd,
+        pipelineWorkspace: path.resolve(scopedRoot),
+        previous: null,
+      };
+      let nextInstance = workspaceSetOutputSlot(instance, "workspaceContext", JSON.stringify(workspaceContext));
+      nextInstance = workspaceSetOutputSlot(nextInstance, "cwd", cwd);
+      graph.instances[nodeId] = nextInstance;
+      publishNodeOutput(nodeId, JSON.stringify(workspaceContext), { emitGraph: true });
+      emit({ type: "graph", nodeId, graph });
       emit({ type: "node-done", nodeId, definitionId: defId });
       continue;
     }
@@ -5180,6 +5897,10 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
         title,
         layout,
         nodeIds,
+        expiresMode: payload.expiresMode,
+        expiresInDays: payload.expiresInDays,
+        permanent: payload.permanent,
+        expiresAt: payload.expiresAt,
       });
       const url = displayShareOutputUrl(share.id, baseUrl);
       let nextInstance = workspaceSetOutputSlot(instance, "url", url);
@@ -5193,6 +5914,7 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
     }
 
     if (defId === "tool_nodejs") {
+      const nodeModelKey = workspaceNodeModelKey(instance, modelKey);
       const prepareStartedAt = Date.now();
       const inputValues = workspaceInputValues(graph, nodeId, outputs, scopedRoot);
       const runPackage = workspaceCreateNodeRunPackage(runTmpRoot, nodeId, {
@@ -5226,7 +5948,7 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
         resultContent,
         structured: normalizedAgentOutput,
         runPackage,
-        modelKey,
+        modelKey: nodeModelKey,
         userCtx,
         emit: (event) => emit({ ...event, nodeId }),
         onActiveChild: opts.onActiveChild,
@@ -5238,12 +5960,15 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       continue;
     }
 
+    const isContextRunNode = isWorkspaceOneClickTaskDefinitionId(defId);
+    const nodeModelKey = workspaceNodeModelKey(instance, modelKey);
     const prepareStartedAt = Date.now();
     const inputValues = workspaceInputValues(graph, nodeId, outputs, scopedRoot);
     const relevantInputs = workspaceRelevantInputValues(instance.body || "", inputValues);
     const upstreamText = workspaceTaskUpstreamText(graph, nodeId, outputs, relevantInputs.placeholders, scopedRoot);
     const upstreamSkillBlocks = workspaceUpstreamSkillBlocks(graph, nodeId, outputs);
-    const promptSkillsBlock = mergeWorkspaceSkillBlocks(upstreamSkillBlocks);
+    const ownSkillBlock = isContextRunNode ? loadSkillsBlockForKeys(selectedSkillKeysFromConfigSlots(instance)) : "";
+    const promptSkillsBlock = mergeWorkspaceSkillBlocks(ownSkillBlock, upstreamSkillBlocks);
     const promptMcpBlock = workspaceUpstreamMcpBlocks(graph, nodeId, outputs);
     const runPackage = workspaceCreateNodeRunPackage(runTmpRoot, nodeId, {
       scopedRoot,
@@ -5265,7 +5990,10 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       // Best-effort debug artifact only.
     }
     const historyBlock = workspaceNodeHistoryBlock(nodeId, scopedRoot, runPackage);
-    const workspaceContextBlock = workspaceNodeWorkspaceContextBlock(graph, nodeId, outputs, scopedRoot, cwd);
+    let workspaceContextBlock = workspaceNodeWorkspaceContextBlock(graph, nodeId, outputs, scopedRoot, cwd);
+    if (isContextRunNode && workspaceBoolSlot(instance, "includeWorkspaceContext", true) && !workspaceContextBlock) {
+      workspaceContextBlock = workspaceDefaultWorkspaceContextBlock(scopedRoot, cwd);
+    }
     const prompt = workspaceNodePrompt(graph, nodeId, promptUpstreamText, promptSkillsBlock, promptMcpBlock, runtimeInputValues, runPackage, historyBlock, workspaceContextBlock);
     try {
       fs.writeFileSync(path.join(runPackage.nodeRunDir, "prompt.md"), prompt.trimEnd() + "\n", "utf-8");
@@ -5280,6 +6008,7 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       nodeRunDir: runPackage.nodeRunDir,
     });
     emit({ type: "natural", kind: "prompt", nodeId, text: prompt });
+    emit({ type: "status", nodeId, line: `Model: ${nodeModelKey || "default"}` });
     let content = "";
     const runHistoryEvents = [];
     const maxAttempts = 3;
@@ -5294,7 +6023,7 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
           uiWorkspaceRoot: scopedRoot,
           cliWorkspace: runPackage.nodeRunDir,
           prompt,
-          modelKey,
+          modelKey: nodeModelKey,
           agentflowUserId: userCtx.userId || "",
           extraEnv: runtimeEnv({
             AGENTFLOW_WORKSPACE_TMP_ROOT: runTmpRoot,
@@ -5364,15 +6093,20 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       resultContent,
       structured: normalizedAgentOutput,
       runPackage,
-      modelKey,
+      modelKey: nodeModelKey,
       userCtx,
       historyEvents: runHistoryEvents,
       emit: (event) => emit({ ...event, nodeId }),
       onActiveChild: opts.onActiveChild,
     });
     if (implementationUpdate.changed) graph.instances[nodeId] = implementationUpdate.instance;
+    let contextRunOutputChanged = false;
+    if (isContextRunNode) {
+      graph.instances[nodeId] = workspaceSetOutputSlot(graph.instances[nodeId] || instance, "displayType", workspaceContextRunDisplayKind(instance));
+      contextRunOutputChanged = true;
+    }
     const updatedDisplays = propagateNodeOutputDisplays(nodeId, resultContent);
-    if (slotUpdate.changed || implementationUpdate.changed || updatedDisplays.length) emit({ type: "graph", nodeId, displayNodeIds: updatedDisplays, graph });
+    if (slotUpdate.changed || implementationUpdate.changed || contextRunOutputChanged || updatedDisplays.length) emit({ type: "graph", nodeId, displayNodeIds: updatedDisplays, graph });
     emit({ type: "node-done", nodeId, definitionId: defId });
   }
   } finally {
@@ -5570,7 +6304,7 @@ const activeFlowRuns = new Map();
 const activeWorkspaceRuns = new Map();
 const WORKSPACE_SCHEDULES_FILENAME = "workspace-schedules.json";
 const WORKSPACE_SCHEDULE_POLL_MS = 30_000;
-const WORKSPACE_IMPLEMENTATION_REFERENCE_ENABLED = false;
+const WORKSPACE_IMPLEMENTATION_REFERENCE_ENABLED = true;
 const WORKSPACE_IMPLEMENTATION_SUMMARY_ENABLED = false;
 const WORKSPACE_NODE_HISTORY_MAX_CHARS = 80000;
 
@@ -5592,6 +6326,13 @@ function workspaceRunEntryKey(scopeKey, runId) {
   return `${scopeKey}:${String(runId || "").trim() || runLedgerId("workspace")}`;
 }
 
+function workspaceRuntimeNodeLabel(graph, nodeId, fallback = "Workspace Run") {
+  const id = String(nodeId || "").trim();
+  const instance = graph?.instances && typeof graph.instances === "object" ? graph.instances[id] : null;
+  const label = String(instance?.label || "").trim();
+  return label || id || fallback;
+}
+
 function workspaceActiveRunsForScope(scopeKey) {
   const key = String(scopeKey || "");
   return Array.from(activeWorkspaceRuns.entries())
@@ -5706,6 +6447,77 @@ function listWorkspaceScheduleStatusesForFlow(userCtx = {}, flowSource = "user",
     .sort((a, b) => String(a.scheduleNodeId || a.runNodeId || "").localeCompare(String(b.scheduleNodeId || b.runNodeId || "")));
 }
 
+function listWorkspaceScheduleStatuses(root, userCtx = {}) {
+  const registry = readWorkspaceScheduleRegistry();
+  const userId = String(userCtx.userId || "");
+  const flows = listFlowsJson(root, { ...userCtx, includeWorkspaceFlows: true })
+    .filter((flow) => !flow.archived && !isReadonlyBuiltinFlowSource(flow.source || "user"));
+  const rows = [];
+  for (const flow of flows) {
+    const flowId = String(flow.id || "");
+    const flowSource = String(flow.source || "user");
+    const scoped = resolveWorkspaceScopeRoot(root, { flowId, flowSource }, userCtx);
+    if (scoped.error || !scoped.root) continue;
+    let graph;
+    try {
+      graph = readWorkspaceGraph(scoped.root).graph;
+    } catch {
+      continue;
+    }
+    const instances = graph?.instances && typeof graph.instances === "object" ? graph.instances : {};
+    for (const [scheduleNodeId, instance] of Object.entries(instances)) {
+      if (String(instance?.definitionId || "") !== "workspace_scheduled_run") continue;
+      const config = normalizeWorkspaceScheduledRunConfig(instance.body || "");
+      const key = workspaceScheduleKey(userId, flowSource, flowId, scheduleNodeId);
+      const current = registry.schedules?.[key] && typeof registry.schedules[key] === "object" ? registry.schedules[key] : {};
+      const targetRunNodeId = workspaceScheduleInferTargetRunNodeId(graph, scheduleNodeId, config);
+      const scopeKey = workspaceRunKey(userCtx, flowSource, flowId);
+      const running = workspaceActiveRunsForScope(scopeKey).some(([, active]) => (
+        active?.scheduled === true &&
+        String(active?.runNodeId || "") === String(targetRunNodeId || scheduleNodeId)
+      ));
+      let nextRunAt = current.nextRunAt || null;
+      let lastStatus = current.lastStatus || (config.enabled ? "armed" : "disabled");
+      let lastError = current.lastError || "";
+      if (config.enabled && !nextRunAt) {
+        try {
+          nextRunAt = workspaceScheduleNextRunAt(config, new Date());
+        } catch (e) {
+          lastStatus = "invalid";
+          lastError = (e && e.message) || String(e);
+        }
+      }
+      rows.push({
+        kind: "workspace",
+        key,
+        flowId,
+        flowSource,
+        scheduleNodeId,
+        runNodeId: targetRunNodeId,
+        label: String(instance.label || "Scheduled Run"),
+        enabled: config.enabled,
+        cron: config.cron,
+        timezone: config.timezone,
+        preset: "",
+        nextRunAt,
+        lastTriggeredAt: current.lastTriggeredAt || null,
+        lastFinishedAt: current.lastFinishedAt || null,
+        lastRunId: current.lastRunId || "",
+        lastStatus,
+        lastError,
+        running,
+        waiting: 0,
+      });
+    }
+  }
+  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;
+}
+
 function workspaceScheduleInferTargetRunNodeId(graph, scheduleNodeId, config = {}) {
   const instances = graph?.instances && typeof graph.instances === "object" ? graph.instances : {};
   return String(instances[scheduleNodeId]?.definitionId || "") === "workspace_scheduled_run"
@@ -5713,6 +6525,35 @@ function workspaceScheduleInferTargetRunNodeId(graph, scheduleNodeId, config = {
     : "";
 }
 
+function setWorkspaceScheduleEnabled(root, payload = {}, authUser = {}, userCtx = {}) {
+  const flowId = String(payload.flowId || "").trim();
+  const flowSource = String(payload.flowSource || "user").trim() || "user";
+  const scheduleNodeId = String(payload.scheduleNodeId || "").trim();
+  if (!flowId) return { success: false, error: "Missing flowId" };
+  if (!scheduleNodeId) return { success: false, error: "Missing scheduleNodeId" };
+  if (!isValidFlowSourceWrite(flowSource)) return { success: false, error: "Cannot update readonly workspace schedule" };
+  const scoped = resolveWorkspaceScopeRoot(root, { flowId, flowSource }, userCtx);
+  if (scoped.error) return { success: false, error: scoped.error };
+  if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+    return { success: false, error: "Cannot update schedule for builtin or archived workspace" };
+  }
+  const { graph } = readWorkspaceGraph(scoped.root);
+  const instance = graph.instances?.[scheduleNodeId];
+  if (!instance || String(instance.definitionId || "") !== "workspace_scheduled_run") {
+    return { success: false, error: "Workspace schedule node not found" };
+  }
+  const config = normalizeWorkspaceScheduledRunConfig(instance.body || "");
+  const nextConfig = { ...config, enabled: payload.enabled === true };
+  graph.instances = { ...(graph.instances || {}) };
+  graph.instances[scheduleNodeId] = {
+    ...instance,
+    body: JSON.stringify(nextConfig),
+  };
+  fs.writeFileSync(workspaceGraphPath(scoped.root), JSON.stringify(graph, null, 2) + "\n", "utf-8");
+  const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, graph, authUser, userCtx);
+  return { success: true, workspaceSchedules };
+}
+
 function syncWorkspaceSchedulesForGraph(root, scoped, graph, authUser, userCtx = {}) {
   const flowId = String(scoped?.flowId || "").trim();
   const flowSource = String(scoped?.flowSource || "user");
@@ -5730,7 +6571,6 @@ function syncWorkspaceSchedulesForGraph(root, scoped, graph, authUser, userCtx =
   for (const [scheduleNodeId, instance] of Object.entries(instances)) {
     if (String(instance?.definitionId || "") !== "workspace_scheduled_run") continue;
     const config = normalizeWorkspaceScheduledRunConfig(instance.body || "");
-    if (!config.enabled) continue;
     const targetRunNodeId = workspaceScheduleInferTargetRunNodeId(graph, scheduleNodeId, config);
     const key = workspaceScheduleKey(userId, flowSource, flowId, scheduleNodeId);
     const previous = registry.schedules?.[key] && typeof registry.schedules[key] === "object" ? registry.schedules[key] : {};
@@ -5744,9 +6584,15 @@ function syncWorkspaceSchedulesForGraph(root, scoped, graph, authUser, userCtx =
     let lastStatus = previous.lastStatus || "armed";
     let lastError = previous.lastError || "";
     try {
-      nextRunAt = previousMatches && Number.isFinite(previousNext) && previousNext > now
+      nextRunAt = !config.enabled
+        ? null
+        : previousMatches && Number.isFinite(previousNext) && previousNext > now
         ? previousNext
         : workspaceScheduleNextRunAt(config, new Date(now));
+      if (!config.enabled) {
+        lastStatus = "disabled";
+        lastError = "";
+      }
       if (!targetRunNodeId) {
         lastStatus = "invalid";
         lastError = "Scheduled Run node is missing";
@@ -5759,7 +6605,7 @@ function syncWorkspaceSchedulesForGraph(root, scoped, graph, authUser, userCtx =
     schedules[key] = {
       ...previous,
       key,
-      enabled: true,
+      enabled: config.enabled,
       userId,
       username: String(authUser?.username || previous.username || userId),
       flowId,
@@ -5799,6 +6645,21 @@ function updateWorkspaceScheduleEntry(key, patch) {
 async function runWorkspaceScheduledEntry(root, entry) {
   const userCtx = { userId: String(entry.userId || "") };
   const scopeKey = workspaceRunKey(userCtx, entry.flowSource || "user", entry.flowId || "");
+  const authUsers = readAuthUsers();
+  const authUser = authUsers[userCtx.userId] || {};
+  const runId = runLedgerId("workspace");
+  const runLog = createWorkspaceRunLogSession({
+    runId,
+    userId: userCtx.userId,
+    username: String(authUser.username || entry.username || userCtx.userId),
+    flowId: String(entry.flowId || ""),
+    flowSource: String(entry.flowSource || "user"),
+    scheduleNodeId: String(entry.scheduleNodeId || entry.key?.split(":").pop() || ""),
+    runNodeId: String(entry.targetRunNodeId || entry.runNodeId || ""),
+    scheduled: true,
+    trigger: "scheduled",
+    label: String(entry.label || "Scheduled Run"),
+  });
   const fallbackConfig = {
     enabled: true,
     cron: String(entry.cron || "0 9 * * *"),
@@ -5819,10 +6680,14 @@ async function runWorkspaceScheduledEntry(root, entry) {
     flowSource: entry.flowSource || "user",
   }, userCtx);
   if (scoped.error || scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+    const error = scoped.error || "Workspace schedule target is not writable";
+    appendWorkspaceRunLogEvent(runLog.runId, { type: "error", error });
+    finishWorkspaceRunLogSession(runLog.runId, "failed", { error });
     updateWorkspaceScheduleEntry(entry.key, {
       nextRunAt,
       lastStatus: "error",
-      lastError: scoped.error || "Workspace schedule target is not writable",
+      lastRunId: runLog.runId,
+      lastError: error,
       lastErrorAt: Date.now(),
     });
     return;
@@ -5834,31 +6699,44 @@ async function runWorkspaceScheduledEntry(root, entry) {
   const config = normalizeWorkspaceScheduledRunConfig(instance?.body || "");
   nextRunAt = computeNext(config);
   if (!instance || String(instance.definitionId || "") !== "workspace_scheduled_run" || !config.enabled) {
+    appendWorkspaceRunLogEvent(runLog.runId, { type: "disabled", scheduleNodeId });
+    finishWorkspaceRunLogSession(runLog.runId, "disabled");
     updateWorkspaceScheduleEntry(entry.key, {
       enabled: false,
       nextRunAt: null,
       lastStatus: "disabled",
+      lastRunId: runLog.runId,
     });
     return;
   }
   const targetRunNodeId = workspaceScheduleInferTargetRunNodeId(graph, scheduleNodeId, config);
+  const scheduleAlias = workspaceRuntimeNodeLabel(graph, scheduleNodeId, String(entry.label || "Scheduled Run"));
   if (!targetRunNodeId) {
+    const error = "Scheduled Run node is missing";
+    appendWorkspaceRunLogEvent(runLog.runId, { type: "invalid", error, scheduleNodeId });
+    finishWorkspaceRunLogSession(runLog.runId, "failed", { error });
     updateWorkspaceScheduleEntry(entry.key, {
       nextRunAt,
       lastStatus: "invalid",
-      lastError: "Scheduled Run node is missing",
+      lastRunId: runLog.runId,
+      lastError: error,
       lastErrorAt: Date.now(),
     });
     return;
   }
+  appendWorkspaceRunLogEvent(runLog.runId, { type: "scheduler-triggered", scheduleNodeId, runNodeId: targetRunNodeId, cron: config.cron, timezone: config.timezone });
   let plan;
   try {
     plan = workspaceRunPlan(graph, targetRunNodeId, scoped.root);
   } catch (e) {
+    const error = (e && e.message) || String(e);
+    appendWorkspaceRunLogEvent(runLog.runId, { type: "error", error });
+    finishWorkspaceRunLogSession(runLog.runId, "failed", { error, runNodeId: targetRunNodeId });
     updateWorkspaceScheduleEntry(entry.key, {
       nextRunAt,
       lastStatus: "failed",
-      lastError: (e && e.message) || String(e),
+      lastRunId: runLog.runId,
+      lastError: error,
       lastErrorAt: Date.now(),
     });
     return;
@@ -5866,19 +6744,25 @@ async function runWorkspaceScheduledEntry(root, entry) {
   const plannedNodeIds = workspaceRunPlanNodeIds(targetRunNodeId, plan);
   const conflict = workspaceFindActiveRunConflict(scopeKey, plannedNodeIds);
   if (conflict) {
+    appendWorkspaceRunLogEvent(runLog.runId, {
+      type: "skipped",
+      reason: "busy",
+      runNodeId: targetRunNodeId,
+      conflictRunId: conflict.entry?.runId || "",
+      conflictNodeIds: conflict.conflictNodeIds,
+    });
+    finishWorkspaceRunLogSession(runLog.runId, "skipped", { runNodeId: targetRunNodeId, error: "" });
     updateWorkspaceScheduleEntry(entry.key, {
       nextRunAt,
       lastSkippedAt: Date.now(),
       lastStatus: "skipped: busy",
+      lastRunId: runLog.runId,
       lastError: "",
     });
     return;
   }
 
   const controller = new AbortController();
-  const authUsers = readAuthUsers();
-  const authUser = authUsers[userCtx.userId] || {};
-  const runId = runLedgerId("workspace");
   const runKey = workspaceRunEntryKey(scopeKey, runId);
   const runEntry = {
     scopeKey,
@@ -5890,6 +6774,7 @@ async function runWorkspaceScheduledEntry(root, entry) {
     runNodeId: targetRunNodeId,
     flowId: String(entry.flowId || ""),
     flowSource: String(entry.flowSource || "user"),
+    label: scheduleAlias,
     plannedNodeIds,
     startedAt: Date.now(),
     scheduled: true,
@@ -5924,6 +6809,7 @@ async function runWorkspaceScheduledEntry(root, entry) {
     }, userCtx, {
       signal: controller.signal,
       onActiveChild: setActiveChild,
+      onEvent: (event) => appendWorkspaceRunLogEvent(runLog.runId, event),
     });
     const currentGraph = readWorkspaceGraph(scoped.root).graph;
     const touchedIds = workspaceRunTouchedNodeIds(result);
@@ -5931,6 +6817,11 @@ async function runWorkspaceScheduledEntry(root, entry) {
     fs.writeFileSync(graphPath, JSON.stringify(mergedGraph, null, 2) + "\n", "utf-8");
     const endedAt = Date.now();
     appendWorkspaceRunFinished({ ...runEntry, endedAt, durationMs: endedAt - runEntry.startedAt }, "success");
+    finishWorkspaceRunLogSession(runLog.runId, "success", {
+      endedAt,
+      durationMs: endedAt - runEntry.startedAt,
+      runNodeId: targetRunNodeId,
+    });
     updateWorkspaceScheduleEntry(entry.key, {
       nextRunAt: computeNext(config),
       lastFinishedAt: endedAt,
@@ -5939,15 +6830,23 @@ async function runWorkspaceScheduledEntry(root, entry) {
     });
   } catch (e) {
     const endedAt = Date.now();
+    const error = (e && e.message) || String(e);
     appendWorkspaceRunFinished({ ...runEntry, endedAt, durationMs: endedAt - runEntry.startedAt }, "failed");
+    appendWorkspaceRunLogEvent(runLog.runId, { type: "error", error, ts: endedAt });
+    finishWorkspaceRunLogSession(runLog.runId, "failed", {
+      endedAt,
+      durationMs: endedAt - runEntry.startedAt,
+      runNodeId: targetRunNodeId,
+      error,
+    });
     updateWorkspaceScheduleEntry(entry.key, {
       nextRunAt: computeNext(config),
       lastFinishedAt: endedAt,
       lastStatus: "failed",
-      lastError: (e && e.message) || String(e),
+      lastError: error,
       lastErrorAt: endedAt,
     });
-    log.info(`[workspace-scheduler] failed ${entry.flowId}/${targetRunNodeId}: ${(e && e.message) || String(e)}`);
+    log.info(`[workspace-scheduler] failed ${entry.flowId}/${targetRunNodeId}: ${error}`);
   } finally {
     if (activeWorkspaceRuns.get(runKey) === runEntry) activeWorkspaceRuns.delete(runKey);
   }
@@ -6171,6 +7070,29 @@ export function startUiServer({
 
     const authUser = getAuthUserFromRequest(req);
     const userCtx = authUser ? { userId: authUser.userId, isAdmin: Boolean(authUser.isAdmin) } : {};
+    if (req.method === "GET" && url.pathname === "/api/auth/session-token") {
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Unauthorized" });
+        return;
+      }
+      json(res, 200, { token: getSessionTokenFromRequest(req) || "" });
+      return;
+    }
+    if (req.method === "GET" && url.pathname === "/api/display/shares") {
+      try {
+        if (!authUser?.userId) {
+          json(res, 401, { error: "Unauthorized" });
+          return;
+        }
+        json(res, 200, {
+          shares: listDisplaySharesForUser(userCtx, requestPublicBaseUrl(req)),
+        });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/display/share") {
       try {
         const id = String(url.searchParams.get("id") || "").trim();
@@ -6195,6 +7117,62 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "PATCH" && url.pathname === "/api/display/share") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        if (!authUser?.userId) {
+          json(res, 401, { error: "Unauthorized" });
+          return;
+        }
+        const id = String(payload?.id || url.searchParams.get("id") || "").trim();
+        if (!id) {
+          json(res, 400, { error: "Missing display share id" });
+          return;
+        }
+        const result = updateDisplayShareExpiryForUser(id, userCtx, payload);
+        if (result.error) {
+          json(res, result.status || 400, { error: result.error });
+          return;
+        }
+        json(res, 200, {
+          ok: true,
+          share: displayShareSummary(result.share, requestPublicBaseUrl(req)),
+        });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "DELETE" && url.pathname === "/api/display/share") {
+      try {
+        if (!authUser?.userId) {
+          json(res, 401, { error: "Unauthorized" });
+          return;
+        }
+        const id = String(url.searchParams.get("id") || "").trim();
+        if (!id) {
+          json(res, 400, { error: "Missing display share id" });
+          return;
+        }
+        const result = deleteDisplayShareForUser(id, userCtx);
+        if (result.error) {
+          json(res, result.status || 400, { error: result.error });
+          return;
+        }
+        json(res, 200, { ok: true });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/display/file/raw") {
       try {
         const id = String(url.searchParams.get("id") || "").trim();
@@ -6631,6 +7609,40 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/workspaces") {
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: url.searchParams.get("flowId") || "",
+          flowSource: url.searchParams.get("flowSource") || "user",
+          archived: url.searchParams.get("archived") === "1",
+        }, userCtx);
+        const scopedRoot = scoped.error ? root : scoped.root;
+        json(res, 200, {
+          path: userWorkspacesPath(userCtx),
+          workspaces: listConfiguredWorkspaces(root, scopedRoot, userCtx),
+          customWorkspaces: readUserWorkspaces(userCtx),
+        });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/workspaces") {
+      try {
+        const payload = await readJson(req);
+        const customWorkspaces = writeUserWorkspaces(userCtx, payload?.workspaces || payload?.customWorkspaces || []);
+        json(res, 200, {
+          path: userWorkspacesPath(userCtx),
+          workspaces: listConfiguredWorkspaces(root, root, userCtx),
+          customWorkspaces,
+        });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/workspace/graph") {
       try {
         const scoped = resolveWorkspaceScopeRoot(root, {
@@ -6693,6 +7705,10 @@ export function startUiServer({
           title: payload.title,
           layout: payload.layout,
           nodeIds,
+          expiresMode: payload.expiresMode,
+          expiresInDays: payload.expiresInDays,
+          permanent: payload.permanent,
+          expiresAt: payload.expiresAt,
         });
         json(res, 200, { ok: true, share, url: `/display/${encodeURIComponent(share.id)}` });
       } catch (e) {
@@ -6800,6 +7816,57 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "POST" && url.pathname === "/api/workspace/run/optimize") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: payload.flowId || "",
+          flowSource: payload.flowSource || "user",
+          archived: payload.archived === true || payload.flowArchived === true,
+        }, userCtx);
+        if (scoped.error) {
+          json(res, 400, { error: scoped.error });
+          return;
+        }
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+          json(res, 400, { error: "Cannot optimize workspace graph for builtin or archived pipeline" });
+          return;
+        }
+        const flowId = String(payload.flowId || "").trim();
+        if (!flowId) {
+          json(res, 400, { error: "Missing flowId" });
+          return;
+        }
+        const graphPath = workspaceGraphPath(scoped.root);
+        const result = await workspaceOptimizeRunImplementations(root, scoped.root, payload, userCtx, {
+          emit: () => {},
+        });
+        const currentGraph = readWorkspaceGraph(scoped.root).graph;
+        const touchedIds = new Set((result.optimized || []).map((item) => item.nodeId).filter(Boolean));
+        const mergedGraph = mergeWorkspaceRunGraph(currentGraph, result.graph, touchedIds);
+        fs.writeFileSync(graphPath, JSON.stringify(mergedGraph, null, 2) + "\n", "utf-8");
+        const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, mergedGraph, authUser, userCtx);
+        json(res, 200, {
+          ok: true,
+          path: graphPath,
+          graph: mergedGraph,
+          order: result.order,
+          optimized: result.optimized,
+          skipped: result.skipped,
+          workspaceSchedules,
+        });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "POST" && url.pathname === "/api/workspace/run") {
       let payload;
       try {
@@ -6846,6 +7913,7 @@ export function startUiServer({
         const controller = new AbortController();
         const runId = String(payload.runSessionId || payload.runId || "").trim() || runLedgerId("workspace");
         const runKey = workspaceRunEntryKey(scopeKey, runId);
+        const runAlias = String(payload.runAlias || "").trim() || workspaceRuntimeNodeLabel(runtimeGraph, runNodeId, "Workspace Run");
         const runEntry = {
           scopeKey,
           controller,
@@ -6854,6 +7922,7 @@ export function startUiServer({
           userId: String(userCtx.userId || ""),
           username: String(authUser?.username || userCtx.userId || ""),
           runNodeId,
+          label: runAlias,
           flowId,
           flowSource: scoped.flowSource || payload.flowSource || "user",
           plannedNodeIds,
@@ -6864,6 +7933,19 @@ export function startUiServer({
             }
           },
         };
+        const runLog = createWorkspaceRunLogSession({
+          runId,
+          userId: runEntry.userId,
+          username: runEntry.username,
+          flowId: runEntry.flowId,
+          flowSource: runEntry.flowSource,
+          scheduleNodeId: String(runtimeGraph.instances?.[runNodeId]?.definitionId || "") === "workspace_scheduled_run" ? runNodeId : "",
+          runNodeId,
+          scheduled: false,
+          trigger: "manual",
+          label: runAlias,
+          startedAt: runEntry.startedAt,
+        });
         activeWorkspaceRuns.set(runKey, runEntry);
         appendWorkspaceRunStarted(runEntry);
         const setActiveChild = (child) => {
@@ -6882,6 +7964,7 @@ export function startUiServer({
             "X-Accel-Buffering": "no",
           });
           const writeEvent = (event) => {
+            appendWorkspaceRunLogEvent(runLog.runId, event);
             try { res.write(JSON.stringify(event) + "\n"); } catch (_) {}
           };
           try {
@@ -6894,28 +7977,47 @@ export function startUiServer({
             const touchedIds = workspaceRunTouchedNodeIds(result);
             const mergedGraph = mergeWorkspaceRunGraph(currentGraph, result.graph, touchedIds);
             fs.writeFileSync(graphPath, JSON.stringify(mergedGraph, null, 2) + "\n", "utf-8");
+            const endedAt = Date.now();
             appendWorkspaceRunFinished({
               ...runEntry,
-              endedAt: Date.now(),
-              durationMs: Date.now() - runEntry.startedAt,
+              endedAt,
+              durationMs: endedAt - runEntry.startedAt,
             }, "success");
+            finishWorkspaceRunLogSession(runLog.runId, "success", {
+              endedAt,
+              durationMs: endedAt - runEntry.startedAt,
+              runNodeId,
+            });
             writeEvent({ type: "done", ok: true, path: graphPath, graph: mergedGraph, order: result.order, touchedNodeIds: Array.from(touchedIds), pauseNodeIds: result.pauseNodeIds || [] });
             res.end();
           } catch (e) {
+            const endedAt = Date.now();
             if (isWorkspaceRunAbortError(e) || controller.signal.aborted) {
               appendWorkspaceRunFinished({
                 ...runEntry,
-                endedAt: Date.now(),
-                durationMs: Date.now() - runEntry.startedAt,
+                endedAt,
+                durationMs: endedAt - runEntry.startedAt,
               }, "stopped");
+              finishWorkspaceRunLogSession(runLog.runId, "stopped", {
+                endedAt,
+                durationMs: endedAt - runEntry.startedAt,
+                runNodeId,
+              });
               writeEvent({ type: "stopped", ok: false, stopped: true, message: "Workspace run stopped" });
             } else {
+              const error = (e && e.message) || String(e);
               appendWorkspaceRunFinished({
                 ...runEntry,
-                endedAt: Date.now(),
-                durationMs: Date.now() - runEntry.startedAt,
+                endedAt,
+                durationMs: endedAt - runEntry.startedAt,
               }, "failed");
-              writeEvent({ type: "error", error: (e && e.message) || String(e) });
+              finishWorkspaceRunLogSession(runLog.runId, "failed", {
+                endedAt,
+                durationMs: endedAt - runEntry.startedAt,
+                runNodeId,
+                error,
+              });
+              writeEvent({ type: "error", error });
             }
             res.end();
           } finally {
@@ -6927,32 +8029,53 @@ export function startUiServer({
           const result = await runWorkspaceGraph(root, scoped.root, { ...payload, requestBaseUrl: requestPublicBaseUrl(req) }, userCtx, {
             signal: controller.signal,
             onActiveChild: setActiveChild,
+            onEvent: (event) => appendWorkspaceRunLogEvent(runLog.runId, event),
           });
           const graphPath = workspaceGraphPath(scoped.root);
           const currentGraph = readWorkspaceGraph(scoped.root).graph;
           const touchedIds = workspaceRunTouchedNodeIds(result);
           const mergedGraph = mergeWorkspaceRunGraph(currentGraph, result.graph, touchedIds);
           fs.writeFileSync(graphPath, JSON.stringify(mergedGraph, null, 2) + "\n", "utf-8");
+          const endedAt = Date.now();
           appendWorkspaceRunFinished({
             ...runEntry,
-            endedAt: Date.now(),
-            durationMs: Date.now() - runEntry.startedAt,
+            endedAt,
+            durationMs: endedAt - runEntry.startedAt,
           }, "success");
+          finishWorkspaceRunLogSession(runLog.runId, "success", {
+            endedAt,
+            durationMs: endedAt - runEntry.startedAt,
+            runNodeId,
+          });
           json(res, 200, { ok: true, path: graphPath, ...result, graph: mergedGraph, touchedNodeIds: Array.from(touchedIds) });
         } catch (e) {
+          const endedAt = Date.now();
           if (isWorkspaceRunAbortError(e) || controller.signal.aborted) {
             appendWorkspaceRunFinished({
               ...runEntry,
-              endedAt: Date.now(),
-              durationMs: Date.now() - runEntry.startedAt,
+              endedAt,
+              durationMs: endedAt - runEntry.startedAt,
             }, "stopped");
+            finishWorkspaceRunLogSession(runLog.runId, "stopped", {
+              endedAt,
+              durationMs: endedAt - runEntry.startedAt,
+              runNodeId,
+            });
             json(res, 200, { ok: false, stopped: true, message: "Workspace run stopped" });
           } else {
+            const error = (e && e.message) || String(e);
             appendWorkspaceRunFinished({
               ...runEntry,
-              endedAt: Date.now(),
-              durationMs: Date.now() - runEntry.startedAt,
+              endedAt,
+              durationMs: endedAt - runEntry.startedAt,
             }, "failed");
+            appendWorkspaceRunLogEvent(runLog.runId, { type: "error", error, ts: endedAt });
+            finishWorkspaceRunLogSession(runLog.runId, "failed", {
+              endedAt,
+              durationMs: endedAt - runEntry.startedAt,
+              runNodeId,
+              error,
+            });
             throw e;
           }
         } finally {
@@ -6964,6 +8087,52 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/workspace/run-logs") {
+      try {
+        const flowId = url.searchParams.get("flowId") || "";
+        const flowSource = url.searchParams.get("flowSource") || "";
+        const scheduleNodeId = url.searchParams.get("scheduleNodeId") || "";
+        const runNodeId = url.searchParams.get("runNodeId") || "";
+        const limit = Number(url.searchParams.get("limit") || 50);
+        json(res, 200, {
+          runs: listWorkspaceRunLogs({
+            userId: userCtx.userId || "",
+            flowId,
+            flowSource,
+            scheduleNodeId,
+            runNodeId,
+            limit,
+          }),
+        });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "GET" && url.pathname.startsWith("/api/workspace/run-logs/")) {
+      try {
+        const runId = decodeURIComponent(url.pathname.slice("/api/workspace/run-logs/".length));
+        if (!runId) {
+          json(res, 400, { error: "Missing runId" });
+          return;
+        }
+        const run = listWorkspaceRunLogs({ userId: userCtx.userId || "", limit: 200 })
+          .find((item) => String(item.runId || "") === runId);
+        if (!run) {
+          json(res, 404, { error: "Run log not found" });
+          return;
+        }
+        json(res, 200, {
+          run,
+          events: readWorkspaceRunLogEvents(runId),
+        });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/workspace/run/status") {
       const flowId = typeof url.searchParams.get("flowId") === "string" ? url.searchParams.get("flowId").trim() : "";
       if (!flowId) {
@@ -6979,10 +8148,12 @@ export function startUiServer({
         flowId,
         flowSource,
         runNodeId: entry?.runNodeId || "",
+        label: entry?.label || "",
         startedAt: entry?.startedAt || null,
         runs: entries.map((item) => ({
           runId: item?.runId || "",
           runNodeId: item?.runNodeId || "",
+          label: item?.label || "",
           startedAt: item?.startedAt || null,
           plannedNodeIds: Array.isArray(item?.plannedNodeIds) ? item.plannedNodeIds : [],
           scheduled: item?.scheduled === true,
@@ -8030,6 +9201,60 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/node-studio/drafts") {
+      try {
+        json(res, 200, { drafts: listNodeStudioDrafts(userCtx) });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "GET" && url.pathname === "/api/node-studio/draft") {
+      try {
+        const id = url.searchParams.get("id") || "";
+        if (!id) {
+          json(res, 200, { draft: null });
+          return;
+        }
+        const draft = readNodeStudioDraft(userCtx, id);
+        json(res, 200, { draft: draft && !isLegacyNodeStudioDemoDraft(draft) ? draft : null });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/node-studio/draft") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const current = readNodeStudioDraft(userCtx, payload.id || "") || emptyNodeStudioDraft(userCtx, payload.id || "untitled_node");
+        const promptDraft = payload.promptDraft != null ? String(payload.promptDraft) : current.promptDraft || "";
+        const agentMessages = Array.isArray(current.agentMessages) ? [...current.agentMessages] : [];
+        if (payload.appendUserMessage === true && promptDraft.trim()) {
+          const at = new Date().toISOString();
+          agentMessages.push({ role: "user", text: promptDraft.trim(), at });
+          agentMessages.push({ role: "assistant", text: "已记录需求，下一步会由节点 Agent 更新 manifest、脚本和 UI schema。", at });
+        }
+        const draft = writeNodeStudioDraft(userCtx, {
+          ...current,
+          ...(payload.config && typeof payload.config === "object" ? { config: { ...(current.config || {}), ...payload.config } } : {}),
+          promptDraft,
+          agentMessages,
+        });
+        json(res, 200, { ok: true, draft });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/marketplace/nodes") {
       try {
         const marketplaceScope = url.searchParams.get("scope") === "owned" ? "owned" : "all";
@@ -8711,6 +9936,128 @@ finishedAt: "${new Date().toISOString()}"
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/flow/schedules") {
+      try {
+        json(res, 200, { schedules: listScheduleStatuses(root, userCtx) });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "GET" && url.pathname === "/api/schedules") {
+      try {
+        const pipelineSchedules = listScheduleStatuses(root, userCtx)
+          .filter((schedule) => (
+            schedule.enabled ||
+            schedule.cron ||
+            schedule.nextRunAt ||
+            schedule.lastTriggeredAt ||
+            schedule.lastRunUuid ||
+            schedule.lastError ||
+            schedule.running ||
+            schedule.waiting
+          ))
+          .map((schedule) => ({
+            kind: "pipeline",
+            ...schedule,
+          }));
+        const workspaceSchedules = listWorkspaceScheduleStatuses(root, userCtx);
+        json(res, 200, {
+          schedules: [...workspaceSchedules, ...pipelineSchedules].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 || "")) || String(a.flowId || "").localeCompare(String(b.flowId || ""));
+          }),
+        });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/schedule/toggle") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      const kind = String(payload.kind || "").trim();
+      if (kind === "workspace") {
+        try {
+          const result = setWorkspaceScheduleEnabled(root, payload, authUser, userCtx);
+          if (!result.success) {
+            json(res, 400, { error: result.error || "Could not update workspace schedule" });
+            return;
+          }
+          json(res, 200, { success: true });
+        } catch (e) {
+          json(res, 500, { error: (e && e.message) || String(e) });
+        }
+        return;
+      }
+      if (kind === "pipeline") {
+        const flowId = String(payload.flowId || "").trim();
+        const flowSource = String(payload.flowSource || "user").trim() || "user";
+        if (!flowId) {
+          json(res, 400, { error: "Missing flowId" });
+          return;
+        }
+        if (!isValidFlowSourceWrite(flowSource)) {
+          json(res, 400, { error: "Cannot update schedule for builtin or readonly flow" });
+          return;
+        }
+        const current = readFlowSchedule(root, flowId, flowSource, userCtx);
+        if (!current.success) {
+          json(res, 400, { error: current.error || "Could not read schedule" });
+          return;
+        }
+        const result = writeFlowSchedule(root, flowId, flowSource, { ...current.schedule, enabled: payload.enabled === true }, userCtx);
+        if (!result.success) {
+          json(res, 400, { error: result.error || "Could not update schedule" });
+          return;
+        }
+        json(res, 200, { success: true, schedule: result.schedule });
+        return;
+      }
+      json(res, 400, { error: "Invalid schedule kind" });
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/flow/schedule/disable") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      const flowId = String(payload.flowId || "").trim();
+      const flowSource = String(payload.flowSource || "user").trim() || "user";
+      if (!flowId) {
+        json(res, 400, { error: "Missing flowId" });
+        return;
+      }
+      if (!isValidFlowSourceWrite(flowSource)) {
+        json(res, 400, { error: "Cannot disable schedule for builtin or readonly flow" });
+        return;
+      }
+      const current = readFlowSchedule(root, flowId, flowSource, userCtx);
+      if (!current.success) {
+        json(res, 400, { error: current.error || "Could not read schedule" });
+        return;
+      }
+      const result = writeFlowSchedule(root, flowId, flowSource, { ...current.schedule, enabled: false }, userCtx);
+      if (!result.success) {
+        json(res, 400, { error: result.error || "Could not disable schedule" });
+        return;
+      }
+      json(res, 200, { success: true, schedule: result.schedule });
+      return;
+    }
+
     if (req.method === "POST" && url.pathname === "/api/flow/run") {
       let payload;
       try {