pi-skill-evolve 0.1.8 → 0.1.10

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>`;
 }
 

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-filter-labels.test.ts

@@ -1,18 +1,19 @@
 /**
- * 筛选栏文案的验收测试（用户 2026-11-08：「这里的下拉应该是中文, 但是这个搜索框是干嘛的?」）。
+ * 筛选栏的验收测试（用户 2026-11-08：「这个搜索框的技能和状态不用了吧, 技能不知道用来搜索什么,
+ * 状态应该在顶部 tab 包含了吧」）。
  *
- * 两条口径：
- * 1. 状态下拉的 **value 仍是状态机原文**（URL / 过滤逻辑一个字符都不改），只把给人看的一侧换中文；
- *    中文名与列表徽章必须同一套词，同一个概念全站只能有一个名字。
- * 2. 技能那个输入框是**筛选条件**，不是搜索框也不是下拉：placeholder 必须写成「技能名包含…」，
- *    让人一眼知道「填一部分就够」。
+ * 口径：
+ * 1. 表单**只剩「时间」**一个条件——技能看不出该填什么、状态与顶部 tab 重复，两个都撤掉；
+ * 2. 撤掉的是**输入控件**，不是参数：`?skill=` / `?status=` 仍由 `parseListQuery` 解析，
+ *    技能页点进来、旧书签、代码内部跳转都不会断；
+ * 3. 表单仍是 GET + 保留 `view`，否则一提交就跳出当前页。
  *
  * 纪律：纯字符串断言，不碰文件系统、不起服务。
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
 
-import { parseListQuery, STATUS_LABEL, STATUS_OPTIONS } from "../lib/web/filter.ts";
+import { parseListQuery } from "../lib/web/filter.ts";
 import { renderFilterForm } from "../lib/web/render-controls.ts";
 
 const FILTER = parseListQuery(new URLSearchParams(""));
@@ -22,36 +23,38 @@ function form(): string {
   return renderFilterForm("pending", FILTER, EXTRAS);
 }
 
-test("状态下拉每一项都显示中文，value 保持状态机原文", () => {
+test("筛选栏不再有技能输入框与状态下拉", () => {
   const html = form();
-  for (const status of STATUS_OPTIONS) {
-    assert.ok(html.includes(`value="${status}"`), `value 必须是 ${status}`);
-    assert.ok(html.includes(`>${STATUS_LABEL[status]}<`), `${status} 要显示成 ${STATUS_LABEL[status]}`);
-  }
+  assert.ok(!html.includes('name="skill"'), "技能搜索框已撤掉");
+  assert.ok(!html.includes('name="status"'), "状态下拉已撤掉（顶部 tab 就是状态）");
+  assert.ok(!html.includes("全部状态"));
+  assert.ok(!html.includes("全部技能"));
 });
 
-test("状态下拉里不出现英文状态词", () => {
+test("时间筛选还在，且三个档位齐全", () => {
   const html = form();
-  const select = html.slice(html.indexOf('name="status"'), html.indexOf("</select>", html.indexOf('name="status"')));
-  for (const status of STATUS_OPTIONS) {
-    assert.ok(!select.includes(`>${status}<`), `不应再出现英文项 >${status}<`);
+  assert.ok(html.includes('name="range"'));
+  for (const label of ["最近 7 天", "最近 30 天", "全部时间"]) {
+    assert.ok(html.includes(`>${label}<`), `缺时间档位：${label}`);
   }
 });
 
-test("中文标签覆盖七个可选状态，且没有空值", () => {
-  assert.equal(Object.keys(STATUS_LABEL).length, STATUS_OPTIONS.length);
-  for (const label of Object.values(STATUS_LABEL)) assert.ok(label.trim().length > 0);
+test("表单仍是 GET，且保留 view", () => {
+  const html = form();
+  assert.ok(html.includes('method="get"'));
+  assert.ok(html.includes('<input type="hidden" name="view" value="pending">'));
 });
 
-test("技能输入框的 placeholder 说明它是筛选条件", () => {
-  const html = form();
-  assert.ok(html.includes('name="skill"'));
-  assert.ok(html.includes('placeholder="技能名包含…"'), "要告诉人这里填的是「技能名的一部分」");
-  assert.ok(!html.includes('placeholder="全部技能"'), "旧 placeholder 让人误以为是静态字段");
+test("参数没被删：URL 里的 skill / status 仍然生效", () => {
+  const parsed = parseListQuery(new URLSearchParams("skill=deploy-test&status=stale&range=30d"));
+  assert.equal(parsed.skill, "deploy-test");
+  assert.equal(parsed.status, "stale");
+  assert.equal(parsed.range, "30d");
 });
 
-test("筛选表单仍然是 GET + 保留 view", () => {
-  const html = form();
-  assert.ok(html.includes('method="get"'));
-  assert.ok(html.includes('<input type="hidden" name="view" value="pending">'));
+test("技能页跳过来的链接照旧能带 skill 参数（只是不再有输入框）", () => {
+  const parsed = parseListQuery(new URLSearchParams("skill=ui-verify"));
+  const html = renderFilterForm("reports", parsed, EXTRAS);
+  assert.ok(!html.includes('name="skill"'));
+  assert.equal(parsed.skill, "ui-verify", "筛选逻辑要能吃到链接里的技能");
 });