pi-skill-evolve 0.1.9 → 0.1.10

package/extensions/skill-evolve/lib/web/reports.ts

@@ -5,7 +5,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { readVerify } from "../apply.ts";
-import type { RunSummary } from "../runs.ts";
+import type { RunStatus, RunSummary } from "../runs.ts";
 import { readRunError } from "../stale.ts";
 import { asNumber, asRecord, asText, readJson, reasonLabel } from "./json-read.ts";
 import { sessionFromRecord, type SessionRef } from "./run-session.ts";
@@ -13,6 +13,12 @@ import { sessionFromRecord, type SessionRef } from "./run-session.ts";
 /** 单条报告里最多列几个技能：全量列会把 details 撑成第二份 findings */
 export const MAX_FINDING_ROWS = 5;
 
+/**
+ * 复盘报告页唯一由 run 状态决定的分支：status=stale 且没有 findings 的失败 run 也要占一行。
+ * （其余 run 靠「能读到 01-findings.json」入场，与状态无关）导出给覆盖性测试用。
+ */
+export const REPORTS_RUN_STATUSES: readonly RunStatus[] = ["stale"];
+
 export interface FindingRow {
   skill: string;
   kind: string;
@@ -126,13 +132,15 @@ export function buildReports(evolutionDir: string, runs: readonly RunSummary[]):
       // 失败也要有一行档案：每条 run 都能在报告里找到，不能因为没产出就从历史里消失
       const summary = summaries.get(runId);
       const raw = readJson<Record<string, unknown>>(path.join(runDir, "run.json"));
-      if ((summary?.status ?? asText(raw?.status)) !== "stale") continue;
+      const status = summary?.status ?? asText(raw?.status);
+      // 判据用清单本体而不是写死 "stale"：清单改了代码就跟着改（同类写法见 ./applied.ts）
+      if (!REPORTS_RUN_STATUSES.some((known) => known === status)) continue;
       const error = readRunError(runDir);
       const tail = error?.childLogTail ?? [];
       const lastLine = tail.length > 0 ? tail[tail.length - 1]!.trim() : "";
       reports.push({
         runId,
-        status: "stale",
+        status,
         trigger: meta.trigger,
         session: meta.session,
         startedAt: summary?.dispatchedAt ?? asNumber(raw?.dispatchedAt),

package/extensions/skill-evolve/lib/web/run-detail.ts

@@ -33,6 +33,14 @@ export interface RunBlocking {
   quote: string;
 }
 
+/** 通过理由（03-review.json 的 passed）：哪一点没问题 + 支撑它的原文 */
+export interface RunPassing {
+  point: string;
+  file: string;
+  line: number | null;
+  quote: string;
+}
+
 export interface RunGate {
   gate: string;
   name: string;
@@ -70,8 +78,18 @@ export interface RunDetail {
   /** candidate 目录里的技能名（与 skill 一致才读全文） */
   candidateSkill: string | null;
   candidateText: string | null;
-  review: { status: string; verdict: string; action: string; reviewerModel: string } | null;
+  review: {
+    status: string;
+    verdict: string;
+    action: string;
+    reviewerModel: string;
+    summary: string | null;
+    /** 03-review.json 里连 summary / passed 两个键都没有 = v0.1.9 之前写的记录（详情页要说旧版，而不是说「没给理由」） */
+    legacy: boolean;
+  } | null;
   blocking: RunBlocking[];
+  /** 通过理由：旧 run 没有这个字段，读出来是空数组 */
+  passed: RunPassing[];
   gates: RunGate[];
   verifyStatus: string | null;
   findings: RunFinding[];
@@ -95,30 +113,40 @@ function exists(file: string): boolean {
   }
 }
 
-/** 03-review.json → verdict / action / reviewerModel + blocking（每条带 file:line 与原文引用） */
-function readReview(runDir: string): Pick<RunDetail, "review" | "blocking"> {
-  const raw = asRecord(readJson<unknown>(path.join(runDir, "03-review.json")));
-  if (!raw) return { review: null, blocking: [] };
-  const blocking: RunBlocking[] = [];
-  for (const item of Array.isArray(raw.blocking) ? raw.blocking : []) {
+/** 03-review.json 里的证据项 → 行上的 file / line / quote（blocking 与 passed 共用同一形状） */
+function readEvidenceRows<T>(items: unknown, build: (text: string, file: string, line: number | null, quote: string) => T): T[] {
+  const rows: T[] = [];
+  for (const item of Array.isArray(items) ? items : []) {
     const record = asRecord(item);
     if (!record) continue;
     const evidence = asRecord(record.evidence);
-    blocking.push({
-      issue: asText(record.issue, "（未写问题描述）"),
-      file: asText(evidence?.file),
-      line: asNumber(evidence?.line),
-      quote: asText(evidence?.quote),
-    });
+    const text = asText(record.issue) || asText(record.point) || "（未写说明）";
+    rows.push(build(text, asText(evidence?.file), asNumber(evidence?.line), asText(evidence?.quote)));
   }
+  return rows;
+}
+
+/**
+ * 03-review.json → verdict / action / reviewerModel / summary + blocking + passed。
+ * 旧版评审产出的文件没有 summary / passed：summary 读成 null、passed 读成空数组（不抛、不补造）。
+ */
+function readReview(runDir: string): Pick<RunDetail, "review" | "blocking" | "passed"> {
+  const raw = asRecord(readJson<unknown>(path.join(runDir, "03-review.json")));
+  if (!raw) return { review: null, blocking: [], passed: [] };
+  const blocking = readEvidenceRows<RunBlocking>(raw.blocking, (issue, file, line, quote) => ({ issue, file, line, quote }));
+  const passed = readEvidenceRows<RunPassing>(raw.passed, (point, file, line, quote) => ({ point, file, line, quote }));
   return {
     review: {
       status: asText(raw.status, "（未写状态）"),
       verdict: asText(raw.verdict, "（未写 verdict）"),
       action: asText(raw.action, "（未写 action）"),
       reviewerModel: asText(raw.reviewerModel, "（未写模型）"),
+      summary: asText(raw.summary, "") || null,
+      // 两个键都不存在才算旧记录：新版即使评审失败也会写 passed: []（空数组也是一个键），不能混谈
+      legacy: raw.summary === undefined && raw.passed === undefined,
     },
     blocking,
+    passed,
   };
 }
 

package/extensions/skill-evolve/lib/web/style.ts

@@ -113,6 +113,8 @@ a.btn { display: inline-block; color: var(--blue); padding: 1px 8px; border: 1px
 .kv .k { color: var(--muted); font-size: 12px }
 .kv .v { color: var(--fg) }
 .kv-line { margin: 4px 0 }
+/* 评审结论摘要：详情页里唯一「大一号」的正文，用户上来先读这一句 */
+.verdict-summary { margin: 6px 0; font-size: 15px; font-weight: 600; color: var(--fg) }
 a.run { color: #c8d3e6; border-bottom: 1px dashed #45505f }
 a.run:hover { border-bottom-color: var(--blue); text-decoration: none }
 a.sess { color: var(--muted); border-bottom: 1px dashed #45505f }

package/extensions/skill-evolve/test/review-post.test.ts

@@ -1,21 +1,27 @@
 /**
  * 评审后处理单测（设计稿 12.3）：结构、证据、一致性一律代码判，不信 LLM 自觉。
  * 每条用例对应「模型输出的一种坏法」，覆盖判 invalid / reject 的每一道关。
+ * 「结论必须写为什么」也在这里钉住：没有 summary、pass 却没有 passed（或 reject 却没有 blocking）一律 invalid。
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { parseReviewJson, postProcessReview } from "../lib/review-post.ts";
+import { parseReviewJson, postProcessReview, SUMMARY_MAX } from "../lib/review-post.ts";
 
-const GOOD_PASS = JSON.stringify({ verdict: "pass", blocking: [], notes: "没问题" });
-const withBlocking = (verdict: string, evidence: unknown): string =>
-  JSON.stringify({ verdict, blocking: [{ issue: "有问题", evidence }], notes: "" });
+const SUMMARY = "新描述补了触发场景词，没删原有禁令";
 const EVIDENCE = { file: ".pi/skills/demo/SKILL.md", line: 12, quote: "允许用 find" };
+const PASSED = [{ point: "原有禁止项仍完整保留", evidence: EVIDENCE }];
+const GOOD_PASS = JSON.stringify({ verdict: "pass", summary: SUMMARY, blocking: [], passed: PASSED, notes: "没问题" });
+const withBlocking = (verdict: string, evidence: unknown): string =>
+  JSON.stringify({ verdict, summary: SUMMARY, blocking: [{ issue: "有问题", evidence }], passed: [], notes: "" });
 
-test("合法 pass 返回 ok", () => {
+test("合法 pass 返回 ok，且 summary / passed 原样带出", () => {
   const result = postProcessReview(GOOD_PASS);
   assert.equal(result.status, "ok");
   assert.equal(result.verdict, "pass");
   assert.deepEqual(result.blocking, []);
+  assert.equal(result.summary, SUMMARY);
+  assert.equal(result.passed.length, 1);
+  assert.equal(result.passed[0].point, "原有禁止项仍完整保留");
 });
 
 test("带 ```json 围栏与前后废话也能抠出 JSON", () => {
@@ -71,11 +77,52 @@ test("pass 却带 blocking 判 invalid：contradiction", () => {
 });
 
 test("reject 带完整证据返回 ok 且保留 blocking/notes", () => {
-  const result = postProcessReview(JSON.stringify({ verdict: "reject", blocking: [{ issue: "引入 find", evidence: EVIDENCE }], notes: "违反 P0" }));
+  const text = JSON.stringify({ verdict: "reject", summary: SUMMARY, blocking: [{ issue: "引入 find", evidence: EVIDENCE }], notes: "违反 P0" });
+  const result = postProcessReview(text);
   assert.equal(result.status, "ok");
   assert.equal(result.verdict, "reject");
   assert.equal(result.blocking[0].evidence.line, 12);
   assert.equal(result.notes, "违反 P0");
+  assert.equal(result.summary, SUMMARY);
+  assert.deepEqual(result.passed, [], "reject 时没给 passed 就是空数组，不补造");
+});
+
+test("pass 但没有 passed（只写「通过」两个字）判 invalid：missing-passed", () => {
+  const text = JSON.stringify({ verdict: "pass", summary: SUMMARY, blocking: [] });
+  const result = postProcessReview(text);
+  assert.equal(result.status, "invalid");
+  assert.match(result.detail ?? "", /missing-passed/);
+});
+
+test("reject / revise 但没有 blocking 判 invalid：missing-blocking", () => {
+  for (const verdict of ["reject", "revise"]) {
+    const result = postProcessReview(JSON.stringify({ verdict, summary: SUMMARY, blocking: [] }));
+    assert.equal(result.status, "invalid", verdict);
+    assert.match(result.detail ?? "", /missing-blocking/);
+  }
+});
+
+test("passed 项也要有 point 与证据：缺了就是 missing-evidence", () => {
+  const noEvidence = postProcessReview(JSON.stringify({ verdict: "pass", summary: SUMMARY, blocking: [], passed: [{ point: "没问题" }] }));
+  assert.equal(noEvidence.status, "invalid");
+  assert.match(noEvidence.detail ?? "", /missing-evidence: passed/);
+  assert.match(noEvidence.detail ?? "", /evidence 不是对象/);
+});
+
+test("没写 summary（缺字段 / 空串 / 非字符串）判 invalid：bad-summary", () => {
+  for (const summary of [undefined, "", "   ", 42]) {
+    const result = postProcessReview(JSON.stringify({ verdict: "pass", summary, blocking: [], passed: PASSED }));
+    assert.equal(result.status, "invalid", `summary=${String(summary)}`);
+    assert.match(result.detail ?? "", /bad-summary/);
+  }
+});
+
+test(`summary 超 ${SUMMARY_MAX} 字按上限截断（含省略号不超过 ${SUMMARY_MAX}），不判 invalid`, () => {
+  const long = "因为".repeat(60);
+  const result = postProcessReview(JSON.stringify({ verdict: "pass", summary: long, blocking: [], passed: PASSED }));
+  assert.equal(result.status, "ok");
+  assert.equal(result.summary?.length, SUMMARY_MAX);
+  assert.ok(result.summary?.endsWith("…"), "截断要留省略号，让人知道后面还有话");
 });
 
 test("机械复验失败一票 reject，覆盖 LLM 的 pass", () => {

package/extensions/skill-evolve/test/review-prompt.test.ts

@@ -103,3 +103,12 @@ test("verdict 语义写进 prompt：能改的小毛病不许判 reject（真实
   assert.match(prompt, /revise：方向可以接受/);
   assert.match(prompt, /reject：删掉了原有的明确禁止项/);
 });
+
+test("输出契约要求写「为什么」：summary 必填 + pass 必须给 passed", () => {
+  const prompt = buildReviewPrompt({ skillName: "demo", skillText: "正文", diffApplied: true, diff: "+++ b/x\n", hardRules: [] });
+  assert.match(prompt, /"summary":"一句话结论（≤80 字，必须写清因为什么）"/);
+  assert.match(prompt, /"passed":\[\{"point"/);
+  assert.match(prompt, /summary 必填/);
+  assert.match(prompt, /verdict=pass 时 blocking=\[\] 且 passed 至少 1 条/);
+  assert.match(prompt, /verdict=reject\/revise 时 blocking 至少 1 条/);
+});

package/extensions/skill-evolve/test/review-record.test.ts

@@ -0,0 +1,59 @@
+/**
+ * 评审记录落盘形态的单测：`03-review.md` 必须写出「为什么」（summary + 通过理由），
+ * 且 v0.1.9 之前的老记录（没有 summary / passed 字段）读进来也不能抛。
+ *
+ * 单独一份测试是因为 review-record.ts 全是纯函数；落盘字段与服务端回写由
+ * test/review-supervisor.test.ts 覆盖，细节页读取由 test/web-run-detail.test.ts 覆盖。
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+import { renderReviewMarkdown, type ReviewRecord } from "../lib/review-record.ts";
+
+const EVIDENCE = { file: ".pi/skills/demo/SKILL.md", line: 3, quote: "description: 检索日志用 rg" };
+
+function record(extra: Partial<ReviewRecord> = {}): ReviewRecord {
+  return {
+    status: "rejected",
+    verdict: "revise",
+    blocking: [{ issue: "描述承诺大于正文", evidence: EVIDENCE }],
+    reviewerModel: "deepseek/deepseek-flash",
+    proposerModel: "deepseek/deepseek-flash",
+    sameModel: false,
+    action: "forbidden",
+    reviewedAt: 1794134158913,
+    reviewedAtIso: "2026-11-08T10:35:58.913Z",
+    ...extra,
+  };
+}
+
+test("03-review.md：summary 紧跟在标题后，blocking 与 passed 各成一段", () => {
+  const md = renderReviewMarkdown(
+    record({
+      summary: "描述承诺了正文没有的能力，其余约束未被破坏",
+      passed: [{ point: "原有禁令仍完整保留", evidence: { ...EVIDENCE, line: 9, quote: "一律用 rg" } }],
+    }),
+    "demo",
+  );
+  const lines = md.split("\n");
+  assert.equal(lines[0], "# 评审结论：revise");
+  assert.equal(lines[2], "**描述承诺了正文没有的能力，其余约束未被破坏**", "摘要要排在元信息之前");
+  assert.match(md, /## blocking\n\n- 描述承诺大于正文\n {2}- 证据：\.pi\/skills\/demo\/SKILL\.md:3 「description: 检索日志用 rg」/);
+  assert.match(md, /## passed\n\n- 原有禁令仍完整保留\n {2}- 证据：\.pi\/skills\/demo\/SKILL\.md:9 「一律用 rg」/);
+});
+
+test("03-review.md：老记录（没有 summary / passed）不抛，也不渲染空段", () => {
+  const md = renderReviewMarkdown(record(), "demo");
+  assert.equal(md.includes("## passed"), false, "没有通过理由就别留空段");
+  assert.equal(md.includes("**"), false, "没有摘要就没有加粗行（同模型警告是 > 开头，不受影响）");
+  assert.match(md, /## blocking/);
+});
+
+test("03-review.md：pass 且没有 blocking 时写「blocking：无」，通过理由照常列出", () => {
+  const md = renderReviewMarkdown(
+    record({ status: "reviewed", verdict: "pass", action: "auto", blocking: [], summary: "只给 description 补了触发词", passed: [{ point: "原有禁令仍在", evidence: EVIDENCE }] }),
+    "demo",
+  );
+  assert.match(md, /blocking：无/);
+  assert.match(md, /## passed/);
+  assert.equal(md.includes("## blocking"), false);
+});

package/extensions/skill-evolve/test/review-supervisor.test.ts

@@ -21,7 +21,14 @@ const DESC_DIFF = [
   "-description: 旧描述",
   "+description: 检索日志时用 rg，禁止 find 全盘扫",
 ].join("\n");
-const PASS = JSON.stringify({ verdict: "pass", blocking: [], notes: "没问题" });
+const EVIDENCE_ROW = { file: ".pi/skills/demo/SKILL.md", line: 4, quote: "description: 检索日志时用 rg，禁止 find 全盘扫" };
+const PASS = JSON.stringify({
+  verdict: "pass",
+  summary: "新描述只补了触发场景词，没删原有禁令",
+  blocking: [],
+  passed: [{ point: "原有禁止项仍在正文里", evidence: EVIDENCE_ROW }],
+  notes: "没问题",
+});
 const RUN_JSON = JSON.stringify({ runId: "run-1", status: "dispatched", cwd: "/repo", stages: [{ name: "analyze", model: "deepseek/flash", usage: {}, ms: 10 }] });
 /** 只放一条与仓库同形的 rg-over-find：用例不依赖 .pi/evolution/rules 文件是否在场 */
 const RULES = compileRules({
@@ -74,11 +81,18 @@ test("正常路径：pass → reviewed，写 03-review.json/.md 并回写 run.js
   assert.equal(review.proposerModel, "deepseek/flash");
   assert.equal(review.sameModel, true);
   assert.equal(review.action, "auto");
+  // 结论要能解释「为什么」：summary 与 passed 都得落盘（面板详情页读的就是这两个字段）
+  assert.equal(review.summary, "新描述只补了触发场景词，没删原有禁令");
+  assert.equal((review.passed as unknown[]).length, 1);
   const md = fs.text(`${RUN_DIR}/03-review.md`) ?? "";
   assert.ok(md.startsWith("> 同模型自评"), "同模型自评警告必须在首行");
+  assert.match(md, /\*\*新描述只补了触发场景词，没删原有禁令\*\*/);
+  assert.match(md, /## passed/);
   const run = fs.json(`${RUN_DIR}/run.json`) as Record<string, unknown>;
   assert.equal(run.status, "reviewed");
   assert.deepEqual((run.review as Record<string, unknown>).sameModel, true);
+  assert.equal((run.review as Record<string, unknown>).summary, "新描述只补了触发场景词，没删原有禁令");
+  assert.equal((run.review as Record<string, unknown>).passed, 1);
   assert.equal(prompts.length, 0);
 });
 

package/extensions/skill-evolve/test/selftest.test.ts

@@ -1,7 +1,10 @@
 /**
- * 必红自检单测（设计稿 12.4）：三个坏样本必须被拦住，任何一条被 pass 就算评审器不可信。
+ * 必红自检单测（设计稿 12.4）：三个坏样本必须被拦住，一个正样本必须放行且写出理由；
+ * 任何一条不符就算评审器不可信。
  *
  * 假 spawn 按 prompt 里的「技能名」回不同结论，所以用例不受 fixtures 目录枚举顺序影响。
+ * 回的 JSON 必须是能过 postProcessReview 的合法形状（summary 必填，pass 必须带 passed），
+ * 否则测的就不是「期望命中」而是「载荷校验」了。
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
@@ -20,11 +23,11 @@ function tmpDir(): string {
 }
 
 /** 按 prompt 末尾的「技能名：x」挑结论 */
-function spawnBySkill(verdicts: Record<string, string>): ReviewSpawn {
+function spawnBySkill(verdicts: Record<string, string>, opts: { dropPassed?: boolean } = {}): ReviewSpawn {
   return (_command, args) => {
     const prompt = args[3] ?? "";
     const skill = Object.keys(verdicts).find((name) => prompt.includes(`技能名：${name}`));
-    const reply = JSON.stringify({ verdict: skill ? verdicts[skill] : "pass", blocking: [], notes: "自检" });
+    const reply = fakeReply(skill ? (verdicts[skill] ?? "pass") : "pass", { dropPassed: opts.dropPassed === true });
     const child = new FakeReviewChild();
     setTimeout(() => {
       child.stdout.emit("data", reply);
@@ -34,42 +37,74 @@ function spawnBySkill(verdicts: Record<string, string>): ReviewSpawn {
   };
 }
 
-test("三个坏样本都能被读到，期望分别是 reject/reject/revise", () => {
+const FAKE_EVIDENCE = { file: ".pi/skills/demo/SKILL.md", line: 9, quote: "凡是查日志一律用 rg" };
+
+/** 造一份合法评审输出：reject/revise 带 blocking，pass 带 passed（可故意抽掉，测正样本的必红判定） */
+function fakeReply(verdict: string, opts: { dropPassed: boolean }): string {
+  const summary = "假评审：只校验自检链路，不代表真实评审质量";
+  if (verdict === "pass") {
+    const passed = opts.dropPassed ? [] : [{ point: "原有禁令仍完整保留", evidence: FAKE_EVIDENCE }];
+    return JSON.stringify({ verdict, summary, blocking: [], passed, notes: "自检" });
+  }
+  return JSON.stringify({ verdict, summary, blocking: [{ issue: "有问题", evidence: FAKE_EVIDENCE }], passed: [], notes: "自检" });
+}
+
+test("三个坏样本 + 一个正样本都能被读到，期望分别是 reject/reject/revise/pass", () => {
   const fixtures = loadFixtures(FIXTURES);
-  assert.deepEqual(fixtures.map((item) => item.name).sort(), ["delete-ban", "rg-to-find", "weak-description"]);
+  assert.deepEqual(fixtures.map((item) => item.name).sort(), ["delete-ban", "good-description", "rg-to-find", "weak-description"]);
   const expected = Object.fromEntries(fixtures.map((item) => [item.name, item.expected]));
-  assert.deepEqual(expected, { "delete-ban": "reject", "rg-to-find": "reject", "weak-description": "revise" });
+  assert.deepEqual(expected, {
+    "delete-ban": "reject",
+    "good-description": "pass",
+    "rg-to-find": "reject",
+    "weak-description": "revise",
+  });
   for (const fixture of fixtures) {
     assert.ok(fixture.diff.length > 0, `${fixture.name} 缺 diff`);
     assert.ok(fixture.after.length > 0, `${fixture.name} 缺改后全文`);
   }
 });
 
-test("三样本全部被正确拦住 → passed:true 并落盘 selftest.json", async () => {
+test("四样本全部命中期望 → passed:true 并落盘 selftest.json", async () => {
   const dir = tmpDir();
   const report = await runSelftest({
     evolutionDir: dir,
     cwd: dir,
     fixturesDir: FIXTURES,
-    spawnFn: spawnBySkill({ "ui-verify-lite": "reject", "rg-retrieval": "reject", "misc-helper": "revise" }),
-    pollMs: 1,
+    spawnFn: spawnBySkill({ "ui-verify-lite": "reject", "rg-retrieval": "reject", "misc-helper": "revise", "log-helper": "pass" }),
   });
   assert.equal(report.passed, true);
-  assert.equal(report.results.length, 3);
-  assert.deepEqual(report.results.map((item) => item.actual), ["reject", "reject", "revise"]);
+  assert.equal(report.results.length, 4);
+  assert.deepEqual(report.results.map((item) => item.actual), ["reject", "pass", "reject", "revise"]);
   const saved = JSON.parse(fs.readFileSync(selftestFile(dir), "utf8")) as { passed: boolean };
   assert.equal(saved.passed, true);
   assert.ok(!renderSelftestReport(report).includes("【红】"));
 });
 
+test("正样本判 pass 但没给 passed 理由 → 判不合格并写清差在哪（必红自检要能拉住无理由的通过）", async () => {
+  const dir = tmpDir();
+  const report = await runSelftest({
+    evolutionDir: dir,
+    cwd: dir,
+    fixturesDir: FIXTURES,
+    spawnFn: spawnBySkill({ "ui-verify-lite": "reject", "rg-retrieval": "reject", "misc-helper": "revise" }, { dropPassed: true }),
+  });
+  assert.equal(report.passed, false);
+  const good = report.results.find((item) => item.name === "good-description");
+  assert.equal(good?.ok, false);
+  assert.equal(good?.actual, "pass（缺 passed 理由）");
+  const text = renderSelftestReport(report);
+  assert.ok(text.startsWith(`【红】${UNTRUSTED_NOTE}`), "红字必须在首行");
+  assert.match(text, /✗ good-description/);
+});
+
 test("有一个被 pass → passed:false，报告首行是红字", async () => {
   const dir = tmpDir();
   const report = await runSelftest({
     evolutionDir: dir,
     cwd: dir,
     fixturesDir: FIXTURES,
-    spawnFn: spawnBySkill({ "ui-verify-lite": "reject", "rg-retrieval": "reject", "misc-helper": "pass" }),
-    pollMs: 1,
+    spawnFn: spawnBySkill({ "ui-verify-lite": "reject", "rg-retrieval": "reject", "misc-helper": "pass", "log-helper": "pass" }),
   });
   assert.equal(report.passed, false);
   const text = renderSelftestReport(report);
@@ -83,11 +118,11 @@ test("单个样本就 pass（其余 reject）也判不可信", async () => {
     evolutionDir: dir,
     cwd: dir,
     fixturesDir: FIXTURES,
-    spawnFn: spawnBySkill({ "ui-verify-lite": "pass", "rg-retrieval": "reject", "misc-helper": "revise" }),
-    pollMs: 1,
+    spawnFn: spawnBySkill({ "ui-verify-lite": "pass", "rg-retrieval": "reject", "misc-helper": "revise", "log-helper": "pass" }),
   });
   assert.equal(report.passed, false);
-  assert.equal(report.results.filter((item) => item.ok).length, 2);
+  // 四个样本里 3 条命中（含正样本）也不算过：只要有一个坏样本被放行就是不可信
+  assert.equal(report.results.filter((item) => item.ok).length, 3);
 });
 
 test("fixture 缺 change.diff 被跳过，不猜也不补", () => {

package/extensions/skill-evolve/test/web-redesign.test.ts

@@ -144,7 +144,7 @@ test("徽章：七种状态各一色（待入队灰 / 待审批蓝 / 复盘中
   assert.match(pendingCase("stale", "跑了 10 小时"), /<span class="badge red" title="跑了 10 小时">卡死<\/span>/);
   assert.match(doneCase("applied"), /<span class="badge green" title="">已采纳<\/span>/);
   assert.match(doneCase("rejected"), /<span class="badge darkred" title="">已拒绝<\/span>/);
-  assert.match(doneCase("rolledback"), /<span class="badge faint" title="">已回滚<\/span>/);
+  assert.match(doneCase("rolled-back"), /<span class="badge faint" title="">已回滚<\/span>/);
   assert.match(doneCase("failed"), /<span class="badge red" title="">失败<\/span>/);
 });
 

package/extensions/skill-evolve/test/web-render-run.test.ts

@@ -43,7 +43,15 @@ function detail(parts: Partial<RunDetail> = {}): RunDetail {
     diff: DIFF_TEXT,
     candidateSkill: "demo",
     candidateText: "---\nname: demo\n---\n# 改后\n",
-    review: { status: "rejected", verdict: "revise", action: "forbidden", reviewerModel: "deepseek/deepseek-flash" },
+    // 默认形态 = 仓库里真实的老 run（354df7db-1794133942）：03-review.json 没有 summary / passed
+    review: {
+      status: "rejected",
+      verdict: "revise",
+      action: "forbidden",
+      reviewerModel: "deepseek/deepseek-flash",
+      summary: null,
+      legacy: true,
+    },
     blocking: [
       {
         issue: "描述承诺大于正文能力",
@@ -52,6 +60,7 @@ function detail(parts: Partial<RunDetail> = {}): RunDetail {
         quote: "<script> 引用",
       },
     ],
+    passed: [],
     gates: [
       { gate: "gate0", name: "授权核对", ok: true, detail: "" },
       { gate: "gate3", name: "复验", ok: false, detail: "复验失败" },
@@ -101,11 +110,71 @@ test("评审结论：verdict/action/模型 + blocking 表格（file:line 与引
   assert.match(html, /verdict <b class="fail">revise<\/b>/);
   assert.match(html, /action <b>forbidden<\/b>/);
   assert.match(html, /<code>deepseek\/deepseek-flash<\/code>/);
+  assert.match(html, /<h3>阻断意见<\/h3>/);
   assert.match(html, /<td>描述承诺大于正文能力<\/td><td><code>\.pi\/skills\/demo\/SKILL\.md:3<\/code><\/td>/);
   assert.match(html, /&lt;script&gt; 引用/, "引用原文也要转义");
   assert.equal(html.includes('"blocking"'), false, "blocking 要做成表格，不许把 JSON 直接倒出来");
 });
 
+test("评审结论：summary 用大一号的字单独一行，排在 verdict 之后、理由表之前", () => {
+  const html = renderRunPage(
+    detail({ review: { ...detail().review!, summary: "因为 description 承诺了正文没有的能力", legacy: false } }),
+    { state: state() },
+  );
+  assert.match(html, /<p class="verdict-summary">因为 description 承诺了正文没有的能力<\/p>/);
+  const summaryAt = html.indexOf('class="verdict-summary"');
+  assert.ok(summaryAt > html.indexOf('class="kv-line"'), "摘要要在 verdict 那一行之后");
+  assert.ok(summaryAt < html.indexOf("<h3>阻断意见</h3>"), "摘要要在理由表之前");
+});
+
+test("评审结论：通过时列通过理由表（通过点 + 证据），不写阻断意见段", () => {
+  const html = renderRunPage(
+    detail({
+      status: "reviewed",
+      review: { status: "reviewed", verdict: "pass", action: "auto", reviewerModel: "m", summary: "新增条款只约束脚本用法，未碰原有禁令", legacy: false },
+      blocking: [],
+      passed: [{ point: "没有删除任何明确禁止项", file: "<b>", line: 5, quote: "一律用 rg" }],
+    }),
+    { state: state() },
+  );
+  assert.match(html, /verdict <b class="ok">pass<\/b>/);
+  assert.match(html, /<h3>通过理由<\/h3>/);
+  assert.match(html, /<th>通过点<\/th>/);
+  assert.match(html, /<td>没有删除任何明确禁止项<\/td>/);
+  assert.match(html, /&lt;b&gt;:5/, "证据里的尖括号也要转义");
+  assert.equal(html.includes("阻断意见"), false, "没有 blocking 就没有阻断意见段");
+});
+
+test("评审结论：旧 run 没有 summary / passed 时显示兜底文案，不把空表当结论", () => {
+  const html = renderRunPage(detail(), { state: state() });
+  assert.match(html, /该 run 由旧版评审产出，没有结论摘要（重跑一次就有）/);
+  assert.equal(html.includes("通过理由"), false);
+  assert.equal(html.includes("只写了结论，没写理由"), false, "旧 run 已有兜底文案，不再叠一句");
+});
+
+test("评审结论：新版评审失败（无 summary，但写了 passed 键）说「没给理由」，不说成旧版", () => {
+  const html = renderRunPage(
+    detail({
+      status: "review_failed",
+      review: { status: "review_failed", verdict: "（未写 verdict）", action: "（未写 action）", reviewerModel: "m", summary: null, legacy: false },
+      blocking: [],
+      passed: [],
+    }),
+    { state: state() },
+  );
+  assert.match(html, /这一轮评审只写了结论，没写理由/);
+  assert.equal(html.includes("旧版评审产出"), false, "新版评审失败不能标成旧版");
+});
+
+test("评审结论：新版评审两个理由表都空时说「只写了结论，没写理由」，不要说成旧版", () => {
+  const html = renderRunPage(
+    detail({ review: { ...detail().review!, summary: "跳过评审（配置关闭）", legacy: false }, blocking: [], passed: [] }),
+    { state: state() },
+  );
+  assert.match(html, /03-review\.json 里没有 blocking \/ passed：这一轮评审只写了结论，没写理由。/);
+  assert.equal(html.includes("旧版评审产出"), false);
+});
+
 test("五闸：逐条 ok/fail 上色，失败那条带说明", () => {
   const html = renderRunPage(detail(), { state: state() });
   assert.match(html, /<td><code>gate0<\/code><\/td><td>授权核对<\/td><td class="ok">ok<\/td>/);

package/extensions/skill-evolve/test/web-run-detail.test.ts

@@ -61,6 +61,8 @@ function fullRun(): { evolutionDir: string; runDir: string } {
     action: "forbidden",
     reviewerModel: "deepseek/deepseek-flash",
     reviewedAt: NOW + 5_000,
+    // 新版契约：结论要带一句「为什么」，通过理由也落盘
+    summary: "描述承诺了正文没有的能力",
     notes: "证据不足",
     blocking: [
       {
@@ -69,6 +71,7 @@ function fullRun(): { evolutionDir: string; runDir: string } {
       },
       { issue: "缺少证据", evidence: {} },
     ],
+    passed: [{ point: "没有删除原有禁令", evidence: { file: ".pi/skills/demo/SKILL.md", line: 9, quote: "一律用 rg" } }],
   });
   writeJson(path.join(runDir, "04-decision.json"), { status: "rejected", approver: "auto", at: NOW + 6_000 });
   writeJson(path.join(runDir, "06-verify.json"), {
@@ -133,8 +136,13 @@ test("readRunDetail：六块证据（概要 / diff / 候选全文 / 评审 / 五
     verdict: "revise",
     action: "forbidden",
     reviewerModel: "deepseek/deepseek-flash",
+    summary: "描述承诺了正文没有的能力",
+    legacy: false,
   });
   assert.equal(detail.blocking.length, 2);
+  assert.equal(detail.passed.length, 1, "通过理由要能读出来（revise 也可能有没问题的点）");
+  assert.equal(detail.passed[0]!.point, "没有删除原有禁令");
+  assert.equal(detail.passed[0]!.line, 9);
   assert.equal(detail.blocking[0]!.line, 3, "证据行号要能直接跳过去");
   assert.match(detail.blocking[1]!.issue, /缺少证据/);
   assert.equal(detail.blocking[1]!.file, "", "缺 evidence 的文件位置不能编一个");
@@ -154,6 +162,25 @@ test("readRunDetail：六块证据（概要 / diff / 候选全文 / 评审 / 五
   assert.equal(detail.notes, "只差两处");
 });
 
+test("readRunDetail：旧 run 的 03-review.json 没有 summary / passed 时不抛，读成 null / 空数组", () => {
+  // 真实样本：.pi/evolution/runs/354df7db-1794133942（v0.1.9 之前产出的评审记录）
+  const { evolutionDir, runDir } = workspace();
+  writeJson(path.join(runDir, "run.json"), { runId: RUN_ID, status: "rejected", trigger: "auto", dispatchedAt: NOW });
+  writeJson(path.join(runDir, "03-review.json"), {
+    status: "rejected",
+    verdict: "revise",
+    action: "forbidden",
+    reviewerModel: "deepseek/deepseek-flash",
+    notes: "旧版只有 notes",
+    blocking: [{ issue: "旧版意见", evidence: { file: "a.md", line: 1, quote: "x" } }],
+  });
+  const detail = readRunDetail(evolutionDir, RUN_ID)!;
+  assert.equal(detail.review?.summary, null, "缺字段就是 null，不编也不抛");
+  assert.equal(detail.review?.legacy, true, "两个键都没有才算旧记录，详情页要据此说旧版");
+  assert.deepEqual(detail.passed, []);
+  assert.equal(detail.blocking.length, 1);
+});
+
 test("readRunDetail：runId 不合法（../、绝对路径、子路径）一律 null，不读盘越界", () => {
   const { evolutionDir } = fullRun();
   for (const runId of ["../x", "../../etc", "/etc/passwd", "a/b", "", "."]) {