@fieldwangai/agentflow 0.1.114 → 0.1.117

package/bin/lib/ui-server.mjs

@@ -3133,6 +3133,48 @@ function hydrateWorkspaceGraphForRuntime(workspaceRoot, scoped = {}, graph = {},
   return hydrateWorkspaceSlotMetaFromDefinitions(workspaceRoot, scoped, withMarketplaceRuntime, userCtx);
 }
 
+function adminWorkspaceOwnerSummary(ownerId = "") {
+  const id = String(ownerId || "").trim();
+  if (!id) return null;
+  const users = readAuthUsers();
+  const knownUserIds = new Set([
+    ...Object.keys(users || {}),
+    ...listAgentflowUserIds(),
+  ].map((value) => String(value || "").trim()).filter(Boolean));
+  if (!knownUserIds.has(id)) return null;
+  return {
+    userId: id,
+    username: String(users?.[id]?.username || id),
+  };
+}
+
+function adminWorkspaceRequestedUserContext(userCtx = {}) {
+  const ownerId = String(userCtx.adminOwnerId || "").trim();
+  if (!ownerId) return { userCtx };
+  if (userCtx.isAdmin !== true) {
+    return { error: "Admin permission required", status: 403 };
+  }
+  const owner = adminWorkspaceOwnerSummary(ownerId);
+  if (!owner) return { error: "Workspace owner not found", status: 404 };
+  return {
+    owner,
+    userCtx: {
+      ...userCtx,
+      userId: owner.userId,
+      adminOwnerId: "",
+    },
+  };
+}
+
+function workspaceScopedUserContext(scoped = {}, userCtx = {}) {
+  if (!scoped.adminReadonly || !scoped.ownerUserId) return userCtx;
+  return {
+    ...userCtx,
+    userId: scoped.ownerUserId,
+    adminOwnerId: "",
+  };
+}
+
 function resolveWorkspaceScopeRoot(workspaceRoot, params = {}, opts = {}) {
   const flowId = params.flowId != null ? String(params.flowId).trim() : "";
   if (!flowId) return { root: path.resolve(workspaceRoot), flowId: "", flowSource: "", archived: false };
@@ -3143,6 +3185,46 @@ function resolveWorkspaceScopeRoot(workspaceRoot, params = {}, opts = {}) {
   if (!isValidFlowSourceRead(flowSource)) {
     return { root: "", error: "Invalid flowSource" };
   }
+  const adminOwnerId = String(params.adminOwnerId || opts.adminOwnerId || "").trim();
+  if (adminOwnerId) {
+    if (opts.isAdmin !== true) {
+      return { root: "", error: "Admin permission required", status: 403 };
+    }
+    if (flowSource !== "user") {
+      return { root: "", error: "Admin read-only review only supports user projects", status: 400 };
+    }
+    const owner = adminWorkspaceOwnerSummary(adminOwnerId);
+    if (!owner) {
+      return { root: "", error: "Workspace owner not found", status: 404 };
+    }
+    const targetFlow = listFlowsJson(workspaceRoot, { userId: owner.userId })
+      .find((flow) => (
+        flow.id === flowId
+        && (flow.source || "user") === "user"
+        && Boolean(flow.archived) === archived
+      ));
+    if (!targetFlow?.path) {
+      return { root: "", error: "Pipeline workspace not found", status: 404 };
+    }
+    return {
+      root: path.resolve(targetFlow.path),
+      flowId,
+      flowSource: "user",
+      requestedFlowSource: flowSource,
+      workspaceId: "",
+      archived,
+      collaboration: null,
+      collaborationAccess: {
+        allowed: true,
+        writable: false,
+        runnable: false,
+        role: "admin-viewer",
+      },
+      adminReadonly: true,
+      ownerUserId: owner.userId,
+      ownerUsername: owner.username,
+    };
+  }
   const workspaceId = String(params.workspaceId || "").trim();
   let collaboration = getWorkspaceCollaborationForProject({
     workspaceId,
@@ -7472,6 +7554,17 @@ function resolvePrdWorkflowScope(workspaceRoot, params = {}, userCtx = {}, capab
   const flowId = String(params.flowId || "").trim();
   const flowSource = String(params.flowSource || "user").trim() || "user";
   const archived = params.archived === true || params.archived === "1" || params.flowArchived === true;
+  const adminOwnerId = String(params.adminOwnerId || userCtx.adminOwnerId || "").trim();
+  if (adminOwnerId && userCtx.isAdmin !== true) {
+    return { error: "Admin permission required", status: 403 };
+  }
+  const adminOwner = adminOwnerId ? adminWorkspaceOwnerSummary(adminOwnerId) : null;
+  if (adminOwnerId && !adminOwner) {
+    return { error: "Workspace owner not found", status: 404 };
+  }
+  if (adminOwner && capability !== "read") {
+    return { error: "Admin Workspace review is read-only", status: 403 };
+  }
   const shareToken = String(params.workflowShare || params.workflow_share || "").trim();
   const linkCollaboration = shareToken ? getPrdWorkflowCollaborationByShareToken(shareToken) : null;
   if (shareToken && (!linkCollaboration || linkCollaboration.tapdId !== tapdId)) {
@@ -7480,8 +7573,10 @@ function resolvePrdWorkflowScope(workspaceRoot, params = {}, userCtx = {}, capab
   const memberCollaboration = tapdId
     ? getPrdWorkflowCollaborationForUser(tapdId, userCtx?.userId)
     : null;
-  const collaboration = linkCollaboration || memberCollaboration;
-  const access = linkCollaboration
+  const collaboration = adminOwner ? null : (linkCollaboration || memberCollaboration);
+  const access = adminOwner
+    ? { allowed: true, writable: false, role: "admin-viewer", via: "admin-review" }
+    : linkCollaboration
     ? { allowed: true, writable: false, role: "viewer", via: "share-link" }
     : prdWorkflowCollaborationAccess(collaboration, userCtx?.userId);
   if (collaboration && !access.allowed) {
@@ -7490,7 +7585,7 @@ function resolvePrdWorkflowScope(workspaceRoot, params = {}, userCtx = {}, capab
   if (capability === "write" && (linkCollaboration || (collaboration && !access.writable))) {
     return { error: "PRD Workflow collaboration edit permission denied", status: 403 };
   }
-  const ownerId = String(collaboration?.ownerId || userCtx?.userId || "").trim();
+  const ownerId = String(adminOwner?.userId || collaboration?.ownerId || userCtx?.userId || "").trim();
   const stateRoot = path.resolve(getAgentflowUserDataRoot(ownerId));
   let executionRoot = path.resolve(workspaceRoot);
   if (flowId) {
@@ -7498,6 +7593,7 @@ function resolvePrdWorkflowScope(workspaceRoot, params = {}, userCtx = {}, capab
       flowId,
       flowSource,
       workspaceId: params.workspaceId || "",
+      adminOwnerId,
       archived,
     }, userCtx);
     if (projectScope.error) {
@@ -7516,6 +7612,7 @@ function resolvePrdWorkflowScope(workspaceRoot, params = {}, userCtx = {}, capab
     collaborationAccess: access,
     shareToken,
     sharedByLink: Boolean(linkCollaboration),
+    adminReadonly: Boolean(adminOwner),
     flowId,
     flowSource,
     archived,
@@ -7526,7 +7623,8 @@ function prdWorkflowKey(userCtx = {}, flowSource = "user", flowId = "", tapdId =
   const id = String(tapdId || "").trim();
   const collaboration = getPrdWorkflowCollaborationByShareToken(shareToken)
     || getPrdWorkflowCollaborationForUser(id, userCtx?.userId);
-  const actorScope = `user:${String(collaboration?.ownerId || userCtx?.userId || "")}`;
+  const adminOwnerId = userCtx?.isAdmin === true ? String(userCtx?.adminOwnerId || "").trim() : "";
+  const actorScope = `user:${String(collaboration?.ownerId || adminOwnerId || userCtx?.userId || "")}`;
   return [actorScope, id].join("\t");
 }
 
@@ -7678,6 +7776,32 @@ function prdWorkflowReviewIdFromRequest(tapdId, payload = {}, durability = "temp
   return prdWorkflowSafeStateId(["review", tapdId, stageHead, digest].filter(Boolean).join("-")).slice(0, 64);
 }
 
+function prdWorkflowReviewArtifactKey(tapdId, payload = {}, durability = "temporary") {
+  const explicit = String(payload.artifactKey || payload.artifact_key || "").trim();
+  if (explicit) return explicit.slice(0, 500);
+  const issueKey = prdWorkflowSafeStateId(
+    payload.issueKey || payload.issue_key || payload.issue || "global",
+  ).toLowerCase();
+  const platform = prdWorkflowSafeStateId(payload.platform || "all").toLowerCase();
+  const stage = prdWorkflowSafeStateId(
+    payload.stage
+    || payload.stageKey
+    || payload.stage_key
+    || payload.action
+    || payload.actionId
+    || payload.action_id
+    || "review",
+  ).toLowerCase();
+  return [
+    "prd-review",
+    prdWorkflowSafeStateId(tapdId).toLowerCase(),
+    issueKey,
+    platform,
+    stage,
+    String(durability || "temporary").trim().toLowerCase() || "temporary",
+  ].join(":").slice(0, 500);
+}
+
 function prdWorkflowStatePath(scopedRoot, tapdId) {
   const rootDir = scopedRoot || process.cwd();
   return path.join(rootDir, ".workspace", "prd-flow", "workflow-state", `${prdWorkflowSafeStateId(tapdId)}.json`);
@@ -7724,6 +7848,78 @@ function prdWorkflowReviewPaths(scopedRoot, tapdId, reviewId) {
   };
 }
 
+function prdWorkflowReviewIndexPath(tapdId, reviewId) {
+  return path.join(
+    getAgentflowDataRoot(),
+    "prd-workflow-review-index",
+    prdWorkflowSafeStateId(tapdId),
+    `${prdWorkflowSafeStateId(reviewId)}.json`,
+  );
+}
+
+function prdWorkflowWriteReviewIndex(ownerId, tapdId, reviewId) {
+  const indexPath = prdWorkflowReviewIndexPath(tapdId, reviewId);
+  const tempPath = `${indexPath}.${process.pid}.${Date.now()}.tmp`;
+  fs.mkdirSync(path.dirname(indexPath), { recursive: true });
+  fs.writeFileSync(tempPath, JSON.stringify({
+    version: 1,
+    tapdId: String(tapdId || ""),
+    reviewId: prdWorkflowSafeStateId(reviewId),
+    ownerId: String(ownerId || "").trim(),
+    updatedAt: new Date().toISOString(),
+  }, null, 2) + "\n", "utf-8");
+  fs.renameSync(tempPath, indexPath);
+}
+
+function prdWorkflowReadReviewIndex(tapdId, reviewId) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(prdWorkflowReviewIndexPath(tapdId, reviewId), "utf-8"));
+    if (
+      String(parsed?.tapdId || "") !== String(tapdId || "")
+      || prdWorkflowSafeStateId(parsed?.reviewId) !== prdWorkflowSafeStateId(reviewId)
+    ) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function prdWorkflowReviewFileExists(paths) {
+  try {
+    return fs.existsSync(paths.markdownPath) && fs.statSync(paths.markdownPath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function prdWorkflowResolveReviewPaths(scopedRoot, tapdId, reviewId) {
+  const direct = prdWorkflowReviewPaths(scopedRoot, tapdId, reviewId);
+  if (prdWorkflowReviewFileExists(direct)) return direct;
+
+  const indexed = prdWorkflowReadReviewIndex(tapdId, reviewId);
+  if (indexed) {
+    const indexedPaths = prdWorkflowReviewPaths(
+      getAgentflowUserDataRoot(indexed.ownerId || ""),
+      tapdId,
+      reviewId,
+    );
+    if (prdWorkflowReviewFileExists(indexedPaths)) return indexedPaths;
+  }
+
+  const candidateOwners = ["", ...listAgentflowUserIds()];
+  for (const ownerId of candidateOwners) {
+    const candidate = prdWorkflowReviewPaths(getAgentflowUserDataRoot(ownerId), tapdId, reviewId);
+    if (!prdWorkflowReviewFileExists(candidate)) continue;
+    try {
+      prdWorkflowWriteReviewIndex(ownerId, tapdId, reviewId);
+    } catch (_) {}
+    return candidate;
+  }
+  return direct;
+}
+
 function prdWorkflowMigrateLegacyState(legacyRoot, stateRoot, tapdId) {
   const sourceRoot = path.resolve(legacyRoot || "");
   const destinationRoot = path.resolve(stateRoot || "");
@@ -7753,6 +7949,75 @@ function prdWorkflowMigrateLegacyState(legacyRoot, stateRoot, tapdId) {
   } catch (_) {}
 }
 
+function prdWorkflowReviewShortLinkDir(root) {
+  return path.join(path.resolve(root || process.cwd()), ".workspace", "prd-flow", "review-short-links");
+}
+
+function prdWorkflowReviewShortLinkPath(root, shortCode) {
+  return path.join(
+    prdWorkflowReviewShortLinkDir(root),
+    `${String(shortCode || "").trim()}.json`,
+  );
+}
+
+function prdWorkflowReadReviewShortLink(root, shortCode) {
+  const code = String(shortCode || "").trim();
+  if (!/^[A-Za-z0-9_-]{8,32}$/.test(code)) return null;
+  try {
+    const filePath = prdWorkflowReviewShortLinkPath(root, code);
+    if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) return null;
+    const link = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    const targetPath = String(link?.targetPath || "").trim();
+    if (!targetPath.startsWith("/api/prd-workflow/review/") || /[\r\n]/.test(targetPath)) return null;
+    return {
+      ...link,
+      shortCode: code,
+      targetPath,
+      filePath,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function prdWorkflowCreateReviewShortLink(root, reviewUrl, review = {}) {
+  let parsed;
+  try {
+    parsed = new URL(String(reviewUrl || ""));
+  } catch {
+    return null;
+  }
+  const targetPath = `${parsed.pathname}${parsed.search}`;
+  if (!targetPath.startsWith("/api/prd-workflow/review/")) return null;
+  const digest = crypto.createHash("sha256").update(targetPath).digest("base64url");
+  const dir = prdWorkflowReviewShortLinkDir(root);
+  fs.mkdirSync(dir, { recursive: true });
+  for (let length = 8; length <= 24; length += 2) {
+    const shortCode = digest.slice(0, length);
+    const existing = prdWorkflowReadReviewShortLink(root, shortCode);
+    if (existing && existing.targetPath !== targetPath) continue;
+    const link = {
+      shortCode,
+      targetPath,
+      tapdId: String(review?.tapdId || ""),
+      reviewId: String(review?.id || ""),
+      durability: String(review?.durability || "temporary"),
+      expiresAt: String(review?.expiresAt || ""),
+      createdAt: String(review?.createdAt || new Date().toISOString()),
+    };
+    fs.writeFileSync(
+      prdWorkflowReviewShortLinkPath(root, shortCode),
+      JSON.stringify(link, null, 2) + "\n",
+      "utf-8",
+    );
+    return {
+      ...link,
+      shortUrl: `${parsed.origin}/r/${shortCode}`,
+    };
+  }
+  throw new Error("Unable to allocate a unique review short code");
+}
+
 function prdWorkflowPruneReviews(scopedRoot, tapdId, maxReviews = 200) {
   try {
     const dir = prdWorkflowReviewDir(scopedRoot, tapdId);
@@ -7773,10 +8038,12 @@ function prdWorkflowPruneReviews(scopedRoot, tapdId, maxReviews = 200) {
     for (const entry of entries.filter((item) => Number.isFinite(item.expiresMs) && item.expiresMs < now)) {
       try { fs.unlinkSync(entry.abs); } catch (_) {}
       try { fs.unlinkSync(path.join(dir, `${entry.id}.md`)); } catch (_) {}
+      try { fs.unlinkSync(prdWorkflowReviewIndexPath(tapdId, entry.id)); } catch (_) {}
     }
     for (const entry of entries.filter((item) => !(Number.isFinite(item.expiresMs) && item.expiresMs < now)).slice(maxReviews)) {
       try { fs.unlinkSync(entry.abs); } catch (_) {}
       try { fs.unlinkSync(path.join(dir, `${entry.id}.md`)); } catch (_) {}
+      try { fs.unlinkSync(prdWorkflowReviewIndexPath(tapdId, entry.id)); } catch (_) {}
     }
   } catch (_) {}
 }
@@ -7805,6 +8072,30 @@ function prdWorkflowReviewSplitFrontmatter(markdown) {
   return { frontmatter: match[1].trim(), body: text.slice(match[0].length) };
 }
 
+function prdWorkflowReviewStripLegacyMetadata(body) {
+  const lines = String(body || "").replace(/\r\n/g, "\n").split("\n");
+  const visible = [];
+  let fenced = false;
+  let hidden = false;
+  for (const line of lines) {
+    if (!hidden && /^\s*```/.test(line)) {
+      fenced = !fenced;
+      visible.push(line);
+      continue;
+    }
+    if (!fenced && !hidden && /<!--\s*prd-flow-start\b/.test(line)) {
+      hidden = !/prd-flow-end\s*-->/.test(line);
+      continue;
+    }
+    if (hidden) {
+      if (/prd-flow-end\s*-->/.test(line)) hidden = false;
+      continue;
+    }
+    visible.push(line);
+  }
+  return visible.join("\n");
+}
+
 function prdWorkflowReviewRenderFrontmatter(frontmatter) {
   if (!String(frontmatter || "").trim()) return "";
   const rows = [];
@@ -8051,20 +8342,24 @@ export function prdWorkflowReviewMarkdownToHtml(markdown) {
   const { frontmatter, body } = prdWorkflowReviewSplitFrontmatter(markdown);
   return [
     prdWorkflowReviewRenderFrontmatter(frontmatter),
-    prdWorkflowReviewBodyToHtml(body),
+    prdWorkflowReviewBodyToHtml(prdWorkflowReviewStripLegacyMetadata(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 visibleBody = prdWorkflowReviewStripLegacyMetadata(body);
+  const lines = String(visibleBody || "").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 || ""),
+      markdown: [
+        frontmatter ? `---\n${frontmatter}\n---` : "",
+        visibleBody,
+      ].filter(Boolean).join("\n\n"),
       title: String(fallbackTitle || "PRD Workflow Review"),
     };
   }
@@ -8276,7 +8571,7 @@ export function prdWorkflowReviewHtml(title, markdown, meta = {}) {
 </html>`;
 }
 
-function prdWorkflowCreateReview(scopedRoot, tapdId, payload = {}, urlBase = "") {
+function prdWorkflowCreateReview(scopedRoot, tapdId, payload = {}, urlBase = "", ownerId = "") {
   const content = String(payload.markdown || payload.content || payload.rawOutput || "").slice(0, 500000);
   if (!content.trim()) throw new Error("Missing review markdown");
   const title = String(payload.title || payload.label || "PRD Workflow Review").trim().slice(0, 160) || "PRD Workflow Review";
@@ -8312,6 +8607,7 @@ function prdWorkflowCreateReview(scopedRoot, tapdId, payload = {}, urlBase = "")
   fs.mkdirSync(paths.dir, { recursive: true });
   fs.writeFileSync(paths.markdownPath, content.trimEnd() + "\n", "utf-8");
   fs.writeFileSync(paths.metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+  prdWorkflowWriteReviewIndex(ownerId, tapdId, paths.id);
   prdWorkflowPruneReviews(scopedRoot, tapdId);
   prdWorkflowAppendAudit(scopedRoot, tapdId, {
     type: "review-created",
@@ -8959,18 +9255,27 @@ function prdWorkflowNormalizeRuntimeEvent(tapdId, event = {}) {
 
 function prdWorkflowMergeRuntimeEventArrays(left, right) {
   const out = [];
-  const seen = new Set();
+  const seen = new Map();
   for (const value of [...(Array.isArray(left) ? left : []), ...(Array.isArray(right) ? right : [])]) {
     if (value == null) continue;
-    let key = "";
+    const explicitKey = value && typeof value === "object" && !Array.isArray(value)
+      ? String(value.key || value.artifactKey || value.artifact_key || "").trim()
+      : "";
+    let key = explicitKey ? `key:${explicitKey}` : "";
     try {
-      key = typeof value === "string" ? value : JSON.stringify(value);
+      if (!key) key = typeof value === "string" ? value : JSON.stringify(value);
     } catch {
       key = String(value);
     }
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(value);
+    const index = seen.get(key);
+    if (index == null) {
+      seen.set(key, out.length);
+      out.push(value);
+      continue;
+    }
+    if (explicitKey) {
+      out[index] = value;
+    }
   }
   return out;
 }
@@ -10699,6 +11004,7 @@ function normalizeContextInstanceIds(raw) {
  * @param {string} opts.workspaceRoot
  * @param {number} opts.port
  * @param {boolean} [opts.hideCommunityLinks]
+ * @param {boolean} [opts.enableWorkspaceScheduler]
  * @param {string} [opts.staticDir] 默认 PACKAGE_ROOT/builtin/web-ui/dist（npm run build 产出）
  * @returns {Promise<import('http').Server>}
  */
@@ -10707,6 +11013,7 @@ export function startUiServer({
   port,
   host = "127.0.0.1",
   hideCommunityLinks = false,
+  enableWorkspaceScheduler = true,
   staticDir = path.join(PACKAGE_ROOT, "builtin", "web-ui", "dist"),
 }) {
   const root = path.resolve(workspaceRoot);
@@ -10784,7 +11091,11 @@ export function startUiServer({
     }
 
     const authUser = getAuthUserFromRequest(req);
-    const userCtx = authUser ? { userId: authUser.userId, isAdmin: Boolean(authUser.isAdmin) } : {};
+    const userCtx = authUser ? {
+      userId: authUser.userId,
+      isAdmin: Boolean(authUser.isAdmin),
+      adminOwnerId: String(url.searchParams.get("adminOwnerId") || "").trim(),
+    } : {};
     if (req.method === "GET" && url.pathname === "/api/auth/session-token") {
       if (!authUser?.userId) {
         json(res, 401, { error: "Unauthorized" });
@@ -11096,7 +11407,19 @@ export function startUiServer({
           baseSnapshot,
           getSessionTokenFromRequest(req) || "",
         );
-        json(res, 200, { ok: true, snapshot });
+        const workflowShare = workflowScope.collaboration?.shareToken
+          ? prdWorkflowShareLinkSummary(
+              workflowScope.collaboration,
+              workflowScope.collaboration.shareToken,
+              serverPublicBaseUrl(req, host, uiPort),
+              userCtx.userId,
+            )
+          : null;
+        json(res, 200, {
+          ok: true,
+          snapshot,
+          ...(workflowShare ? { workflowShare, shareUrl: workflowShare.url } : {}),
+        });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
       }
@@ -11121,6 +11444,22 @@ export function startUiServer({
           json(res, 400, { error: "Missing tapdId" });
           return;
         }
+        const rawSnapshot = payload.snapshot && typeof payload.snapshot === "object" && !Array.isArray(payload.snapshot)
+          ? payload.snapshot
+          : payload.prd || payload.next ? payload : null;
+        if (!rawSnapshot) {
+          json(res, 400, { error: "Missing snapshot" });
+          return;
+        }
+        const existingCollaboration = getPrdWorkflowCollaborationForUser(tapdId, userCtx.userId);
+        const existingAccess = prdWorkflowCollaborationAccess(existingCollaboration, userCtx.userId);
+        const shareResult = existingCollaboration && existingAccess.role !== "owner"
+          ? { record: existingCollaboration, created: false }
+          : ensurePrdWorkflowShareLink({ tapdId, userId: userCtx.userId });
+        if (shareResult.error) {
+          json(res, shareResult.status || 400, { error: shareResult.error });
+          return;
+        }
         const flowId = String(payload.flowId || "").trim();
         const flowSource = String(payload.flowSource || "user").trim() || "user";
         const archived = payload.archived === true || payload.flowArchived === true;
@@ -11137,13 +11476,6 @@ export function startUiServer({
         }
         const scopedRoot = workflowScope.stateRoot;
         prdWorkflowMigrateLegacyState(workflowScope.executionRoot, scopedRoot, tapdId);
-        const rawSnapshot = payload.snapshot && typeof payload.snapshot === "object" && !Array.isArray(payload.snapshot)
-          ? payload.snapshot
-          : payload.prd || payload.next ? payload : null;
-        if (!rawSnapshot) {
-          json(res, 400, { error: "Missing snapshot" });
-          return;
-        }
         const normalizedSnapshot = {
           ...prdWorkflowSnapshotFromParsed(scopedRoot, tapdId, rawSnapshot, userCtx, { flowSource, flowId }),
           clientReportedAt: new Date().toISOString(),
@@ -11263,8 +11595,20 @@ export function startUiServer({
         }
         const materialized = prdWorkflowMaterializeSnapshot(workflowScope.executionRoot, scopedRoot, tapdId, userCtx, { flowSource, flowId });
         const withDiagnostic = prdWorkflowWithAgentflowTokenDiagnostic(materialized, getSessionTokenFromRequest(req) || "");
+        const workflowShare = shareResult.record?.shareToken
+          ? prdWorkflowShareLinkSummary(
+              shareResult.record,
+              shareResult.record.shareToken,
+              serverPublicBaseUrl(req, host, uiPort, payload),
+              userCtx.userId,
+            )
+          : null;
         prdWorkflowBroadcast(prdWorkflowKey(userCtx, flowSource, flowId, tapdId), { type: "snapshot-report", tapdId, snapshot: withDiagnostic });
-        json(res, 200, { ok: true, snapshot: withDiagnostic });
+        json(res, 200, {
+          ok: true,
+          snapshot: withDiagnostic,
+          ...(workflowShare ? { workflowShare, shareUrl: workflowShare.url } : {}),
+        });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
       }
@@ -11967,20 +12311,45 @@ export function startUiServer({
         }
         const scopedRoot = workflowScope.stateRoot;
         prdWorkflowMigrateLegacyState(workflowScope.executionRoot, scopedRoot, tapdId);
-        const review = prdWorkflowCreateReview(scopedRoot, tapdId, payload, serverPublicBaseUrl(req, host, uiPort, payload));
-        const reviewUrl = review.url;
+        const review = prdWorkflowCreateReview(
+          scopedRoot,
+          tapdId,
+          payload,
+          serverPublicBaseUrl(req, host, uiPort, payload),
+          workflowScope.ownerId,
+        );
+        const query = new URLSearchParams();
+        if (flowId) query.set("flowId", flowId);
+        if (flowId && flowSource && flowSource !== "user") query.set("flowSource", flowSource);
+        if (archived) query.set("archived", "1");
+        const reviewUrl = query.toString() ? `${review.url}?${query.toString()}` : review.url;
+        let shortLink = null;
+        try {
+          shortLink = prdWorkflowCreateReviewShortLink(root, reviewUrl, review);
+        } catch (e) {
+          log.debug(`[prd-workflow] review short link failed: ${(e && e.message) || String(e)}`);
+        }
+        const shortUrl = shortLink?.shortUrl || "";
+        const displayUrl = shortUrl || reviewUrl;
         const durability = review.durability || "temporary";
+        const artifactKey = prdWorkflowReviewArtifactKey(tapdId, payload, durability);
         const reviewSource = review.source && typeof review.source === "object" && !Array.isArray(review.source)
           ? review.source
           : { kind: durability === "durable" ? "ai-doc" : "local-draft", durability };
+        const idempotencyKey = String(
+          payload.idempotencyKey || payload.idempotency_key || "",
+        ).trim();
         const artifact = {
+          key: artifactKey,
           label: payload.artifactLabel || "Markdown Review",
           kind: durability === "temporary" ? "temporary-review" : "review",
           persistence: "runtime",
           durability,
           source: reviewSource,
           confirmed: payload.confirmed === true || payload.confirmed === "1",
-          url: reviewUrl,
+          url: displayUrl,
+          canonicalUrl: reviewUrl,
+          shortUrl,
           expiresAt: review.expiresAt || "",
         };
         const event = prdWorkflowAppendRuntimeEvent(scopedRoot, tapdId, {
@@ -11995,19 +12364,42 @@ export function startUiServer({
           detail: "已生成临时 Markdown review 链接",
           status: "current",
           issueKey: payload.issueKey || payload.issue_key || "",
+          idempotencyKey,
           durability,
           sourceArtifact: reviewSource,
           expiresAt: review.expiresAt || "",
           artifacts: [artifact],
-          links: [{ label: "Markdown Review", url: reviewUrl, persistence: "runtime", durability, source: reviewSource, expiresAt: review.expiresAt || "" }],
+          links: [{
+            key: artifactKey,
+            label: "Markdown Review",
+            kind: artifact.kind,
+            url: displayUrl,
+            canonicalUrl: reviewUrl,
+            shortUrl,
+            persistence: "runtime",
+            durability,
+            source: reviewSource,
+            expiresAt: review.expiresAt || "",
+          }],
           reviewId: review.id,
+          reviewShortCode: shortLink?.shortCode || "",
         });
         const snapshot = prdWorkflowWithAgentflowTokenDiagnostic(
           await prdWorkflowSnapshot(workflowScope.executionRoot, scopedRoot, tapdId, userCtx, { flowSource, flowId }),
           getSessionTokenFromRequest(req) || "",
         );
         prdWorkflowBroadcast(prdWorkflowKey(userCtx, flowSource, flowId, tapdId), { type: "review-link", tapdId, event, snapshot });
-        json(res, 200, { ok: true, review: { ...review, url: reviewUrl }, event, snapshot });
+        json(res, 200, {
+          ok: true,
+          review: {
+            ...review,
+            url: reviewUrl,
+            shortUrl,
+            shortCode: shortLink?.shortCode || "",
+          },
+          event,
+          snapshot,
+        });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
       }
@@ -12054,6 +12446,41 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "GET" && url.pathname.startsWith("/r/")) {
+      try {
+        const parts = url.pathname.split("/").filter(Boolean);
+        const shortCode = decodeURIComponent(parts[1] || "");
+        if (parts.length !== 2) {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const link = prdWorkflowReadReviewShortLink(root, shortCode);
+        if (!link) {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const expiresMs = Date.parse(link.expiresAt || "");
+        if (Number.isFinite(expiresMs) && expiresMs < Date.now()) {
+          try { fs.unlinkSync(link.filePath); } catch (_) {}
+          res.writeHead(410, { "Content-Type": "text/plain; charset=utf-8" });
+          res.end("Review link expired");
+          return;
+        }
+        res.writeHead(302, {
+          Location: link.targetPath,
+          "Cache-Control": "no-store",
+          "Referrer-Policy": "no-referrer",
+        });
+        res.end();
+      } catch {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname.startsWith("/api/prd-workflow/review/")) {
       try {
         const parts = url.pathname.split("/").filter(Boolean);
@@ -12082,8 +12509,8 @@ export function startUiServer({
         }
         const scopedRoot = workflowScope.stateRoot;
         prdWorkflowMigrateLegacyState(workflowScope.executionRoot, scopedRoot, tapdId);
-        const paths = prdWorkflowReviewPaths(scopedRoot, tapdId, reviewId);
-        if (!fs.existsSync(paths.markdownPath) || !fs.statSync(paths.markdownPath).isFile()) {
+        const paths = prdWorkflowResolveReviewPaths(scopedRoot, tapdId, reviewId);
+        if (!prdWorkflowReviewFileExists(paths)) {
           res.writeHead(404);
           res.end("Not found");
           return;
@@ -12365,6 +12792,36 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/admin/user-workspaces") {
+      if (!authUser?.isAdmin) {
+        json(res, 403, { error: "Admin permission required" });
+        return;
+      }
+      const owner = adminWorkspaceOwnerSummary(url.searchParams.get("userId") || "");
+      if (!owner) {
+        json(res, 404, { error: "Workspace owner not found" });
+        return;
+      }
+      try {
+        const workspaces = listFlowsJson(root, { userId: owner.userId })
+          .filter((flow) => (flow.source || "user") === "user")
+          .map((flow) => ({
+            id: String(flow.id || ""),
+            source: "user",
+            archived: flow.archived === true,
+            description: String(flow.description || ""),
+            ownerUserId: owner.userId,
+            ownerUsername: owner.username,
+            adminReadonly: true,
+          }))
+          .sort((a, b) => Number(a.archived) - Number(b.archived) || a.id.localeCompare(b.id));
+        json(res, 200, { owner, workspaces });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/admin/run-detail") {
       if (!authUser?.isAdmin) {
         json(res, 403, { error: "Admin permission required" });
@@ -12740,12 +13197,17 @@ export function startUiServer({
           flowId,
           flowSource,
           workspaceId: payload.workspaceId || "",
+          adminOwnerId: payload.adminOwnerId || "",
           archived,
         }, userCtx);
         if (scoped.error) {
           json(res, scoped.status || 400, { error: scoped.error });
           return;
         }
+        if (scoped.adminReadonly) {
+          json(res, 403, { error: "Admin Workspace review is read-only" });
+          return;
+        }
         const ensured = ensureWorkspaceCollaboration({
           flowId,
           flowSource,
@@ -12857,7 +13319,12 @@ export function startUiServer({
         json(res, scoped.status || 400, { error: scoped.error });
         return;
       }
-      const key = workspaceCollaborationEventKey(userCtx, scoped.flowSource, scoped.flowId, scoped.archived);
+      const key = workspaceCollaborationEventKey(
+        workspaceScopedUserContext(scoped, userCtx),
+        scoped.flowSource,
+        scoped.flowId,
+        scoped.archived,
+      );
       let subscribers = workspaceCollaborationSubscribers.get(key);
       if (!subscribers) {
         subscribers = new Set();
@@ -12974,7 +13441,8 @@ export function startUiServer({
           return;
         }
         const { path: graphPath, graph } = readWorkspaceGraph(scoped.root);
-        const hydratedGraph = hydrateWorkspaceGraphForRuntime(root, scoped, graph, userCtx);
+        const scopedUserCtx = workspaceScopedUserContext(scoped, userCtx);
+        const hydratedGraph = hydrateWorkspaceGraphForRuntime(root, scoped, graph, scopedUserCtx);
         const collaborationAccess = scoped.collaborationAccess || workspaceCollaborationAccess(null, userCtx.userId);
         json(res, 200, {
           ok: true,
@@ -12988,9 +13456,15 @@ export function startUiServer({
           flowSource: scoped.flowSource,
           archived: scoped.archived,
           writable: !(scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource))
+            && scoped.adminReadonly !== true
             && collaborationAccess.writable !== false,
           collaboration: workspaceCollaborationSummaryWithUsers(scoped.collaboration, userCtx.userId),
-          workspaceSchedules: listWorkspaceScheduleStatusesForFlow(userCtx, scoped.flowSource || "user", scoped.flowId || ""),
+          adminReview: scoped.adminReadonly ? {
+            readonly: true,
+            ownerUserId: scoped.ownerUserId,
+            ownerUsername: scoped.ownerUsername,
+          } : null,
+          workspaceSchedules: listWorkspaceScheduleStatusesForFlow(scopedUserCtx, scoped.flowSource || "user", scoped.flowId || ""),
         });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
@@ -13011,12 +13485,17 @@ export function startUiServer({
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
           workspaceId: payload.workspaceId || "",
+          adminOwnerId: payload.adminOwnerId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
           json(res, 400, { error: scoped.error });
           return;
         }
+        if (scoped.adminReadonly) {
+          json(res, 403, { error: "Admin Workspace review is read-only" });
+          return;
+        }
         const { graph } = readWorkspaceGraph(scoped.root);
         const nodeIds = normalizeDisplayShareNodeIds(payload.nodeIds, graph);
         if (nodeIds.length === 0) {
@@ -13056,6 +13535,7 @@ export function startUiServer({
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
           workspaceId: payload.workspaceId || "",
+          adminOwnerId: payload.adminOwnerId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
@@ -13169,8 +13649,21 @@ export function startUiServer({
           json(res, 400, { error: "Missing flowId" });
           return;
         }
+        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;
+        }
         json(res, 200, {
-          schedules: listWorkspaceScheduleStatusesForFlow(userCtx, flowSource, flowId),
+          schedules: listWorkspaceScheduleStatusesForFlow(
+            workspaceScopedUserContext(scoped, userCtx),
+            flowSource,
+            flowId,
+          ),
         });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
@@ -13191,12 +13684,17 @@ export function startUiServer({
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
           workspaceId: payload.workspaceId || "",
+          adminOwnerId: payload.adminOwnerId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
           json(res, 400, { error: scoped.error });
           return;
         }
+        if (scoped.collaborationAccess?.runnable === false) {
+          json(res, 403, { error: "Workspace run permission denied" });
+          return;
+        }
         const flowId = String(payload.flowId || "").trim();
         if (!flowId) {
           json(res, 400, { error: "Missing flowId" });
@@ -13239,6 +13737,7 @@ export function startUiServer({
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
           workspaceId: payload.workspaceId || "",
+          adminOwnerId: payload.adminOwnerId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
@@ -13303,6 +13802,7 @@ export function startUiServer({
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
           workspaceId: payload.workspaceId || "",
+          adminOwnerId: payload.adminOwnerId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
@@ -13586,9 +14086,10 @@ export function startUiServer({
           json(res, scoped.status || 400, { error: scoped.error });
           return;
         }
+        const scopedUserCtx = workspaceScopedUserContext(scoped, userCtx);
         json(res, 200, {
           runs: listWorkspaceRunLogs({
-            userId: flowSource === "workspace" ? "" : userCtx.userId || "",
+            userId: flowSource === "workspace" ? "" : scopedUserCtx.userId || "",
             flowId,
             flowSource,
             scheduleNodeId,
@@ -13620,8 +14121,9 @@ export function startUiServer({
           json(res, scoped.status || 400, { error: scoped.error });
           return;
         }
+        const scopedUserCtx = workspaceScopedUserContext(scoped, userCtx);
         const run = listWorkspaceRunLogs({
-          userId: flowSource === "workspace" ? "" : userCtx.userId || "",
+          userId: flowSource === "workspace" ? "" : scopedUserCtx.userId || "",
           flowId,
           flowSource,
           limit: 200,
@@ -13657,7 +14159,7 @@ export function startUiServer({
         json(res, scoped.status || 400, { error: scoped.error });
         return;
       }
-      const scopeKey = workspaceRunKey(userCtx, flowSource, flowId);
+      const scopeKey = workspaceRunKey(workspaceScopedUserContext(scoped, userCtx), flowSource, flowId);
       const entries = workspaceActiveRunsForScope(scopeKey).map(([, entry]) => entry);
       const entry = entries[0] || null;
       json(res, 200, {
@@ -13698,6 +14200,7 @@ export function startUiServer({
       const scoped = resolveWorkspaceScopeRoot(root, {
         flowId,
         flowSource,
+        adminOwnerId: payload.adminOwnerId || "",
         archived: payload.archived === true || payload.flowArchived === true,
       }, userCtx);
       if (scoped.error) {
@@ -13842,6 +14345,7 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
+          adminOwnerId: payload.adminOwnerId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
@@ -13903,6 +14407,7 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
+          adminOwnerId: payload.adminOwnerId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
@@ -13977,6 +14482,7 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: parsed.fields.flowId || "",
           flowSource: parsed.fields.flowSource || "user",
+          adminOwnerId: parsed.fields.adminOwnerId || "",
           archived: parsed.fields.archived === "1" || parsed.fields.archived === "true" || parsed.fields.flowArchived === "true",
         }, userCtx);
         if (scoped.error) {
@@ -14022,6 +14528,7 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
+          adminOwnerId: payload.adminOwnerId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
@@ -14062,6 +14569,7 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
+          adminOwnerId: payload.adminOwnerId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
@@ -14112,6 +14620,7 @@ export function startUiServer({
         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"),
+          adminOwnerId: req.method === "POST" ? (payload.adminOwnerId || "") : "",
           archived: req.method === "POST"
             ? (payload.archived === true || payload.flowArchived === true)
             : (url.searchParams.get("archived") === "1" || url.searchParams.get("flowArchived") === "1"),
@@ -14153,6 +14662,7 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
+          adminOwnerId: payload.adminOwnerId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
@@ -14243,6 +14753,7 @@ export function startUiServer({
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId: payload.flowId || "",
           flowSource: payload.flowSource || "user",
+          adminOwnerId: payload.adminOwnerId || "",
           archived: payload.archived === true || payload.flowArchived === true,
         }, userCtx);
         if (scoped.error) {
@@ -14886,9 +15397,18 @@ export function startUiServer({
       }
       const nodesArchived = url.searchParams.get("archived") === "1";
       try {
+        const requestedContext = adminWorkspaceRequestedUserContext(userCtx);
+        if (requestedContext.error) {
+          json(res, requestedContext.status || 403, { error: requestedContext.error });
+          return;
+        }
         const { setLanguage } = await import("./i18n.mjs");
         setLanguage(lang);
-        json(res, 200, listNodesJson(root, flowId || "", flowId ? flowSource : "", { archived: nodesArchived, ...userCtx, marketplaceScope }));
+        json(res, 200, listNodesJson(root, flowId || "", flowId ? flowSource : "", {
+          archived: nodesArchived,
+          ...requestedContext.userCtx,
+          marketplaceScope,
+        }));
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
       }
@@ -14909,7 +15429,15 @@ export function startUiServer({
       }
       const archived = url.searchParams.get("archived") === "1";
       try {
-        const detail = readNodeDetailJson(root, nodeId, flowId, flowId ? (flowSource || "user") : "", { archived, ...userCtx });
+        const requestedContext = adminWorkspaceRequestedUserContext(userCtx);
+        if (requestedContext.error) {
+          json(res, requestedContext.status || 403, { error: requestedContext.error });
+          return;
+        }
+        const detail = readNodeDetailJson(root, nodeId, flowId, flowId ? (flowSource || "user") : "", {
+          archived,
+          ...requestedContext.userCtx,
+        });
         if (detail.error) {
           json(res, 404, { error: detail.error });
           return;
@@ -15156,7 +15684,12 @@ export function startUiServer({
         json(res, collaborationDenied.status, { error: collaborationDenied.error });
         return;
       }
-      const result = readFlowJson(root, flowId, flowSource, { archived: flowArchived, ...userCtx });
+      const requestedContext = adminWorkspaceRequestedUserContext(userCtx);
+      if (requestedContext.error) {
+        json(res, requestedContext.status || 403, { error: requestedContext.error });
+        return;
+      }
+      const result = readFlowJson(root, flowId, flowSource, { archived: flowArchived, ...requestedContext.userCtx });
       if (result.error) {
         json(res, 404, result);
         return;
@@ -16669,24 +17202,26 @@ finishedAt: "${new Date().toISOString()}"
     res.end(data);
   });
 
-  const workspaceScheduleTimer = setInterval(() => {
-    try {
-      pollWorkspaceSchedules(root);
-    } catch (e) {
-      log.debug(`[workspace-scheduler] poll failed: ${(e && e.message) || String(e)}`);
-    }
-  }, WORKSPACE_SCHEDULE_POLL_MS);
-  try {
-    workspaceScheduleTimer.unref?.();
-  } catch (_) {}
-  server.on("close", () => clearInterval(workspaceScheduleTimer));
-  setTimeout(() => {
+  if (enableWorkspaceScheduler) {
+    const workspaceScheduleTimer = setInterval(() => {
+      try {
+        pollWorkspaceSchedules(root);
+      } catch (e) {
+        log.debug(`[workspace-scheduler] poll failed: ${(e && e.message) || String(e)}`);
+      }
+    }, WORKSPACE_SCHEDULE_POLL_MS);
     try {
-      pollWorkspaceSchedules(root);
-    } catch (e) {
-      log.debug(`[workspace-scheduler] initial poll failed: ${(e && e.message) || String(e)}`);
-    }
-  }, 1000).unref?.();
+      workspaceScheduleTimer.unref?.();
+    } catch (_) {}
+    server.on("close", () => clearInterval(workspaceScheduleTimer));
+    setTimeout(() => {
+      try {
+        pollWorkspaceSchedules(root);
+      } catch (e) {
+        log.debug(`[workspace-scheduler] initial poll failed: ${(e && e.message) || String(e)}`);
+      }
+    }, 1000).unref?.();
+  }
 
   return new Promise((resolve, reject) => {
     server.once("error", reject);