@fieldwangai/agentflow 0.1.89 → 0.1.91

package/bin/lib/ui-server.mjs

@@ -1617,10 +1617,48 @@ 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 = {}) {
+function workspacesPath() {
+  return path.join(getAgentflowDataRoot(), USER_WORKSPACES_FILENAME);
+}
+
+function legacyUserWorkspacesPath(userCtx = {}) {
   return path.join(getAgentflowUserDataRoot(userCtx.userId || ""), USER_WORKSPACES_FILENAME);
 }
 
+function defaultWorkspaceGitPath(id) {
+  return path.join(getAgentflowDataRoot(), "workspaces", "repos", id);
+}
+
+function legacyDefaultWorkspaceGitPath(userCtx = {}, id = "") {
+  return path.join(getAgentflowUserDataRoot(userCtx.userId || ""), "workspaces", "repos", id);
+}
+
+function isLegacyDefaultWorkspaceGitPath(rawPath = "", id = "", userCtx = {}) {
+  const raw = String(rawPath || "").trim();
+  if (!raw || !id) return false;
+  try {
+    return path.resolve(raw.replace(/^~(?=$|\/|\\)/, os.homedir())) === path.resolve(legacyDefaultWorkspaceGitPath(userCtx, id));
+  } catch {
+    return false;
+  }
+}
+
+function workspaceRepoNameFromUrl(repoUrl = "") {
+  const raw = String(repoUrl || "").trim();
+  if (!raw) return "";
+  let pathname = raw;
+  try {
+    pathname = new URL(raw).pathname;
+  } catch {
+    pathname = raw.split("?")[0].split("#")[0];
+  }
+  const name = pathname.replace(/\/+$/, "").split("/").filter(Boolean).pop() || "";
+  return name
+    .replace(/\.git$/i, "")
+    .replace(/[^A-Za-z0-9._-]+/g, "_")
+    .replace(/^_+|_+$/g, "");
+}
+
 function normalizeWorkspaceEntry(entry = {}, index = 0, userCtx = {}) {
   const label = String(entry?.label || entry?.name || "").trim();
   const kindRaw = String(entry?.kind || entry?.source || "").trim().toLowerCase();
@@ -1632,9 +1670,11 @@ function normalizeWorkspaceEntry(entry = {}, index = 0, userCtx = {}) {
   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 suggestedMountPath = kind === "git" ? workspaceRepoNameFromUrl(repoUrl) : "";
+  const mountPath = (mountPathRaw || suggestedMountPath || id).replace(/^\/+/, "").replace(/\.\.(\/|\\|$)/g, "").trim() || id;
+  const defaultGitPath = defaultWorkspaceGitPath(id);
+  const explicitPath = kind === "git" && isLegacyDefaultWorkspaceGitPath(rawPath, id, userCtx) ? "" : rawPath;
+  const absPath = path.resolve((explicitPath || defaultGitPath).replace(/^~(?=$|\/|\\)/, os.homedir()));
   const exists = fs.existsSync(absPath) && fs.statSync(absPath).isDirectory();
   return {
     id,
@@ -1653,8 +1693,7 @@ function normalizeWorkspaceEntry(entry = {}, index = 0, userCtx = {}) {
   };
 }
 
-function readUserWorkspaces(userCtx = {}) {
-  const p = userWorkspacesPath(userCtx);
+function readWorkspacesFromPath(p, userCtx = {}) {
   if (!fs.existsSync(p)) return [];
   try {
     const data = JSON.parse(fs.readFileSync(p, "utf-8"));
@@ -1665,6 +1704,49 @@ function readUserWorkspaces(userCtx = {}) {
   }
 }
 
+function readLegacyAdminWorkspaces(userCtx = {}) {
+  const users = readAuthUsers();
+  const candidates = [];
+  for (const [userId, user] of Object.entries(users || {})) {
+    if (user?.isAdmin) candidates.push(String(userId || ""));
+  }
+  if (userCtx?.isAdmin && userCtx.userId) candidates.unshift(String(userCtx.userId));
+  const seenPaths = new Set();
+  const seenEntries = new Set();
+  const out = [];
+  for (const userId of candidates) {
+    const p = legacyUserWorkspacesPath({ userId });
+    const resolved = path.resolve(p);
+    if (seenPaths.has(resolved) || resolved === path.resolve(workspacesPath())) continue;
+    seenPaths.add(resolved);
+    for (const entry of readWorkspacesFromPath(p, { userId })) {
+      const key = entry.id || entry.path || entry.repoUrl;
+      if (seenEntries.has(key)) continue;
+      seenEntries.add(key);
+      out.push(entry);
+    }
+  }
+  return out;
+}
+
+function readUserWorkspaces(userCtx = {}) {
+  const globalPath = workspacesPath();
+  const globalWorkspaces = fs.existsSync(globalPath) ? readWorkspacesFromPath(globalPath, userCtx) : [];
+  const adminLegacy = readLegacyAdminWorkspaces(userCtx);
+  if (globalWorkspaces.length || adminLegacy.length) {
+    const seen = new Set();
+    const out = [];
+    for (const entry of [...globalWorkspaces, ...adminLegacy]) {
+      const key = entry.id || entry.path || entry.repoUrl;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(entry);
+    }
+    return out;
+  }
+  return readWorkspacesFromPath(legacyUserWorkspacesPath(userCtx), userCtx);
+}
+
 function writeUserWorkspaces(userCtx = {}, entries = []) {
   const seen = new Set();
   const workspaces = (Array.isArray(entries) ? entries : [])
@@ -1676,7 +1758,7 @@ function writeUserWorkspaces(userCtx = {}, entries = []) {
       seen.add(key);
       return true;
     });
-  const p = userWorkspacesPath(userCtx);
+  const p = workspacesPath();
   fs.mkdirSync(path.dirname(p), { recursive: true });
   fs.writeFileSync(p, JSON.stringify({ version: 1, workspaces }, null, 2) + "\n", "utf-8");
   return workspaces;
@@ -2898,6 +2980,114 @@ function resolveWorkspaceScopeRoot(workspaceRoot, params = {}, opts = {}) {
   return { root: path.resolve(result.path), flowId, flowSource, archived };
 }
 
+function workspaceConversationsPath(scopedRoot) {
+  return path.join(path.resolve(scopedRoot), ".workspace", "agentflow", "conversations.json");
+}
+
+function workspaceConversationText(value, max = 4000) {
+  const text = String(value ?? "").trim();
+  if (!text) return "";
+  return text.length > max ? `${text.slice(0, max)}\n...[truncated ${text.length - max} chars]` : text;
+}
+
+function normalizeWorkspaceConversationMessage(message = {}) {
+  const text = workspaceConversationText(message?.text, 4000);
+  if (!text) return null;
+  const role = String(message?.role || "assistant").trim() === "user" ? "user" : "assistant";
+  const kind = String(message?.kind || "").trim();
+  return {
+    role,
+    ...(kind ? { kind } : {}),
+    text,
+    ...(message?.error ? { error: true } : {}),
+    at: Number.isFinite(Number(message?.at)) ? Number(message.at) : Date.now(),
+  };
+}
+
+function normalizeWorkspaceConversationMessages(messages, limit = 80) {
+  return (Array.isArray(messages) ? messages : [])
+    .map(normalizeWorkspaceConversationMessage)
+    .filter(Boolean)
+    .slice(-limit);
+}
+
+function normalizeWorkspaceNodeChatSessions(nodeChats = {}) {
+  const source = nodeChats && typeof nodeChats === "object" && !Array.isArray(nodeChats) ? nodeChats : {};
+  const entries = Object.entries(source).slice(-80);
+  const next = {};
+  for (const [nodeId, session] of entries) {
+    if (!session || typeof session !== "object" || Array.isArray(session)) continue;
+    const id = String(nodeId || "").trim();
+    if (!id) continue;
+    const messages = normalizeWorkspaceConversationMessages(session.messages, 40);
+    const draft = workspaceConversationText(session.draft || "", 2000);
+    if (!messages.length && !draft) continue;
+    next[id] = {
+      sessionId: String(session.sessionId || `nodechat_${id}`).trim(),
+      messages,
+      ...(draft ? { draft } : {}),
+      candidateContent: "",
+      running: false,
+      error: "",
+    };
+  }
+  return next;
+}
+
+function normalizeWorkspaceComposerRunSessions(sessions = []) {
+  return (Array.isArray(sessions) ? sessions : [])
+    .map((session) => {
+      if (!session || typeof session !== "object" || Array.isArray(session)) return null;
+      const id = String(session.id || "").trim();
+      if (!id) return null;
+      const messages = normalizeWorkspaceConversationMessages(session.messages, 80);
+      if (!messages.length) return null;
+      const status = String(session.status || "done").trim();
+      return {
+        id,
+        label: workspaceConversationText(session.label || id, 120),
+        status: status === "failed" ? "failed" : "done",
+        messages,
+      };
+    })
+    .filter(Boolean)
+    .slice(-20);
+}
+
+function normalizeWorkspaceConversations(raw = {}) {
+  const data = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  const composer = data.composer && typeof data.composer === "object" && !Array.isArray(data.composer) ? data.composer : {};
+  const activeSessionId = String(composer.activeSessionId || "workspace").trim() || "workspace";
+  return {
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    composer: {
+      activeSessionId,
+      messages: normalizeWorkspaceConversationMessages(composer.messages, 100),
+      runSessions: normalizeWorkspaceComposerRunSessions(composer.runSessions),
+    },
+    nodeChats: normalizeWorkspaceNodeChatSessions(data.nodeChats),
+  };
+}
+
+function readWorkspaceConversations(scopedRoot) {
+  const filePath = workspaceConversationsPath(scopedRoot);
+  if (!fs.existsSync(filePath)) return normalizeWorkspaceConversations({});
+  try {
+    return normalizeWorkspaceConversations(JSON.parse(fs.readFileSync(filePath, "utf-8")));
+  } catch {
+    return normalizeWorkspaceConversations({});
+  }
+}
+
+function writeWorkspaceConversations(scopedRoot, raw) {
+  const filePath = workspaceConversationsPath(scopedRoot);
+  const conversations = normalizeWorkspaceConversations(raw);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(conversations, null, 2) + "\n", "utf-8");
+  return conversations;
+}
+
 function workspaceSearchGuardrailsBlock() {
   return [
     "## 检索约束",
@@ -4071,7 +4261,7 @@ function workspaceTargetSlotForEdge(graph, edge) {
 function isWorkspaceSemanticInputSlot(slot) {
   const name = String(slot?.name || "");
   const type = String(slot?.type || "");
-  return type === "node" || name === "prev" || name === "next" || name === "skillsContext" || name === "mcpContext" || name === "workspaceContext" || name === "gitContext";
+  return type === "node" || name === "prev" || name === "next" || name === "skillsContext" || name === "mcpContext" || name === "knowledgeContext" || name === "workspaceContext" || name === "gitContext";
 }
 
 function workspaceAgentInputBlock(inputValues = {}, inputMounts = {}) {
@@ -4904,11 +5094,86 @@ function workspaceContextObjectFromText(text, baseCwd, scopedRoot) {
   };
 }
 
+function workspaceKnowledgeSourceFromObject(source = {}, baseCwd = "", scopedRoot = "") {
+  if (!source || typeof source !== "object" || Array.isArray(source)) return null;
+  const rawPath = String(source.path || source.repoPath || source.cwd || source.workspaceRoot || "").trim();
+  if (!rawPath) return null;
+  const resolvedPath = workspaceResolvePath(baseCwd || scopedRoot, rawPath) || rawPath;
+  return {
+    id: String(source.id || source.mountPath || source.label || path.basename(resolvedPath) || "").trim(),
+    label: String(source.label || source.id || source.mountPath || path.basename(resolvedPath) || "知识库").trim(),
+    kind: String(source.kind || (source.repoUrl ? "git" : "local")).trim() || "local",
+    type: String(source.type || "").trim(),
+    path: resolvedPath,
+    repoPath: resolvedPath,
+    mountPath: String(source.mountPath || "").trim(),
+    repoUrl: String(source.repoUrl || "").trim(),
+    branch: String(source.branch || "").trim(),
+    readonly: source.readonly !== false,
+  };
+}
+
+function workspaceKnowledgeSourcesFromText(text, baseCwd = "", scopedRoot = "") {
+  const raw = String(text || "").trim();
+  if (!raw) return [];
+  const parsed = parseJsonText(raw, null);
+  const candidates = Array.isArray(parsed)
+    ? parsed
+    : (parsed && typeof parsed === "object" && Array.isArray(parsed.sources)
+      ? parsed.sources
+      : (parsed && typeof parsed === "object" && (parsed.path || parsed.repoPath || parsed.cwd || parsed.workspaceRoot) ? [parsed] : []));
+  if (candidates.length) {
+    return candidates
+      .map((source) => workspaceKnowledgeSourceFromObject(source, baseCwd, scopedRoot))
+      .filter(Boolean);
+  }
+  const resolved = workspaceResolvePath(baseCwd || scopedRoot, raw) || raw;
+  return [{
+    id: path.basename(resolved) || "knowledge",
+    label: path.basename(resolved) || "知识库",
+    kind: "local",
+    type: "",
+    path: resolved,
+    repoPath: resolved,
+    mountPath: "",
+    repoUrl: "",
+    branch: "",
+    readonly: true,
+  }];
+}
+
+function workspaceKnowledgeContextBlockFromSources(sources = []) {
+  const valid = Array.isArray(sources) ? sources.filter((source) => source?.path || source?.repoPath) : [];
+  if (!valid.length) return "";
+  const lines = [
+    "## 知识库上下文",
+    "",
+    "这些路径是只读知识库/上下文源，用于检索、阅读和分析；它们不代表当前执行 cwd。需要修改代码时，请先创建或使用可写工作区。",
+    "",
+  ];
+  valid.forEach((source, index) => {
+    const label = String(source.label || source.id || source.mountPath || `知识库 ${index + 1}`).trim();
+    const sourcePath = String(source.path || source.repoPath || "").trim();
+    lines.push(`${index + 1}. ${label}`);
+    if (source.kind) lines.push(`   - 类型：${source.kind}${source.type ? `/${source.type}` : ""}`);
+    if (sourcePath) lines.push(`   - 路径：\`${sourcePath}\``);
+    if (source.mountPath) lines.push(`   - 挂载目录：${source.mountPath}`);
+    if (source.repoUrl) lines.push(`   - Git URL：${source.repoUrl}`);
+    if (source.branch) lines.push(`   - 分支：${source.branch}`);
+  });
+  return lines.join("\n");
+}
+
 function workspaceNodeWorkspaceContextBlock(graph, nodeId, outputs, scopedRoot = "", logicalCwd = "") {
   const root = scopedRoot ? path.resolve(scopedRoot) : "";
   const cwd = logicalCwd ? path.resolve(logicalCwd) : root;
+  const knowledgeText = workspaceSemanticInputText(graph, nodeId, outputs, "knowledgeContext", scopedRoot);
+  let knowledgeSources = workspaceKnowledgeSourcesFromText(knowledgeText, cwd || root, scopedRoot);
   const workspaceText = workspaceSemanticInputText(graph, nodeId, outputs, "workspaceContext", scopedRoot);
   let workspaceContext = workspaceContextObjectFromText(workspaceText, cwd || root, scopedRoot);
+  if (!knowledgeSources.length && workspaceContext?.cwd) {
+    knowledgeSources = workspaceKnowledgeSourcesFromText(JSON.stringify([workspaceContext]), cwd || root, scopedRoot);
+  }
   if (!workspaceContext && cwd && root && cwd !== root) {
     workspaceContext = {
       version: 1,
@@ -4920,7 +5185,8 @@ function workspaceNodeWorkspaceContextBlock(graph, nodeId, outputs, scopedRoot =
     };
   }
   const gitContext = normalizeGitContext(workspaceSemanticInputText(graph, nodeId, outputs, "gitContext", scopedRoot));
-  if (!workspaceContext && !gitContext) return "";
+  const knowledgeBlock = workspaceKnowledgeContextBlockFromSources(knowledgeSources);
+  if (!workspaceContext && !gitContext) return knowledgeBlock;
 
   const contextCwd = workspaceContext?.cwd ? path.resolve(String(workspaceContext.cwd)) : "";
   const workspaceRoot = workspaceContext?.workspaceRoot ? path.resolve(String(workspaceContext.workspaceRoot)) : contextCwd;
@@ -4943,7 +5209,7 @@ function workspaceNodeWorkspaceContextBlock(graph, nodeId, outputs, scopedRoot =
     "- 读取、搜索、分析当前项目或资料时，优先从“当前工作目录上下文”开始；不要把节点的“当前执行目录”误认为项目根目录。",
     "- 临时文件和正式产物仍必须按“文件边界”写入本节点的 `tmp/` 与 `outputs/`。",
   ].filter((line) => line !== "");
-  return lines.join("\n");
+  return [knowledgeBlock, lines.join("\n")].filter(Boolean).join("\n\n");
 }
 
 function workspaceDefaultWorkspaceContextBlock(scopedRoot = "", logicalCwd = "") {
@@ -5731,28 +5997,51 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       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 knowledgeSlot = inputSlots.find((slot) => String(slot?.name || "") === "knowledgeContext");
       const contextSlot = inputSlots.find((slot) => String(slot?.name || "") === "workspaceContext");
+      const knowledgeText = workspaceSlotValue(knowledgeSlot);
+      let knowledgeSources = workspaceKnowledgeSourcesFromText(knowledgeText, cwd || scopedRoot, scopedRoot);
       const candidate = workspaceSlotValue(pathSlot) || workspaceInstanceText(instance) || inputText;
-      const abs = candidate ? path.resolve(scopedRoot, candidate) : scopedRoot;
-      if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
-        throw new Error(`Load Workspace path does not exist or is not a directory: ${abs}`);
+      if (!knowledgeSources.length && candidate) {
+        const abs = path.resolve(scopedRoot, candidate);
+        if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
+          throw new Error(`Load Knowledge path does not exist or is not a directory: ${abs}`);
+        }
+        knowledgeSources = [{
+          id: path.basename(abs) || "knowledge",
+          label: workspaceSlotValue(labelSlot) || path.basename(abs) || "知识库",
+          kind: "local",
+          type: "",
+          path: abs,
+          repoPath: abs,
+          mountPath: "",
+          repoUrl: "",
+          branch: "",
+          readonly: true,
+        }];
       }
-      cwd = abs;
       const parsedContext = parseJsonText(workspaceSlotValue(contextSlot), {});
       const configuredContext = parsedContext && typeof parsedContext === "object" && !Array.isArray(parsedContext) ? parsedContext : {};
-      const workspaceContext = {
+      const primarySource = knowledgeSources[0] || null;
+      const primaryPath = primarySource?.path ? path.resolve(String(primarySource.path)) : "";
+      const knowledgeContext = {
+        version: 1,
+        sources: knowledgeSources,
+      };
+      const workspaceContext = primarySource ? {
         ...configuredContext,
         version: 1,
-        label: workspaceSlotValue(labelSlot) || path.basename(cwd) || "workspace",
-        cwd,
-        workspaceRoot: cwd,
+        label: primarySource.label || workspaceSlotValue(labelSlot) || path.basename(primaryPath) || "知识库",
+        cwd: primaryPath,
+        workspaceRoot: primaryPath,
         pipelineWorkspace: path.resolve(scopedRoot),
         previous: null,
-      };
-      let nextInstance = workspaceSetOutputSlot(instance, "workspaceContext", JSON.stringify(workspaceContext));
-      nextInstance = workspaceSetOutputSlot(nextInstance, "cwd", cwd);
+      } : null;
+      let nextInstance = workspaceSetOutputSlot(instance, "knowledgeContext", JSON.stringify(knowledgeContext));
+      nextInstance = workspaceSetOutputSlot(nextInstance, "workspaceContext", workspaceContext ? JSON.stringify(workspaceContext) : "");
+      nextInstance = workspaceSetOutputSlot(nextInstance, "cwd", primaryPath);
       graph.instances[nodeId] = nextInstance;
-      publishNodeOutput(nodeId, JSON.stringify(workspaceContext), { emitGraph: true });
+      publishNodeOutput(nodeId, JSON.stringify(knowledgeContext), { emitGraph: true });
       emit({ type: "graph", nodeId, graph });
       emit({ type: "node-done", nodeId, definitionId: defId });
       continue;
@@ -6125,7 +6414,7 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
     }
     const historyBlock = workspaceNodeHistoryBlock(nodeId, scopedRoot, runPackage);
     let workspaceContextBlock = workspaceNodeWorkspaceContextBlock(graph, nodeId, outputs, scopedRoot, cwd);
-    if (isContextRunNode && workspaceBoolSlot(instance, "includeWorkspaceContext", true) && !workspaceContextBlock) {
+    if (!isContextRunNode && workspaceBoolSlot(instance, "includeWorkspaceContext", true) && !workspaceContextBlock) {
       workspaceContextBlock = workspaceDefaultWorkspaceContextBlock(scopedRoot, cwd);
     }
     const prompt = workspaceNodePrompt(graph, nodeId, promptUpstreamText, promptSkillsBlock, promptMcpBlock, runtimeInputValues, runPackage, historyBlock, workspaceContextBlock);
@@ -7752,7 +8041,7 @@ export function startUiServer({
         }, userCtx);
         const scopedRoot = scoped.error ? root : scoped.root;
         json(res, 200, {
-          path: userWorkspacesPath(userCtx),
+          path: workspacesPath(),
           workspaces: listConfiguredWorkspaces(root, scopedRoot, userCtx),
           customWorkspaces: readUserWorkspaces(userCtx),
         });
@@ -7767,7 +8056,7 @@ export function startUiServer({
         const payload = JSON.parse(await readBody(req));
         const customWorkspaces = writeUserWorkspaces(userCtx, payload?.workspaces || payload?.customWorkspaces || []);
         json(res, 200, {
-          path: userWorkspacesPath(userCtx),
+          path: workspacesPath(),
           workspaces: listConfiguredWorkspaces(root, root, userCtx),
           customWorkspaces,
         });
@@ -8628,6 +8917,47 @@ export function startUiServer({
       return;
     }
 
+    if (url.pathname === "/api/workspace/conversations") {
+      let payload = {};
+      if (req.method === "POST") {
+        try {
+          payload = JSON.parse(await readBody(req));
+        } catch {
+          json(res, 400, { error: "Invalid JSON body" });
+          return;
+        }
+      } else if (req.method !== "GET") {
+        json(res, 405, { error: "Method not allowed" });
+        return;
+      }
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: req.method === "POST" ? (payload.flowId || "") : (url.searchParams.get("flowId") || ""),
+          flowSource: req.method === "POST" ? (payload.flowSource || "user") : (url.searchParams.get("flowSource") || "user"),
+          archived: req.method === "POST"
+            ? (payload.archived === true || payload.flowArchived === true)
+            : (url.searchParams.get("archived") === "1" || url.searchParams.get("flowArchived") === "1"),
+        }, userCtx);
+        if (scoped.error) {
+          json(res, 400, { error: scoped.error });
+          return;
+        }
+        if (req.method === "GET") {
+          json(res, 200, { ok: true, conversations: readWorkspaceConversations(scoped.root) });
+          return;
+        }
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+          json(res, 400, { error: "Cannot write conversations for builtin or archived pipeline workspace" });
+          return;
+        }
+        const conversations = writeWorkspaceConversations(scoped.root, payload.conversations || payload);
+        json(res, 200, { ok: true, conversations });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "POST" && url.pathname === "/api/workspace/generate") {
       let payload;
       try {

package/builtin/nodes/control_cd_workspace.md

@@ -1,47 +1,56 @@
 ---
-# 内置节点：CD Workspace
+# 内置节点：加载知识库
 description: |
-  Switch the runtime workspace context for downstream nodes without changing the AgentFlow pipeline workspace.
+  Load one or more read-only knowledge sources for downstream Agent nodes.
 
-  Modes:
-  - `set`: switch to path, keep previous stack unchanged.
-  - `push`: switch to path and save the incoming context as previous.
-  - `pop`: restore the previous context.
-
-  `path` supports `${workspaceRoot}`, `${pipelineWorkspace}`, `${flowDir}`, absolute paths, and paths relative to the input workspace context.
-displayName: CD Workspace
+  This node does not change the runtime cwd. It publishes `knowledgeContext`
+  for reading/searching referenced repos or folders. `workspaceContext` and
+  `cwd` are retained as legacy compatibility outputs for the first source.
+displayName: 加载知识库
 input:
   - type: node
     name: prev
     default: ""
+  - type: text
+    name: knowledgeContext
+    default: ""
+    showOnNode: false
   - type: text
     name: path
     default: ""
-    required: true
-    showOnNode: true
+    showOnNode: false
   - type: text
     name: mode
     default: "set"
+    showOnNode: false
   - type: text
     name: label
     default: ""
+    showOnNode: false
   - type: text
     name: workspaceContext
     default: ""
+    showOnNode: false
 output:
   - type: node
     name: next
     default: ""
   - type: text
-    name: workspaceContext
+    name: knowledgeContext
     default: ""
     required: true
     showOnNode: true
+  - type: text
+    name: workspaceContext
+    default: ""
+    showOnNode: false
   - type: file
     name: cwd
     default: ""
+    showOnNode: false
   - type: text
     name: previous
     default: ""
+    showOnNode: false
 ---
-Switch downstream execution to `${path}` using mode `${mode}`.
+Load selected knowledge sources for downstream agents.