@fieldwangai/agentflow 0.1.100 → 0.1.102

package/bin/lib/ui-server.mjs

@@ -84,6 +84,11 @@ import {
 import { runNodeScript } from "./pipeline-scripts.mjs";
 import { computeNextRunAt, readFlowSchedule, writeFlowSchedule } from "./schedule-config.mjs";
 import { listScheduleStatuses } from "./scheduler.mjs";
+import {
+  mergeWorkspaceGraphs,
+  workspaceDesignRevision,
+  workspaceRuntimeRevision,
+} from "./workspace-graph-merge.mjs";
 import {
   deleteMarketplaceFlowSnippetPackage,
   deleteMarketplaceNodePackage,
@@ -129,6 +134,20 @@ import {
   readWorkspaceRunLogEvents,
 } from "./workspace-run-logs.mjs";
 import { createWorkspaceRunController } from "./workspace-run-controller.mjs";
+import {
+  acceptWorkspaceCollaborationInvite,
+  addWorkspaceCollaborationMember,
+  deleteWorkspaceCollaborationById,
+  deleteWorkspaceCollaborationForFlow,
+  ensureWorkspaceCollaboration,
+  getWorkspaceCollaborationByFlow,
+  getWorkspaceCollaborationForProject,
+  listWorkspaceCollaborationsForUser,
+  removeWorkspaceCollaborationMember,
+  updateWorkspaceCollaborationFlow,
+  workspaceCollaborationAccess,
+  workspaceCollaborationSummary,
+} from "./workspace-collaboration.mjs";
 
 const MIME = {
   ".html": "text/html; charset=utf-8",
@@ -1668,6 +1687,13 @@ function workspaceGraphPath(workspaceRoot) {
   return path.join(path.resolve(workspaceRoot), WORKSPACE_GRAPH_FILENAME);
 }
 
+function writeWorkspaceGraphAtomic(graphPath, graph) {
+  fs.mkdirSync(path.dirname(graphPath), { recursive: true });
+  const tmp = `${graphPath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(graph, null, 2) + "\n", "utf-8");
+  fs.renameSync(tmp, graphPath);
+}
+
 function emptyWorkspaceGraph() {
   return { version: 1, instances: {}, edges: [], ui: { nodePositions: {} } };
 }
@@ -3079,11 +3105,93 @@ function resolveWorkspaceScopeRoot(workspaceRoot, params = {}, opts = {}) {
   if (!isValidFlowSourceRead(flowSource)) {
     return { root: "", error: "Invalid flowSource" };
   }
-  const result = getPipelineFiles(workspaceRoot, flowId, flowSource, archived, opts);
+  const workspaceId = String(params.workspaceId || "").trim();
+  let collaboration = getWorkspaceCollaborationForProject({
+    workspaceId,
+    flowId,
+    flowSource,
+    archived,
+    ownerId: workspaceId ? "" : opts.userId,
+  });
+  if (!collaboration && !workspaceId) {
+    collaboration = listWorkspaceCollaborationsForUser(opts.userId).find((record) => (
+      record.flowId === flowId
+      && record.archived === archived
+      && (record.projectSource || record.flowSource || "workspace") === flowSource
+    )) || null;
+  }
+  if (!collaboration && flowSource === "workspace") {
+    collaboration = getWorkspaceCollaborationByFlow(flowId, archived);
+  }
+  if (collaboration) {
+    const access = workspaceCollaborationAccess(collaboration, opts.userId);
+    if (!access.allowed) {
+      return { root: "", error: "Workspace collaboration permission denied", status: 403 };
+    }
+  }
+  const physicalFlowSource = collaboration?.projectSource || collaboration?.flowSource || flowSource;
+  const physicalOpts = collaboration && physicalFlowSource === "user"
+    ? { ...opts, userId: collaboration.ownerId }
+    : opts;
+  const result = getPipelineFiles(workspaceRoot, flowId, physicalFlowSource, archived, physicalOpts);
   if (result.error || !result.path) {
     return { root: "", error: result.error || "Pipeline workspace not found" };
   }
-  return { root: path.resolve(result.path), flowId, flowSource, archived };
+  return {
+    root: path.resolve(result.path),
+    flowId,
+    flowSource: physicalFlowSource,
+    requestedFlowSource: flowSource,
+    workspaceId: collaboration?.id || workspaceId,
+    archived,
+    collaboration,
+    collaborationAccess: workspaceCollaborationAccess(collaboration, opts.userId),
+  };
+}
+
+function workspaceFlowCollaborationGuard(flowId, flowSource, archived, userCtx = {}, capability = "read") {
+  if (flowSource !== "workspace") return null;
+  const collaboration = getWorkspaceCollaborationByFlow(flowId, archived === true);
+  if (!collaboration) return null;
+  const access = workspaceCollaborationAccess(collaboration, userCtx.userId);
+  if (!access.allowed) return { error: "Workspace collaboration permission denied", status: 403 };
+  if (capability === "write" && !access.writable) {
+    return { error: "Workspace collaboration edit permission denied", status: 403 };
+  }
+  if (capability === "run" && !access.runnable) {
+    return { error: "Workspace collaboration run permission denied", status: 403 };
+  }
+  if (capability === "owner" && access.role !== "owner") {
+    return { error: "Only the workspace owner can manage this workflow", status: 403 };
+  }
+  return null;
+}
+
+function findWorkspaceShareUser(username) {
+  const query = String(username || "").trim().toLowerCase();
+  if (!query) return null;
+  const users = readAuthUsers();
+  for (const [userId, user] of Object.entries(users)) {
+    const storedUsername = String(user?.username || userId).trim();
+    if (String(userId).toLowerCase() === query || storedUsername.toLowerCase() === query) {
+      return { userId: String(userId), username: storedUsername };
+    }
+  }
+  return null;
+}
+
+function workspaceCollaborationSummaryWithUsers(record, userId) {
+  const summary = workspaceCollaborationSummary(record, userId);
+  if (!summary) return null;
+  const users = readAuthUsers();
+  return {
+    ...summary,
+    ownerUsername: String(users[summary.ownerId]?.username || summary.ownerId),
+    members: (summary.members || []).map((member) => ({
+      ...member,
+      username: String(users[member.userId]?.username || member.userId),
+    })),
+  };
 }
 
 function workspaceConversationsPath(scopedRoot) {
@@ -7069,7 +7177,8 @@ const flowEditorSyncSubscribers = new Map();
 const flowEditorSyncVersions = new Map();
 
 function flowEditorSyncKey(flowId, flowSource, flowArchived, userId = "") {
-  return `${String(userId || "")}\t${String(flowId)}\t${String(flowSource)}\t${flowArchived ? "1" : "0"}`;
+  const actorScope = flowSource === "workspace" ? "" : String(userId || "");
+  return `${actorScope}\t${String(flowId)}\t${String(flowSource)}\t${flowArchived ? "1" : "0"}`;
 }
 
 function broadcastFlowEditorSync(flowId, flowSource, flowArchived = false, userId = "") {
@@ -7093,6 +7202,8 @@ function broadcastFlowEditorSync(flowId, flowSource, flowArchived = false, userI
 const activeFlowRuns = new Map();
 /** 正在执行的 Workspace 临时 run（runId/sessionId → { controller, child, runNodeId, startedAt, plannedNodeIds }） */
 const activeWorkspaceRuns = new Map();
+const workspaceCollaborationSubscribers = new Map();
+const workspaceCollaborationSequences = new Map();
 const prdWorkflowSubscribers = new Map();
 const prdWorkflowIdempotency = new Map();
 const prdWorkflowActionLocks = new Map();
@@ -7105,8 +7216,9 @@ const WORKSPACE_IMPLEMENTATION_SUMMARY_ENABLED = false;
 const WORKSPACE_NODE_HISTORY_MAX_CHARS = 80000;
 
 function prdWorkflowKey(userCtx = {}, flowSource = "user", flowId = "", tapdId = "") {
+  const actorScope = flowSource === "workspace" ? "shared" : String(userCtx?.userId || "");
   return [
-    String(userCtx?.userId || ""),
+    actorScope,
     String(flowSource || "user"),
     String(flowId || ""),
     String(tapdId || ""),
@@ -7421,9 +7533,7 @@ function prdWorkflowReviewRenderTable(lines) {
   ].join("");
 }
 
-function prdWorkflowReviewMarkdownToHtml(markdown) {
-  const { frontmatter, body } = prdWorkflowReviewSplitFrontmatter(markdown);
-  const lines = String(body || "").replace(/\r\n/g, "\n").split("\n");
+function prdWorkflowReviewMarkdownLinesToHtml(lines) {
   const html = [];
   let paragraph = [];
   let list = [];
@@ -7500,11 +7610,147 @@ function prdWorkflowReviewMarkdownToHtml(markdown) {
   }
   if (code) html.push(`<pre><code>${htmlEscapeAttribute(prdWorkflowReviewNormalizeText(code.lines.join("\n")))}</code></pre>`);
   flushBlocks();
-  return [prdWorkflowReviewRenderFrontmatter(frontmatter), ...html].filter(Boolean).join("\n");
+  return html.join("\n");
+}
+
+function prdWorkflowReviewActionLine(line) {
+  const match = String(line || "").match(/^\s*[-*]\s+(?:\[( |x|X)\]\s+)?(A\d+|Action\s*\d+)(?=\s|[（(：:.-]|$)(.*)$/i);
+  if (!match) return null;
+  return {
+    checked: match[1] ? match[1].toLowerCase() === "x" : null,
+    label: match[2].replace(/\s+/g, " ").toUpperCase(),
+    title: String(match[3] || "").replace(/^\s*[-:：]\s*/, "").trim(),
+  };
+}
+
+function prdWorkflowReviewIsActionsHeading(line) {
+  const heading = String(line || "").trim().match(/^(#{1,6})\s+(.+)$/);
+  if (!heading) return null;
+  const title = heading[2].replace(/[*_`]/g, "").trim();
+  if (!/(?:\bTODO\s+Actions?\b|\bActions?\b|待办(?:事项|行动)?|行动项)/i.test(title)) return null;
+  return { level: heading[1].length };
 }
 
-function prdWorkflowReviewHtml(title, markdown, meta = {}) {
-  const escapedTitle = htmlEscapeAttribute(title || "PRD Workflow Review");
+function prdWorkflowReviewRenderActionSection(lines, sectionIndex) {
+  const actionStarts = [];
+  lines.forEach((line, index) => {
+    const action = prdWorkflowReviewActionLine(line);
+    if (action) actionStarts.push({ index, action });
+  });
+  if (!actionStarts.length) return prdWorkflowReviewMarkdownLinesToHtml(lines);
+
+  const ids = new Map();
+  const actions = actionStarts.map(({ index, action }, actionIndex) => {
+    const nextStart = actionStarts[actionIndex + 1]?.index ?? lines.length;
+    let bodyStart = index + 1;
+    const titleParts = [action.title].filter(Boolean);
+    while (bodyStart < nextStart) {
+      const continuation = String(lines[bodyStart] || "");
+      if (!/^\s{2,}\S/.test(continuation) || /^\s*[-*]\s+/.test(continuation) || /^\s*```/.test(continuation)) break;
+      titleParts.push(continuation.trim());
+      bodyStart += 1;
+    }
+    const labelId = action.label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || actionIndex + 1;
+    const baseId = `action-${labelId}${sectionIndex ? `-${sectionIndex + 1}` : ""}`;
+    const duplicate = ids.get(baseId) || 0;
+    ids.set(baseId, duplicate + 1);
+    return {
+      ...action,
+      id: duplicate ? `${baseId}-${sectionIndex + 1}-${duplicate + 1}` : baseId,
+      title: titleParts.join(" ") || action.label,
+      body: lines.slice(bodyStart, nextStart),
+    };
+  });
+
+  const intro = prdWorkflowReviewMarkdownLinesToHtml(lines.slice(0, actionStarts[0].index));
+  const navigation = actions.length > 1
+    ? `<nav class="action-index" aria-label="Action 快速跳转"><span class="action-index__label">快速跳转</span>${actions.map((action) => `<a href="#${htmlEscapeAttribute(action.id)}">${htmlEscapeAttribute(action.label)}</a>`).join("")}</nav>`
+    : "";
+  const cards = actions.map((action) => {
+    const status = action.checked === null
+      ? ""
+      : `<span class="action-card__status${action.checked ? " is-complete" : ""}">${action.checked ? "已完成" : "待完成"}</span>`;
+    const body = prdWorkflowReviewMarkdownLinesToHtml(action.body);
+    return `<section class="action-card${action.checked ? " is-complete" : ""}" id="${htmlEscapeAttribute(action.id)}">
+  <div class="action-card__header">
+    <span class="action-card__index">${htmlEscapeAttribute(action.label)}</span>
+    <h3 class="action-card__title">${prdWorkflowReviewInlineMarkdown(action.title)}</h3>
+    ${status}
+  </div>
+  <div class="action-card__body">${body}</div>
+</section>`;
+  }).join("\n");
+  return [intro, navigation, cards].filter(Boolean).join("\n");
+}
+
+function prdWorkflowReviewBodyToHtml(body) {
+  const lines = String(body || "").replace(/\r\n/g, "\n").split("\n");
+  const html = [];
+  let cursor = 0;
+  let sectionIndex = 0;
+  while (cursor < lines.length) {
+    const actionsHeading = prdWorkflowReviewIsActionsHeading(lines[cursor]);
+    if (!actionsHeading) {
+      const nextHeading = lines.findIndex((line, index) => index > cursor && prdWorkflowReviewIsActionsHeading(line));
+      const end = nextHeading >= 0 ? nextHeading : lines.length;
+      html.push(prdWorkflowReviewMarkdownLinesToHtml(lines.slice(cursor, end)));
+      cursor = end;
+      continue;
+    }
+    let end = cursor + 1;
+    while (end < lines.length) {
+      const heading = String(lines[end] || "").trim().match(/^(#{1,6})\s+/);
+      if (heading && heading[1].length <= actionsHeading.level) break;
+      end += 1;
+    }
+    html.push(prdWorkflowReviewMarkdownLinesToHtml([lines[cursor]]));
+    html.push(prdWorkflowReviewRenderActionSection(lines.slice(cursor + 1, end), sectionIndex));
+    sectionIndex += 1;
+    cursor = end;
+  }
+  return html.filter(Boolean).join("\n");
+}
+
+export function prdWorkflowReviewMarkdownToHtml(markdown) {
+  const { frontmatter, body } = prdWorkflowReviewSplitFrontmatter(markdown);
+  return [
+    prdWorkflowReviewRenderFrontmatter(frontmatter),
+    prdWorkflowReviewBodyToHtml(body),
+  ].filter(Boolean).join("\n");
+}
+
+function prdWorkflowReviewExtractPageTitle(markdown, fallbackTitle) {
+  const { frontmatter, body } = prdWorkflowReviewSplitFrontmatter(markdown);
+  const lines = String(body || "").replace(/\r\n/g, "\n").split("\n");
+  const firstContentIndex = lines.findIndex((line) => String(line || "").trim());
+  const heading = firstContentIndex >= 0
+    ? String(lines[firstContentIndex] || "").trim().match(/^#\s+(.+)$/)
+    : null;
+  if (!heading) {
+    return {
+      markdown: String(markdown || ""),
+      title: String(fallbackTitle || "PRD Workflow Review"),
+    };
+  }
+
+  lines.splice(firstContentIndex, 1);
+  const markdownTitle = prdWorkflowReviewNormalizeText(heading[1])
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+    .replace(/[`*_~]/g, "")
+    .trim();
+  const bodyWithoutTitle = lines.join("\n").replace(/^\n+/, "");
+  return {
+    markdown: [
+      frontmatter ? `---\n${frontmatter}\n---` : "",
+      bodyWithoutTitle,
+    ].filter(Boolean).join("\n\n"),
+    title: markdownTitle || String(fallbackTitle || "PRD Workflow Review"),
+  };
+}
+
+export function prdWorkflowReviewHtml(title, markdown, meta = {}) {
+  const page = prdWorkflowReviewExtractPageTitle(markdown, title);
+  const escapedTitle = htmlEscapeAttribute(page.title);
   const escapedMeta = htmlEscapeAttribute([
     meta.tapdId ? `TAPD ${meta.tapdId}` : "",
     meta.stage ? `stage ${meta.stage}` : "",
@@ -7518,7 +7764,7 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     meta.persistence ? `persistence ${meta.persistence}` : "",
   ].filter(Boolean).join(" · ");
   const escapedLifecycle = htmlEscapeAttribute(lifecycle);
-  const renderedMarkdown = prdWorkflowReviewMarkdownToHtml(markdown || "");
+  const renderedMarkdown = prdWorkflowReviewMarkdownToHtml(page.markdown);
   const rawHref = htmlEscapeAttribute(meta.rawHref || "?raw=1");
   return `<!doctype html>
 <html lang="zh-CN" data-theme="dark">
@@ -7530,57 +7776,80 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     :root {
       color-scheme: dark;
       font-family: Inter, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-      --bg: #0b1020;
-      --bg-radial: rgba(124,58,237,.18);
-      --panel: rgba(15,23,42,.68);
-      --panel-strong: rgba(15,23,42,.88);
-      --panel-soft: rgba(30,41,59,.74);
-      --border: rgba(148,163,184,.20);
-      --border-soft: rgba(148,163,184,.14);
+      --bg: #1a1b26;
+      --panel: #1f2335;
+      --panel-strong: #24283b;
+      --panel-soft: #292e42;
+      --border: #3b4261;
+      --border-soft: #30364f;
       --text: #e5e7eb;
-      --heading: #f8fafc;
-      --muted: #94a3b8;
-      --body: #dbe4f0;
-      --link: #c4b5fd;
-      --button: rgba(124,58,237,.16);
-      --button-text: #ddd6fe;
-      --code-bg: rgba(2,6,23,.58);
-      --code-block: rgba(2,6,23,.72);
-      --shadow: rgba(0,0,0,.28);
+      --heading: #f4f4f5;
+      --muted: #8b90a0;
+      --body: #d4d4d8;
+      --link: #7dcfff;
+      --interactive: #7aa2f7;
+      --purple: #bb9af7;
+      --button: #24283b;
+      --button-text: #cbd0da;
+      --code-bg: #292e42;
+      --code-inline: #7dcfff;
+      --code-block: #16161e;
+      --code-block-text: #e5e7eb;
+      --action-bg: #1f2335;
+      --action-header: #24283b;
+      --pending-bg: rgba(224,175,104,.10);
+      --pending-border: rgba(224,175,104,.34);
+      --pending-text: #e0af68;
+      --complete-bg: rgba(158,206,106,.10);
+      --complete-border: rgba(158,206,106,.34);
+      --complete-text: #9ece6a;
+      --shadow: rgba(9,10,15,.28);
       background: var(--bg);
     }
     :root[data-theme="light"] {
       color-scheme: light;
-      --bg: #f8fafc;
-      --bg-radial: rgba(124,58,237,.12);
-      --panel: rgba(255,255,255,.92);
-      --panel-strong: rgba(255,255,255,.98);
-      --panel-soft: rgba(241,245,249,.96);
-      --border: rgba(100,116,139,.24);
-      --border-soft: rgba(100,116,139,.18);
-      --text: #0f172a;
-      --heading: #020617;
-      --muted: #64748b;
-      --body: #1e293b;
-      --link: #6d28d9;
-      --button: rgba(124,58,237,.10);
-      --button-text: #4c1d95;
-      --code-bg: rgba(226,232,240,.76);
-      --code-block: rgba(241,245,249,.92);
-      --shadow: rgba(15,23,42,.10);
+      --bg: #e1e2e7;
+      --panel: #f3f3f5;
+      --panel-strong: #e9e9ed;
+      --panel-soft: #dcdfe7;
+      --border: #c8cad4;
+      --border-soft: #d5d7df;
+      --text: #4c505e;
+      --heading: #343b58;
+      --muted: #7f849c;
+      --body: #4c505e;
+      --link: #007197;
+      --interactive: #2e7de9;
+      --purple: #7847bd;
+      --button: #e7e8ed;
+      --button-text: #4c505e;
+      --code-bg: #dcdfe7;
+      --code-inline: #007197;
+      --code-block: #d5d8e1;
+      --code-block-text: #343b58;
+      --action-bg: #f3f3f5;
+      --action-header: #e9e9ed;
+      --pending-bg: rgba(177,92,0,.08);
+      --pending-border: rgba(177,92,0,.28);
+      --pending-text: #9a5200;
+      --complete-bg: rgba(88,117,57,.10);
+      --complete-border: rgba(88,117,57,.28);
+      --complete-text: #587539;
+      --shadow: rgba(52,59,88,.10);
     }
     *, *::before, *::after { box-sizing: border-box; }
     html, body { overflow-x: hidden; }
-    body { margin: 0; min-height: 100vh; background: radial-gradient(circle at top left, var(--bg-radial), transparent 34rem), var(--bg); color: var(--text); }
-    main { width: min(100%, 1120px); margin: 0 auto; padding: 40px 24px 72px; min-width: 0; }
+    body { margin: 0; min-height: 100vh; background: var(--bg); color: var(--text); }
+    main { width: min(100%, 1180px); margin: 0 auto; padding: 40px 24px 72px; min-width: 0; }
     header { display: flex; align-items: flex-start; justify-content: space-between; gap: 1rem; margin-bottom: 22px; }
-    h1 { margin: 0 0 10px; font-size: clamp(28px, 5vw, 56px); line-height: 1.05; letter-spacing: 0; }
+    h1 { margin: 0 0 10px; font-size: clamp(28px, 4vw, 44px); line-height: 1.12; letter-spacing: -.015em; }
     .meta { margin: 0; color: var(--muted); font-size: 14px; }
     .toolbar { flex: 0 0 auto; display: flex; flex-wrap: wrap; justify-content: flex-end; gap: 10px; }
-    .raw, .theme-toggle { border: 1px solid rgba(124,58,237,.34); border-radius: 999px; color: var(--button-text); background: var(--button); padding: 9px 14px; text-decoration: none; font-size: 13px; font-weight: 800; line-height: 1.2; }
+    .raw, .theme-toggle { border: 1px solid var(--border); border-radius: 999px; color: var(--button-text); background: var(--button); padding: 9px 14px; text-decoration: none; font-size: 13px; font-weight: 800; line-height: 1.2; }
+    .raw:hover, .theme-toggle:hover { border-color: var(--interactive); color: var(--link); }
     .theme-toggle { cursor: pointer; font-family: inherit; }
-    .lifecycle { margin-top: 10px; display: inline-flex; max-width: 100%; border: 1px solid rgba(124,58,237,.30); border-radius: 999px; background: rgba(124,58,237,.12); color: var(--button-text); padding: 6px 10px; font-size: 12px; font-weight: 800; line-height: 1.35; overflow-wrap: anywhere; }
-    article { min-width: 0; border: 1px solid var(--border); border-radius: 14px; background: var(--panel); box-shadow: 0 28px 80px var(--shadow); padding: clamp(20px, 4vw, 34px); }
+    .lifecycle { margin-top: 10px; display: inline-flex; max-width: 100%; border: 1px solid var(--border); border-radius: 999px; background: var(--button); color: var(--muted); padding: 6px 10px; font-size: 12px; font-weight: 800; line-height: 1.35; overflow-wrap: anywhere; }
+    article { min-width: 0; border: 1px solid var(--border); border-radius: 14px; background: var(--panel); box-shadow: 0 18px 50px var(--shadow); padding: clamp(20px, 4vw, 34px); }
     article > *:first-child { margin-top: 0; }
     article > *:last-child { margin-bottom: 0; }
     h2, h3, h4, h5, h6 { margin: 1.7em 0 .65em; line-height: 1.25; letter-spacing: 0; color: var(--heading); overflow-wrap: anywhere; }
@@ -7591,10 +7860,10 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     ul { margin: .65rem 0 1rem; padding-left: 1.35rem; }
     li { margin: .28rem 0; color: var(--body); }
     li input { margin-right: .38rem; transform: translateY(1px); }
-    code { display: inline; max-width: 100%; border: 1px solid var(--border-soft); border-radius: 6px; background: var(--code-bg); color: var(--heading); padding: .1rem .34rem; font-family: "SFMono-Regular", Consolas, monospace; font-size: .92em; white-space: normal; overflow-wrap: anywhere; word-break: break-word; }
+    code { display: inline; max-width: 100%; border: 1px solid var(--border-soft); border-radius: 6px; background: var(--code-bg); color: var(--code-inline); padding: .1rem .34rem; font-family: "SFMono-Regular", Consolas, monospace; font-size: .92em; white-space: normal; overflow-wrap: anywhere; word-break: break-word; }
     pre { max-width: 100%; overflow: auto; border: 1px solid var(--border); border-radius: 10px; background: var(--code-block); padding: 16px; line-height: 1.65; }
-    pre code { border: 0; background: transparent; padding: 0; white-space: pre; overflow-wrap: normal; word-break: normal; }
-    blockquote { margin: 1rem 0; border-left: 3px solid rgba(124,58,237,.72); background: rgba(124,58,237,.10); padding: .75rem 1rem; color: var(--body); }
+    pre code { border: 0; background: transparent; color: var(--code-block-text); padding: 0; white-space: pre; overflow-wrap: normal; word-break: normal; }
+    blockquote { margin: 1rem 0; border-left: 3px solid var(--purple); background: var(--panel-soft); padding: .75rem 1rem; color: var(--body); }
     a { color: var(--link); text-decoration-thickness: .08em; text-underline-offset: .16em; overflow-wrap: anywhere; }
     .table-wrap { max-width: 100%; overflow-x: auto; margin: 1rem 0 1.25rem; border: 1px solid var(--border-soft); border-radius: 10px; background: var(--panel-strong); }
     table { width: 100%; max-width: 100%; border-collapse: collapse; table-layout: fixed; }
@@ -7606,7 +7875,34 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     .frontmatter table { min-width: 0; margin-top: .7rem; }
     .frontmatter th { width: min(34%, 12rem); background: var(--panel-soft); color: var(--body); }
     .frontmatter-list { margin: 0; padding-left: 1.1rem; }
-    @media (max-width: 720px) { main { padding: 28px 14px 48px; } header { display: block; } .toolbar { justify-content: flex-start; margin-top: 14px; } article { padding: 18px; } th, td { padding: .58rem .65rem; } }
+    .action-index { position: sticky; top: 10px; z-index: 4; display: flex; align-items: center; flex-wrap: wrap; gap: 8px; margin: 1rem 0 1.25rem; border: 1px solid var(--border); border-radius: 12px; background: var(--panel-strong); box-shadow: 0 8px 22px var(--shadow); padding: 10px 12px; }
+    .action-index__label { margin-right: 2px; color: var(--muted); font-size: 12px; font-weight: 800; }
+    .action-index a { min-width: 38px; border: 1px solid color-mix(in srgb, var(--interactive) 38%, var(--border)); border-radius: 999px; background: color-mix(in srgb, var(--interactive) 10%, var(--button)); color: var(--interactive); padding: 5px 10px; text-align: center; text-decoration: none; font-size: 12px; font-weight: 900; }
+    .action-index a:hover { border-color: var(--link); background: color-mix(in srgb, var(--interactive) 18%, var(--button)); color: var(--link); }
+    .action-card { scroll-margin-top: 78px; margin: 0 0 20px; overflow: hidden; border: 1px solid var(--border); border-radius: 12px; background: var(--action-bg); box-shadow: 0 8px 24px var(--shadow); }
+    .action-card:target { border-color: var(--interactive); box-shadow: 0 0 0 2px color-mix(in srgb, var(--interactive) 18%, transparent), 0 8px 24px var(--shadow); }
+    .action-card__header { display: grid; grid-template-columns: auto minmax(0, 1fr) auto; align-items: start; gap: 12px; border-bottom: 1px solid var(--border-soft); background: var(--action-header); padding: 16px 18px; }
+    .action-card__index { display: inline-grid; place-items: center; min-width: 42px; min-height: 30px; border: 1px solid color-mix(in srgb, var(--interactive) 34%, var(--border)); border-radius: 8px; background: color-mix(in srgb, var(--interactive) 10%, var(--panel-soft)); color: var(--interactive); font: 900 13px/1 "SFMono-Regular", Consolas, monospace; }
+    .action-card__title { margin: 3px 0 0; font-size: 16px; line-height: 1.55; letter-spacing: 0; color: var(--heading); }
+    .action-card__status { margin-top: 2px; border: 1px solid var(--pending-border); border-radius: 999px; background: var(--pending-bg); color: var(--pending-text); padding: 5px 9px; font-size: 11px; font-weight: 900; white-space: nowrap; }
+    .action-card__status.is-complete { border-color: var(--complete-border); background: var(--complete-bg); color: var(--complete-text); }
+    .action-card__body { padding: 15px 20px 20px; }
+    .action-card__body > *:first-child { margin-top: 0; }
+    .action-card__body > *:last-child { margin-bottom: 0; }
+    .action-card__body > ul { margin: 0 0 1rem; padding-left: 1.3rem; }
+    .action-card__body > ul > li { margin: .55rem 0; padding-left: .15rem; }
+    .action-card__body pre { margin: .9rem 0 1.1rem; }
+    @media (max-width: 720px) {
+      main { padding: 28px 14px 48px; }
+      header { display: block; }
+      .toolbar { justify-content: flex-start; margin-top: 14px; }
+      article { padding: 18px; }
+      th, td { padding: .58rem .65rem; }
+      .action-index { top: 6px; }
+      .action-card__header { grid-template-columns: auto minmax(0, 1fr); padding: 14px; }
+      .action-card__status { grid-column: 2; justify-self: start; }
+      .action-card__body { padding: 14px 16px 18px; }
+    }
   </style>
 </head>
 <body>
@@ -9045,7 +9341,45 @@ function workspaceIntervalMinutesToCron(intervalMinutes) {
 }
 
 function workspaceRunKey(userCtx, flowSource, flowId) {
-  return `${userCtx?.userId || ""}:${flowSource || "user"}:${flowId}`;
+  const source = flowSource || "user";
+  const collaboration = listWorkspaceCollaborationsForUser(userCtx?.userId).find((record) => (
+    record.flowId === flowId
+    && record.archived !== true
+    && (record.projectSource || record.flowSource || "workspace") === source
+  ));
+  if (collaboration?.id) return `shared:${collaboration.id}`;
+  const actorScope = source === "workspace" ? "shared" : userCtx?.userId || "";
+  return `${actorScope}:${source}:${flowId}`;
+}
+
+function workspaceCollaborationEventKey(userCtx, flowSource, flowId, archived = false) {
+  const source = flowSource || "user";
+  const collaboration = listWorkspaceCollaborationsForUser(userCtx?.userId).find((record) => (
+    record.flowId === flowId
+    && record.archived === (archived === true)
+    && (record.projectSource || record.flowSource || "workspace") === source
+  ));
+  if (collaboration?.id) return `shared:${collaboration.id}:${archived ? "1" : "0"}`;
+  const actorScope = source === "workspace" ? "shared" : userCtx?.userId || "";
+  return `${actorScope}:${source}:${flowId}:${archived ? "1" : "0"}`;
+}
+
+function broadcastWorkspaceCollaborationEvent(userCtx, flowSource, flowId, archived, event = {}) {
+  const key = workspaceCollaborationEventKey(userCtx, flowSource, flowId, archived);
+  const seq = (workspaceCollaborationSequences.get(key) || 0) + 1;
+  workspaceCollaborationSequences.set(key, seq);
+  const payload = JSON.stringify({
+    seq,
+    at: new Date().toISOString(),
+    ...event,
+  });
+  const subscribers = workspaceCollaborationSubscribers.get(key);
+  if (!subscribers?.size) return seq;
+  const chunk = `id: ${seq}\ndata: ${payload}\n\n`;
+  for (const clientRes of subscribers) {
+    try { clientRes.write(chunk); } catch (_) {}
+  }
+  return seq;
 }
 
 function workspaceRunEntryKey(scopeKey, runId) {
@@ -9169,9 +9503,19 @@ function workspaceScheduleKey(userId, flowSource, flowId, scheduleNodeId) {
   ].join(":");
 }
 
+function workspaceScheduleOwnerUserId(userCtx = {}, flowSource = "user", flowId = "") {
+  const collaboration = listWorkspaceCollaborationsForUser(userCtx.userId).find((record) => (
+    record.flowId === flowId
+    && record.archived !== true
+    && (record.projectSource || record.flowSource || "workspace") === flowSource
+  ));
+  if (collaboration?.ownerId) return String(collaboration.ownerId);
+  return String(userCtx.userId || "");
+}
+
 function listWorkspaceScheduleStatusesForFlow(userCtx = {}, flowSource = "user", flowId = "") {
   const registry = readWorkspaceScheduleRegistry();
-  const userId = String(userCtx.userId || "");
+  const userId = workspaceScheduleOwnerUserId(userCtx, flowSource, flowId);
   return Object.values(registry.schedules || {})
     .filter((entry) => (
       String(entry?.userId || "") === userId &&
@@ -9183,13 +9527,13 @@ function listWorkspaceScheduleStatusesForFlow(userCtx = {}, flowSource = "user",
 
 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 scheduleUserId = workspaceScheduleOwnerUserId(userCtx, flowSource, flowId);
     const scoped = resolveWorkspaceScopeRoot(root, { flowId, flowSource }, userCtx);
     if (scoped.error || !scoped.root) continue;
     let graph;
@@ -9202,7 +9546,7 @@ function listWorkspaceScheduleStatuses(root, userCtx = {}) {
     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 key = workspaceScheduleKey(scheduleUserId, 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);
@@ -9291,15 +9635,25 @@ function setWorkspaceScheduleEnabled(root, payload = {}, authUser = {}, userCtx
 function syncWorkspaceSchedulesForGraph(root, scoped, graph, authUser, userCtx = {}) {
   const flowId = String(scoped?.flowId || "").trim();
   const flowSource = String(scoped?.flowSource || "user");
-  const userId = String(userCtx.userId || authUser?.userId || "");
+  const userId = workspaceScheduleOwnerUserId(
+    { userId: userCtx.userId || authUser?.userId || "" },
+    flowSource,
+    flowId,
+  );
   if (!flowId || !userId) return [];
   const now = Date.now();
   const nowIso = new Date(now).toISOString();
   const registry = readWorkspaceScheduleRegistry();
   const schedules = { ...(registry.schedules || {}) };
   const prefix = `${userId}:${flowSource}:${flowId}:`;
-  for (const key of Object.keys(schedules)) {
-    if (key.startsWith(prefix)) delete schedules[key];
+  for (const [key, entry] of Object.entries(schedules)) {
+    const sameSharedFlow = (
+      flowSource === "workspace"
+      && scoped?.collaboration
+      && String(entry?.flowSource || "") === flowSource
+      && String(entry?.flowId || "") === flowId
+    );
+    if (sameSharedFlow || key.startsWith(prefix)) delete schedules[key];
   }
   const instances = graph?.instances && typeof graph.instances === "object" ? graph.instances : {};
   for (const [scheduleNodeId, instance] of Object.entries(instances)) {
@@ -10971,7 +11325,49 @@ export function startUiServer({
     if (url.pathname === "/api/flows") {
       if (req.method === "GET") {
         try {
-          json(res, 200, listFlowsJson(root, userCtx));
+          const flows = listFlowsJson(root, { ...userCtx, includeWorkspaceFlows: true })
+            .filter((flow) => (
+              !workspaceFlowCollaborationGuard(
+                flow.id,
+                flow.source || "user",
+                flow.archived === true,
+                userCtx,
+                "read",
+              )
+            ))
+            .map((flow) => {
+              const source = flow.source || "user";
+              const collaboration = source === "workspace"
+                ? getWorkspaceCollaborationByFlow(flow.id, flow.archived === true)
+                : getWorkspaceCollaborationForProject({
+                  flowId: flow.id,
+                  flowSource: source,
+                  archived: flow.archived === true,
+                  ownerId: userCtx.userId,
+                });
+              return collaboration
+                ? { ...flow, collaboration: workspaceCollaborationSummaryWithUsers(collaboration, userCtx.userId) }
+                : flow;
+            });
+          const existingCollaborationIds = new Set(flows.map((flow) => flow.collaboration?.id).filter(Boolean));
+          for (const record of listWorkspaceCollaborationsForUser(userCtx.userId)) {
+            const source = record.projectSource || record.flowSource || "workspace";
+            if (source !== "user" || record.ownerId === userCtx.userId) continue;
+            if (existingCollaborationIds.has(record.id)) continue;
+            const ownerFlow = listFlowsJson(root, { userId: record.ownerId })
+              .find((flow) => (
+                flow.id === record.flowId
+                && (flow.source || "user") === "user"
+                && Boolean(flow.archived) === Boolean(record.archived)
+              ));
+            if (!ownerFlow) continue;
+            flows.push({
+              ...ownerFlow,
+              collaboration: workspaceCollaborationSummaryWithUsers(record, userCtx.userId),
+            });
+            existingCollaborationIds.add(record.id);
+          }
+          json(res, 200, flows);
         } catch (e) {
           json(res, 500, { error: (e && e.message) || String(e) });
         }
@@ -11023,6 +11419,9 @@ export function startUiServer({
           json(res, 400, result);
           return;
         }
+        if (targetSpace === "workspace") {
+          ensureWorkspaceCollaboration({ flowId, userId: userCtx.userId });
+        }
         json(res, 200, { success: true, flowId, flowSource: targetSpace });
         return;
       }
@@ -11103,6 +11502,9 @@ export function startUiServer({
         json(res, 400, { error: w.error });
         return;
       }
+      if (targetSpace === "workspace") {
+        ensureWorkspaceCollaboration({ flowId, userId: userCtx.userId });
+      }
       json(res, 200, { success: true, flowId, flowSource: targetSpace });
       return;
     }
@@ -11207,11 +11609,188 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "POST" && url.pathname === "/api/workspace/collaboration/accept") {
+      try {
+        const payload = JSON.parse(await readBody(req));
+        const accepted = acceptWorkspaceCollaborationInvite({
+          token: payload?.token,
+          userId: userCtx.userId,
+        });
+        if (accepted.error) {
+          json(res, accepted.status || 400, { error: accepted.error });
+          return;
+        }
+        json(res, 200, { ok: true, workspace: accepted.workspace });
+      } catch (e) {
+        json(res, 400, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/workspace/collaboration/share") {
+      try {
+        const payload = JSON.parse(await readBody(req));
+        const flowId = String(payload?.flowId || "").trim();
+        const flowSource = String(payload?.flowSource || "user").trim();
+        const archived = payload?.archived === true || payload?.flowArchived === true;
+        if (flowSource !== "workspace" && flowSource !== "user") {
+          json(res, 400, { error: "当前 Project 不支持协作分享" });
+          return;
+        }
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId,
+          flowSource,
+          workspaceId: payload.workspaceId || "",
+          archived,
+        }, userCtx);
+        if (scoped.error) {
+          json(res, scoped.status || 400, { error: scoped.error });
+          return;
+        }
+        const ensured = ensureWorkspaceCollaboration({
+          flowId,
+          flowSource,
+          archived,
+          userId: userCtx.userId,
+        });
+        if (ensured.error) {
+          json(res, ensured.status || 400, { error: ensured.error });
+          return;
+        }
+        const targetUser = findWorkspaceShareUser(payload?.username || payload?.userId);
+        if (!targetUser) {
+          json(res, 404, { error: "未找到该用户名，请确认对方已经登录或注册 AgentFlow" });
+          return;
+        }
+        const added = addWorkspaceCollaborationMember({
+          workspaceId: ensured.workspace.id,
+          userId: userCtx.userId,
+          memberUserId: targetUser.userId,
+          role: payload?.role,
+        });
+        if (added.error) {
+          json(res, added.status || 400, { error: added.error });
+          return;
+        }
+        const record = getWorkspaceCollaborationForProject({ workspaceId: ensured.workspace.id });
+        broadcastWorkspaceCollaborationEvent(userCtx, flowSource, flowId, archived, {
+          type: "member.added",
+          actorId: userCtx.userId || "",
+          memberUserId: targetUser.userId,
+        });
+        json(res, 200, {
+          ok: true,
+          workspace: workspaceCollaborationSummaryWithUsers(record, userCtx.userId),
+          member: { userId: targetUser.userId, username: targetUser.username, role: "editor" },
+        });
+      } catch (e) {
+        json(res, 400, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "DELETE" && url.pathname === "/api/workspace/collaboration/share") {
+      try {
+        const payload = JSON.parse(await readBody(req));
+        const flowId = String(payload?.flowId || "").trim();
+        const flowSource = String(payload?.flowSource || "user").trim();
+        const archived = payload?.archived === true || payload?.flowArchived === true;
+        if (!flowId || (flowSource !== "workspace" && flowSource !== "user")) {
+          json(res, 400, { error: "Missing shared project" });
+          return;
+        }
+        const record = getWorkspaceCollaborationForProject({
+          workspaceId: payload.workspaceId || "",
+          flowId,
+          flowSource,
+          archived,
+          ownerId: userCtx.userId,
+        }) || listWorkspaceCollaborationsForUser(userCtx.userId).find((item) => (
+          item.flowId === flowId
+          && (item.projectSource || item.flowSource || "workspace") === flowSource
+          && item.archived === archived
+        ));
+        if (!record) {
+          json(res, 404, { error: "Workspace collaboration not found" });
+          return;
+        }
+        const requestedUser = String(payload?.username || payload?.memberUserId || "").trim();
+        const targetUser = requestedUser ? findWorkspaceShareUser(requestedUser) : null;
+        if (requestedUser && !targetUser) {
+          json(res, 404, { error: "未找到该用户" });
+          return;
+        }
+        const removed = removeWorkspaceCollaborationMember({
+          workspaceId: record.id,
+          userId: userCtx.userId,
+          memberUserId: targetUser?.userId || userCtx.userId,
+        });
+        if (removed.error) {
+          json(res, removed.status || 400, { error: removed.error });
+          return;
+        }
+        broadcastWorkspaceCollaborationEvent(userCtx, flowSource, flowId, archived, {
+          type: removed.left ? "member.left" : "member.removed",
+          actorId: userCtx.userId || "",
+          memberUserId: removed.removedUserId || "",
+        });
+        const nextRecord = getWorkspaceCollaborationForProject({ workspaceId: record.id });
+        json(res, 200, {
+          ok: true,
+          left: removed.left === true,
+          removedUserId: removed.removedUserId || "",
+          workspace: removed.left ? null : workspaceCollaborationSummaryWithUsers(nextRecord, userCtx.userId),
+        });
+      } catch (e) {
+        json(res, 400, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "GET" && url.pathname === "/api/workspace/events") {
+      const scoped = resolveWorkspaceScopeRoot(root, {
+        flowId: url.searchParams.get("flowId") || "",
+        flowSource: url.searchParams.get("flowSource") || "user",
+        workspaceId: url.searchParams.get("workspaceId") || "",
+        archived: url.searchParams.get("archived") === "1",
+      }, userCtx);
+      if (scoped.error) {
+        json(res, scoped.status || 400, { error: scoped.error });
+        return;
+      }
+      const key = workspaceCollaborationEventKey(userCtx, scoped.flowSource, scoped.flowId, scoped.archived);
+      let subscribers = workspaceCollaborationSubscribers.get(key);
+      if (!subscribers) {
+        subscribers = new Set();
+        workspaceCollaborationSubscribers.set(key, subscribers);
+      }
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no",
+      });
+      res.write(`event: connected\ndata: ${JSON.stringify({ seq: workspaceCollaborationSequences.get(key) || 0 })}\n\n`);
+      subscribers.add(res);
+      const heartbeat = setInterval(() => {
+        try { res.write(`: heartbeat ${Date.now()}\n\n`); } catch (_) {}
+      }, 15_000);
+      const detach = () => {
+        clearInterval(heartbeat);
+        subscribers.delete(res);
+        if (subscribers.size === 0) workspaceCollaborationSubscribers.delete(key);
+      };
+      req.on("close", detach);
+      res.on("close", detach);
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/workspace/files") {
       try {
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: url.searchParams.get("flowId") || "",
           flowSource: url.searchParams.get("flowSource") || "user",
+          workspaceId: url.searchParams.get("workspaceId") || "",
           archived: url.searchParams.get("archived") === "1",
         }, userCtx);
         if (scoped.error) {
@@ -11230,6 +11809,7 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: url.searchParams.get("flowId") || "",
           flowSource: url.searchParams.get("flowSource") || "user",
+          workspaceId: url.searchParams.get("workspaceId") || "",
           archived: url.searchParams.get("archived") === "1",
         }, userCtx);
         const scopedRoot = scoped.error ? root : scoped.root;
@@ -11287,23 +11867,30 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: url.searchParams.get("flowId") || "",
           flowSource: url.searchParams.get("flowSource") || "user",
+          workspaceId: url.searchParams.get("workspaceId") || "",
           archived: url.searchParams.get("archived") === "1",
         }, userCtx);
         if (scoped.error) {
-          json(res, 400, { error: scoped.error });
+          json(res, scoped.status || 400, { error: scoped.error });
           return;
         }
         const { path: graphPath, graph } = readWorkspaceGraph(scoped.root);
         const hydratedGraph = hydrateWorkspaceGraphForRuntime(root, scoped, graph, userCtx);
+        const collaborationAccess = scoped.collaborationAccess || workspaceCollaborationAccess(null, userCtx.userId);
         json(res, 200, {
           ok: true,
           graph: hydratedGraph,
+          revision: workspaceDesignRevision(hydratedGraph),
+          designRevision: workspaceDesignRevision(hydratedGraph),
+          runtimeRevision: workspaceRuntimeRevision(hydratedGraph),
           path: graphPath,
           root: scoped.root,
           flowId: scoped.flowId,
           flowSource: scoped.flowSource,
           archived: scoped.archived,
-          writable: !(scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)),
+          writable: !(scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource))
+            && collaborationAccess.writable !== false,
+          collaboration: workspaceCollaborationSummaryWithUsers(scoped.collaboration, userCtx.userId),
           workspaceSchedules: listWorkspaceScheduleStatusesForFlow(userCtx, scoped.flowSource || "user", scoped.flowId || ""),
         });
       } catch (e) {
@@ -11324,6 +11911,7 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
+          workspaceId: payload.workspaceId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
@@ -11368,23 +11956,106 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
+          workspaceId: payload.workspaceId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
-          json(res, 400, { error: scoped.error });
+          json(res, scoped.status || 400, { error: scoped.error });
           return;
         }
-        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+        if (
+          scoped.archived
+          || isReadonlyBuiltinFlowSource(scoped.flowSource)
+          || scoped.collaborationAccess?.writable === false
+        ) {
           json(res, 400, { error: "Cannot write workspace graph for builtin or archived pipeline" });
           return;
         }
         const submittedGraph = hydrateWorkspaceGraphForRuntime(root, scoped, payload.graph || payload, userCtx);
         const graphPath = workspaceGraphPath(scoped.root);
-        const currentGraph = hydrateWorkspaceGraphForRuntime(root, scoped, readWorkspaceGraph(scoped.root).graph, userCtx);
-        const graph = mergeWorkspacePersistentNodeRefs(submittedGraph, currentGraph);
-        fs.writeFileSync(graphPath, JSON.stringify(graph, null, 2) + "\n", "utf-8");
+        const currentStoredGraph = readWorkspaceGraph(scoped.root).graph;
+        const currentGraph = hydrateWorkspaceGraphForRuntime(root, scoped, currentStoredGraph, userCtx);
+        const currentRevision = workspaceDesignRevision(currentGraph);
+        const baseRevision = String(payload.baseRevision || "").trim();
+        if (scoped.collaboration && !baseRevision) {
+          json(res, 428, {
+            error: "Shared workspace save requires baseRevision",
+            currentRevision,
+          });
+          return;
+        }
+        let nextGraph = submittedGraph;
+        let merged = false;
+        const baseGraph = payload.baseGraph;
+        if (baseRevision && baseGraph && typeof baseGraph === "object") {
+          const actualBaseRevision = workspaceDesignRevision(baseGraph);
+          if (actualBaseRevision !== baseRevision) {
+            json(res, 400, {
+              error: "Workspace 合并基线与 baseRevision 不匹配",
+              conflict: "invalid-merge-base",
+              expectedRevision: baseRevision,
+              actualBaseRevision,
+              currentRevision,
+            });
+            return;
+          }
+          const mergeResult = mergeWorkspaceGraphs({
+            baseGraph,
+            currentGraph,
+            incomingGraph: submittedGraph,
+          });
+          if (mergeResult.conflicts.length) {
+            json(res, 409, {
+              error: `Workspace 存在 ${mergeResult.conflicts.length} 处同字段冲突`,
+              conflict: "field-conflict",
+              expectedRevision: baseRevision,
+              currentRevision,
+              conflictPaths: mergeResult.conflicts.map((item) => item.path),
+              conflictItems: mergeResult.conflicts,
+              mergeGraph: mergeResult.graph,
+              currentGraph,
+            });
+            return;
+          }
+          nextGraph = mergeResult.graph;
+          merged = baseRevision !== currentRevision
+            || workspaceRuntimeRevision(baseGraph) !== workspaceRuntimeRevision(currentGraph);
+        } else if (baseRevision && baseRevision !== currentRevision) {
+          json(res, 409, {
+            error: "Workspace 已被其他成员更新，当前客户端缺少合并基线，请刷新后重试",
+            conflict: "missing-merge-base",
+            expectedRevision: baseRevision,
+            currentRevision,
+          });
+          return;
+        }
+        const graph = mergeWorkspacePersistentNodeRefs(nextGraph, currentGraph);
+        writeWorkspaceGraphAtomic(graphPath, graph);
+        const revision = workspaceDesignRevision(graph);
+        const runtimeRevision = workspaceRuntimeRevision(graph);
         const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, graph, authUser, userCtx);
-        json(res, 200, { ok: true, path: graphPath, graph, workspaceSchedules });
+        broadcastWorkspaceCollaborationEvent(
+          userCtx,
+          scoped.flowSource,
+          scoped.flowId,
+          scoped.archived,
+          {
+            type: "graph.committed",
+            revision,
+            actorId: userCtx.userId || "",
+            clientId: String(payload.clientId || ""),
+          },
+        );
+        json(res, 200, {
+          ok: true,
+          path: graphPath,
+          graph,
+          revision,
+          designRevision: revision,
+          runtimeRevision,
+          merged,
+          workspaceSchedules,
+        });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
       }
@@ -11420,6 +12091,7 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
+          workspaceId: payload.workspaceId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
@@ -11467,13 +12139,18 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
+          workspaceId: payload.workspaceId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
           json(res, 400, { error: scoped.error });
           return;
         }
-        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+        if (
+          scoped.archived
+          || isReadonlyBuiltinFlowSource(scoped.flowSource)
+          || scoped.collaborationAccess?.writable === false
+        ) {
           json(res, 400, { error: "Cannot optimize workspace graph for builtin or archived pipeline" });
           return;
         }
@@ -11489,12 +12166,20 @@ export function startUiServer({
         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");
+        writeWorkspaceGraphAtomic(graphPath, mergedGraph);
+        const revision = workspaceDesignRevision(mergedGraph);
         const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, mergedGraph, authUser, userCtx);
+        broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
+          type: "graph.committed",
+          revision,
+          actorId: userCtx.userId || "",
+          clientId: String(payload.clientId || ""),
+        });
         json(res, 200, {
           ok: true,
           path: graphPath,
           graph: mergedGraph,
+          revision,
           order: result.order,
           optimized: result.optimized,
           skipped: result.skipped,
@@ -11518,13 +12203,18 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
+          workspaceId: payload.workspaceId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
           json(res, 400, { error: scoped.error });
           return;
         }
-        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+        if (
+          scoped.archived
+          || isReadonlyBuiltinFlowSource(scoped.flowSource)
+          || scoped.collaborationAccess?.runnable === false
+        ) {
           json(res, 400, { error: "Cannot run workspace graph for builtin or archived pipeline" });
           return;
         }
@@ -11534,7 +12224,27 @@ export function startUiServer({
           json(res, 400, { error: "Missing flowId" });
           return;
         }
-        const runtimeGraph = hydrateWorkspaceGraphForRuntime(root, scoped, payload.graph || {}, userCtx);
+        const canonicalStoredGraph = readWorkspaceGraph(scoped.root).graph;
+        const canonicalGraph = hydrateWorkspaceGraphForRuntime(
+          root,
+          scoped,
+          canonicalStoredGraph,
+          userCtx,
+        );
+        const canonicalRevision = workspaceDesignRevision(canonicalGraph);
+        const expectedRevision = String(payload.expectedRevision || payload.baseRevision || "").trim();
+        if (scoped.collaboration && expectedRevision && expectedRevision !== canonicalRevision) {
+          json(res, 409, {
+            error: "Workspace 已更新，请刷新后再运行",
+            conflict: "revision-mismatch",
+            expectedRevision,
+            currentRevision: canonicalRevision,
+          });
+          return;
+        }
+        const runtimeGraph = scoped.collaboration
+          ? canonicalGraph
+          : hydrateWorkspaceGraphForRuntime(root, scoped, payload.graph || canonicalGraph, userCtx);
         const runNodeId = String(payload.runNodeId || "").trim();
         const plan = workspaceRunPlan(runtimeGraph, runNodeId, scoped.root);
         const plannedNodeIds = workspaceRunPlanNodeIds(runNodeId, plan);
@@ -11583,12 +12293,27 @@ export function startUiServer({
         });
         activeWorkspaceRuns.set(runKey, runEntry);
         appendWorkspaceRunStarted(runEntry);
+        broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
+          type: "run.started",
+          runId,
+          runNodeId,
+          plannedNodeIds,
+          revision: canonicalRevision,
+          actorId: userCtx.userId || "",
+        });
         const setActiveChild = (child, childOptions = {}) => {
           runControl.setChild(child, childOptions);
         };
         const clearActiveRun = (status = "finished") => {
           runControl.finish(status);
           if (activeWorkspaceRuns.get(runKey) === runEntry) activeWorkspaceRuns.delete(runKey);
+          broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
+            type: "run.finished",
+            status,
+            runId,
+            runNodeId,
+            actorId: userCtx.userId || "",
+          });
         };
         if (wantsStream) {
           const graphPath = workspaceGraphPath(scoped.root);
@@ -11611,7 +12336,12 @@ export function startUiServer({
             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");
+            writeWorkspaceGraphAtomic(graphPath, mergedGraph);
+            const revision = workspaceDesignRevision(mergedGraph);
+            const runtimeRevision = workspaceRuntimeRevision(mergedGraph);
+            const collaborationEventType = revision === workspaceDesignRevision(currentGraph)
+              ? "runtime.committed"
+              : "graph.committed";
             const endedAt = Date.now();
             appendWorkspaceRunFinished({
               ...runEntry,
@@ -11623,7 +12353,14 @@ export function startUiServer({
               durationMs: endedAt - runEntry.startedAt,
               runNodeId,
             });
-            writeEvent({ type: "done", ok: true, path: graphPath, graph: mergedGraph, order: result.order, touchedNodeIds: Array.from(touchedIds), pauseNodeIds: result.pauseNodeIds || [] });
+            broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
+              type: collaborationEventType,
+              revision,
+              runtimeRevision,
+              actorId: userCtx.userId || "",
+              source: "run",
+            });
+            writeEvent({ type: "done", ok: true, path: graphPath, graph: mergedGraph, revision, runtimeRevision, order: result.order, touchedNodeIds: Array.from(touchedIds), pauseNodeIds: result.pauseNodeIds || [] });
             res.end();
           } catch (e) {
             const endedAt = Date.now();
@@ -11670,7 +12407,12 @@ export function startUiServer({
           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");
+          writeWorkspaceGraphAtomic(graphPath, mergedGraph);
+          const revision = workspaceDesignRevision(mergedGraph);
+          const runtimeRevision = workspaceRuntimeRevision(mergedGraph);
+          const collaborationEventType = revision === workspaceDesignRevision(currentGraph)
+            ? "runtime.committed"
+            : "graph.committed";
           const endedAt = Date.now();
           appendWorkspaceRunFinished({
             ...runEntry,
@@ -11682,7 +12424,14 @@ export function startUiServer({
             durationMs: endedAt - runEntry.startedAt,
             runNodeId,
           });
-          json(res, 200, { ok: true, path: graphPath, ...result, graph: mergedGraph, touchedNodeIds: Array.from(touchedIds) });
+          broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
+            type: collaborationEventType,
+            revision,
+            runtimeRevision,
+            actorId: userCtx.userId || "",
+            source: "run",
+          });
+          json(res, 200, { ok: true, path: graphPath, ...result, graph: mergedGraph, revision, runtimeRevision, touchedNodeIds: Array.from(touchedIds) });
         } catch (e) {
           const endedAt = Date.now();
           if (isWorkspaceRunAbortError(e) || controller.signal.aborted) {
@@ -11729,9 +12478,18 @@ export function startUiServer({
         const scheduleNodeId = url.searchParams.get("scheduleNodeId") || "";
         const runNodeId = url.searchParams.get("runNodeId") || "";
         const limit = Number(url.searchParams.get("limit") || 50);
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId,
+          flowSource: flowSource || "user",
+          archived: url.searchParams.get("archived") === "1",
+        }, userCtx);
+        if (scoped.error) {
+          json(res, scoped.status || 400, { error: scoped.error });
+          return;
+        }
         json(res, 200, {
           runs: listWorkspaceRunLogs({
-            userId: userCtx.userId || "",
+            userId: flowSource === "workspace" ? "" : userCtx.userId || "",
             flowId,
             flowSource,
             scheduleNodeId,
@@ -11752,7 +12510,23 @@ export function startUiServer({
           json(res, 400, { error: "Missing runId" });
           return;
         }
-        const run = listWorkspaceRunLogs({ userId: userCtx.userId || "", limit: 200 })
+        const flowId = url.searchParams.get("flowId") || "";
+        const flowSource = url.searchParams.get("flowSource") || "user";
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId,
+          flowSource,
+          archived: url.searchParams.get("archived") === "1",
+        }, userCtx);
+        if (scoped.error) {
+          json(res, scoped.status || 400, { error: scoped.error });
+          return;
+        }
+        const run = listWorkspaceRunLogs({
+          userId: flowSource === "workspace" ? "" : userCtx.userId || "",
+          flowId,
+          flowSource,
+          limit: 200,
+        })
           .find((item) => String(item.runId || "") === runId);
         if (!run) {
           json(res, 404, { error: "Run log not found" });
@@ -11775,6 +12549,15 @@ export function startUiServer({
         return;
       }
       const flowSource = url.searchParams.get("flowSource") || "user";
+      const scoped = resolveWorkspaceScopeRoot(root, {
+        flowId,
+        flowSource,
+        archived: url.searchParams.get("archived") === "1",
+      }, userCtx);
+      if (scoped.error) {
+        json(res, scoped.status || 400, { error: scoped.error });
+        return;
+      }
       const scopeKey = workspaceRunKey(userCtx, flowSource, flowId);
       const entries = workspaceActiveRunsForScope(scopeKey).map(([, entry]) => entry);
       const entry = entries[0] || null;
@@ -11812,7 +12595,21 @@ export function startUiServer({
         json(res, 400, { error: "Missing flowId" });
         return;
       }
-      const scopeKey = workspaceRunKey(userCtx, payload.flowSource || "user", flowId);
+      const flowSource = payload.flowSource || "user";
+      const scoped = resolveWorkspaceScopeRoot(root, {
+        flowId,
+        flowSource,
+        archived: payload.archived === true || payload.flowArchived === true,
+      }, userCtx);
+      if (scoped.error) {
+        json(res, scoped.status || 400, { error: scoped.error });
+        return;
+      }
+      if (scoped.collaborationAccess?.runnable === false) {
+        json(res, 403, { error: "Workspace collaboration run permission denied" });
+        return;
+      }
+      const scopeKey = workspaceRunKey(userCtx, flowSource, flowId);
       const runId = String(payload.runId || payload.runSessionId || "").trim();
       const runNodeId = String(payload.runNodeId || "").trim();
       const entries = workspaceActiveRunsForScope(scopeKey);
@@ -11829,6 +12626,12 @@ export function startUiServer({
         runNodeId: entry.runNodeId || "",
         ts: Date.now(),
       });
+      broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
+        type: "run.stop-requested",
+        runId: entry.runId,
+        runNodeId: entry.runNodeId || "",
+        actorId: userCtx.userId || "",
+      });
       const result = await entry.runControl.stop();
       if (!result.stopped) {
         appendWorkspaceRunLogEvent(entry.runId, {
@@ -11880,7 +12683,13 @@ export function startUiServer({
           json(res, 413, { error: "File too large" });
           return;
         }
-        json(res, 200, { path: rel, content: fs.readFileSync(abs, "utf-8"), size: stat.size });
+        const content = fs.readFileSync(abs, "utf-8");
+        json(res, 200, {
+          path: rel,
+          content,
+          size: stat.size,
+          revision: crypto.createHash("sha256").update(content).digest("hex"),
+        });
       } catch (e) {
         json(res, /traversal/i.test(String(e.message || e)) ? 403 : 500, { error: (e && e.message) || String(e) });
       }
@@ -12001,7 +12810,11 @@ export function startUiServer({
           json(res, 400, { error: scoped.error });
           return;
         }
-        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+        if (
+          scoped.archived
+          || isReadonlyBuiltinFlowSource(scoped.flowSource)
+          || scoped.collaborationAccess?.writable === false
+        ) {
           json(res, 400, { error: "Cannot write to builtin or archived pipeline workspace" });
           return;
         }
@@ -12010,9 +12823,39 @@ export function startUiServer({
           json(res, 400, { error: "Missing path" });
           return;
         }
+        const content = String(payload.content ?? "");
+        const baseRevision = String(payload.baseRevision || "").trim();
+        if (baseRevision && fs.existsSync(abs) && fs.statSync(abs).isFile()) {
+          const currentContent = fs.readFileSync(abs, "utf-8");
+          const currentRevision = crypto.createHash("sha256").update(currentContent).digest("hex");
+          if (currentRevision !== baseRevision) {
+            json(res, 409, {
+              error: "文件已被其他成员更新，请处理冲突后重试",
+              conflict: "revision-mismatch",
+              currentRevision,
+            });
+            return;
+          }
+        }
         fs.mkdirSync(path.dirname(abs), { recursive: true });
-        fs.writeFileSync(abs, String(payload.content ?? ""), "utf-8");
-        json(res, 200, { ok: true, path: rel });
+        const tmp = `${abs}.${process.pid}.${Date.now()}.tmp`;
+        fs.writeFileSync(tmp, content, "utf-8");
+        fs.renameSync(tmp, abs);
+        const revision = crypto.createHash("sha256").update(content).digest("hex");
+        broadcastWorkspaceCollaborationEvent(
+          userCtx,
+          scoped.flowSource,
+          scoped.flowId,
+          scoped.archived,
+          {
+            type: "file.committed",
+            path: rel,
+            revision,
+            actorId: userCtx.userId || "",
+            clientId: String(payload.clientId || ""),
+          },
+        );
+        json(res, 200, { ok: true, path: rel, revision });
       } catch (e) {
         json(res, /traversal/i.test(String(e.message || e)) ? 403 : 500, { error: (e && e.message) || String(e) });
       }
@@ -12041,7 +12884,7 @@ export function startUiServer({
           json(res, 400, { error: scoped.error });
           return;
         }
-        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource) || scoped.collaborationAccess?.writable === false) {
           json(res, 400, { error: "Cannot write to builtin or archived pipeline workspace" });
           return;
         }
@@ -12051,6 +12894,11 @@ export function startUiServer({
         const target = uniqueWorkspaceRelPath(scoped.root, targetRel);
         fs.mkdirSync(path.dirname(target.abs), { recursive: true });
         fs.writeFileSync(target.abs, parsed.file);
+        broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
+          type: "file.committed",
+          path: target.rel,
+          actorId: userCtx.userId || "",
+        });
         json(res, 200, {
           ok: true,
           path: target.rel,
@@ -12081,7 +12929,7 @@ export function startUiServer({
           json(res, 400, { error: scoped.error });
           return;
         }
-        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource) || scoped.collaborationAccess?.writable === false) {
           json(res, 400, { error: "Cannot write to builtin or archived pipeline workspace" });
           return;
         }
@@ -12091,6 +12939,11 @@ export function startUiServer({
           return;
         }
         fs.mkdirSync(abs, { recursive: true });
+        broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
+          type: "file.tree-changed",
+          path: rel,
+          actorId: userCtx.userId || "",
+        });
         json(res, 200, { ok: true, path: rel });
       } catch (e) {
         json(res, /traversal/i.test(String(e.message || e)) ? 403 : 500, { error: (e && e.message) || String(e) });
@@ -12116,7 +12969,7 @@ export function startUiServer({
           json(res, 400, { error: scoped.error });
           return;
         }
-        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource) || scoped.collaborationAccess?.writable === false) {
           json(res, 400, { error: "Cannot write to builtin or archived pipeline workspace" });
           return;
         }
@@ -12130,6 +12983,12 @@ export function startUiServer({
           return;
         }
         fs.rmSync(abs, { recursive: true, force: true });
+        broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
+          type: "file.tree-changed",
+          path: rel,
+          deleted: true,
+          actorId: userCtx.userId || "",
+        });
         json(res, 200, { ok: true, path: rel });
       } catch (e) {
         json(res, /traversal/i.test(String(e.message || e)) ? 403 : 500, { error: (e && e.message) || String(e) });
@@ -12166,7 +13025,7 @@ export function startUiServer({
           json(res, 200, { ok: true, conversations: readWorkspaceConversations(scoped.root) });
           return;
         }
-        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource) || scoped.collaborationAccess?.writable === false) {
           json(res, 400, { error: "Cannot write conversations for builtin or archived pipeline workspace" });
           return;
         }
@@ -12201,6 +13060,10 @@ export function startUiServer({
           json(res, 400, { error: scoped.error });
           return;
         }
+        if (scoped.collaborationAccess?.writable === false) {
+          json(res, 403, { error: "Workspace collaboration edit permission denied" });
+          return;
+        }
         const selectedSkillKeys = Array.isArray(payload?.selectedSkills)
           ? payload.selectedSkills.map((x) => String(x || "").trim()).filter(Boolean)
           : [];
@@ -12287,10 +13150,14 @@ export function startUiServer({
           json(res, 400, { error: scoped.error });
           return;
         }
+        if (scoped.collaborationAccess?.writable === false) {
+          json(res, 403, { error: "Workspace collaboration edit permission denied" });
+          return;
+        }
         const targetFilePath = String(payload?.targetFilePath || "").trim();
         let targetFile = null;
         if (targetFilePath) {
-          if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+          if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource) || scoped.collaborationAccess?.writable === false) {
             json(res, 400, { error: "Cannot edit builtin or archived pipeline workspace" });
             return;
           }
@@ -13151,12 +14018,26 @@ export function startUiServer({
         return;
       }
       const flowArchived = url.searchParams.get("archived") === "1";
+      const collaborationDenied = workspaceFlowCollaborationGuard(
+        flowId,
+        flowSource,
+        flowArchived,
+        userCtx,
+        "read",
+      );
+      if (collaborationDenied) {
+        json(res, collaborationDenied.status, { error: collaborationDenied.error });
+        return;
+      }
       const result = readFlowJson(root, flowId, flowSource, { archived: flowArchived, ...userCtx });
       if (result.error) {
         json(res, 404, result);
         return;
       }
-      json(res, 200, result);
+      json(res, 200, {
+        ...result,
+        revision: crypto.createHash("sha256").update(String(result.flowYaml || "")).digest("hex").slice(0, 24),
+      });
       return;
     }
 
@@ -13335,12 +14216,53 @@ finishedAt: "${new Date().toISOString()}"
         return;
       }
       const flowArchived = Boolean(payload.flowArchived);
+      const collaborationDenied = workspaceFlowCollaborationGuard(
+        flowId,
+        flowSource,
+        flowArchived,
+        userCtx,
+        "write",
+      );
+      if (collaborationDenied) {
+        json(res, collaborationDenied.status, { error: collaborationDenied.error });
+        return;
+      }
+      if (flowSource === "workspace" && getWorkspaceCollaborationByFlow(flowId, flowArchived)) {
+        const current = readFlowJson(root, flowId, flowSource, { archived: flowArchived, ...userCtx });
+        if (current.error) {
+          json(res, 404, current);
+          return;
+        }
+        const currentRevision = crypto.createHash("sha256")
+          .update(String(current.flowYaml || ""))
+          .digest("hex")
+          .slice(0, 24);
+        const baseRevision = String(payload.baseRevision || "").trim();
+        if (!baseRevision) {
+          json(res, 428, { error: "Shared workspace save requires baseRevision", currentRevision });
+          return;
+        }
+        if (baseRevision !== currentRevision) {
+          json(res, 409, {
+            error: "Workflow 已被其他成员更新，请处理冲突后重试",
+            conflict: "revision-mismatch",
+            expectedRevision: baseRevision,
+            currentRevision,
+          });
+          return;
+        }
+      }
       const result = writeFlowYaml(root, flowId, flowSource, flowYaml, { archived: flowArchived, ...userCtx });
       if (!result.success) {
         json(res, 400, result);
         return;
       }
-      json(res, 200, { success: true });
+      broadcastFlowEditorSync(flowId, flowSource, flowArchived, userCtx.userId);
+      const saved = readFlowJson(root, flowId, flowSource, { archived: flowArchived, ...userCtx });
+      json(res, 200, {
+        success: true,
+        revision: crypto.createHash("sha256").update(String(saved.flowYaml || "")).digest("hex").slice(0, 24),
+      });
       return;
     }
 
@@ -13363,6 +14285,17 @@ finishedAt: "${new Date().toISOString()}"
         return;
       }
       const flowArchived = Boolean(payload.flowArchived);
+      const collaborationDenied = workspaceFlowCollaborationGuard(
+        flowId,
+        flowSource,
+        flowArchived,
+        userCtx,
+        "read",
+      );
+      if (collaborationDenied) {
+        json(res, collaborationDenied.status, { error: collaborationDenied.error });
+        return;
+      }
       broadcastFlowEditorSync(flowId, flowSource, flowArchived, userCtx.userId);
       json(res, 200, { ok: true });
       return;
@@ -13380,6 +14313,17 @@ finishedAt: "${new Date().toISOString()}"
         return;
       }
       const flowArchived = url.searchParams.get("archived") === "1";
+      const collaborationDenied = workspaceFlowCollaborationGuard(
+        flowId,
+        flowSource,
+        flowArchived,
+        userCtx,
+        "read",
+      );
+      if (collaborationDenied) {
+        json(res, collaborationDenied.status, { error: collaborationDenied.error });
+        return;
+      }
       const key = flowEditorSyncKey(flowId, flowSource, flowArchived, userCtx.userId);
       let set = flowEditorSyncSubscribers.get(key);
       if (!set) {
@@ -13414,6 +14358,17 @@ finishedAt: "${new Date().toISOString()}"
         return;
       }
       const flowArchived = url.searchParams.get("archived") === "1";
+      const collaborationDenied = workspaceFlowCollaborationGuard(
+        flowId,
+        flowSource,
+        flowArchived,
+        userCtx,
+        "read",
+      );
+      if (collaborationDenied) {
+        json(res, collaborationDenied.status, { error: collaborationDenied.error });
+        return;
+      }
       const key = flowEditorSyncKey(flowId, flowSource, flowArchived, userCtx.userId);
       const serverVer = flowEditorSyncVersions.get(key) ?? 0;
       const clientVer = parseInt(url.searchParams.get("v") ?? "0", 10) || 0;
@@ -13444,11 +14399,21 @@ finishedAt: "${new Date().toISOString()}"
         json(res, 400, { error: "Invalid toSource" });
         return;
       }
+      const collaborationDenied = workspaceFlowCollaborationGuard(flowId, fromSource, false, userCtx, "owner");
+      if (collaborationDenied) {
+        json(res, collaborationDenied.status, { error: collaborationDenied.error });
+        return;
+      }
       const result = moveFlowDirectory(root, flowId.trim(), fromSource, toSource, userCtx);
       if (!result.success) {
         json(res, 400, { error: result.error || "Move failed" });
         return;
       }
+      if (fromSource === "workspace" && toSource !== "workspace") {
+        deleteWorkspaceCollaborationForFlow(flowId.trim(), false);
+      } else if (fromSource !== "workspace" && toSource === "workspace") {
+        ensureWorkspaceCollaboration({ flowId: flowId.trim(), userId: userCtx.userId });
+      }
       json(res, 200, { success: true, flowId: flowId.trim(), flowSource: result.flowSource });
       return;
     }
@@ -13472,6 +14437,11 @@ finishedAt: "${new Date().toISOString()}"
         json(res, 400, { error: "仅支持重命名用户目录或工作区流水线" });
         return;
       }
+      const collaborationDenied = workspaceFlowCollaborationGuard(flowId, flowSource, false, userCtx, "owner");
+      if (collaborationDenied) {
+        json(res, collaborationDenied.status, { error: collaborationDenied.error });
+        return;
+      }
       const validation = validateUserPipelineId(newFlowId);
       if (!validation.ok) {
         json(res, 400, { error: validation.error });
@@ -13494,6 +14464,12 @@ finishedAt: "${new Date().toISOString()}"
       }
       try {
         fs.renameSync(fromDir, toDir);
+        updateWorkspaceCollaborationFlow({
+          previousFlowId: flowId,
+          flowSource,
+          ownerId: userCtx.userId,
+          flowId: validation.flowId,
+        });
         json(res, 200, { success: true, flowId: validation.flowId, flowSource });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
@@ -13524,11 +14500,24 @@ finishedAt: "${new Date().toISOString()}"
         json(res, 400, { error: "仅支持归档用户目录或工作区流水线" });
         return;
       }
+      const collaborationDenied = workspaceFlowCollaborationGuard(flowId, flowSource, false, userCtx, "owner");
+      if (collaborationDenied) {
+        json(res, collaborationDenied.status, { error: collaborationDenied.error });
+        return;
+      }
       const result = archiveFlowPipeline(root, flowId, flowSource, userCtx);
       if (!result.success) {
         json(res, 400, { error: result.error || "归档失败" });
         return;
       }
+      updateWorkspaceCollaborationFlow({
+        previousFlowId: flowId,
+        previousArchived: false,
+        flowSource,
+        ownerId: userCtx.userId,
+        flowId,
+        archived: true,
+      });
       json(res, 200, { success: true, flowId, flowSource, archived: true });
       return;
     }
@@ -13557,11 +14546,53 @@ finishedAt: "${new Date().toISOString()}"
         json(res, 400, { error: "仅支持删除用户目录或工作区流水线" });
         return;
       }
+      const collaboration = getWorkspaceCollaborationForProject({
+        workspaceId: payload.workspaceId || "",
+        flowId,
+        flowSource,
+        archived: flowArchived,
+        ownerId: userCtx.userId,
+      }) || listWorkspaceCollaborationsForUser(userCtx.userId).find((record) => (
+        record.flowId === flowId
+        && record.archived === flowArchived
+        && (record.projectSource || record.flowSource || "workspace") === flowSource
+      )) || null;
+      const collaborationAccess = workspaceCollaborationAccess(collaboration, userCtx.userId);
+      if (collaboration && collaborationAccess.allowed && collaborationAccess.role !== "owner") {
+        const left = removeWorkspaceCollaborationMember({
+          workspaceId: collaboration.id,
+          userId: userCtx.userId,
+        });
+        if (left.error) {
+          json(res, left.status || 400, { error: left.error });
+          return;
+        }
+        broadcastWorkspaceCollaborationEvent(userCtx, flowSource, flowId, flowArchived, {
+          type: "member.left",
+          actorId: userCtx.userId || "",
+          memberUserId: userCtx.userId || "",
+        });
+        json(res, 200, {
+          success: true,
+          flowId,
+          flowSource,
+          deleted: false,
+          left: true,
+        });
+        return;
+      }
+      const collaborationDenied = workspaceFlowCollaborationGuard(flowId, flowSource, flowArchived, userCtx, "owner");
+      if (collaborationDenied) {
+        json(res, collaborationDenied.status, { error: collaborationDenied.error });
+        return;
+      }
       const result = deleteFlowPipeline(root, flowId, flowSource, { archived: flowArchived, ...userCtx });
       if (!result.success) {
         json(res, 400, { error: result.error || "删除失败" });
         return;
       }
+      if (collaboration?.id) deleteWorkspaceCollaborationById(collaboration.id);
+      else deleteWorkspaceCollaborationForFlow(flowId, flowArchived);
       json(res, 200, { success: true, flowId, flowSource, deleted: true });
       return;
     }
@@ -13824,8 +14855,20 @@ finishedAt: "${new Date().toISOString()}"
         json(res, 400, { error: "Missing flowId" });
         return;
       }
+      const flowSource = payload.flowSource || "user";
+      const collaborationDenied = workspaceFlowCollaborationGuard(
+        flowId,
+        flowSource,
+        false,
+        userCtx,
+        "run",
+      );
+      if (collaborationDenied) {
+        json(res, collaborationDenied.status, { error: collaborationDenied.error });
+        return;
+      }
       const runUuid = typeof payload.uuid === "string" ? payload.uuid.trim() : "";
-      const runKey = `${userCtx.userId || ""}:${payload.flowSource || "user"}:${flowId}`;
+      const runKey = workspaceRunKey(userCtx, flowSource, flowId);
       if (activeFlowRuns.has(runKey)) {
         json(res, 409, { error: "该流水线已在运行中" });
         return;
@@ -13904,7 +14947,7 @@ finishedAt: "${new Date().toISOString()}"
       }
 
       /** @type {{ child: import("child_process").ChildProcess, runUuid: string | null }} */
-      const runEntry = { child, runUuid: runUuid || null };
+      const runEntry = { child, runUuid: runUuid || null, userId: userCtx.userId || "" };
       activeFlowRuns.set(runKey, runEntry);
       log.debug(`[ui] flow/run: spawned pid=${child.pid} flowId=${flowId}${runUuid ? ` uuid=${runUuid}` : ""}`);
 
@@ -13978,7 +15021,19 @@ finishedAt: "${new Date().toISOString()}"
         json(res, 400, { error: "Missing flowId" });
         return;
       }
-      const runKey = `${userCtx.userId || ""}:${payload.flowSource || "user"}:${flowId}`;
+      const flowSource = payload.flowSource || "user";
+      const collaborationDenied = workspaceFlowCollaborationGuard(
+        flowId,
+        flowSource,
+        false,
+        userCtx,
+        "run",
+      );
+      if (collaborationDenied) {
+        json(res, collaborationDenied.status, { error: collaborationDenied.error });
+        return;
+      }
+      const runKey = workspaceRunKey(userCtx, flowSource, flowId);
       const entry = activeFlowRuns.get(runKey);
       if (!entry || !entry.child) {
         json(res, 404, { error: "该流水线未在运行" });
@@ -14000,7 +15055,7 @@ finishedAt: "${new Date().toISOString()}"
       activeFlowRuns.delete(runKey);
       if (uuid) {
         try {
-          const runDir = getRunDir(root, flowId, uuid, userCtx);
+          const runDir = getRunDir(root, flowId, uuid, { userId: entry.userId || userCtx.userId || "" });
           fs.mkdirSync(runDir, { recursive: true });
           fs.writeFileSync(
             path.join(runDir, RUN_INTERRUPTED_FILENAME),