paseo-req-kit 1.14.0-beta.1 → 1.14.0-beta.3

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 每个版本分为"使用者会看到的变化"和"升级须知"。升级步骤见 [docs/guide/安装与升级.md](docs/guide/安装与升级.md)。
 
+## 1.14.0-beta.3
+
+### 使用者会看到的变化
+
+- **验收清单**（`req checklist <需求>`，插件需求页面上的"验收清单（可一键试用）"）：按需求说明的验收标准生成清单，每条写着前置条件、操作、预期结果和流水线的验证结果，没验证或没通过的排在前面，报告里"需要你确认的决定"也列上。逐条点"通过 / 不对 / 先不验"，进度自动保存；提交后写成 `acceptance.md` 并提交，不通过时把不对的地方转给需求的对话。
+- **一键试用**（`req try <需求>`，验收清单页右上角"把它跑起来试用"）：用项目的 Paseo 服务脚本在需求自己的工作区里启动，给出访问地址和提测说明里的测试账号、数据；`--stop` 或"停止试用"停掉。没有服务脚本的项目给出提测说明里的启动方法。
+
+### 升级须知
+
+- `req api review-url` 新增 `--page check`；`req reply` 新增 `--acceptance`（验收页用）。验收页和原型审查页是同一个本机服务。
+
+## 1.14.0-beta.2
+
+### 使用者会看到的变化
+
+- **修复：已经开发完（待验收、已验收）的需求在插件里显示"已确认，未开始开发"和"开始开发"按钮。** 需求分支合并到主分支后，主分支里的需求文件夹没有运行状态（运行状态不提交），beta.1 把它当成了没开始。现在看到方案、完成报告等只有流水线才会写的文件，就按已开发处理：有完成报告的显示"待验收"（或验收记录里的结论），不会进"等你处理"。
+
 ## 1.14.0-beta.1
 
 ### 使用者会看到的变化

package/bin/req.mjs

@@ -31,6 +31,8 @@ const HELP = `req-kit ${version}（${kitRoot}）
                                让 Paseo 按时间表发送需求总览（例子为每周一 9:00）；取消：req digest --cancel <ID>
   req sync <需求>              把需求同步到对接的外部系统（补发失败的调用、补建卡片、更新状态）
   req review <需求>            在浏览器打开原型审查页：点选要改的地方、直接改文字，提交意见或确认方案
+  req try <需求> [--stop]      把做好的需求跑起来试用：给出访问地址和测试数据（--stop 停止）
+  req checklist <需求>         验收清单：按验收标准逐条勾选，提交后写成验收记录
   req ui-check <网址> [--prototype <原型文件>] [--width 1280,390]
                                不靠看图检查网页：显示不全、遮挡、超出屏幕、文字太淡、报错，和原型对文字
   req reply <需求> <回复>      把回答或方案意见转给需求的对话（插件的"等你处理"用它）
@@ -221,6 +223,12 @@ switch (command) {
   case "review":
     code = needTsx() ? node([tsxCli, path.join(kitRoot, "engine", "src", "review.ts"), ...rest]) : 1;
     break;
+  case "try":
+    code = needTsx() ? node([tsxCli, path.join(kitRoot, "engine", "src", "try.ts"), ...rest]) : 1;
+    break;
+  case "checklist":
+    code = needTsx() ? node([tsxCli, path.join(kitRoot, "engine", "src", "checklist-cmd.ts"), ...rest]) : 1;
+    break;
   case "ui-check":
     code = needTsx() ? node([tsxCli, path.join(kitRoot, "engine", "src", "ui-check.ts"), ...rest]) : 1;
     break;

package/contracts/cli-json.md

@@ -32,7 +32,7 @@
 | `req api config [--repo <目录>] [--machine]` | 1.12 起。`{ sources, ignored, error, repo, groups }`：`sources` 是生效的配置文件（`layer` 为 `machine` / `team` / `project`，按叠加顺序）；`groups` 按主题分组，每项 `{ key, label, description, display, value, setBy, scope, changed }`：`display` 是用大白话写的值，`value` 中看起来像密钥的值和个人账号替换为 `••••`，`setBy` 是写了它的文件，`changed` 表示与默认值不同。配置有错误时 `error` 写明原因，值按各文件所写。`--machine` 不看项目配置 |
 | `req api set-agents --json <设置>` | 1.12 起。`{ ok, message }`。`<设置>` 是 `{ builder, reviewer, fallback }`（`fallback` 可以为 null），检查后写入本机配置的 `agents`，原文件备份 |
 | `req api watchdog [--by plugin\|factory] [--dry-run]` | 1.13 起。`{ checked, resumed, failed, skipped }`：把本机"运行中但后台进程已不在"的需求直接继续（`req resume`）。每个进程只继续一次，每个需求 24 小时内最多 3 次；`--by plugin` 同时记下插件在检查（流水线据此不再预约对话的定时检查） |
-| `req api review-url <需求> [--repo <目录>] [--read-only]` | 1.13 起。`{ url, readOnly }`：这个需求的原型审查页地址（需要时在后台启动审查页的服务）。`--read-only` 的地址只能看，不能提交意见或确认方案。需求不在本机的需求索引中或还没有 `prototype/` 时报 `not_found` |
+| `req api review-url <需求> [--repo <目录>] [--read-only] [--page check]` | 1.13 起；`--page check`（1.14）给出同一服务上的验收清单页地址（需要 `spec.md`）。`{ url, readOnly }`：这个需求的原型审查页地址（需要时在后台启动审查页的服务）。`--read-only` 的地址只能看，不能提交意见或确认方案。需求不在本机的需求索引中或还没有 `prototype/` 时报 `not_found` |
 
 `<需求>` 的写法与 `req status` 相同：功能目录、目录名或名称中能唯一确定的一部分。需求在为它新建的工作区中开发时，`--repo` 写对话所在的目录或那个工作区都可以。
 

package/docs/guide//344/275/277/347/224/250/350/200/205/346/214/207/345/215/227.md

@@ -97,6 +97,13 @@ req-kit 帮你把一个需求从"我想要……"做到"可以验收"：你在 P
 
 然后说"我要验收"。AI 会按验收标准一条一条带你核对：告诉你怎么操作、应该看到什么；能用命令验证的给出命令，你可以自己执行。每条结果记入功能目录的 `acceptance.md`。
 
+**在插件里自己验收（1.14 起）。** 需求页面上点**"验收清单（可一键试用）"**（终端里是 `req checklist <需求>`），验收清单在 Paseo 里打开：
+
+- 每条验收标准写着前置条件、怎么操作、应该看到什么，以及流水线的验证结果；流水线没验证或没通过的排在最前面，报告里"需要你确认的决定"也列在后面请你表态。
+- 右上角**"把它跑起来试用"**（终端里是 `req try <需求>`）：用项目的 Paseo 服务脚本（`paseo.json`）在这个需求自己的工作区里把它启动起来，给出访问地址和提测说明里的测试账号、数据；用完点"停止试用"。项目没有服务脚本时，会给出提测说明里写的启动方法，也可以在需求的对话里说"帮我把它跑起来"。
+- 每条点"通过"、"不对"（写下看到了什么）或"先不验"，进度自动保存。必须验的都核对完才能提交"通过"；有"不对"的就提交"不通过"。
+- 提交后写成 `acceptance.md` 并提交。不通过时，不对的地方会转给这个需求的对话，它会和你一起确定怎么处理。
+
 - **全部通过**：请开发同事审阅代码并合并上线。流水线只做本地提交，不会自己合并或上线。
 - **有不通过的**：逐项决定怎么处理：做得不对的，补进需求说明后继续开发；发现想要的不是这样的，按改需求处理；也可以接受现状并记下理由。
 

package/engine/src/api.ts

@@ -185,7 +185,7 @@ function item(repo: string, branch: string | null, featureDir: string, extra: {
   const summary = summarize({ path: repo, branch }, name);
   if (!summary) return null;
   const state = readStateSafe(repo, featureDir);
-  const notStarted = state ? null : notStartedOf(repo, summary.featureDir, summary.confirmed, summary.updatedAt);
+  const notStarted = state || summary.developed ? null : notStartedOf(repo, summary.featureDir, summary.confirmed, summary.updatedAt);
   // 1.14: a worktree made for it before the pipeline ran: it still belongs to the chat's checkout.
   if (!state && !extra.sourceRepo) {
     const made = recordFor(repo, summary.featureDir);
@@ -579,12 +579,16 @@ export function apiMain(argvIn: string[], cwd = process.cwd()): unknown {
       // 1.13: the prototype review page of a requirement (starts the page's server when needed).
       const feature = need("需求");
       const readOnly = flag(argv, "--read-only");
+      // 1.14 --page check: the acceptance checklist page of the same server.
+      const page = option(argv, "--page") === "check" ? "check" : "prototype";
       const { repo: r, featureDir } = locate(repo, feature);
       return import("./review.js").then(async ({ ensureReviewServer, keyOf, reviewUrl }) => {
         const key = keyOf(r, featureDir);
         if (!key) throw new ApiError("not_found", `${featureDir} 不在本机的需求列表中`);
-        if (!fs.existsSync(path.join(r, featureDir, "prototype"))) throw new ApiError("not_found", `${featureDir} 还没有界面原型`);
-        return { url: reviewUrl(await ensureReviewServer(), key, readOnly), readOnly };
+        if (page === "prototype" && !fs.existsSync(path.join(r, featureDir, "prototype"))) throw new ApiError("not_found", `${featureDir} 还没有界面原型`);
+        if (page === "check" && !fs.existsSync(path.join(r, featureDir, "spec.md"))) throw new ApiError("not_found", `${featureDir} 中没有 spec.md`);
+        const url = reviewUrl(await ensureReviewServer(), key, readOnly);
+        return { url: page === "check" ? `${url}check/` : url, readOnly };
       });
     }
     default:

package/engine/src/checklist-cmd.ts

@@ -0,0 +1,37 @@
+// `req checklist <需求> [--no-open]` (1.14): the acceptance checklist in words, and the page where
+// the requester ticks it (served by the review page's server).
+import fs from "node:fs";
+import path from "node:path";
+import { buildChecklist, checklistText } from "./checklist.js";
+
+async function main(argv: string[]): Promise<number> {
+  const feature = argv.find((a) => !a.startsWith("--"));
+  if (!feature || argv.includes("--help") || argv.includes("-h")) {
+    console.log("用法：req checklist <需求> [--no-open] [--text]\n\n按需求说明的验收标准生成验收清单（流水线没验证、没通过的排在前面），在浏览器里逐条勾选，提交后写成 acceptance.md。--text 只在终端里列出清单。");
+    return feature ? 0 : 2;
+  }
+  const { locate } = await import("./api.js");
+  const { repo, featureDir } = locate(process.cwd(), feature);
+  if (!fs.existsSync(path.join(repo, featureDir, "spec.md"))) {
+    console.error(`${featureDir} 中没有 spec.md`);
+    return 1;
+  }
+  const list = buildChecklist(path.join(repo, featureDir));
+  let url: string | null = null;
+  if (!argv.includes("--text")) {
+    const { ensureReviewServer, keyOf, reviewUrl } = await import("./review.js");
+    const key = keyOf(repo, featureDir);
+    if (key) url = `${reviewUrl(await ensureReviewServer(), key)}check/`;
+  }
+  console.log(checklistText(list, url));
+  if (url && !argv.includes("--no-open")) (await import("./review.js")).openBrowser(url);
+  return 0;
+}
+
+main(process.argv.slice(2)).then(
+  (code) => process.exit(code),
+  (error: Error) => {
+    console.error(error.message);
+    process.exit(1);
+  },
+);

package/engine/src/checklist.ts

@@ -0,0 +1,254 @@
+// The acceptance checklist (1.14): what the requester checks by hand, built from the spec's
+// acceptance criteria, with what the pipeline found for each one. People tick each item on a
+// page (or read it with `req checklist`); the result is written as acceptance.md, the same record
+// the /req acceptance playbook writes. Plain parsing, no model.
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+export type PipelineResult = "pass" | "fail" | "unverified" | "unknown";
+
+export interface ChecklistItem {
+  /** AC-2.1, or D-1 for a decision the report asks the requester to confirm. */
+  id: string;
+  kind: "criterion" | "decision";
+  title: string;
+  /** 前置条件 / 操作 / 预期结果 and any example rows, as written in the spec. */
+  details: string[];
+  /** False for criteria of a "可以以后再说" requirement: they do not decide the verdict. */
+  required: boolean;
+  pipeline: PipelineResult;
+  /** The line of verification.md / report.md the pipeline result was read from. */
+  evidence: string | null;
+}
+
+export interface Checklist {
+  title: string;
+  specVersion: string | null;
+  reportVerdict: string | null;
+  items: ChecklistItem[];
+  /** handoff.md: what to watch for (已知问题) and where test data comes from, for the page. */
+  notes: string[];
+}
+
+const clean = (s: string) => s.replace(/\*\*|__|`/g, "").replace(/\s+/g, " ").trim();
+
+function read(file: string): string {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function header(text: string, name: string): string | null {
+  const m = new RegExp(`^[-*]\\s*${name}[:：]\\s*(.+)$`, "m").exec(text);
+  return m ? m[1].trim() : null;
+}
+
+/** The lines under the first heading whose text matches `title` (until the next heading of the same or higher level). */
+export function section(text: string, title: RegExp): string[] {
+  const lines = text.split(/\r?\n/);
+  const start = lines.findIndex((l) => /^#{1,6}\s/.test(l) && title.test(l));
+  if (start < 0) return [];
+  const level = /^(#+)/.exec(lines[start])![1].length;
+  const out: string[] = [];
+  for (const line of lines.slice(start + 1)) {
+    const h = /^(#+)\s/.exec(line);
+    if (h && h[1].length <= level) break;
+    out.push(line);
+  }
+  return out;
+}
+
+/** The criteria of a spec, with their details and whether their requirement is a must. */
+export function parseCriteria(spec: string): Array<Omit<ChecklistItem, "pipeline" | "evidence">> {
+  const items: Array<Omit<ChecklistItem, "pipeline" | "evidence">> = [];
+  let required = true;
+  let current: (typeof items)[number] | null = null;
+  for (const raw of spec.split(/\r?\n/)) {
+    const heading = /^#{1,6}\s+(.*)$/.exec(raw);
+    if (heading) {
+      current = null;
+      if (/FR-\d+/.test(heading[1])) required = !/可以以后再说|可选|以后再说/.test(heading[1]);
+      continue;
+    }
+    const ac = /^\s{0,3}[-*]\s+(.*?\bAC-(\d+(?:\.\d+)*)\b.*)$/.exec(raw);
+    if (ac) {
+      const line = ac[1];
+      if (/~~/.test(line) || /已取消/.test(line)) {
+        current = null;
+        continue;
+      }
+      const id = `AC-${ac[2]}`;
+      if (items.some((i) => i.id === id)) {
+        current = null;
+        continue;
+      }
+      const title = clean(line.replace(new RegExp(`.*?\\bAC-${ac[2].replace(/\./g, "\\.")}\\b[\\s*_\`)）\\]】:：-]*`), ""));
+      current = { id, kind: "criterion", title: title || id, details: [], required };
+      items.push(current);
+      continue;
+    }
+    if (!current) continue;
+    if (/^\s*$/.test(raw)) continue;
+    // Its details: indented bullets, or a table under it.
+    if (/^\s{2,}\S/.test(raw) || /^\s*\|/.test(raw)) {
+      const t = raw.trim();
+      if (/^\|?\s*-{3,}/.test(t)) continue;
+      current.details.push(clean(t.replace(/^[-*]\s+/, "")));
+    } else current = null;
+  }
+  return items;
+}
+
+/** A table row as words: "| AC-1.2 | 未验证 | 没有空数据 |" → "AC-1.2，未验证，没有空数据". */
+const evidenceOf = (line: string) =>
+  clean(line.trim().replace(/^\|/, "").replace(/\|\s*$/, "").split("|").map((c) => c.trim()).filter(Boolean).join("，")).slice(0, 300);
+
+/** What the pipeline wrote about one criterion, from verification.md (preferred) and report.md. */
+export function pipelineResult(id: string, ...documents: string[]): { result: PipelineResult; evidence: string | null } {
+  const re = new RegExp(`\\b${id.replace(/\./g, "\\.")}\\b(?![.\\d])`);
+  for (const doc of documents) {
+    const lines = doc.split(/\r?\n/).filter((l) => re.test(l));
+    // The last mention wins: a later round (复验) supersedes an earlier one.
+    for (const line of lines.reverse()) {
+      if (/未验证|没有验证|无法验证|未验/.test(line)) return { result: "unverified", evidence: evidenceOf(line) };
+      if (/未通过|不通过|失败|未达成|没有达成|✗|❌/.test(line)) return { result: "fail", evidence: evidenceOf(line) };
+      if (/通过|达成|✓|✅|pass/i.test(line)) return { result: "pass", evidence: evidenceOf(line) };
+    }
+  }
+  return { result: "unknown", evidence: null };
+}
+
+/** The decisions the report asks the requester to confirm ("需要你确认的决定"). */
+function decisions(report: string): ChecklistItem[] {
+  return section(report, /需要你确认/)
+    .map((l) => /^\s*(?:[-*]|\d+[.、)])\s+(.+)$/.exec(l)?.[1])
+    .filter((x): x is string => !!x && clean(x).length > 0 && !/^(无|没有)/.test(clean(x)))
+    .map((text, i) => ({ id: `D-${i + 1}`, kind: "decision" as const, title: clean(text).slice(0, 300), details: [], required: true, pipeline: "unknown" as const, evidence: null }));
+}
+
+const ORDER: Record<PipelineResult, number> = { fail: 0, unverified: 1, unknown: 2, pass: 3 };
+
+export function buildChecklist(featureAbs: string): Checklist {
+  const spec = read(path.join(featureAbs, "spec.md"));
+  const report = read(path.join(featureAbs, "report.md"));
+  const verification = read(path.join(featureAbs, "verification.md"));
+  const handoff = read(path.join(featureAbs, "handoff.md"));
+  const criteria = parseCriteria(spec).map((c) => {
+    const { result, evidence } = pipelineResult(c.id, verification, report);
+    return { ...c, pipeline: result, evidence };
+  });
+  // What the pipeline did not verify, or found wrong, first: that is where a person's eyes help most.
+  criteria.sort((a, b) => ORDER[a.pipeline] - ORDER[b.pipeline]);
+  const notes = [...section(handoff, /已知问题|未完成/), ...section(handoff, /测试需要的准备|测试数据|准备/)]
+    .map((l) => clean(l.replace(/^\s*[-*]\s+/, "")))
+    .filter((l) => l && !/^(无|没有)[。.]?$/.test(l))
+    .slice(0, 20);
+  return {
+    title: (/^#\s+(.+)$/m.exec(spec)?.[1] ?? path.basename(featureAbs)).replace(/^需求说明[:：\s]*/, "").trim(),
+    specVersion: header(spec, "版本"),
+    reportVerdict: header(report, "结论") ?? (/结论[:：]\s*(.+)/.exec(report)?.[1]?.trim() ?? null),
+    items: [...criteria, ...decisions(report)],
+    notes,
+  };
+}
+
+export type Mark = "pass" | "fail" | "skip";
+
+export interface Answer {
+  id: string;
+  mark: Mark;
+  note?: string;
+}
+
+export interface Verdict {
+  verdict: "通过" | "不通过";
+  failed: ChecklistItem[];
+  /** Required items not checked yet: the verdict cannot be "通过" while there are any. */
+  missing: ChecklistItem[];
+}
+
+export function verdictOf(list: Checklist, answers: Answer[]): Verdict {
+  const by = new Map(answers.map((a) => [a.id, a]));
+  const failed = list.items.filter((i) => by.get(i.id)?.mark === "fail" && i.required);
+  const missing = list.items.filter((i) => i.required && (!by.get(i.id) || by.get(i.id)!.mark === "skip"));
+  return { verdict: failed.length > 0 ? "不通过" : "通过", failed, missing };
+}
+
+const MARK_TEXT: Record<Mark, string> = { pass: "通过", fail: "不通过", skip: "未验" };
+
+/** acceptance.md in the format of contracts/feature-files.md. Keeps a "不通过的处理" section already there. */
+export function acceptanceText(list: Checklist, answers: Answer[], input: { verdict: "通过" | "不通过"; reviewer: string; date: string; previous?: string }): string {
+  const by = new Map(answers.map((a) => [a.id, a]));
+  const cell = (s: string) => s.replace(/\|/g, "\\|").replace(/\s+/g, " ").trim();
+  const rows = list.items.map((i) => {
+    const a = by.get(i.id);
+    const mark = a ? MARK_TEXT[a.mark] : "未验";
+    const how = i.kind === "decision" ? "需求方表态（同意 / 不同意）" : "在验收页上亲自核对";
+    const note = [i.kind === "decision" ? i.title : null, a?.note?.trim() || null, !i.required ? "可以以后再说，不影响结论" : null].filter(Boolean).join("；");
+    return `| ${i.id} | ${i.kind === "decision" ? (a?.mark === "pass" ? "同意" : a?.mark === "fail" ? "不同意" : "未表态") : mark} | ${how} | ${cell(note)} |`;
+  });
+  const kept = input.previous ? section(input.previous, /不通过的处理/).join("\n").trim() : "";
+  const failed = list.items.filter((i) => by.get(i.id)?.mark === "fail");
+  const handling = kept || failed.map((i) => `- ${i.id}：${cell(by.get(i.id)?.note?.trim() || i.title)} → 待和需求方确定处理方式（作为缺陷处理 / 作为需求修改 / 接受现状）`).join("\n");
+  return [
+    `# 验收记录：${list.title}`,
+    "",
+    `- 验收结论：${input.verdict}（${input.date}）`,
+    `- 验收人：${input.reviewer}`,
+    `- 对照的需求版本：${list.specVersion ?? "未写明"}`,
+    `- 对照的报告：report.md${list.reportVerdict ? `（流水线结论：${list.reportVerdict}）` : ""}`,
+    "",
+    "| AC | 结果 | 怎么验证的 | 备注 |",
+    "| --- | --- | --- | --- |",
+    ...rows,
+    ...(handling ? ["", "## 不通过的处理", "", handling] : []),
+    "",
+  ].join("\n");
+}
+
+/** Writes acceptance.md and commits it alone (when the feature directory is in a git repository). */
+export function recordAcceptance(repo: string, featureDir: string, text: string): { committed: boolean } {
+  const file = path.join(repo, featureDir, "acceptance.md");
+  fs.writeFileSync(file, text);
+  try {
+    const rel = path.join(featureDir, "acceptance.md");
+    execFileSync("git", ["add", "--", rel], { cwd: repo, stdio: "pipe" });
+    const staged = execFileSync("git", ["diff", "--cached", "--name-only", "--", rel], { cwd: repo, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    if (!staged) return { committed: false };
+    execFileSync("git", ["commit", "-q", "-m", `docs(${path.basename(featureDir)}): 验收记录`, "--", rel], { cwd: repo, stdio: "pipe" });
+    return { committed: true };
+  } catch {
+    return { committed: false };
+  }
+}
+
+/** What the requirement's chat is told when the requester found problems. */
+export function acceptanceFailMessage(featureDir: string, list: Checklist, answers: Answer[]): string {
+  const by = new Map(answers.map((a) => [a.id, a]));
+  const failed = list.items.filter((i) => by.get(i.id)?.mark === "fail");
+  return [
+    `【需求开发流水线通知】需求方在验收页上完成了验收（${featureDir}），结论：不通过。验收记录已写入 acceptance.md 并提交。`,
+    "",
+    "不通过的项：",
+    ...failed.map((i) => `- ${i.id} ${i.title}${by.get(i.id)?.note?.trim() ? `：${by.get(i.id)!.note!.trim()}` : ""}`),
+    "",
+    `请按 /req 的"验收"手册第 5 步，和需求方逐项确定处理方式（实现与需求不符 / 需求本身要改 / 接受现状），记入 acceptance.md 的"不通过的处理"一节，再按对应的手册继续。`,
+  ].join("\n");
+}
+
+/** `req checklist` in a terminal: the list in words. */
+export function checklistText(list: Checklist, url: string | null): string {
+  const mark: Record<PipelineResult, string> = { pass: "流水线：通过", fail: "流水线：没通过", unverified: "流水线：没验证", unknown: "流水线：没有记录" };
+  const lines = [`# 验收清单：${list.title}`, ""];
+  if (list.reportVerdict) lines.push(`流水线结论：${list.reportVerdict}`, "");
+  list.items.forEach((i, n) => {
+    lines.push(`${n + 1}. ${i.id} ${i.title}${i.required ? "" : "（可以以后再说）"}${i.kind === "criterion" ? `　[${mark[i.pipeline]}]` : "　[请表态：同意 / 不同意]"}`);
+    for (const d of i.details) lines.push(`   ${d}`);
+  });
+  if (list.notes.length) lines.push("", "注意（提测说明）：", ...list.notes.map((n) => `- ${n}`));
+  if (url) lines.push("", `在验收页上逐条勾选、写下哪里不对：${url}`);
+  return lines.join("\n");
+}

package/engine/src/features.ts

@@ -29,6 +29,8 @@ export interface FeatureSummary {
   profile: ProfileName | null;
   /** Plain-language stage, e.g. "对齐中", "开发中", "待验收", "已验收". */
   stage: string;
+  /** 1.14.0-beta.2: the pipeline ran for it (its state, or the documents only it writes, are here). */
+  developed: boolean;
   /** Last change to the feature directory's state or spec, ISO time. */
   updatedAt: string;
   /** Time and usage of all pipeline attempts, in words; null before the first run. */
@@ -77,13 +79,27 @@ interface RawState {
   history?: Array<{ attempt: number; startedAt: string; endedAt: string | null; usage?: Record<string, number> | null }>;
 }
 
-function stageOf(confirmed: boolean, state: RawState | null, acceptance: string | null): string {
+/**
+ * Files only the pipeline writes: their presence means it ran, even where its state is not (a
+ * copy merged into the main branch: the state file under .pipeline/ is never committed).
+ */
+const PIPELINE_OUTPUTS = ["design.md", "assessment.md", "diagnosis.md", "implementation.md", "handoff.md", "verification.md", "report.md"];
+
+export function developedIn(dir: string): boolean {
+  return PIPELINE_OUTPUTS.some((f) => fs.existsSync(path.join(dir, f)));
+}
+
+function stageOf(confirmed: boolean, state: RawState | null, acceptance: string | null, developed = false, reported = false): string {
   if (acceptance) {
     const verdict = headerValue(acceptance, "验收结论");
     if (verdict?.startsWith("通过")) return "已验收";
     if (verdict?.startsWith("不通过")) return "验收未通过";
   }
-  if (!state) return confirmed ? "已确认，未开始开发" : "对齐中";
+  if (!state) {
+    // 1.14.0-beta.2: developed elsewhere (e.g. merged here from its own branch) is not "not started".
+    if (developed) return reported ? "待验收" : "已开发（这个目录里没有运行状态）";
+    return confirmed ? "已确认，未开始开发" : "对齐中";
+  }
   switch (state.status) {
     case "running":
       return state.pid && isAlive(state.pid) ? "开发中" : "已中断（可继续）";
@@ -131,6 +147,7 @@ export function summarize(worktree: Worktree, name: string): FeatureSummary | nu
       confirmed: false,
       profile: null,
       stage: "对齐中",
+      developed: false,
       updatedAt: new Date(updated || Date.now()).toISOString(),
       usage: null,
     };
@@ -146,6 +163,7 @@ export function summarize(worktree: Worktree, name: string): FeatureSummary | nu
   const acceptanceFile = path.join(dir, "acceptance.md");
   const acceptance = fs.existsSync(acceptanceFile) ? fs.readFileSync(acceptanceFile, "utf8") : null;
   const confirmed = isSpecConfirmed(spec);
+  const developed = state !== null || developedIn(dir);
   const version = Number(headerValue(spec, "版本"));
   const updated = Math.max(mtime(specFile), mtime(stateFile), mtime(acceptanceFile), mtime(path.join(dir, "changes.md")));
   return {
@@ -158,7 +176,8 @@ export function summarize(worktree: Worktree, name: string): FeatureSummary | nu
     specVersion: Number.isInteger(version) && version > 0 ? version : null,
     confirmed,
     profile: specProfile(spec),
-    stage: stageOf(confirmed, state, acceptance),
+    stage: stageOf(confirmed, state, acceptance, developed, fs.existsSync(path.join(dir, "report.md"))),
+    developed,
     updatedAt: new Date(updated || Date.now()).toISOString(),
     usage: state?.history && state.history.length > 0 ? describeTotals(totals(state.history)) : null,
   };

package/engine/src/reply.ts

@@ -8,7 +8,10 @@ import { pluginReplyMessage } from "./messages.js";
 import { loadRuntimeFactory } from "./runtime-loader.js";
 import { readState, statePath } from "./state.js";
 
-async function main(argv: string[]): Promise<number> {
+async function main(argvIn: string[]): Promise<number> {
+  // 1.14 --acceptance: the checklist page found problems; the text is the whole notice.
+  const acceptance = argvIn.includes("--acceptance");
+  const argv = argvIn.filter((a) => a !== "--acceptance");
   const [feature, ...words] = argv;
   const text = words.join(" ").trim();
   if (!feature || !text) {
@@ -17,7 +20,7 @@ async function main(argv: string[]): Promise<number> {
   }
   const { repo, featureDir } = locate(process.cwd(), feature);
   const state = readState(statePath(repo, featureDir));
-  if (!state || (state.status !== "waiting_for_business" && state.status !== "waiting_for_approval")) {
+  if (!state || (!acceptance && state.status !== "waiting_for_business" && state.status !== "waiting_for_approval")) {
     console.error(`${featureDir} 现在没有在等待回答或确认，不用回复。`);
     return 1;
   }
@@ -36,7 +39,7 @@ async function main(argv: string[]): Promise<number> {
   try {
     await runtime.notifyAgent(
       state.originAgentId,
-      pluginReplyMessage({
+      acceptance ? text.slice(0, 8000) : pluginReplyMessage({
         featureDir,
         waitingFor: state.status === "waiting_for_approval" ? "approval" : "business",
         text: text.slice(0, 8000),
@@ -46,7 +49,7 @@ async function main(argv: string[]): Promise<number> {
   } finally {
     await runtime.close().catch(() => undefined);
   }
-  console.log("已转给这个需求的对话，它会按回复更新需求说明并继续开发。");
+  console.log(acceptance ? "已转给这个需求的对话。" : "已转给这个需求的对话，它会按回复更新需求说明并继续开发。");
   return 0;
 }
 

package/engine/src/review-assets/check.css

@@ -0,0 +1,57 @@
+:root {
+  --bg: #f6f7f9; --surface: #ffffff; --surface-2: #f1f3f6; --text: #1c2430; --muted: #5d6b7c; --border: #dfe3e9;
+  --accent: #2457d6; --accent-text: #ffffff; --accent-soft: #e8eefc; --ok: #15803d; --ok-soft: #e7f6ec; --danger: #b91c1c; --danger-soft: #fdecec; --warn: #b45309; --warn-soft: #fdf3e2;
+  color-scheme: light;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg: #12161c; --surface: #1a2029; --surface-2: #222a35; --text: #e6eaf0; --muted: #9aa7b8; --border: #2e3846;
+    --accent: #6f9bff; --accent-text: #0d1420; --accent-soft: #1f2c47; --ok: #4ade80; --ok-soft: #173322; --danger: #f87171; --danger-soft: #3a1c1c; --warn: #fbbf24; --warn-soft: #3a2c12;
+    color-scheme: dark;
+  }
+}
+* { box-sizing: border-box; }
+[hidden] { display: none !important; }
+body { margin: 0; background: var(--bg); color: var(--text); font: 15px/1.6 system-ui, -apple-system, "Segoe UI", "PingFang SC", "Microsoft YaHei", sans-serif; padding-bottom: 96px; }
+.top { display: flex; justify-content: space-between; align-items: flex-start; gap: 16px; padding: 20px 24px 8px; flex-wrap: wrap; }
+.eyebrow { font-size: 13px; color: var(--muted); }
+h1 { margin: 2px 0 4px; font-size: 22px; }
+.muted { color: var(--muted); }
+main { padding: 0 24px; max-width: 980px; }
+.intro { margin: 8px 0 16px; }
+.card { background: var(--surface); border: 1px solid var(--border); border-radius: 12px; padding: 14px 16px; margin: 12px 0; }
+.notes h2, .card h2 { font-size: 15px; margin: 0 0 6px; }
+.notes ul { margin: 0; padding-left: 20px; }
+.items { list-style: none; padding: 0; margin: 0; display: flex; flex-direction: column; gap: 12px; }
+.item { background: var(--surface); border: 1px solid var(--border); border-left: 4px solid var(--border); border-radius: 12px; padding: 14px 16px; }
+.item.pass { border-left-color: var(--ok); }
+.item.fail { border-left-color: var(--danger); }
+.item.skip { border-left-color: var(--warn); }
+.item-head { display: flex; gap: 10px; align-items: baseline; flex-wrap: wrap; }
+.id { font-weight: 700; font-variant-numeric: tabular-nums; }
+.item-title { font-weight: 600; }
+.badge { font-size: 12px; padding: 1px 8px; border-radius: 999px; background: var(--surface-2); color: var(--muted); white-space: nowrap; }
+.badge.fail { background: var(--danger-soft); color: var(--danger); }
+.badge.unverified { background: var(--warn-soft); color: var(--warn); }
+.badge.pass { background: var(--ok-soft); color: var(--ok); }
+.details { margin: 8px 0 0; padding-left: 18px; }
+.details li { margin: 2px 0; }
+.evidence { font-size: 13px; color: var(--muted); margin-top: 6px; }
+.marks { display: flex; gap: 8px; margin-top: 10px; flex-wrap: wrap; }
+.btn { font: inherit; border: 1px solid var(--border); background: var(--surface); color: var(--text); border-radius: 8px; padding: 6px 14px; cursor: pointer; min-height: 36px; }
+.btn:hover { border-color: var(--accent); }
+.btn:disabled { opacity: 0.5; cursor: default; }
+.btn.primary { background: var(--accent); color: var(--accent-text); border-color: var(--accent); font-weight: 600; }
+.btn.on-pass { background: var(--ok); color: #fff; border-color: var(--ok); }
+.btn.on-fail { background: var(--danger); color: #fff; border-color: var(--danger); }
+.btn.on-skip { background: var(--warn); color: #fff; border-color: var(--warn); }
+textarea { width: 100%; margin-top: 8px; font: inherit; color: var(--text); background: var(--surface-2); border: 1px solid var(--border); border-radius: 8px; padding: 8px; min-height: 64px; }
+.bar { position: fixed; left: 0; right: 0; bottom: 0; display: flex; align-items: center; gap: 16px; padding: 12px 24px; background: var(--surface); border-top: 1px solid var(--border); flex-wrap: wrap; }
+.summary { flex: 1; min-width: 200px; }
+.reviewer input { font: inherit; color: var(--text); background: var(--surface-2); border: 1px solid var(--border); border-radius: 8px; padding: 6px 8px; width: 160px; }
+.toast { position: fixed; right: 24px; bottom: 84px; background: var(--text); color: var(--bg); padding: 10px 14px; border-radius: 10px; max-width: 520px; white-space: pre-line; }
+.services a { color: var(--accent); }
+pre.howto { white-space: pre-wrap; font: inherit; margin: 6px 0 0; }
+.done { background: var(--ok-soft); border-color: var(--ok); }
+
+@media (max-width: 640px) { body { padding-bottom: 200px; } }

package/engine/src/review-assets/check.html

@@ -0,0 +1,35 @@
+<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>验收清单</title>
+<link rel="stylesheet" href="check.css">
+</head>
+<body>
+<header class="top">
+  <div>
+    <div class="eyebrow" id="project"></div>
+    <h1 id="title">验收清单</h1>
+    <div class="muted" id="sub"></div>
+  </div>
+  <div class="top-actions">
+    <button id="try" class="btn">把它跑起来试用</button>
+    <button id="try-stop" class="btn" hidden>停止试用</button>
+  </div>
+</header>
+<main>
+  <section id="try-box" class="card" hidden></section>
+  <section id="notes" class="card notes" hidden></section>
+  <p class="muted intro">一条一条看：照着"前置条件"准备，按"操作"去做，看到的和"预期结果"一样就点<b>通过</b>；不一样点<b>不对</b>，写下看到了什么。流水线没验证或没通过的排在最前面。进度会自动保存。</p>
+  <ol id="items" class="items"></ol>
+</main>
+<footer class="bar">
+  <div class="summary" id="summary"></div>
+  <label class="reviewer">验收人 <input id="reviewer" placeholder="你的名字（可不填）" maxlength="60"></label>
+  <button id="submit" class="btn primary" disabled>提交验收结果</button>
+</footer>
+<div id="toast" class="toast" hidden></div>
+<script src="check.js"></script>
+</body>
+</html>