@fieldwangai/agentflow 0.1.94 → 0.1.96

package/bin/lib/ui-server.mjs

@@ -4347,13 +4347,17 @@ function workspaceCachedOutputValueExists(value, scopedRoot = "") {
 }
 
 function workspaceUpstreamText(graph, nodeId, outputs, scopedRoot = "") {
+  const contentEdge = workspaceContentInputEdge(graph, nodeId);
+  if (!contentEdge) return "";
+  return workspaceOutputSlotValueForEdge(graph, outputs, contentEdge, scopedRoot);
+}
+
+function workspaceContentInputEdge(graph, nodeId) {
   const edges = Array.isArray(graph?.edges) ? graph.edges : [];
   const incoming = edges
     .filter((edge) => String(edge?.target || "") === String(nodeId))
     .filter((edge) => !isWorkspaceSemanticInputSlot(workspaceTargetSlotForEdge(graph, edge)));
-  const contentEdge = incoming.find((edge) => String(edge?.targetHandle || "") === "input-1") || incoming[0];
-  if (!contentEdge) return "";
-  return workspaceOutputSlotValueForEdge(graph, outputs, contentEdge, scopedRoot);
+  return incoming.find((edge) => String(edge?.targetHandle || "") === "input-1") || incoming[0] || null;
 }
 
 function workspaceHandleIndex(handle, prefix) {
@@ -6089,6 +6093,11 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
     }
 
     if (workspaceDisplayKind(defId)) {
+      if (!workspaceContentInputEdge(graph, nodeId)) {
+        emit({ type: "status", nodeId, line: "Display unchanged: no content input edge" });
+        emit({ type: "node-done", nodeId, definitionId: defId, unchanged: true });
+        continue;
+      }
       const content = workspaceUpstreamText(graph, nodeId, outputs, scopedRoot);
       graph.instances[nodeId] = workspaceWriteDisplayContent(instance, content);
       const updatedDisplays = publishNodeOutput(nodeId, content);
@@ -7073,6 +7082,11 @@ function prdWorkflowEventsPath(scopedRoot, tapdId) {
   return path.join(rootDir, ".workspace", "prd-flow", "workflow-state", `${prdWorkflowSafeStateId(tapdId)}.events.json`);
 }
 
+function prdWorkflowAuditPath(scopedRoot, tapdId) {
+  const rootDir = scopedRoot || process.cwd();
+  return path.join(rootDir, ".workspace", "prd-flow", "workflow-state", `${prdWorkflowSafeStateId(tapdId)}.audit.jsonl`);
+}
+
 function prdWorkflowReviewDir(scopedRoot, tapdId) {
   const rootDir = path.resolve(scopedRoot || process.cwd());
   return path.join(rootDir, ".workspace", "prd-flow", "reviews", prdWorkflowSafeStateId(tapdId));
@@ -7143,13 +7157,48 @@ function prdWorkflowReviewSplitFrontmatter(markdown) {
 
 function prdWorkflowReviewRenderFrontmatter(frontmatter) {
   if (!String(frontmatter || "").trim()) return "";
-  const rows = String(frontmatter || "").split(/\r?\n/)
-    .map((line) => {
-      const match = line.match(/^([^:]+):\s*(.*)$/);
-      if (!match) return `<tr><td colspan="2">${prdWorkflowReviewInlineMarkdown(line)}</td></tr>`;
-      return `<tr><th>${htmlEscapeAttribute(match[1].trim())}</th><td>${prdWorkflowReviewInlineMarkdown(match[2].trim())}</td></tr>`;
-    })
-    .join("");
+  const rows = [];
+  const lines = String(frontmatter || "").split(/\r?\n/);
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    let valueHtml = "";
+    if (current.items.length) {
+      valueHtml = `<ul class="frontmatter-list">${current.items.map((item) => `<li>${prdWorkflowReviewInlineMarkdown(item)}</li>`).join("")}</ul>`;
+    } else {
+      valueHtml = prdWorkflowReviewInlineMarkdown(current.value);
+    }
+    rows.push(`<tr><th>${htmlEscapeAttribute(current.key)}</th><td>${valueHtml}</td></tr>`);
+    current = null;
+  };
+  for (const rawLine of lines) {
+    const line = String(rawLine || "");
+    const keyValue = line.match(/^([^:\s][^:]*):\s*(.*)$/);
+    if (keyValue) {
+      flush();
+      const key = keyValue[1].trim();
+      const value = keyValue[2].trim();
+      const inlineList = value.match(/^\[(.*)\]$/);
+      current = {
+        key,
+        value: inlineList ? "" : value,
+        items: inlineList
+          ? inlineList[1].split(",").map((item) => item.trim()).filter(Boolean)
+          : [],
+      };
+      continue;
+    }
+    const listItem = line.match(/^\s*-\s+(.+)$/);
+    if (listItem && current) {
+      current.items.push(listItem[1].trim());
+      continue;
+    }
+    if (line.trim()) {
+      flush();
+      rows.push(`<tr><td colspan="2">${prdWorkflowReviewInlineMarkdown(line.trim())}</td></tr>`);
+    }
+  }
+  flush();
   return `<details class="frontmatter" open><summary>文档元数据</summary><table>${rows}</table></details>`;
 }
 
@@ -7260,6 +7309,13 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     meta.issueKey ? `issue ${meta.issueKey}` : "",
     meta.createdAt || "",
   ].filter(Boolean).join(" · "));
+  const durability = String(meta.durability || "").trim().toLowerCase();
+  const lifecycle = [
+    durability === "temporary" ? "Temporary review link" : durability === "durable" ? "Durable preview" : "",
+    meta.expiresAt ? `Expires ${meta.expiresAt}` : "",
+    meta.persistence ? `persistence ${meta.persistence}` : "",
+  ].filter(Boolean).join(" · ");
+  const escapedLifecycle = htmlEscapeAttribute(lifecycle);
   const renderedMarkdown = prdWorkflowReviewMarkdownToHtml(markdown || "");
   const rawHref = htmlEscapeAttribute(meta.rawHref || "?raw=1");
   return `<!doctype html>
@@ -7321,6 +7377,7 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     .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; }
     .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); }
     article > *:first-child { margin-top: 0; }
     article > *:last-child { margin-bottom: 0; }
@@ -7346,6 +7403,7 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     .frontmatter summary { cursor: pointer; color: var(--body); font-weight: 800; }
     .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; } }
   </style>
 </head>
@@ -7355,6 +7413,7 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
       <div>
         <h1>${escapedTitle}</h1>
         ${escapedMeta ? `<p class="meta">${escapedMeta}</p>` : ""}
+        ${escapedLifecycle ? `<p class="lifecycle">${escapedLifecycle}</p>` : ""}
       </div>
       <div class="toolbar">
         <button class="theme-toggle" type="button" data-theme-toggle>明亮模式</button>
@@ -7386,13 +7445,15 @@ function prdWorkflowReviewHtml(title, markdown, meta = {}) {
 function prdWorkflowCreateReview(scopedRoot, tapdId, payload = {}, urlBase = "") {
   const content = String(payload.markdown || payload.content || payload.rawOutput || "").slice(0, 500000);
   if (!content.trim()) throw new Error("Missing review markdown");
-  const requestedReviewId = String(payload.reviewId || payload.review_id || "").trim();
-  const reviewId = requestedReviewId
-    ? prdWorkflowSafeStateId(requestedReviewId)
-    : `review_${Date.now().toString(36)}_${crypto.randomBytes(4).toString("hex")}`;
-  const paths = prdWorkflowReviewPaths(scopedRoot, tapdId, reviewId);
   const title = String(payload.title || payload.label || "PRD Workflow Review").trim().slice(0, 160) || "PRD Workflow Review";
   const durability = String(payload.durability || (payload.durable === true || payload.permanent === true ? "durable" : "temporary")).trim().toLowerCase() || "temporary";
+  const requestedReviewId = String(payload.reviewId || payload.review_id || "").trim();
+  const reviewId = durability === "temporary"
+    ? `r-${crypto.randomBytes(5).toString("hex")}`
+    : requestedReviewId
+      ? prdWorkflowSafeStateId(requestedReviewId)
+      : `review_${Date.now().toString(36)}_${crypto.randomBytes(4).toString("hex")}`;
+  const paths = prdWorkflowReviewPaths(scopedRoot, tapdId, reviewId);
   const ttlDaysRaw = Number(payload.ttlDays || payload.ttl_days || (durability === "temporary" ? 7 : 0));
   const ttlDays = Number.isFinite(ttlDaysRaw) && ttlDaysRaw > 0 ? ttlDaysRaw : 0;
   const createdAt = new Date();
@@ -7423,6 +7484,19 @@ function prdWorkflowCreateReview(scopedRoot, tapdId, payload = {}, urlBase = "")
   fs.writeFileSync(paths.markdownPath, content.trimEnd() + "\n", "utf-8");
   fs.writeFileSync(paths.metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
   prdWorkflowPruneReviews(scopedRoot, tapdId);
+  prdWorkflowAppendAudit(scopedRoot, tapdId, {
+    type: "review-created",
+    reviewId: paths.id,
+    title,
+    stage: meta.stage,
+    action: meta.action,
+    issueKey: meta.issueKey,
+    durability,
+    persistence: "runtime",
+    sourceKind: String(meta.source?.kind || ""),
+    expiresAt,
+    contentBytes: Buffer.byteLength(content, "utf-8"),
+  });
   const url = `${String(urlBase || "").replace(/\/+$/, "")}/api/prd-workflow/review/${encodeURIComponent(prdWorkflowSafeStateId(tapdId))}/${encodeURIComponent(paths.id)}`;
   return { ...meta, url, markdownPath: paths.markdownPath };
 }
@@ -7472,6 +7546,19 @@ function prdWorkflowWriteJsonFile(filePath, data) {
   return data;
 }
 
+function prdWorkflowAppendAudit(scopedRoot, tapdId, event = {}) {
+  try {
+    const p = prdWorkflowAuditPath(scopedRoot, tapdId);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    const entry = {
+      at: new Date().toISOString(),
+      tapdId: String(tapdId || ""),
+      ...event,
+    };
+    fs.appendFileSync(p, JSON.stringify(entry) + "\n", "utf-8");
+  } catch (_) {}
+}
+
 function prdWorkflowReadProjectState(scopedRoot, tapdId) {
   return prdWorkflowReadJsonFile(prdWorkflowProjectPath(scopedRoot, tapdId), {
     version: 1,
@@ -7712,12 +7799,25 @@ function prdWorkflowMergedClientIssues(clientRows = []) {
   return out;
 }
 
+function prdWorkflowArrayCount(value) {
+  return Array.isArray(value) ? value.length : 0;
+}
+
+function prdWorkflowSnapshotActionCount(snapshot = {}) {
+  return prdWorkflowArrayCount(snapshot?.actions) +
+    prdWorkflowArrayCount(snapshot?.workflowActions) +
+    prdWorkflowArrayCount(snapshot?.workflow_actions) +
+    prdWorkflowArrayCount(snapshot?.timeline) +
+    prdWorkflowArrayCount(snapshot?.history);
+}
+
 function prdWorkflowMaterializeSnapshot(root, scopedRoot, tapdId, userCtx = {}, opts = {}) {
   const flowSource = String(opts.flowSource || "user").trim() || "user";
   const flowId = String(opts.flowId || "").trim();
   const project = prdWorkflowReadProjectStateWithFallback(root, scopedRoot, tapdId);
   const legacy = prdWorkflowReadCachedSnapshotWithFallback(root, scopedRoot, tapdId);
   const latestClient = prdWorkflowLatestClientSnapshot(root, scopedRoot, tapdId);
+  const baseSource = project?.snapshot ? "project" : latestClient ? "client-observations" : legacy?.snapshot ? "legacy-cache" : "empty";
   const base = (
     project?.snapshot ||
     latestClient ||
@@ -7743,6 +7843,45 @@ function prdWorkflowMaterializeSnapshot(root, scopedRoot, tapdId, userCtx = {},
   }));
   const clientRows = prdWorkflowClientObservationRows(root, scopedRoot, tapdId);
   const clientIssues = prdWorkflowMergedClientIssues(clientRows);
+  const runtimeState = prdWorkflowReadRuntimeEvents(scopedRoot, tapdId);
+  const projectionAudit = [
+    {
+      step: "select-base",
+      source: baseSource,
+      reason: project?.snapshot
+        ? "project materialized snapshot is available"
+        : latestClient
+          ? "no project snapshot; latest client current observation is used as display base"
+          : legacy?.snapshot
+            ? "no project/client snapshot; legacy projection cache is used"
+            : "no stored workflow projection exists",
+      projectSnapshot: Boolean(project?.snapshot),
+      latestClientSnapshot: Boolean(latestClient),
+      legacySnapshot: Boolean(legacy?.snapshot),
+      clientObservationCount: clientRows.length,
+      runtimeEventCount: runtimeState.events.length,
+      baseActionCount: prdWorkflowSnapshotActionCount(base),
+      latestClientRevision: String(latestClient?.revision || ""),
+      projectRevision: String(project?.snapshot?.revision || ""),
+    },
+    {
+      step: "merge-client-issues",
+      source: "clients",
+      applied: !project?.snapshot && clientIssues.length > 0,
+      issueCount: clientIssues.length,
+      reason: project?.snapshot
+        ? "project snapshot owns issue projection"
+        : clientIssues.length
+          ? "merged issue views from client observations"
+          : "no client issue projection available",
+    },
+    {
+      step: "merge-runtime-events",
+      source: "runtime-events",
+      eventCount: runtimeState.events.length,
+      reason: "runtime events are merged after base selection and must not replace durable facts",
+    },
+  ];
   const materialized = prdWorkflowMergeRuntimeEvents(scopedRoot, tapdId, {
     ...base,
     issues: project?.snapshot ? base.issues : clientIssues.length ? clientIssues : base.issues,
@@ -7758,6 +7897,32 @@ function prdWorkflowMaterializeSnapshot(root, scopedRoot, tapdId, userCtx = {},
       clientsUpdatedAt: prdWorkflowReadClientStateWithFallback(root, scopedRoot, tapdId).updatedAt || "",
       checkedAt: new Date().toISOString(),
     },
+    projectionAudit,
+  });
+  materialized.projectionAudit = [
+    ...projectionAudit,
+    {
+      step: "result",
+      source: "materialized",
+      phase: String(materialized.phase || ""),
+      pointer: String(materialized.pointer || ""),
+      actionCount: prdWorkflowSnapshotActionCount(materialized) + prdWorkflowArrayCount(materialized.runtimeEvents) + prdWorkflowArrayCount(materialized.runtime_events),
+      revision: String(materialized.revision || ""),
+    },
+  ];
+  prdWorkflowAppendAudit(scopedRoot, tapdId, {
+    type: "projection-materialized",
+    flowSource,
+    flowId,
+    baseSource,
+    projectSnapshot: Boolean(project?.snapshot),
+    latestClientSnapshot: Boolean(latestClient),
+    legacySnapshot: Boolean(legacy?.snapshot),
+    clientObservationCount: clientRows.length,
+    runtimeEventCount: runtimeState.events.length,
+    baseActionCount: prdWorkflowSnapshotActionCount(base),
+    resultActionCount: prdWorkflowSnapshotActionCount(materialized) + prdWorkflowArrayCount(materialized.runtimeEvents) + prdWorkflowArrayCount(materialized.runtime_events),
+    revision: String(materialized.revision || ""),
   });
   if (!project?.snapshot && latestClient) {
     materialized.optionalGaps = [
@@ -8019,13 +8184,15 @@ function prdWorkflowAppendRuntimeEvent(scopedRoot, tapdId, event = {}) {
       if (String(item?.idempotencyKey || "").trim() === entryIdem) return true;
       return Array.isArray(item?.idempotencyHistory) && item.idempotencyHistory.includes(entryIdem);
     });
+    const updatedExisting = index >= 0;
+    let artifactConflict = false;
     const events = [...current.events];
     if (index >= 0) {
       const prevArtifact = prdWorkflowRuntimeEventArtifactSignature(events[index]);
       const nextArtifact = prdWorkflowRuntimeEventArtifactSignature(entry);
-      const artifactConflict = prevArtifact && nextArtifact && prevArtifact !== nextArtifact &&
+      artifactConflict = Boolean(prevArtifact && nextArtifact && prevArtifact !== nextArtifact &&
         prdWorkflowRuntimeEventShouldConflictOnArtifact(events[index]) &&
-        prdWorkflowRuntimeEventShouldConflictOnArtifact(entry);
+        prdWorkflowRuntimeEventShouldConflictOnArtifact(entry));
       const idempotencyHistory = [
         ...(events[index].idempotencyKey ? [events[index].idempotencyKey] : []),
         ...(entry.idempotencyKey ? [entry.idempotencyKey] : []),
@@ -8060,6 +8227,26 @@ function prdWorkflowAppendRuntimeEvent(scopedRoot, tapdId, event = {}) {
       events.push(entry);
     }
     prdWorkflowWriteRuntimeEvents(scopedRoot, tapdId, events);
+    prdWorkflowAppendAudit(scopedRoot, tapdId, {
+      type: "runtime-event-stored",
+      eventId: entry.id,
+      eventType: entry.type,
+      source: entry.source,
+      scope: entry.scope || "",
+      issueKey: entry.issueKey || entry.issue_key || entry.issue || "",
+      platform: entry.platform || "",
+      stage: entry.stage || entry.stageKey || entry.stage_key || "",
+      action: entry.action || entry.actionId || entry.action_id || "",
+      status: entry.status || "",
+      truth: entry.truth || "",
+      authority: entry.authority || "",
+      persistence: entry.persistence || "",
+      idempotencyKey: entry.idempotencyKey || "",
+      updatedExisting,
+      artifactConflict,
+      eventCount: events.length,
+      note: "runtime event stored as append-only workflow event; projection may merge it into the visible timeline",
+    });
     return entry;
   } catch {
     return null;
@@ -9515,6 +9702,23 @@ export function startUiServer({
         };
         const storedObservationSnapshot = prdWorkflowStoredObservationSnapshot(normalizedSnapshot, reportSource);
         prdWorkflowWriteClientObservation(scopedRoot, tapdId, reportMeta, storedObservationSnapshot);
+        prdWorkflowAppendAudit(scopedRoot, tapdId, {
+          type: "client-observation-stored",
+          flowSource,
+          flowId,
+          clientId: reportMeta.clientId,
+          userId: reportMeta.userId,
+          observedAt: reportMeta.observedAt,
+          reportedAt: reportMeta.reportedAt,
+          phase: String(storedObservationSnapshot?.phase || ""),
+          pointer: String(storedObservationSnapshot?.pointer || ""),
+          revision: String(storedObservationSnapshot?.revision || ""),
+          actionCount: prdWorkflowSnapshotActionCount(storedObservationSnapshot),
+          truth: "observation",
+          authority: "client",
+          persistence: "runtime",
+          note: "ordinary current snapshot stored as client observation; it must not overwrite project state",
+        });
 
         const projectFactSource = reportMeta.scope === "project"
           ? prdWorkflowProjectFactSource(payload, rawSnapshot)
@@ -9573,6 +9777,20 @@ export function startUiServer({
               observedAt: reportMeta.observedAt,
             },
           });
+          prdWorkflowAppendAudit(scopedRoot, tapdId, {
+            type: "project-fact-stored",
+            flowSource,
+            flowId,
+            clientId: reportMeta.clientId,
+            observedAt: reportMeta.observedAt,
+            phase: String(projectFactSnapshot?.phase || ""),
+            pointer: String(projectFactSnapshot?.pointer || ""),
+            revision: String(projectFactSnapshot?.revision || ""),
+            actionCount: prdWorkflowSnapshotActionCount(projectFactSnapshot),
+            truth: projectFactSource.truth,
+            authority: projectFactSource.authority,
+            persistence: projectFactSource.persistence,
+          });
         }
         const materialized = prdWorkflowMaterializeSnapshot(root, scopedRoot, tapdId, userCtx, { flowSource, flowId });
         const withDiagnostic = prdWorkflowWithAgentflowTokenDiagnostic(materialized, getSessionTokenFromRequest(req) || "");
@@ -10135,7 +10353,7 @@ export function startUiServer({
         const review = prdWorkflowCreateReview(scopedRoot, tapdId, payload, serverPublicBaseUrl(req, host, uiPort, payload));
         const query = new URLSearchParams();
         if (flowId) query.set("flowId", flowId);
-        if (flowSource) query.set("flowSource", flowSource);
+        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;
         const durability = review.durability || "temporary";