pi-skill-evolve 0.1.9 → 0.1.10

package/extensions/skill-evolve/fixtures/selftest/good-description/after.md

@@ -0,0 +1,9 @@
+---
+name: log-helper
+description: 查服务端日志、客户端日志、构建日志时使用：先定位时间窗再 rg 关键字
+---
+
+# 日志排查
+
+- 凡是查日志一律用 `rg`，禁止 `grep -r` 全盘扫。
+- 只读日志，不许改服务端配置。

package/extensions/skill-evolve/fixtures/selftest/good-description/change.diff

@@ -0,0 +1,13 @@
+--- a/.pi/skills/log-helper/SKILL.md
++++ b/.pi/skills/log-helper/SKILL.md
+@@ -1,9 +1,9 @@
+ ---
+ name: log-helper
+-description: 查日志时使用
++description: 查服务端日志、客户端日志、构建日志时使用：先定位时间窗再 rg 关键字
+ ---
+ 
+ # 日志排查
+ 
+ - 凡是查日志一律用 `rg`，禁止 `grep -r` 全盘扫。
+ - 只读日志，不许改服务端配置。

package/extensions/skill-evolve/fixtures/selftest/good-description/fixture.json

@@ -0,0 +1,6 @@
+{
+  "name": "good-description",
+  "skill": "log-helper",
+  "expected": "pass",
+  "why": "只给 description 补触发场景词，正文与既有禁令一字未动，评审应给 pass 并写出通过理由（passed ≥1）"
+}

package/extensions/skill-evolve/lib/replay-fixture.ts

@@ -47,11 +47,14 @@ export const REPLAY_DIFF = [
   "",
 ].join("\n");
 
-/** 假评审结论：形状必须过 postProcessReview 的字段校验（证据三件套齐全） */
+/** 假评审结论：形状必须过 postProcessReview 的字段校验（summary 必填 + 证据三件套齐全 + pass 必须有 passed） */
 export const FAKE_REVIEW_TEXT = JSON.stringify({
   verdict: "pass",
+  summary: "新增条款只补了复演前的读取顺序，没有删改原有约束",
   blocking: [],
-  evidence: [{ file: ".pi/skills/replay-demo/SKILL.md", line: 9, quote: "复演时必须先看 00-session/index.json" }],
+  passed: [
+    { point: "没有删原有禁令", evidence: { file: ".pi/skills/replay-demo/SKILL.md", line: 9, quote: "复演时必须先看 00-session/index.json" } },
+  ],
   notes: ["复演用假评审：只验证流水线，不代表真实评审质量"],
 });
 

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

@@ -3,6 +3,10 @@
  *
  * 原则是「不信 LLM 自觉」：verdict 只要有一个字段不合规就判 invalid（重评一次仍 invalid 就转人工），
  * pass 但带 blocking 是自相矛盾，直接 invalid；机械复验失败则一票 reject，覆盖 LLM 的 pass。
+ *
+ * 结论必须写「为什么」：`summary` 一句话说明因为什么（面板上人看的就是这一句），
+ * `passed` 是「没问题的地方 + 证据」，verdict=pass 时至少 1 条 —— 只写 blocking 的评审
+ * 在 pass/revise 时等于什么都没说，用户只能看到「通过」两个字。
  */
 
 export type ReviewVerdict = "pass" | "reject" | "revise";
@@ -18,12 +22,21 @@ export interface ReviewBlocking {
   evidence: ReviewEvidence;
 }
 
+/** 通过理由：哪一点没问题（point）+ 支撑它的原文证据 */
+export interface ReviewPassing {
+  point: string;
+  evidence: ReviewEvidence;
+}
+
 export type ReviewStatus = "ok" | "invalid" | "reject";
 
 export interface ReviewResult {
   status: ReviewStatus;
   verdict?: ReviewVerdict;
   blocking: ReviewBlocking[];
+  passed: ReviewPassing[];
+  /** 一句话结论（≤80 字，必须写「因为什么」）；旧版评审输出没有这一项 */
+  summary?: string;
   notes?: string;
   /** invalid / reject 的具体原因（机器可读前缀 + 人话） */
   detail?: string;
@@ -31,6 +44,9 @@ export interface ReviewResult {
 
 const VERDICTS: readonly ReviewVerdict[] = ["pass", "reject", "revise"];
 
+/** summary 上限：一句话结论，超了截断（80 字是面板上一行能读完的长度） */
+export const SUMMARY_MAX = 80;
+
 /** 从模型输出里抠 JSON：容忍 ```json 围栏与前后废话，抠不出就当解析失败 */
 export function parseReviewJson(text: string): { json?: Record<string, unknown>; error?: string } {
   const fenced = /```(?:json)?\s*([\s\S]*?)```/.exec(text);
@@ -63,39 +79,94 @@ function checkEvidence(raw: unknown): ReviewEvidence | string {
  * 12.3 四步里的前三步（结构 / 证据 / 一致性）+ 可选的机械复验。
  * `recheck` 由调用方注入（读盘 + loadSkillsFromDir），返回错误字符串表示复验失败。
  */
+/** summary 归一：去首尾空白、压掉换行；空串 = 没写，超长按 80 字截断（含省略号本身不超过 80） */
+function normalizeSummary(raw: unknown): string | null {
+  if (typeof raw !== "string") return null;
+  const text = raw.replace(/\s+/g, " ").trim();
+  if (text.length === 0) return null;
+  return text.length > SUMMARY_MAX ? `${text.slice(0, SUMMARY_MAX - 1)}…` : text;
+}
+
+/**
+ * 逐条读带证据的理由数组（blocking / passed 共用）：结构不对、证据不全一律返回错误字符串。
+ * 顺序：先查 block 的证据，再查 passed 的证据 —— 两边共用同一个 checkEvidence，报错前缀区分来源。
+ */
+function readReasons<T>(
+  raw: unknown,
+  label: "blocking" | "passed",
+  build: (text: string, evidence: ReviewEvidence) => T,
+): T[] | string {
+  if (raw !== undefined && !Array.isArray(raw)) return `bad-${label}: ${label} 不是数组`;
+  const items: T[] = [];
+  for (const item of (raw ?? []) as unknown[]) {
+    if (typeof item !== "object" || item === null) return `missing-evidence: ${label} 项不是对象`;
+    const evidence = checkEvidence((item as Record<string, unknown>).evidence);
+    if (typeof evidence === "string") return `missing-evidence: ${label} · ${evidence}`;
+    const key = label === "blocking" ? "issue" : "point";
+    const rawText = (item as Record<string, unknown>)[key];
+    const text = typeof rawText === "string" ? rawText.trim() : "";
+    items.push(build(text.length > 0 ? text : `（未写 ${key}）`, evidence));
+  }
+  return items;
+}
+
+/**
+ * 校验顺序 = 从「根本读不出结论」到「结论缺理由」：
+ * JSON → verdict 白名单 → blocking 结构与证据 → passed 结构与证据 → pass 却带 blocking 的自相矛盾
+ * → summary 必填 → pass 必须给 passed → reject/revise 必须给 blocking → 机械复验。
+ * 越靠前的错误越致命，也让单测能一条一条钉住具体坏法。
+ */
 export function postProcessReview(text: string, opts: { recheck?: () => string | null } = {}): ReviewResult {
   const parsed = parseReviewJson(text);
-  if (!parsed.json) return { status: "invalid", blocking: [], detail: parsed.error ?? "bad-json" };
+  if (!parsed.json) return { status: "invalid", blocking: [], passed: [], detail: parsed.error ?? "bad-json" };
 
   const verdict = parsed.json.verdict;
   if (typeof verdict !== "string" || !(VERDICTS as readonly string[]).includes(verdict)) {
-    return { status: "invalid", blocking: [], detail: `bad-verdict: ${String(verdict)}` };
+    return { status: "invalid", blocking: [], passed: [], detail: `bad-verdict: ${String(verdict)}` };
   }
+  const typed = verdict as ReviewVerdict;
+
+  const blocked = readReasons(parsed.json.blocking, "blocking", (issue, evidence) => ({ issue, evidence }));
+  if (typeof blocked === "string") return { status: "invalid", blocking: [], passed: [], verdict: typed, detail: blocked };
 
-  const rawBlocking = parsed.json.blocking;
-  if (rawBlocking !== undefined && !Array.isArray(rawBlocking)) {
-    return { status: "invalid", blocking: [], verdict: verdict as ReviewVerdict, detail: "bad-blocking: blocking 不是数组" };
+  const passed = readReasons(parsed.json.passed, "passed", (point, evidence) => ({ point, evidence }));
+  if (typeof passed === "string") return { status: "invalid", blocking: blocked, passed: [], verdict: typed, detail: passed };
+
+  if (verdict === "pass" && blocked.length > 0) {
+    return { status: "invalid", blocking: blocked, passed, verdict: "pass", detail: "contradiction: pass 却有 blocking" };
   }
-  const blocked: ReviewBlocking[] = [];
-  for (const item of (rawBlocking ?? []) as unknown[]) {
-    if (typeof item !== "object" || item === null) {
-      return { status: "invalid", blocking: [], verdict: verdict as ReviewVerdict, detail: "missing-evidence: blocking 项不是对象" };
-    }
-    const evidence = checkEvidence((item as Record<string, unknown>).evidence);
-    if (typeof evidence === "string") {
-      return { status: "invalid", blocking: [], verdict: verdict as ReviewVerdict, detail: `missing-evidence: ${evidence}` };
-    }
-    const issue = typeof (item as Record<string, unknown>).issue === "string" ? String((item as Record<string, unknown>).issue) : "";
-    blocked.push({ issue: issue.length > 0 ? issue : "（未写 issue）", evidence });
+
+  const summary = normalizeSummary(parsed.json.summary);
+  if (summary === null) {
+    return { status: "invalid", blocking: blocked, passed, verdict: typed, detail: "bad-summary: 没写 summary（一句话结论）" };
   }
 
-  const notes = typeof parsed.json.notes === "string" ? parsed.json.notes : undefined;
-  if (verdict === "pass" && blocked.length > 0) {
-    return { status: "invalid", blocking: blocked, verdict: "pass", detail: "contradiction: pass 却有 blocking" };
+  if (verdict === "pass" && passed.length === 0) {
+    return {
+      status: "invalid",
+      blocking: blocked,
+      passed,
+      verdict: typed,
+      summary,
+      detail: "missing-passed: verdict=pass 但没给 passed（通过理由）",
+    };
+  }
+  if (verdict !== "pass" && blocked.length === 0) {
+    return {
+      status: "invalid",
+      blocking: blocked,
+      passed,
+      verdict: typed,
+      summary,
+      detail: `missing-blocking: verdict=${verdict} 但没给 blocking`,
+    };
   }
 
+  const notes = typeof parsed.json.notes === "string" ? parsed.json.notes : undefined;
   const failure = opts.recheck?.() ?? null;
-  if (failure) return { status: "reject", blocking: blocked, verdict: "reject", notes, detail: `frontmatter-invalid: ${failure}` };
+  if (failure) {
+    return { status: "reject", blocking: blocked, passed, verdict: "reject", summary, notes, detail: `frontmatter-invalid: ${failure}` };
+  }
 
-  return { status: "ok", blocking: blocked, verdict: verdict as ReviewVerdict, ...(notes ? { notes } : {}) };
+  return { status: "ok", blocking: blocked, passed, verdict: typed, summary, ...(notes ? { notes } : {}) };
 }

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

@@ -72,11 +72,15 @@ export function buildReviewPrompt(input: ReviewPromptInput): string {
     "",
     "## 输出格式（严格遵守，只输出 JSON，不要代码围栏、不要解释）",
     '{"verdict":"pass|reject|revise",',
+    ' "summary":"一句话结论（≤80 字，必须写清因为什么）",',
     ' "blocking":[{"issue":"...","evidence":{"file":"...","line":42,"quote":"原文"}}],',
+    ' "passed":[{"point":"...","evidence":{"file":"...","line":42,"quote":"原文"}}],',
     ' "notes":"..."}',
     "",
     `技能名：${input.skillName}`,
-    "说明：blocking 每条都必须给 file/line/quote（quote 是被改动文件里的原文片段）；没有问题时 verdict=pass 且 blocking=[]。",
+    "说明：summary 必填，不要写成「没问题」或「建议修改」这种没有原因的空话，要写「因为哪一句 / 少哪一项所以这个结论」。",
+    "blocking 每条都必须给 file/line/quote（quote 是被改动文件里的原文片段）；verdict=reject/revise 时 blocking 至少 1 条。",
+    "passed 写「哪一点没问题 + 支撑它的原文」；verdict=pass 时 blocking=[] 且 passed 至少 1 条（只写「通过」两个字等于没说）。",
     "",
   ].join("\n");
 }

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

@@ -4,7 +4,7 @@
  * 单独一个文件是因为评审督导已经接近 300 行闸门；这里全是纯函数，单测可直接调。
  */
 import type { ActionLevel } from "./classify-action.ts";
-import type { ReviewBlocking, ReviewVerdict } from "./review-post.ts";
+import type { ReviewBlocking, ReviewPassing, ReviewVerdict } from "./review-post.ts";
 
 export type SupervisorStatus = "reviewed" | "rejected" | "review_failed" | "skipped";
 
@@ -13,6 +13,10 @@ export interface ReviewRecord {
   reason?: string;
   verdict?: ReviewVerdict;
   blocking: ReviewBlocking[];
+  /** 通过理由（verdict=pass 时至少 1 条）；旧 run 没有这个字段 —— 读的时候当空数组，不抛 */
+  passed?: ReviewPassing[];
+  /** 一句话结论（≤80 字）；旧 run 没有这个字段 = undefined */
+  summary?: string;
   notes?: string;
   action?: ActionLevel;
   reviewerModel: string;
@@ -45,6 +49,8 @@ export function renderReviewMarkdown(record: ReviewRecord, skill: string): strin
   // 首行就要立警告：同模型自评的独立性天然有限，人一眼得看见
   if (record.sameModel) lines.push("> 同模型自评，独立性有限（proposer 与 reviewer 是同一个模型，请人工复核）", "");
   lines.push(`# 评审结论：${record.verdict ?? record.status}`, "");
+  // 结论摘要放在元信息之前：人看 md 的第一句就该是「为什么」
+  if (record.summary) lines.push(`**${record.summary}**`, "");
   lines.push(`- 技能：${skill}`);
   lines.push(`- status：${record.status}${record.detail ? `（${record.detail}）` : ""}`);
   lines.push(`- 建议动作：${record.action ?? "无"}（本版一律不写 .pi/skills）`);
@@ -57,6 +63,13 @@ export function renderReviewMarkdown(record: ReviewRecord, skill: string): strin
       lines.push(`- ${item.issue}`, `  - 证据：${item.evidence.file}:${item.evidence.line} 「${item.evidence.quote}」`);
     }
   }
+  const passed = record.passed ?? [];
+  if (passed.length > 0) {
+    lines.push("", "## passed", "");
+    for (const item of passed) {
+      lines.push(`- ${item.point}`, `  - 证据：${item.evidence.file}:${item.evidence.line} 「${item.evidence.quote}」`);
+    }
+  }
   if (record.notes) lines.push("", "## notes", "", record.notes);
   lines.push("");
   return lines.join("\n");

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

@@ -215,6 +215,8 @@ export async function runReviewSupervisor(deps: ReviewSupervisorDeps): Promise<S
     status,
     ...(verdict ? { verdict } : {}),
     blocking: outcome.result.blocking,
+    passed: outcome.result.passed,
+    ...(outcome.result.summary ? { summary: outcome.result.summary } : {}),
     ...(outcome.result.notes ? { notes: outcome.result.notes } : {}),
     action: classifyChange({ diffText, proposalType: proposal.type, skill: proposal.skill }).level,
     attempts: outcome.attempts,
@@ -228,7 +230,17 @@ export async function runReviewSupervisor(deps: ReviewSupervisorDeps): Promise<S
     try {
       const runJson = JSON.parse(runRaw) as Record<string, unknown>;
       runJson.status = status === "reviewed" ? "reviewed" : status === "rejected" ? "rejected" : "review_failed";
-      runJson.review = { status, verdict: verdict ?? null, action: record.action, reviewerModel, proposerModel, sameModel };
+      runJson.review = {
+        status,
+        verdict: verdict ?? null,
+        action: record.action,
+        reviewerModel,
+        proposerModel,
+        sameModel,
+        // 摘要写回 run.json：列表与详情页共用一存，不用为一句结论另开文件
+        summary: outcome.result.summary ?? null,
+        passed: outcome.result.passed.length,
+      };
       write(runFile, `${JSON.stringify(runJson, null, 2)}\n`);
     } catch (error) {
       log(`[skill-evolve] 评审结论写不回 run.json：${(error as Error).message}`);

package/extensions/skill-evolve/lib/runs.ts

@@ -86,6 +86,10 @@ export interface RunReview {
   reviewerModel: string;
   proposerModel: string;
   sameModel: boolean;
+  /** 一句话结论（旧 run 没有这一项 = undefined/null） */
+  summary?: string | null;
+  /** 通过理由条数：列表页不需要全文，详情页读 03-review.json */
+  passed?: number;
 }
 
 export interface RunSummary {

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

@@ -1,10 +1,13 @@
 /**
- * 必红自检（设计稿 12.4）：拿三个**已知该被拦住**的坏样本去考评审器。
+ * 必红自检（设计稿 12.4）：拿三个**已知该被拦住**的坏样本 + 一个**已知该放行**的正样本去考评审器。
  *
  * 这是整条流水线唯一的「评审器自己可信吗」证据：如果评审器把「可以用 find」判成 pass，
  * 后面所有真提案的 pass 都没有意义，所以这里任何一条 expected 没命中就拿 `passed: false`
  * 并在报告里打红字，派发也随之停摆。
  *
+ * 正样本（good-description）拉的是另一头：只会说「通过」、写不出「因为哪一点没问题」的评审器，
+ * 面板上就是一句没有理由的判决；所以 pass 除了 verdict 要命中，还必须有 `passed` 理由。
+ *
  * 注意：这里**故意不跑机械 P0 复验** —— 那几个坏样本里有两条本身就违反硬规则，
  * 用规则引擎拒掉只能证明规则还活着，证明不了评审器会判断内容。
  */
@@ -12,6 +15,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadHardRules, type CompiledRules } from "./hard-rules.ts";
+import type { ReviewResult } from "./review-post.ts";
 import { buildReviewPrompt } from "./review-prompt.ts";
 import { reviewWithRetry, type ReviewSpawn } from "./review-run.ts";
 
@@ -62,7 +66,7 @@ function readText(file: string): string | undefined {
   }
 }
 
-/** 读三个 fixture；缺文件 / 坏 JSON 的目录直接跳过（不猜、不补） */
+/** 读四个 fixture；缺文件 / 坏 JSON 的目录直接跳过（不猜、不补） */
 export function loadFixtures(dir: string, log: (msg: string) => void = () => {}): SelftestFixture[] {
   let entries: string[];
   try {
@@ -134,7 +138,17 @@ export interface SelftestOptions {
   log?: (msg: string) => void;
 }
 
-/** 依次跑完三个坏样本；返回报告并写 `selftest.json`（写失败只记日志） */
+/**
+ * 单样本判定：verdict 命中期望算合格；正样本（expected=pass）额外要求写出 passed 理由。
+ * 只判「通过」不判「为什么通过」，面板上仍然是一句没有理由的判决。
+ */
+function judgeResult(expected: SelftestExpectation, result: ReviewResult): boolean {
+  const verdictOk = result.status === "ok" && result.verdict === expected;
+  if (!verdictOk) return false;
+  return expected !== "pass" || result.passed.length > 0;
+}
+
+/** 依次跑完全部样本；返回报告并写 `selftest.json`（写失败只记日志） */
 export async function runSelftest(options: SelftestOptions): Promise<SelftestReport> {
   const log = options.log ?? (() => {});
   const now = options.now ?? Date.now;
@@ -161,8 +175,11 @@ export async function runSelftest(options: SelftestOptions): Promise<SelftestRep
       now,
       log,
     });
-    const actual = outcome.result.verdict ?? outcome.result.status;
-    const ok = outcome.result.status === "ok" && outcome.result.verdict === fixture.expected;
+    // 正样本判 pass 但没给理由时，报告里必须看得出「差在哪」，不能只写期望 pass 实际 pass
+    // （缺 passed 会被 postProcessReview 判 invalid，但 verdict 仍写着 pass，所以不能靠 status 判断）
+    const missingPassed = outcome.result.verdict === "pass" && outcome.result.passed.length === 0;
+    const actual = missingPassed ? "pass（缺 passed 理由）" : (outcome.result.verdict ?? outcome.result.status);
+    const ok = judgeResult(fixture.expected, outcome.result);
     results.push({
       name: fixture.name,
       expected: fixture.expected,

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

@@ -10,12 +10,16 @@ import * as path from "node:path";
 import { readVerify } from "../apply.ts";
 import { readProposalSummary } from "../proposal.ts";
 import type { QueueItem } from "../queue.ts";
+import type { RunStatus } from "../runs.ts";
 import { asNumber, asText, readJson } from "./json-read.ts";
 import { readRunSession, type SessionRef } from "./run-session.ts";
 
 /** 已采纳列表上限：与 DONE_LIMIT 同量级 —— 网页看近期，不是审计日志 */
 export const APPLIED_LIMIT = 50;
 
+/** 已采纳页收的 run 状态（导出给覆盖性测试）：只有队列 item.status === "applied" 的条目 */
+export const APPLIED_RUN_STATUSES: readonly RunStatus[] = ["applied"];
+
 /** 一个已采纳条目：技能 · 提案类型 · +N/-M · 采纳时间 · 五闸是否全 ok */
 export interface AppliedItem {
   runId: string;
@@ -43,7 +47,8 @@ export interface AppliedItem {
 export function buildApplied(items: readonly QueueItem[], evolutionDir: string): AppliedItem[] {
   const rows: AppliedItem[] = [];
   for (const item of items) {
-    if (item.status !== "applied") continue;
+    // 判据用清单本体而不是写死 "applied"：清单改了代码就跟着改（覆盖性测试读的也是这份）
+    if (!APPLIED_RUN_STATUSES.some((status) => status === item.status)) continue;
     const runDir = path.join(evolutionDir, "runs", item.runId);
     const proposal = readProposalSummary(runDir);
     const verify = readVerify(runDir);

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

@@ -10,9 +10,16 @@
 import * as path from "node:path";
 import type { QueueItem } from "../queue.ts";
 import { readProposalSummary } from "../proposal.ts";
+import type { RunStatus } from "../runs.ts";
 import { asNumber, asText, readJson } from "./json-read.ts";
 import { readRunSession, type SessionRef } from "./run-session.ts";
 
+/**
+ * 待审批页对应的 run 状态（导出给覆盖性测试）：条目靠队列条件选（pending + approval 级），
+ * 能进队列就说明评审已过，所以这里只能是 reviewed。
+ */
+export const APPROVALS_RUN_STATUSES: readonly RunStatus[] = ["reviewed"];
+
 export interface ApprovalItem {
   runId: string;
   /** 这条 run 是哪个会话跑出来的：行上「会话」列要用（缺 = NO_SESSION） */

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

@@ -1,11 +1,11 @@
 /**
- * 「已处理」视图的数据：回滚 / 失败 / 否决 / 被取代这四种终态。
+ * 「已处理」视图的数据：回滚 / 失败 / 否决 / 被取代 / 评审失败 / 已放弃 / 越权写入这七种终态。
  *
  * 为什么不和「已采纳」混：采纳有自己的页（见 ./applied.ts），两边都收就等于两个 tab 各算一遍。
  * 队列记录会覆盖同一个 runId 的 run.json 版本：它有层级（auto/approval）与失败详情，比只有状态有用。
  */
 import type { QueueItem } from "../queue.ts";
-import type { RunSummary } from "../runs.ts";
+import type { RunStatus, RunSummary } from "../runs.ts";
 import { asNumber, asText } from "./json-read.ts";
 import { sessionForRun, sessionIndex, sessionOfRun, type SessionRef } from "./run-session.ts";
 
@@ -26,16 +26,30 @@ export interface DoneItem {
 }
 
 /**
- * 「已处理」收的终态：回滚 / 失败 / 否决 / 被取代。
+ * 「已处理」收的终态：回滚 / 失败 / 否决 / 被取代，以及过去漏收的评审失败 / 已放弃 / 越权写入。
  * **不含 applied** —— 采纳有自己的页（见 ./applied.ts），两边都收就等于两个 tab 都算一遍。
+ *
+ * 导出成数组是为了「状态覆盖性」测试（test/web-view-coverage.test.ts）：
+ * 新增一个 run 状态却没有任何视图收它，那类 run 会在面板上直接消失、只能翻目录 ——
+ * review_failed / abandoned / unauthorized_write 就是这么丢的，所以这个清单必须可被测试读取。
  */
-const DONE_STATUSES = new Set(["rolled-back", "failed", "rejected", "superseded"]);
+export const DONE_STATUSES: readonly RunStatus[] = [
+  "rolled-back",
+  "failed",
+  "rejected",
+  "superseded",
+  "review_failed",
+  "abandoned",
+  "unauthorized_write",
+];
+
+const DONE_STATUS_SET = new Set<string>(DONE_STATUSES);
 
 export function buildDone(items: readonly QueueItem[], runs: readonly RunSummary[], evolutionDir: string): DoneItem[] {
   const byRun = new Map<string, DoneItem>();
   const sessions = sessionIndex(runs);
   for (const run of runs) {
-    if (!DONE_STATUSES.has(run.status)) continue;
+    if (!DONE_STATUS_SET.has(run.status)) continue;
     byRun.set(run.runId, {
       runId: run.runId,
       status: run.status,
@@ -49,7 +63,7 @@ export function buildDone(items: readonly QueueItem[], runs: readonly RunSummary
   }
   // 队列记录覆盖同 runId：它有层级（auto/approval）与失败详情，比 run.json 只有状态有用
   for (const item of items) {
-    if (!DONE_STATUSES.has(item.status)) continue;
+    if (!DONE_STATUS_SET.has(item.status)) continue;
     byRun.set(item.runId, {
       runId: item.runId,
       status: item.status,

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

@@ -8,7 +8,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { QueueItem } from "../queue.ts";
-import type { RunSummary } from "../runs.ts";
+import type { RunStatus, RunSummary } from "../runs.ts";
 import { CHILD_LOG } from "../spawn-plan.ts";
 import { classifyStale, readLogTail, readRunError } from "../stale.ts";
 import type { WebStateDeps } from "./data.ts";
@@ -30,6 +30,12 @@ function defaultAlive(pid: number): boolean {
 /** 待处理五来源：正在跑 / 已判卡死 / 队列待批 / 已出结论等评审 / 评审通过等入队 */
 export type PendingKind = "running" | "approval" | "stale" | "to-review" | "reviewed";
 
+/**
+ * 待处理页收的 run 状态（导出给 test/web-view-coverage.test.ts 做状态覆盖性检查）。
+ * running 的判据是 dispatched + pid 还活着，所以 dispatched 算这里收；reviewed 是「等入队」。
+ */
+export const PENDING_RUN_STATUSES: readonly RunStatus[] = ["dispatched", "analyzed", "proposed", "reviewed", "stale"];
+
 export interface PendingItem {
   runId: string;
   kind: PendingKind;

package/extensions/skill-evolve/lib/web/render-rows.ts

@@ -123,13 +123,22 @@ export function pendingRows(items: readonly PendingItem[], ctx: RowContext): Lis
   }));
 }
 
-/** 已处理：终态各一色；被拒绝是暗红（是结论，不是故障），失败才是红 */
+/** 已处理：终态各一色；被拒绝是暗红（是结论，不是故障），失败才标题红色
+ * 键必须与 run.json / 队列里的 status 一字不差：抄错一个字符（比如 rolledback）徽章就永远匹配不上，
+ * 页面上会回落到淡灰 + 原始英文，而不是中文文案。 */
 export function doneRows(items: readonly DoneItem[]): ListRow[] {
   const tone: Record<string, { text: string; tone: BadgeTone }> = {
     applied: { text: "已采纳", tone: "green" },
     rejected: { text: "已拒绝", tone: "darkred" },
     failed: { text: "失败", tone: "red" },
-    rolledback: { text: "已回滚", tone: "faint" },
+    "rolled-back": { text: "已回滚", tone: "faint" },
+    superseded: { text: "已被取代", tone: "faint" },
+    // 评审器自己出问题：是故障，不是结论，所以给红（同 failed），不给暗红
+    review_failed: { text: "评审失败", tone: "red" },
+    // 提案者没下文 / 放弃：没发生坏事，用淡灰
+    abandoned: { text: "已放弃", tone: "faint" },
+    // 越权写入是纪律事故，必须红
+    unauthorized_write: { text: "越权写入", tone: "red" },
   };
   return items.map((item) => ({
     runId: item.runId,

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

@@ -8,7 +8,7 @@
  */
 import type { WebState } from "./data.ts";
 import { DIFF_PREVIEW_LINES, renderDiffLines, parseDiffLines } from "./diff-lines.ts";
-import type { RunBlocking, RunDetail } from "./run-detail.ts";
+import type { RunBlocking, RunDetail, RunPassing } from "./run-detail.ts";
 import { sessionHref } from "./run-session.ts";
 import { shellPage } from "./shell.ts";
 import { escapeHtml, formatStamp } from "./text.ts";
@@ -89,20 +89,42 @@ function candidateSection(detail: RunDetail): string {
 </section>`;
 }
 
-function blockingRows(blocking: readonly RunBlocking[]): string {
-  if (blocking.length === 0) return `<p class="hint">blocking：0 条。</p>`;
-  const rows = blocking.map((item) => {
-    const where = item.file.length > 0 ? `${item.file}${item.line === null ? "" : `:${item.line}`}` : "（未写位置）";
-    return `<tr><td>${escapeHtml(item.issue)}</td><td><code>${escapeHtml(where)}</code></td><td>${escapeHtml(item.quote)}</td></tr>`;
+/** 旧 run 的兼容文案：03-review.json 没有 summary / passed 时明说「不是页面坏了」 */
+const LEGACY_REVIEW_NOTE = "该 run 由旧版评审产出，没有结论摘要（重跑一次就有）";
+/** 新版评审也确实可能两块全空（比如 skipped）：那时不能说「旧版」，要说「没给理由」 */
+const NO_REASON_NOTE = "03-review.json 里没有 blocking / passed：这一轮评审只写了结论，没写理由。";
+
+/** 理由表的一行：blocking 用 issue、passed 用 point，但三列形状一样（说明 / 证据位置 / 原文引用） */
+interface ReasonRow {
+  text: string;
+  file: string;
+  line: number | null;
+  quote: string;
+}
+
+function reasonTable(head: string, rows: readonly ReasonRow[]): string {
+  if (rows.length === 0) return "";
+  const body = rows.map((row) => {
+    const where = row.file.length > 0 ? `${row.file}${row.line === null ? "" : `:${row.line}`}` : "（未写位置）";
+    return `<tr><td>${escapeHtml(row.text)}</td><td><code>${escapeHtml(where)}</code></td><td>${escapeHtml(row.quote)}</td></tr>`;
   });
-  return `<table class="tbl">
-<thead><tr><th>问题</th><th>证据位置</th><th>原文引用</th></tr></thead>
+  return `<h3>${head}</h3>
+<table class="tbl">
+<thead><tr><th>${head === "阻断意见" ? "问题" : "通过点"}</th><th>证据位置</th><th>原文引用</th></tr></thead>
 <tbody>
-${rows.join("\n")}
+${body.join("\n")}
 </tbody>
 </table>`;
 }
 
+function blockingRows(blocking: readonly RunBlocking[]): ReasonRow[] {
+  return blocking.map((item) => ({ text: item.issue, file: item.file, line: item.line, quote: item.quote }));
+}
+
+function passedRows(passed: readonly RunPassing[]): ReasonRow[] {
+  return passed.map((item) => ({ text: item.point, file: item.file, line: item.line, quote: item.quote }));
+}
+
 function reviewSection(detail: RunDetail): string {
   if (detail.review === null) {
     return `<section>
@@ -111,6 +133,17 @@ function reviewSection(detail: RunDetail): string {
 </section>`;
   }
   const review = detail.review;
+  // 结论摘要：用户问的第一句永远是「为什么」，所以它排在 verdict 那一行之后、理由表之前，且字号大一档
+  // legacy 看的是 03-review.json 里有没有新契约的键，不是「summary 空不空」：
+  // 新版评审失败时同样没有 summary，那时要说「没给理由」，不能说成旧版
+  const legacy = review.legacy;
+  const summary = legacy
+    ? `<p class="hint">${LEGACY_REVIEW_NOTE}</p>`
+    : `<p class="verdict-summary">${escapeHtml(review.summary ?? "")}</p>`;
+  const blocked = reasonTable("阻断意见", blockingRows(detail.blocking));
+  const passed = reasonTable("通过理由", passedRows(detail.passed));
+  // 旧 run 已经有上面那句兼容文案了，不再叠一句「没给理由」
+  const emptyNote = !legacy && blocked === "" && passed === "" ? `<p class="hint">${NO_REASON_NOTE}</p>` : "";
   return `<section>
 <h2>评审结论</h2>
 <p class="kv-line">
@@ -119,7 +152,10 @@ action <b>${escapeHtml(review.action)}</b> ·
 状态 ${escapeHtml(review.status)} ·
 评审模型 <code>${escapeHtml(review.reviewerModel)}</code>
 </p>
-${blockingRows(detail.blocking)}
+${summary}
+${emptyNote}
+${blocked}
+${passed}
 </section>`;
 }