@loomhelm/multi-task-flow 0.0.0-stage → 0.2.1

package/toolkit/skills/bin/modules/plan/private_snapshot.ts

@@ -0,0 +1,372 @@
+import {
+  chmodSync,
+  closeSync,
+  constants,
+  fstatSync,
+  lstatSync,
+  mkdtempSync,
+  openSync,
+  realpathSync,
+  statSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { CString, dlopen, FFIType } from "bun:ffi";
+
+export interface PrivateSnapshot {
+  path: string;
+  identity: string;
+  parentIdentity: string;
+}
+
+function assertNoSymlinkComponents(path: string): void {
+  const absolute = resolve(path);
+  let current = "/";
+  for (const part of absolute.split("/").filter(Boolean)) {
+    current = current === "/" ? "/" + part : current + "/" + part;
+    if (lstatSync(current).isSymbolicLink())
+      throw new Error("DEV_PLAN_SOURCE_SYMLINK_FORBIDDEN: " + current);
+  }
+}
+
+function assertTrustedDirectory(path: string): string {
+  const absolute = resolve(path);
+  const canonical = realpathSync(absolute);
+  assertNoSymlinkComponents(canonical);
+  const entry = statSync(canonical);
+  const uid = process.getuid?.() ?? -1;
+  if (!entry.isDirectory())
+    throw new Error("DEV_PLAN_TEMP_DIRECTORY_INVALID: " + canonical);
+  if (entry.uid !== 0 && entry.uid !== uid)
+    throw new Error("DEV_PLAN_TEMP_DIRECTORY_OWNER_UNTRUSTED: " + canonical);
+  if ((entry.mode & 0o022) !== 0 && (entry.mode & 0o1000) === 0)
+    throw new Error("DEV_PLAN_TEMP_DIRECTORY_WRITABLE: " + canonical);
+  let current = dirname(canonical);
+  while (true) {
+    assertNoSymlinkComponents(current);
+    const ancestor = statSync(current);
+    if (ancestor.uid !== 0 && ancestor.uid !== uid)
+      throw new Error("DEV_PLAN_TEMP_ANCESTOR_OWNER_UNTRUSTED: " + current);
+    if ((ancestor.mode & 0o022) !== 0 && (ancestor.mode & 0o1000) === 0)
+      throw new Error("DEV_PLAN_TEMP_ANCESTOR_WRITABLE: " + current);
+    if (current === "/") break;
+    current = dirname(current);
+  }
+  return canonical;
+}
+
+function identity(entry: { dev: number; ino: number }): string {
+  return String(entry.dev) + ":" + String(entry.ino);
+}
+
+function isNoEntry(error: unknown): boolean {
+  return (
+    error !== null &&
+    typeof error === "object" &&
+    "code" in error &&
+    error.code === "ENOENT"
+  );
+}
+
+interface PosixLibrary {
+  symbols: {
+    openat(
+      directoryFd: number,
+      path: Uint8Array,
+      flags: number,
+      mode: number,
+    ): number;
+    unlinkat(directoryFd: number, path: Uint8Array, flags: number): number;
+    dup(fileDescriptor: number): number;
+    fdopendir(fileDescriptor: number): number;
+    readdir(directory: number): number;
+    closedir(directory: number): number;
+  };
+}
+
+let posixLibrary: PosixLibrary | undefined;
+
+function loadPosix(): PosixLibrary {
+  if (posixLibrary) return posixLibrary;
+  const muslArch: Record<string, string> = { x64: "x86_64", arm64: "aarch64" };
+  const libraries =
+    process.platform === "darwin"
+      ? ["libSystem.B.dylib"]
+      : [
+          "libc.so.6",
+          ...(muslArch[process.arch] === undefined
+            ? []
+            : [`libc.musl-${muslArch[process.arch]}.so.1`]),
+          "libc.so",
+        ];
+  for (const library of libraries) {
+    try {
+      posixLibrary = dlopen(library, {
+        openat: {
+          args: [FFIType.i32, FFIType.ptr, FFIType.i32, FFIType.i32],
+          returns: FFIType.i32,
+        },
+        unlinkat: {
+          args: [FFIType.i32, FFIType.ptr, FFIType.i32],
+          returns: FFIType.i32,
+        },
+        dup: {
+          args: [FFIType.i32],
+          returns: FFIType.i32,
+        },
+        fdopendir: {
+          args: [FFIType.i32],
+          returns: FFIType.ptr,
+        },
+        readdir: {
+          args: [FFIType.ptr],
+          returns: FFIType.ptr,
+        },
+        closedir: {
+          args: [FFIType.ptr],
+          returns: FFIType.i32,
+        },
+      }) as PosixLibrary;
+      return posixLibrary;
+    } catch {}
+  }
+  throw new Error("DEV_PLAN_TEMP_NATIVE_LIBRARY_UNAVAILABLE");
+}
+
+// Pass the owning buffer to Bun FFI; a bare pointer cannot keep it alive.
+function cString(value: string): Uint8Array {
+  if (value.includes("\0")) throw new Error("native path contains NUL");
+  return new TextEncoder().encode(value + "\0");
+}
+
+function directoryFlags(): number {
+  return (
+    constants.O_RDONLY |
+    constants.O_DIRECTORY |
+    constants.O_NOFOLLOW |
+    constants.O_NONBLOCK
+  );
+}
+
+function fileFlags(): number {
+  return constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK;
+}
+
+function openAt(directoryFd: number, name: string, flags: number): number {
+  const fd = loadPosix().symbols.openat(directoryFd, cString(name), flags, 0);
+  if (fd < 0) throw new Error("private snapshot entry open failed: " + name);
+  return fd;
+}
+
+function unlinkAt(directoryFd: number, name: string, flags: number): void {
+  if (loadPosix().symbols.unlinkat(directoryFd, cString(name), flags) < 0)
+    throw new Error("private snapshot entry removal failed: " + name);
+}
+
+function tryOpenAt(directoryFd: number, name: string, flags: number): number {
+  return loadPosix().symbols.openat(directoryFd, cString(name), flags, 0);
+}
+
+function directoryNames(directoryFd: number): string[] {
+  const duplicate = loadPosix().symbols.dup(directoryFd);
+  if (duplicate < 0)
+    throw new Error("private snapshot directory duplication failed");
+  const directory = loadPosix().symbols.fdopendir(duplicate);
+  if (!directory) {
+    closeSync(duplicate);
+    throw new Error("private snapshot directory open failed");
+  }
+  const names: string[] = [];
+  const nameOffset = process.platform === "darwin" ? 21 : 19;
+  try {
+    let entry: number | null;
+    while (
+      (entry = loadPosix().symbols.readdir(directory)) !== null &&
+      entry !== 0
+    )
+      names.push(new CString(entry + nameOffset));
+  } finally {
+    loadPosix().symbols.closedir(directory);
+  }
+  return names;
+}
+
+function removeDirectoryContents(directoryFd: number): void {
+  for (const name of directoryNames(directoryFd)) {
+    if (name === "." || name === "..") continue;
+    if (!name || name.includes("/"))
+      throw new Error(
+        "private snapshot entry name changed: " + JSON.stringify(name),
+      );
+    const childFd = tryOpenAt(directoryFd, name, directoryFlags());
+    if (childFd >= 0) {
+      try {
+        const entry = fstatSync(childFd);
+        removeDirectoryContents(childFd);
+        const currentFd = tryOpenAt(directoryFd, name, directoryFlags());
+        try {
+          if (
+            currentFd < 0 ||
+            identity(fstatSync(currentFd)) !== identity(entry)
+          )
+            throw new Error("private snapshot directory identity changed");
+        } finally {
+          if (currentFd >= 0) closeSync(currentFd);
+        }
+      } finally {
+        closeSync(childFd);
+      }
+      unlinkAt(directoryFd, name, process.platform === "darwin" ? 0x80 : 0x200);
+      continue;
+    }
+    const fileFd = openAt(directoryFd, name, fileFlags());
+    try {
+      const entry = fstatSync(fileFd);
+      if (!entry.isFile())
+        throw new Error("private snapshot entry type changed");
+      const currentFd = tryOpenAt(directoryFd, name, fileFlags());
+      try {
+        if (currentFd < 0 || identity(fstatSync(currentFd)) !== identity(entry))
+          throw new Error("private snapshot file identity changed");
+      } finally {
+        if (currentFd >= 0) closeSync(currentFd);
+      }
+    } finally {
+      closeSync(fileFd);
+    }
+    unlinkAt(directoryFd, name, 0);
+  }
+}
+
+export function cleanupPrivateSnapshot(
+  path: string,
+  expectedIdentity: string,
+  expectedParentIdentity = "",
+): void {
+  if (!path || !/\/plan-review\.[^/]+$/.test(path)) return;
+  const parent = dirname(path);
+  let parentIdentity: string;
+  let parentFd = -1;
+  let snapshotFd = -1;
+  try {
+    if (assertTrustedDirectory(parent) !== parent)
+      throw new Error("parent canonicalization changed");
+    parentIdentity = identity(lstatSync(parent));
+    if (expectedParentIdentity && parentIdentity !== expectedParentIdentity)
+      throw new Error("private snapshot parent identity changed");
+    parentFd = openSync(parent, directoryFlags());
+    if (identity(fstatSync(parentFd)) !== parentIdentity)
+      throw new Error("private snapshot parent identity changed");
+  } catch (error) {
+    if (parentFd >= 0) closeSync(parentFd);
+    throw new Error(
+      "DEV_PLAN_TEMP_CLEANUP_FAILED: " +
+        (error instanceof Error ? error.message : String(error)),
+    );
+  }
+  try {
+    const initial = lstatSync(path);
+    if (
+      !initial.isDirectory() ||
+      initial.isSymbolicLink() ||
+      identity(initial) !== expectedIdentity
+    )
+      throw new Error("private snapshot identity changed");
+  } catch (error) {
+    if (isNoEntry(error)) {
+      closeSync(parentFd);
+      parentFd = -1;
+      return;
+    }
+    closeSync(parentFd);
+    parentFd = -1;
+    throw new Error(
+      "DEV_PLAN_TEMP_CLEANUP_FAILED: " +
+        (error instanceof Error ? error.message : String(error)),
+    );
+  }
+  try {
+    const name = path.slice(parent.length + 1);
+    snapshotFd = openAt(parentFd, name, directoryFlags());
+    const entry = fstatSync(snapshotFd);
+    if (!entry.isDirectory() || identity(entry) !== expectedIdentity)
+      throw new Error("private snapshot identity changed");
+    removeDirectoryContents(snapshotFd);
+    if (identity(lstatSync(parent)) !== parentIdentity)
+      throw new Error("private snapshot parent changed during cleanup");
+    const current = lstatSync(path);
+    if (
+      !current.isDirectory() ||
+      current.isSymbolicLink() ||
+      identity(current) !== expectedIdentity
+    )
+      throw new Error("private snapshot identity changed");
+    const currentFd = tryOpenAt(parentFd, name, directoryFlags());
+    try {
+      if (currentFd < 0 || identity(fstatSync(currentFd)) !== expectedIdentity)
+        throw new Error("private snapshot identity changed");
+    } finally {
+      if (currentFd >= 0) closeSync(currentFd);
+    }
+    closeSync(snapshotFd);
+    snapshotFd = -1;
+    unlinkAt(parentFd, name, process.platform === "darwin" ? 0x80 : 0x200);
+  } catch (error) {
+    let missing = false;
+    try {
+      lstatSync(path);
+    } catch (currentError) {
+      missing = isNoEntry(currentError);
+    }
+    const parentChanged =
+      error instanceof Error && error.message.includes("parent changed");
+    if (snapshotFd >= 0) closeSync(snapshotFd);
+    if (parentFd >= 0) closeSync(parentFd);
+    if (missing && !parentChanged) return;
+    throw new Error(
+      "DEV_PLAN_TEMP_CLEANUP_FAILED: " +
+        (error instanceof Error ? error.message : String(error)),
+    );
+  }
+  try {
+    if (
+      identity(lstatSync(parent)) !== parentIdentity ||
+      identity(fstatSync(parentFd)) !== parentIdentity
+    )
+      throw new Error("private snapshot parent changed during cleanup");
+  } catch (error) {
+    throw new Error(
+      "DEV_PLAN_TEMP_CLEANUP_FAILED: " +
+        (error instanceof Error ? error.message : String(error)),
+    );
+  } finally {
+    if (snapshotFd >= 0) closeSync(snapshotFd);
+    if (parentFd >= 0) closeSync(parentFd);
+  }
+}
+
+export function createPrivateSnapshot(): PrivateSnapshot {
+  const parent = assertTrustedDirectory(tmpdir());
+  const parentIdentity = identity(lstatSync(parent));
+  const created = mkdtempSync(join(parent, "plan-review."));
+  let createdIdentity = "";
+  try {
+    createdIdentity = identity(lstatSync(created));
+    chmodSync(created, 0o700);
+    const canonical = realpathSync(created);
+    const current = lstatSync(canonical);
+    if (
+      !current.isDirectory() ||
+      identity(current) !== createdIdentity ||
+      identity(lstatSync(parent)) !== parentIdentity
+    )
+      throw new Error("DEV_PLAN_TEMP_DIRECTORY_CHANGED: " + created);
+    return { path: canonical, identity: createdIdentity, parentIdentity };
+  } catch (error) {
+    try {
+      const cleanupIdentity = createdIdentity || identity(lstatSync(created));
+      cleanupPrivateSnapshot(created, cleanupIdentity, parentIdentity);
+    } catch {}
+    throw error;
+  }
+}

package/toolkit/skills/bin/modules/plan/projection.ts

@@ -0,0 +1,4 @@
+export * from "./projection_base";
+export * from "./projection_expected";
+export * from "./projection_render";
+export * from "./projection_findings";

package/toolkit/skills/bin/modules/plan/projection_base.ts

@@ -0,0 +1,220 @@
+import { escapeHtml } from "./text";
+import { escapeRegExp } from "./markdown";
+import { parseAcceptance, type AcceptanceManifest } from "./acceptance";
+import {
+  PYTHON_WHITESPACE_CLASS,
+  parseOrchestration,
+  pythonRstrip,
+  pythonStrip,
+  section,
+  validate,
+  type BatchMap,
+  type TaskMap,
+  type BatchRecord,
+  type TaskRecord,
+} from "./orchestration";
+
+const PYTHON_WHITESPACE = new RegExp(`[${PYTHON_WHITESPACE_CLASS}]+`, "g");
+
+export const PROJECTION_HEADINGS = [
+  "决策卡",
+  "目标",
+  "不包含的工作",
+  "波次与依赖",
+  "执行规则",
+  "任务卡",
+  "约束",
+  "验收清单",
+  "Review、运行时门禁与收口",
+] as const;
+
+export const BATCH_DISPLAY_LABELS: Record<string, string> = {
+  mode: "模式",
+  target: "目标",
+  depends_on: "批次依赖",
+  condition: "条件",
+  acceptance: "验收绑定",
+  observation_window: "观察窗口",
+  parent_branch: "父分支",
+  child_pr: "子 PR",
+  topology: "拓扑",
+  event_protocol: "事件协议",
+  release_policy: "发布策略",
+};
+
+const FLOW_ALIASES: Record<string, Set<string>> = {
+  "implement-only": new Set([
+    "implement-only",
+    "implement_only",
+    "implementonly",
+    "仅实现",
+  ]),
+  "retired-initiative": new Set([
+    "initiative",
+    "initiative-flow",
+    "initiative_flow",
+    "initiativeflow",
+    "倡议流",
+    "多ticket倡议",
+  ]),
+  "retired-parallel-pr": new Set([
+    "parallel-pr",
+    "parallel_pr",
+    "parallelpr",
+    "parallel-pr-flow",
+    "并行pr",
+    "并行-pr",
+    "并行直连pr",
+  ]),
+  normal: new Set(["normal", "普通流程"]),
+  "fast-track": new Set([
+    "fast-track",
+    "fast_track",
+    "fastpr",
+    "fast-pr",
+    "fast-flow",
+    "fast-pr-delivery",
+    "快车道",
+  ]),
+  "local-merge": new Set([
+    "local-merge",
+    "local_merge",
+    "localmerge",
+    "local-merge-flow",
+    "本地快车道",
+    "本地合主干",
+    "本地合主干流程",
+    "no-pr",
+    "no_pr",
+    "no-pr-fast",
+    "no_pr_fast",
+  ]),
+};
+
+export interface Finding {
+  code: string;
+  message: string;
+}
+
+export function nonEmptyLines(text: string): string[] {
+  return text
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter((line) => line.trim());
+}
+export function markdownText(value: string): string {
+  return escapeHtml(value.replaceAll("\\", "\\\\"), false)
+    .replaceAll("[", "\\[")
+    .replaceAll("]", "\\]")
+    .replaceAll("`", "\\`")
+    .replaceAll("*", "\\*")
+    .replaceAll("_", "\\_")
+    .replaceAll("#", "\\#")
+    .replace(/(https?|ftp):\/\//gi, "$1&#58;//")
+    .replace(/(^|[^\w])www\./gi, "$1www&#46;");
+}
+export function markdownCode(value: string): string {
+  const runs = value.match(/`+/g) ?? [];
+  const fence = "`".repeat(Math.max(0, ...runs.map((run) => run.length)) + 1);
+  const padding = value.startsWith("`") || value.endsWith("`") ? " " : "";
+  return `${fence}${padding}${value}${padding}${fence}`;
+}
+export function markdownValue(value: string): string {
+  const trimmed = value.trim();
+  return trimmed.length >= 2 && trimmed.startsWith("`") && trimmed.endsWith("`")
+    ? markdownCode(trimmed.slice(1, -1))
+    : markdownText(trimmed);
+}
+export function copyBlock(text: string, fallback: string): string[] {
+  return nonEmptyLines(text).map(markdownText).length
+    ? nonEmptyLines(text).map(markdownText)
+    : [markdownText(fallback)];
+}
+function unfencedNonEmptyLines(text: string): string[] {
+  let inFence = false;
+  let marker = "";
+  const lines: string[] = [];
+  for (const line of text.split(/\r?\n/)) {
+    const match = line.match(/^\s{0,3}(`{3,}|~{3,})/);
+    if (match) {
+      if (!inFence) {
+        inFence = true;
+        marker = match[1]!;
+      } else if (
+        match[1]![0] === marker[0] &&
+        new RegExp(`^\\s{0,3}${marker[0]}{${marker.length},}\\s*$`).test(line)
+      )
+        inFence = false;
+      continue;
+    }
+    if (!inFence && line.trim()) lines.push(pythonRstrip(line));
+  }
+  return lines;
+}
+export function flowItems(text: string): Array<[string, string]> {
+  return unfencedNonEmptyLines(text).map((line) => {
+    const match = line.match(
+      /^\s*-\s+(?:`(?<code>[^`]+)`|(?<plain>[^:：]+))\s*[:：]\s*(?<value>.+)$/,
+    );
+    return match?.groups
+      ? [
+          pythonStrip(match.groups.code ?? match.groups.plain ?? ""),
+          pythonStrip(match.groups.value!),
+        ]
+      : ["", pythonStrip(line.replace(/^\s*-\s+/, ""))];
+  });
+}
+export function flowValue(plan: string, key: string, fallback = ""): string {
+  const value = flowItems(section(plan, "Flow Decision")).find(
+    ([itemKey]) => itemKey === key,
+  )?.[1];
+  return value === undefined
+    ? fallback
+    : pythonStrip(value).replace(/^`|`$/g, "");
+}
+export function flowType(plan: string): string {
+  const normalized = pythonStrip(flowValue(plan, "flow_type"))
+    .replace(/^`|`$/g, "")
+    .replaceAll("_", "-")
+    .replace(PYTHON_WHITESPACE, "-")
+    .toLowerCase();
+  for (const [canonical, aliases] of Object.entries(FLOW_ALIASES))
+    if (
+      [...aliases].some(
+        (alias) =>
+          alias.replaceAll("_", "-").replace(/\s+/g, "-").toLowerCase() ===
+          normalized,
+      )
+    )
+      return canonical;
+  return normalized;
+}
+export function acceptanceOptions(plan: string) {
+  const type = flowType(plan);
+  return { requireScopedAcceptance: type === "multi-task-flow" };
+}
+export function safeMermaidId(...parts: string[]): string {
+  return `n_${parts.map((part) => Buffer.from(part).toString("hex")).join("__")}`;
+}
+export function mermaidText(value: string): string {
+  return escapeHtml(value.replaceAll("\\", "\\\\"), true)
+    .replaceAll("`", "&#96;")
+    .replaceAll("\n", "<br/>");
+}
+export function displayDependency(value: string): string {
+  if (value.trim().toLowerCase() === "none") return "无显式前置依赖";
+  return (
+    value
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean)
+      .map((item) => {
+        const [identity = "", milestone] = item.split("/", 2);
+        const clean = identity.replace(/^task:|^batch:/, "");
+        return milestone
+          ? `${markdownText(clean)} / ${markdownText(milestone)}`
+          : markdownText(clean);
+      })
+      .join(", ") || "无显式前置依赖"
+  );
+}

package/toolkit/skills/bin/modules/plan/projection_expected.ts

@@ -0,0 +1,111 @@
+import { parseAcceptance, type AcceptanceManifest } from "./acceptance";
+import { pythonStrip, type BatchMap } from "./orchestration";
+import {
+  BATCH_DISPLAY_LABELS,
+  acceptanceOptions,
+  displayDependency,
+  markdownCode,
+  markdownText,
+} from "./projection_base";
+
+function withoutTrailingBlank(lines: string[]): string[] {
+  return lines.at(-1) === "" ? lines.slice(0, -1) : lines;
+}
+
+export function expectedTaskCardLines(batches: BatchMap): string[] {
+  const lines: string[] = [];
+  for (const batch of Object.values(batches))
+    for (const wave of batch.waves)
+      for (const task of wave.tasks) {
+        const fields = task.fields;
+        lines.push(
+          `### ${markdownText(task.id)} · ${markdownText(fields.title ?? task.id)}`,
+          `- 批次与波次：${markdownCode(batch.id)} / Wave ${task.wave}`,
+          `- 目的：${markdownText(fields.purpose ?? "未声明")}`,
+          `- 启动条件：${displayDependency(fields.depends_on ?? "none")}`,
+          `- 条件：${markdownCode(fields.condition ?? "unknown")}`,
+        );
+        if (task.profile)
+          lines.push(
+            `- Profile：${markdownCode(`${task.profile.model} + ${task.profile.thinking}`)}`,
+          );
+        const surfaces = fields.owned_surfaces;
+        if (surfaces)
+          lines.push(
+            `- 文件范围：${surfaces
+              .split(",")
+              .map(pythonStrip)
+              .filter(Boolean)
+              .map(markdownCode)
+              .join(", ")}`,
+          );
+        if (fields.outputs)
+          lines.push(`- 产出：${markdownText(fields.outputs)}`);
+        if (fields.skill) lines.push(`- Skill：${markdownCode(fields.skill)}`);
+        if (fields.profile)
+          lines.push(`- Agent profile：${markdownCode(fields.profile)}`);
+        if (fields.acceptance)
+          lines.push(`- 验收绑定：${markdownText(fields.acceptance)}`);
+        lines.push("");
+      }
+  return withoutTrailingBlank(lines);
+}
+
+export function expectedBatchCardLines(batches: BatchMap): string[] {
+  const lines: string[] = [];
+  for (const batch of Object.values(batches)) {
+    lines.push(`### 批次 ${markdownCode(batch.id)}`);
+    for (const [field, label] of Object.entries(BATCH_DISPLAY_LABELS))
+      if (batch.fields[field])
+        lines.push(`- ${label}：${markdownCode(batch.fields[field])}`);
+    lines.push("");
+  }
+  return withoutTrailingBlank(lines);
+}
+
+function expectedAcceptanceProjectionLines(
+  manifest: AcceptanceManifest,
+): string[] {
+  const pre = manifest.items.filter((item) => item.phase === "pre_merge");
+  const post = manifest.items.filter((item) => item.phase !== "pre_merge");
+  const showScope = manifest.items.some((item) => item.scope !== "plan");
+  const phaseLines = (
+    heading: string,
+    items: typeof manifest.items,
+  ): string[] => {
+    const lines = [heading, ""];
+    if (!items.length) {
+      lines.push("- 无适用验收项。");
+      return lines;
+    }
+    items.forEach((item, index) => {
+      if (index) lines.push("");
+      const trigger =
+        item.phase === "post_merge"
+          ? "Merge Receipt 已存在"
+          : item.phase === "post_deploy"
+            ? "部署身份已核验"
+            : undefined;
+      lines.push(`#### ${markdownCode(item.id)}`, "");
+      if (showScope) lines.push(`- 归属：${markdownCode(item.scope)}`);
+      if (trigger) lines.push(`- 触发点：${markdownText(trigger)}`);
+      lines.push(
+        `- 必须证明：${markdownText(item.target)}`,
+        "- 通过条件：",
+        ...item.assertions.map((assertion) => `  - ${markdownText(assertion)}`),
+        "- 验证：",
+        ...item.evidence.map((evidence) => `  - ${markdownCode(evidence)}`),
+      );
+    });
+    return lines;
+  };
+  const lines = phaseLines("### PR 合并前验收", pre);
+  lines.push("", ...phaseLines("### PR 合并后验收", post));
+  return lines;
+}
+
+export function expectedAcceptanceLines(plan: string): string[] {
+  return expectedAcceptanceProjectionLines(
+    parseAcceptance(plan, acceptanceOptions(plan)),
+  );
+}