@fieldwangai/agentflow 0.1.123 → 0.1.125

package/bin/lib/ui-server.mjs

@@ -8169,11 +8169,186 @@ function prdWorkflowReviewDedentPlannedCode(lines) {
   return lines.map((line) => String(line || "").slice(indent));
 }
 
+const PRD_WORKFLOW_REVIEW_CODE_KEYWORDS = new Set([
+  "abstract", "as", "async", "await", "break", "case", "catch", "class", "const",
+  "continue", "default", "delete", "do", "else", "enum", "export", "extends",
+  "final", "finally", "for", "from", "fun", "function", "goto", "if", "implements",
+  "import", "in", "instanceof", "interface", "internal", "is", "native", "new",
+  "object", "of", "open", "package", "private", "protected", "public", "return",
+  "sealed", "static", "strictfp", "super", "switch", "synchronized", "throw",
+  "throws", "transient", "try", "typeof", "val", "var", "void", "volatile",
+  "when", "while", "with", "yield",
+]);
+
+const PRD_WORKFLOW_REVIEW_CODE_LITERALS = new Set([
+  "false", "null", "this", "true", "undefined",
+]);
+
+const PRD_WORKFLOW_REVIEW_CODE_TYPES = new Set([
+  "any", "boolean", "byte", "char", "double", "float", "int", "long", "never",
+  "number", "short", "string", "unknown",
+]);
+
+function prdWorkflowReviewCodeLanguage(filePath) {
+  const extension = String(filePath || "").trim().toLowerCase().match(/\.([a-z0-9]+)$/)?.[1] || "";
+  return {
+    c: "c",
+    cc: "cpp",
+    cpp: "cpp",
+    cs: "csharp",
+    go: "go",
+    java: "java",
+    js: "javascript",
+    json: "json",
+    jsx: "jsx",
+    kt: "kotlin",
+    kts: "kotlin",
+    m: "objective-c",
+    mm: "objective-cpp",
+    py: "python",
+    rs: "rust",
+    sh: "shell",
+    swift: "swift",
+    ts: "typescript",
+    tsx: "tsx",
+  }[extension] || "text";
+}
+
+function prdWorkflowReviewSyntaxToken(kind, value) {
+  const escaped = htmlEscapeAttribute(prdWorkflowReviewNormalizeText(value));
+  return kind ? `<span class="syntax-${kind}">${escaped}</span>` : escaped;
+}
+
+function prdWorkflowReviewHighlightCodeLine(line, language, state) {
+  const source = prdWorkflowReviewNormalizeText(line);
+  let html = "";
+  let cursor = 0;
+  const isIdentifierStart = (char) => /[A-Za-z_$]/.test(char || "");
+  const isIdentifierPart = (char) => /[A-Za-z0-9_$]/.test(char || "");
+
+  while (cursor < source.length) {
+    if (state.blockComment) {
+      const end = source.indexOf("*/", cursor);
+      if (end < 0) {
+        html += prdWorkflowReviewSyntaxToken("comment", source.slice(cursor));
+        cursor = source.length;
+        continue;
+      }
+      html += prdWorkflowReviewSyntaxToken("comment", source.slice(cursor, end + 2));
+      state.blockComment = false;
+      cursor = end + 2;
+      continue;
+    }
+
+    if (source.startsWith("//", cursor) || (
+      language === "shell"
+      && source[cursor] === "#"
+    )) {
+      html += prdWorkflowReviewSyntaxToken("comment", source.slice(cursor));
+      break;
+    }
+
+    if (source.startsWith("/*", cursor)) {
+      const end = source.indexOf("*/", cursor + 2);
+      if (end < 0) {
+        html += prdWorkflowReviewSyntaxToken("comment", source.slice(cursor));
+        state.blockComment = true;
+        break;
+      }
+      html += prdWorkflowReviewSyntaxToken("comment", source.slice(cursor, end + 2));
+      cursor = end + 2;
+      continue;
+    }
+
+    const char = source[cursor];
+    if (char === "\"" || char === "'" || char === "`") {
+      let end = cursor + 1;
+      while (end < source.length) {
+        if (source[end] === "\\") {
+          end += 2;
+          continue;
+        }
+        if (source[end] === char) {
+          end += 1;
+          break;
+        }
+        end += 1;
+      }
+      html += prdWorkflowReviewSyntaxToken("string", source.slice(cursor, end));
+      cursor = end;
+      continue;
+    }
+
+    if (char === "@" && isIdentifierStart(source[cursor + 1])) {
+      let end = cursor + 2;
+      while (end < source.length && isIdentifierPart(source[end])) end += 1;
+      html += prdWorkflowReviewSyntaxToken("annotation", source.slice(cursor, end));
+      cursor = end;
+      continue;
+    }
+
+    if (/[0-9]/.test(char)) {
+      const number = source.slice(cursor).match(/^(?:0[xX][\dA-Fa-f_]+|0[bB][01_]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?[fFdDlL]?)/)?.[0] || char;
+      html += prdWorkflowReviewSyntaxToken("number", number);
+      cursor += number.length;
+      continue;
+    }
+
+    if (isIdentifierStart(char)) {
+      let end = cursor + 1;
+      while (end < source.length && isIdentifierPart(source[end])) end += 1;
+      const word = source.slice(cursor, end);
+      const next = source.slice(end).match(/^\s*(.)/)?.[1] || "";
+      let kind = "";
+      if (PRD_WORKFLOW_REVIEW_CODE_KEYWORDS.has(word)) kind = "keyword";
+      else if (PRD_WORKFLOW_REVIEW_CODE_LITERALS.has(word)) kind = "literal";
+      else if (/^[A-Z][A-Z0-9_]*$/.test(word)) kind = "constant";
+      else if (PRD_WORKFLOW_REVIEW_CODE_TYPES.has(word) || /^[A-Z][A-Za-z0-9_$]*$/.test(word)) kind = "type";
+      else if (next === "(") kind = "function";
+      html += prdWorkflowReviewSyntaxToken(kind, word);
+      cursor = end;
+      continue;
+    }
+
+    const operator = source.slice(cursor).match(/^(?:>>>=|===|!==|>>>|<<=|>>=|->|=>|==|!=|<=|>=|&&|\|\||\+\+|--|\+=|-=|\*=|\/=|%=|::|<<|>>|\?\.|\?:)/)?.[0];
+    if (operator) {
+      html += prdWorkflowReviewSyntaxToken("operator", operator);
+      cursor += operator.length;
+      continue;
+    }
+    if (/[+\-*/%=&|!<>?:~^]/.test(char)) {
+      html += prdWorkflowReviewSyntaxToken("operator", char);
+      cursor += 1;
+      continue;
+    }
+    if (/[()[\]{},.;]/.test(char)) {
+      html += prdWorkflowReviewSyntaxToken("punctuation", char);
+      cursor += 1;
+      continue;
+    }
+
+    html += htmlEscapeAttribute(char);
+    cursor += 1;
+  }
+
+  return html || " ";
+}
+
+function prdWorkflowReviewHighlightCodeLines(lines, filePath) {
+  const language = prdWorkflowReviewCodeLanguage(filePath);
+  const state = { blockComment: false };
+  return {
+    language,
+    lines: lines.map((line) => prdWorkflowReviewHighlightCodeLine(line, language, state)),
+  };
+}
+
 function prdWorkflowReviewRenderPlannedCode(filePath, codeLines, startLine = 0, endLine = 0) {
   const safePath = htmlEscapeAttribute(
     String(filePath || "").trim().replace(/^`|`$/g, ""),
   );
   const normalizedLines = prdWorkflowReviewDedentPlannedCode(codeLines);
+  const highlighted = prdWorkflowReviewHighlightCodeLines(normalizedLines, filePath);
   const firstLine = Number.isFinite(Number(startLine)) && Number(startLine) > 0
     ? Number(startLine)
     : 0;
@@ -8183,11 +8358,11 @@ function prdWorkflowReviewRenderPlannedCode(filePath, codeLines, startLine = 0,
   const lineLabel = firstLine
     ? `L${firstLine}${explicitEnd && explicitEnd !== firstLine ? `–L${explicitEnd}` : ""}`
     : "拟修改";
-  const rows = normalizedLines.map((line, index) => {
+  const rows = highlighted.lines.map((line, index) => {
     const lineNumber = firstLine ? String(firstLine + index) : "·";
-    return `<span class="planned-code__line"><span class="planned-code__number">${lineNumber}</span><span class="planned-code__text">${htmlEscapeAttribute(prdWorkflowReviewNormalizeText(line)) || " "}</span></span>`;
+    return `<span class="planned-code__line"><span class="planned-code__number">${lineNumber}</span><span class="planned-code__text">${line}</span></span>`;
   }).join("");
-  return `<section class="planned-code" data-file="${safePath}">
+  return `<section class="planned-code" data-file="${safePath}" data-language="${highlighted.language}">
   <div class="planned-code__header">
     <code class="planned-code__file">${safePath}</code>
     <span class="planned-code__anchor">${htmlEscapeAttribute(lineLabel)}</span>
@@ -8211,7 +8386,8 @@ function prdWorkflowReviewParseChangeIntent(lines, startIndex) {
     base: "",
     insertNear: "",
     destination: "",
-    reference: null,
+    references: [],
+    annotations: [],
     proposals: [],
   };
   for (let i = startIndex + 1; i < lines.length; i += 1) {
@@ -8240,11 +8416,31 @@ function prdWorkflowReviewParseChangeIntent(lines, startIndex) {
         end += 1;
       }
       if (end >= lines.length) return null;
-      change.reference = {
+      change.references.push({
         startLine: Number(reference[1]),
         endLine: Number(reference[2] || reference[1]),
         lines: body,
-      };
+      });
+      i = end;
+      continue;
+    }
+    const annotation = trimmed.match(
+      /^#annotation\s+line\s*(\d+)(?:\s*-\s*(\d+))?\s+(problem|change|preserve)\s*$/i,
+    );
+    if (annotation) {
+      const body = [];
+      let end = i + 1;
+      while (end < lines.length && !/^#annotationend\s*$/i.test(String(lines[end] || "").trim())) {
+        body.push(lines[end]);
+        end += 1;
+      }
+      if (end >= lines.length) return null;
+      change.annotations.push({
+        startLine: Number(annotation[1]),
+        endLine: Number(annotation[2] || annotation[1]),
+        type: annotation[3].toLowerCase(),
+        lines: body,
+      });
       i = end;
       continue;
     }
@@ -8286,6 +8482,11 @@ function prdWorkflowReviewRenderChangeIntent(change) {
     pseudocode: "方案伪代码",
     code: "拟议代码 · 未写入",
   };
+  const annotationLabels = {
+    problem: "当前问题",
+    change: "计划修改",
+    preserve: "保持不变",
+  };
   const operation = operationLabels[change.operation] || "变更";
   const target = targetLabels[change.target] || "目标";
   const locator = change.module || change.file || "未定位";
@@ -8300,23 +8501,66 @@ function prdWorkflowReviewRenderChangeIntent(change) {
     safeDestination ? `<span><strong>移动到</strong> <code>${safeDestination}</code></span>` : "",
   ].filter(Boolean).join("");
 
+  const references = Array.isArray(change.references)
+    ? change.references
+    : (change.reference ? [change.reference] : []);
+  const annotations = Array.isArray(change.annotations) ? change.annotations : [];
+  const sourceLanguage = prdWorkflowReviewCodeLanguage(change.file || change.module);
+  const sourceLineLabel = (item) => `L${item.startLine}${
+    item.endLine !== item.startLine
+      ? `–L${item.endLine}`
+      : ""
+  }`;
   let referenceHtml = "";
-  if (change.reference) {
-    const normalized = prdWorkflowReviewDedentPlannedCode(change.reference.lines);
-    const lineLabel = `L${change.reference.startLine}${
-      change.reference.endLine !== change.reference.startLine
-        ? `–L${change.reference.endLine}`
-        : ""
-    }`;
-    const rows = normalized.map((line, index) => (
-      `<span class="change-intent__source-line">`
-      + `<span class="change-intent__source-number">${change.reference.startLine + index}</span>`
-      + `<span class="change-intent__source-text">${htmlEscapeAttribute(prdWorkflowReviewNormalizeText(line)) || " "}</span>`
-      + "</span>"
-    )).join("");
-    referenceHtml = `<details class="change-intent__context" open>
-  <summary><span>当前上下文</span><span class="change-intent__line-anchor">${lineLabel}</span></summary>
-  <pre class="change-intent__source"><code>${rows}</code></pre>
+  if (references.length) {
+    const totalLines = references.reduce(
+      (total, reference) => total + Math.max(0, reference.endLine - reference.startLine + 1),
+      0,
+    );
+    const hunks = references.map((reference, referenceIndex) => {
+      const normalized = prdWorkflowReviewDedentPlannedCode(reference.lines);
+      const highlighted = prdWorkflowReviewHighlightCodeLines(normalized, change.file || change.module);
+      const rows = highlighted.lines.map((line, index) => (
+        `<span class="change-intent__source-line">`
+        + `<span class="change-intent__source-number">${reference.startLine + index}</span>`
+        + `<span class="change-intent__source-text">${line}</span>`
+        + "</span>"
+      )).join("");
+      const annotationHtml = annotations
+        .filter((annotation) => (
+          reference.startLine <= annotation.startLine
+          && annotation.endLine <= reference.endLine
+        ))
+        .map((annotation) => {
+          const type = annotation.type || "change";
+          const label = annotationLabels[type] || "Review 指引";
+          const body = prdWorkflowReviewMarkdownLinesToHtml(
+            prdWorkflowReviewDedentPlannedCode(annotation.lines),
+          );
+          return `<aside class="change-intent__annotation is-${htmlEscapeAttribute(type)}">
+  <div class="change-intent__annotation-header">
+    <span class="change-intent__annotation-title">Review 指引</span>
+    <span class="change-intent__annotation-badge">${htmlEscapeAttribute(label)}</span>
+    <span class="change-intent__annotation-anchor">${htmlEscapeAttribute(sourceLineLabel(annotation))}</span>
+  </div>
+  <div class="change-intent__annotation-body">${body}</div>
+</aside>`;
+        }).join("");
+      return `<section class="change-intent__hunk">
+  <div class="change-intent__hunk-header">
+    <span>片段 ${referenceIndex + 1}</span>
+    <span class="change-intent__line-anchor">${htmlEscapeAttribute(sourceLineLabel(reference))}</span>
+  </div>
+  <pre class="change-intent__source" data-language="${highlighted.language}"><code>${rows}</code></pre>
+  ${annotationHtml}
+</section>`;
+    }).join("");
+    referenceHtml = `<details class="change-intent__context" data-language="${sourceLanguage}" open>
+  <summary>
+    <span>当前上下文</span>
+    <span class="change-intent__context-stats">${references.length} 个片段 · ${totalLines} 行</span>
+  </summary>
+  <div class="change-intent__hunks">${hunks}</div>
 </details>`;
   }
 
@@ -8328,13 +8572,14 @@ function prdWorkflowReviewRenderChangeIntent(change) {
     if (type === "natural") {
       body = `<div class="change-intent__natural">${prdWorkflowReviewMarkdownLinesToHtml(normalized)}</div>`;
     } else if (type === "code") {
-      const rows = normalized.map((line) => (
+      const highlighted = prdWorkflowReviewHighlightCodeLines(normalized, change.file || change.module);
+      const rows = highlighted.lines.map((line) => (
         `<span class="change-intent__proposal-line is-code">`
         + '<span class="change-intent__proposal-mark">+</span>'
-        + `<span class="change-intent__proposal-text">${htmlEscapeAttribute(prdWorkflowReviewNormalizeText(line)) || " "}</span>`
+        + `<span class="change-intent__proposal-text">${line}</span>`
         + "</span>"
       )).join("");
-      body = `<pre class="change-intent__proposal-body is-code"><code>${rows}</code></pre>`;
+      body = `<pre class="change-intent__proposal-body is-code" data-language="${highlighted.language}"><code>${rows}</code></pre>`;
     } else {
       const rows = normalized.map((line) => (
         `<span class="change-intent__proposal-line">`
@@ -8681,6 +8926,17 @@ export function prdWorkflowReviewHtml(title, markdown, meta = {}) {
       --change-modify: #7dcfff;
       --change-remove: #f7768e;
       --change-move: #bb9af7;
+      --syntax-comment: #737aa2;
+      --syntax-keyword: #bb9af7;
+      --syntax-literal: #ff9e64;
+      --syntax-type: #2ac3de;
+      --syntax-function: #7aa2f7;
+      --syntax-string: #9ece6a;
+      --syntax-number: #ff9e64;
+      --syntax-annotation: #e0af68;
+      --syntax-constant: #ff9e64;
+      --syntax-operator: #89ddff;
+      --syntax-punctuation: #a9b1d6;
       --action-bg: #1f2335;
       --action-header: #24283b;
       --pending-bg: rgba(224,175,104,.10);
@@ -8726,6 +8982,17 @@ export function prdWorkflowReviewHtml(title, markdown, meta = {}) {
       --change-modify: #007197;
       --change-remove: #c64343;
       --change-move: #7847bd;
+      --syntax-comment: #8990a7;
+      --syntax-keyword: #7847bd;
+      --syntax-literal: #965027;
+      --syntax-type: #007197;
+      --syntax-function: #2e7de9;
+      --syntax-string: #587539;
+      --syntax-number: #965027;
+      --syntax-annotation: #9a5200;
+      --syntax-constant: #965027;
+      --syntax-operator: #007197;
+      --syntax-punctuation: #565a6e;
       --action-bg: #f3f3f5;
       --action-header: #e9e9ed;
       --pending-bg: rgba(177,92,0,.08);
@@ -8767,9 +9034,9 @@ export function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     .planned-code__file { min-width: 0; border: 0; background: transparent; color: var(--link); padding: 0; font-weight: 800; }
     .planned-code__anchor, .planned-code__badge { border: 1px solid var(--border); border-radius: 999px; padding: 3px 8px; color: var(--muted); font: 800 11px/1.35 "SFMono-Regular", Consolas, monospace; }
     .planned-code__badge { margin-left: auto; border-color: var(--planned-border); color: var(--complete-text); }
-    .planned-code__body { margin: 0; border: 0; border-radius: 0; padding: 10px 0; }
-    .planned-code__body code { display: block; }
-    .planned-code__line { display: grid; grid-template-columns: 4.25rem minmax(max-content, 1fr); min-height: 1.65em; }
+    .planned-code__body { margin: 0; border: 0; border-radius: 0; padding: 10px 0; font: 500 13px/1.55 "SFMono-Regular", "JetBrains Mono", Consolas, monospace; }
+    .planned-code__body code { display: block; font: inherit; }
+    .planned-code__line { display: grid; grid-template-columns: 3.75rem minmax(max-content, 1fr); min-height: 1.55em; }
     .planned-code__line:hover { background: var(--planned-line); }
     .planned-code__number { border-right: 1px solid var(--border-soft); color: var(--planned-gutter); padding: 0 .8rem 0 .5rem; text-align: right; user-select: none; }
     .planned-code__text { padding: 0 1rem; white-space: pre; }
@@ -8787,13 +9054,26 @@ export function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     .change-intent__meta code { border: 0; background: transparent; padding: 0; color: var(--muted); }
     .change-intent__context { border-bottom: 1px solid var(--border-soft); background: var(--change-context); }
     .change-intent__context summary { display: flex; align-items: center; justify-content: space-between; gap: 10px; cursor: pointer; padding: 10px 14px; color: var(--body); font-size: 13px; font-weight: 900; list-style-position: inside; }
-    .change-intent__line-anchor, .change-intent__proposal-badge { margin-left: auto; border: 1px solid var(--border); border-radius: 999px; padding: 3px 8px; color: var(--muted); font: 800 11px/1.35 "SFMono-Regular", Consolas, monospace; white-space: nowrap; }
-    .change-intent__source { margin: 0; border: 0; border-top: 1px solid var(--border-soft); border-radius: 0; padding: 10px 0; background: var(--code-block); }
-    .change-intent__source code, .change-intent__proposal-body code { display: block; }
-    .change-intent__source-line { display: grid; grid-template-columns: 4.25rem minmax(max-content, 1fr); min-height: 1.65em; }
+    .change-intent__context-stats, .change-intent__line-anchor, .change-intent__proposal-badge, .change-intent__annotation-anchor { margin-left: auto; border: 1px solid var(--border); border-radius: 999px; padding: 3px 8px; color: var(--muted); font: 800 11px/1.35 "SFMono-Regular", Consolas, monospace; white-space: nowrap; }
+    .change-intent__hunk + .change-intent__hunk { border-top: 8px solid var(--panel-strong); }
+    .change-intent__hunk-header { display: flex; align-items: center; gap: 10px; border-top: 1px solid var(--border-soft); padding: 8px 14px; color: var(--muted); font-size: 12px; font-weight: 800; }
+    .change-intent__source { margin: 0; border: 0; border-top: 1px solid var(--border-soft); border-radius: 0; padding: 10px 0; background: var(--code-block); font: 500 13px/1.55 "SFMono-Regular", "JetBrains Mono", Consolas, monospace; }
+    .change-intent__source code, .change-intent__proposal-body code { display: block; font: inherit; }
+    .change-intent__source-line { display: grid; grid-template-columns: 3.75rem minmax(max-content, 1fr); min-height: 1.55em; }
     .change-intent__source-line:hover { background: var(--planned-line); }
     .change-intent__source-number { border-right: 1px solid var(--border-soft); color: var(--planned-gutter); padding: 0 .8rem 0 .5rem; text-align: right; user-select: none; }
     .change-intent__source-text { padding: 0 1rem; white-space: pre; }
+    .change-intent__annotation { border-top: 1px solid var(--border-soft); border-left: 3px solid var(--change-modify); background: var(--change-proposal); padding: 10px 14px 11px; }
+    .change-intent__annotation.is-problem { border-left-color: var(--change-remove); }
+    .change-intent__annotation.is-preserve { border-left-color: var(--change-add); }
+    .change-intent__annotation-header { display: flex; align-items: center; flex-wrap: wrap; gap: 8px; color: var(--body); }
+    .change-intent__annotation-title { font-size: 12px; font-weight: 900; }
+    .change-intent__annotation-badge { border: 1px solid currentColor; border-radius: 999px; color: var(--change-modify); padding: 3px 8px; font-size: 11px; font-weight: 900; line-height: 1.3; }
+    .change-intent__annotation.is-problem .change-intent__annotation-badge { color: var(--change-remove); }
+    .change-intent__annotation.is-preserve .change-intent__annotation-badge { color: var(--change-add); }
+    .change-intent__annotation-body { margin-top: 7px; }
+    .change-intent__annotation-body > *:first-child { margin-top: 0; }
+    .change-intent__annotation-body > *:last-child { margin-bottom: 0; }
     .change-intent__proposal { background: var(--change-proposal); }
     .change-intent__proposal + .change-intent__proposal { border-top: 1px solid var(--border-soft); }
     .change-intent__proposal-header { display: flex; align-items: center; gap: 10px; padding: 10px 14px; color: var(--heading); font-size: 13px; font-weight: 900; }
@@ -8802,11 +9082,22 @@ export function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     .change-intent__natural { border-top: 1px solid var(--border-soft); padding: 11px 14px 13px; }
     .change-intent__natural > *:first-child { margin-top: 0; }
     .change-intent__natural > *:last-child { margin-bottom: 0; }
-    .change-intent__proposal-body { margin: 0; border: 0; border-top: 1px solid var(--border-soft); border-radius: 0; padding: 11px 14px 13px; background: var(--code-block); }
-    .change-intent__proposal-line { display: block; min-height: 1.65em; }
+    .change-intent__proposal-body { margin: 0; border: 0; border-top: 1px solid var(--border-soft); border-radius: 0; padding: 11px 14px 13px; background: var(--code-block); font: 500 13px/1.55 "SFMono-Regular", "JetBrains Mono", Consolas, monospace; }
+    .change-intent__proposal-line { display: block; min-height: 1.55em; }
     .change-intent__proposal-line.is-code { display: grid; grid-template-columns: 2rem minmax(max-content, 1fr); margin: 0 -14px; padding: 0 14px; background: var(--change-code); }
     .change-intent__proposal-mark { color: var(--change-add); font-weight: 900; text-align: center; user-select: none; }
     .change-intent__proposal-text { white-space: pre; }
+    .syntax-comment { color: var(--syntax-comment); font-style: italic; }
+    .syntax-keyword { color: var(--syntax-keyword); font-weight: 700; }
+    .syntax-literal { color: var(--syntax-literal); font-weight: 650; }
+    .syntax-type { color: var(--syntax-type); }
+    .syntax-function { color: var(--syntax-function); }
+    .syntax-string { color: var(--syntax-string); }
+    .syntax-number { color: var(--syntax-number); }
+    .syntax-annotation { color: var(--syntax-annotation); }
+    .syntax-constant { color: var(--syntax-constant); }
+    .syntax-operator { color: var(--syntax-operator); }
+    .syntax-punctuation { color: var(--syntax-punctuation); }
     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); }
@@ -8840,7 +9131,7 @@ export function prdWorkflowReviewHtml(title, markdown, meta = {}) {
       main { padding: 28px 14px 48px; }
       .change-intent__header { align-items: flex-start; flex-direction: column; }
       .change-intent__locator { width: 100%; }
-      .change-intent__source-line { grid-template-columns: 3.35rem minmax(max-content, 1fr); }
+      .change-intent__source-line, .planned-code__line { grid-template-columns: 3.25rem minmax(max-content, 1fr); }
       header { display: block; }
       .toolbar { justify-content: flex-start; margin-top: 14px; }
       article { padding: 18px; }
@@ -9000,6 +9291,50 @@ function prdWorkflowAppendAudit(scopedRoot, tapdId, event = {}) {
   } catch (_) {}
 }
 
+function prdWorkflowReadAuditEntries(scopedRoot, tapdId, limit = 500) {
+  try {
+    const p = prdWorkflowAuditPath(scopedRoot, tapdId);
+    if (!fs.existsSync(p)) return [];
+    return fs.readFileSync(p, "utf-8")
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .slice(-Math.max(1, Number(limit) || 500))
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function prdWorkflowReadRecentActionAudit(scopedRoot, tapdId, limit = 24) {
+  return prdWorkflowReadAuditEntries(scopedRoot, tapdId, 500)
+    .filter((item) => item?.type === "snapshot-action-change")
+    .slice(-Math.max(1, Number(limit) || 24));
+}
+
+function prdWorkflowFirstPointerObservation(scopedRoot, tapdId, snapshot = {}) {
+  const phase = String(snapshot?.phase || "").trim();
+  const pointer = String(snapshot?.pointer || "").trim();
+  if (!phase && !pointer) return "";
+  let earliest = "";
+  for (const entry of prdWorkflowReadAuditEntries(scopedRoot, tapdId, 5000)) {
+    if (entry?.type !== "client-observation-stored") continue;
+    if (phase && String(entry.phase || "").trim() !== phase) continue;
+    if (pointer && String(entry.pointer || "").trim() !== pointer) continue;
+    const candidate = String(entry.observedAt || entry.reportedAt || entry.at || "").trim();
+    const candidateTime = Date.parse(candidate);
+    if (!Number.isFinite(candidateTime)) continue;
+    if (!earliest || candidateTime < Date.parse(earliest)) earliest = candidate;
+  }
+  return earliest;
+}
+
 function prdWorkflowReadProjectState(scopedRoot, tapdId) {
   return prdWorkflowReadJsonFile(prdWorkflowProjectPath(scopedRoot, tapdId), {
     version: 1,
@@ -9092,6 +9427,160 @@ function prdWorkflowWriteClientObservation(scopedRoot, tapdId, meta, snapshot) {
   });
 }
 
+const PRD_WORKFLOW_SNAPSHOT_ACTION_ARRAY_KEYS = [
+  "actions",
+  "workflowActions",
+  "workflow_actions",
+  "timeline",
+  "history",
+];
+
+function prdWorkflowSnapshotActionKey(action = {}) {
+  const stageKey = String(
+    action.stageKey ||
+    action.stage_key ||
+    action.stage ||
+    action.actionId ||
+    action.action_id ||
+    action.action ||
+    action.id ||
+    "",
+  ).trim();
+  const issueKey = String(action.issueKey || action.issue_key || action.issue || "").trim();
+  const platform = String(action.platform || "").trim().toLowerCase();
+  return [stageKey, issueKey, platform].filter(Boolean).join("|");
+}
+
+function prdWorkflowSnapshotActionTime(action = {}) {
+  return String(
+    action.stageEnteredAt ||
+    action.stage_entered_at ||
+    action.time ||
+    action.at ||
+    action.observedAt ||
+    action.observed_at ||
+    action.startedAt ||
+    action.started_at ||
+    action.completedAt ||
+    action.completed_at ||
+    action.updatedAt ||
+    action.updated_at ||
+    action.createdAt ||
+    action.created_at ||
+    "",
+  ).trim();
+}
+
+function prdWorkflowSnapshotSourceActionTime(action = {}) {
+  return String(
+    action.time ||
+    action.at ||
+    action.observedAt ||
+    action.observed_at ||
+    action.startedAt ||
+    action.started_at ||
+    action.completedAt ||
+    action.completed_at ||
+    action.updatedAt ||
+    action.updated_at ||
+    action.createdAt ||
+    action.created_at ||
+    "",
+  ).trim();
+}
+
+function prdWorkflowSnapshotActionMap(snapshot = {}) {
+  const out = new Map();
+  for (const key of PRD_WORKFLOW_SNAPSHOT_ACTION_ARRAY_KEYS) {
+    const rows = Array.isArray(snapshot?.[key]) ? snapshot[key] : [];
+    for (const action of rows) {
+      if (!action || typeof action !== "object" || Array.isArray(action)) continue;
+      const actionKey = prdWorkflowSnapshotActionKey(action);
+      if (actionKey && !out.has(actionKey)) out.set(actionKey, action);
+    }
+  }
+  return out;
+}
+
+function prdWorkflowSnapshotActionChanges(previousSnapshot = {}, nextSnapshot = {}) {
+  const previous = prdWorkflowSnapshotActionMap(previousSnapshot);
+  const next = prdWorkflowSnapshotActionMap(nextSnapshot);
+  const changes = [];
+  const compact = (kind, action, previousAction = null) => ({
+    kind,
+    stageKey: String(action?.stageKey || action?.stage_key || action?.stage || action?.id || "").trim(),
+    issueKey: String(action?.issueKey || action?.issue_key || action?.issue || "").trim(),
+    platform: String(action?.platform || "").trim(),
+    title: String(action?.title || action?.label || action?.name || "").trim(),
+    status: String(action?.status || "").trim(),
+    previousStatus: String(previousAction?.status || "").trim(),
+    actionAt: prdWorkflowSnapshotActionTime(action),
+    previousActionAt: prdWorkflowSnapshotActionTime(previousAction || {}),
+    sourceActionAt: prdWorkflowSnapshotSourceActionTime(action),
+    previousSourceActionAt: prdWorkflowSnapshotSourceActionTime(previousAction || {}),
+  });
+  for (const [key, action] of next) {
+    const previousAction = previous.get(key);
+    if (!previousAction) {
+      changes.push(compact("added", action));
+      continue;
+    }
+    const statusChanged = String(previousAction.status || "") !== String(action.status || "");
+    const timeChanged =
+      prdWorkflowSnapshotActionTime(previousAction) !== prdWorkflowSnapshotActionTime(action) ||
+      prdWorkflowSnapshotSourceActionTime(previousAction) !== prdWorkflowSnapshotSourceActionTime(action);
+    const titleChanged = String(previousAction.title || previousAction.label || "") !== String(action.title || action.label || "");
+    if (statusChanged || timeChanged || titleChanged) {
+      changes.push(compact(
+        statusChanged ? "status-changed" : timeChanged ? "time-changed" : "title-changed",
+        action,
+        previousAction,
+      ));
+    }
+  }
+  for (const [key, action] of previous) {
+    if (!next.has(key)) changes.push(compact("removed", action, action));
+  }
+  return changes.slice(0, 80);
+}
+
+function prdWorkflowStampCurrentActionEntryTimes(scopedRoot, tapdId, snapshot = {}, clientState = {}, meta = {}) {
+  const existingTimes = new Map();
+  for (const client of Object.values(clientState?.clients || {})) {
+    const observedAt = String(client?.observedAt || client?.reportedAt || "").trim();
+    for (const [key, action] of prdWorkflowSnapshotActionMap(client?.snapshot || {})) {
+      if (String(action?.status || "").trim().toLowerCase() !== "current") continue;
+      const value = String(action.stageEnteredAt || action.stage_entered_at || observedAt).trim();
+      if (!value || !Number.isFinite(Date.parse(value))) continue;
+      const previous = existingTimes.get(key);
+      if (!previous || Date.parse(value) < Date.parse(previous)) existingTimes.set(key, value);
+    }
+  }
+  const auditedAt = prdWorkflowFirstPointerObservation(scopedRoot, tapdId, snapshot);
+  const observedAt = String(meta.observedAt || meta.reportedAt || new Date().toISOString()).trim();
+  const stamp = (action) => {
+    if (!action || typeof action !== "object" || Array.isArray(action)) return action;
+    if (String(action.status || "").trim().toLowerCase() !== "current") return action;
+    const actionKey = prdWorkflowSnapshotActionKey(action);
+    const candidates = [
+      String(action.stageEnteredAt || action.stage_entered_at || "").trim(),
+      existingTimes.get(actionKey) || "",
+      auditedAt,
+      observedAt,
+    ].filter((value) => Number.isFinite(Date.parse(value)));
+    const stageEnteredAt = candidates.sort((left, right) => Date.parse(left) - Date.parse(right))[0] || observedAt;
+    return {
+      ...action,
+      stageEnteredAt,
+    };
+  };
+  const next = { ...snapshot };
+  for (const key of PRD_WORKFLOW_SNAPSHOT_ACTION_ARRAY_KEYS) {
+    if (Array.isArray(snapshot?.[key])) next[key] = snapshot[key].map(stamp);
+  }
+  return next;
+}
+
 const PRD_WORKFLOW_PROJECTION_SOURCE_KEYS = new Set([
   "projectionMode",
   "projectCacheScope",
@@ -9121,6 +9610,7 @@ function prdWorkflowStoredObservationSnapshot(snapshot, sourcePatch = {}) {
   delete clean.collaboration;
   delete clean.clientObservations;
   delete clean.clients;
+  delete clean.snapshotAudit;
   clean.sources = prdWorkflowStoredObservationSources(snapshot.sources, sourcePatch);
   return clean;
 }
@@ -9351,6 +9841,7 @@ function prdWorkflowMaterializeSnapshot(root, scopedRoot, tapdId, userCtx = {},
       revision: String(materialized.revision || ""),
     },
   ];
+  materialized.snapshotAudit = prdWorkflowReadRecentActionAudit(scopedRoot, tapdId);
   prdWorkflowAppendAudit(scopedRoot, tapdId, {
     type: "projection-materialized",
     flowSource,
@@ -11969,7 +12460,21 @@ export function startUiServer({
           issueKey: reportMeta.issueKey,
           stageKey: reportMeta.stageKey,
         };
-        const storedObservationSnapshot = prdWorkflowStoredObservationSnapshot(normalizedSnapshot, reportSource);
+        const existingClientState = prdWorkflowReadClientState(scopedRoot, tapdId);
+        const existingClientId = prdWorkflowSafeStateId(reportMeta.clientId || "anonymous");
+        const previousClientSnapshot = existingClientState.clients?.[existingClientId]?.snapshot || null;
+        const stampedSnapshot = prdWorkflowStampCurrentActionEntryTimes(
+          scopedRoot,
+          tapdId,
+          normalizedSnapshot,
+          existingClientState,
+          reportMeta,
+        );
+        const storedObservationSnapshot = prdWorkflowStoredObservationSnapshot(stampedSnapshot, reportSource);
+        const actionChanges = prdWorkflowSnapshotActionChanges(
+          previousClientSnapshot || {},
+          storedObservationSnapshot,
+        );
         prdWorkflowWriteClientObservation(scopedRoot, tapdId, reportMeta, storedObservationSnapshot);
         prdWorkflowAppendAudit(scopedRoot, tapdId, {
           type: "client-observation-stored",
@@ -11988,12 +12493,51 @@ export function startUiServer({
           persistence: "runtime",
           note: "ordinary current snapshot stored as client observation; it must not overwrite project state",
         });
+        for (const change of actionChanges) {
+          const changeLabel = {
+            added: "新增",
+            removed: "移除",
+            "status-changed": "状态变更",
+            "time-changed": "时间更正",
+            "title-changed": "标题变更",
+          }[change.kind] || "变更";
+          prdWorkflowAppendAudit(scopedRoot, tapdId, {
+            type: "snapshot-action-change",
+            change: change.kind,
+            title: `Workflow Action ${changeLabel}${change.title ? `：${change.title}` : ""}`,
+            detail: [
+              change.stageKey,
+              change.previousStatus && change.previousStatus !== change.status
+                ? `${change.previousStatus} -> ${change.status}`
+                : change.status,
+              change.previousActionAt && change.previousActionAt !== change.actionAt
+                ? `${change.previousActionAt} -> ${change.actionAt || "无时间"}`
+                : change.actionAt,
+              change.previousSourceActionAt !== change.sourceActionAt
+                ? `来源时间 ${change.previousSourceActionAt || "无"} -> ${change.sourceActionAt || "无"}`
+                : "",
+            ].filter(Boolean).join(" · "),
+            auditStatus: "observed",
+            truth: "audit",
+            authority: "agentflow",
+            persistence: "runtime",
+            clientId: reportMeta.clientId,
+            userId: reportMeta.userId,
+            observedAt: reportMeta.observedAt,
+            reportedAt: reportMeta.reportedAt,
+            revision: String(storedObservationSnapshot.revision || ""),
+            previousRevision: String(previousClientSnapshot?.revision || ""),
+            pointer: String(storedObservationSnapshot.pointer || ""),
+            previousPointer: String(previousClientSnapshot?.pointer || ""),
+            ...change,
+          });
+        }
 
         const projectFactSource = reportMeta.scope === "project"
           ? prdWorkflowProjectFactSource(payload, rawSnapshot)
           : null;
         const projectFactSnapshot = projectFactSource
-          ? prdWorkflowStoredObservationSnapshot(normalizedSnapshot, {
+          ? prdWorkflowStoredObservationSnapshot(stampedSnapshot, {
               ...reportSource,
               ...projectFactSource,
             })