pi-skill-evolve 0.1.9 → 0.1.11

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/dispatch-types.ts

@@ -51,7 +51,7 @@ export type DispatchOutcome =
   | { status: "dispatched"; run: DispatchedRun }
   | {
       status: "skipped";
-      why: "disabled" | "cap" | "lock" | "lock-error" | "selftest-failed" | "busy";
+      why: "disabled" | "cap" | "lock" | "lock-error" | "selftest-failed" | "busy" | "pi-not-found";
       ownerPid: number | null;
     }
   | { status: "superseded"; rounds: number }

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

@@ -16,7 +16,7 @@ import { acquireLock, releaseLock, writeOwnerSync } from "./lock.ts";
 import { buildPrompt, readPromptTemplateSync } from "./prompt.ts";
 import { writeRunRecord } from "./runs.ts";
 import { writeSessionIndex } from "./session-index.ts";
-import { CHILD_LOG, resolvePiBin, spawnDetached, uniqueRunId, sessionHashOf } from "./spawn-plan.ts";
+import { CHILD_LOG, isExecutableFile, resolvePiBin, spawnDetached, uniqueRunId, sessionHashOf } from "./spawn-plan.ts";
 import { mergePendingRounds } from "./pending.ts";
 import { watchRunChild } from "./run-watch.ts";
 import { spawnReviewSupervisor } from "./review-spawn.ts";
@@ -160,6 +160,23 @@ export function createDispatcher(deps: DispatchDeps): Dispatcher {
     lockHeld = true;
 
     try {
+      // 先验 pi 真的可执行：spawn 的 ENOENT 是**异步** emit 的，早于收尸 listener 挂载，
+      // 会把整个 pi 进程 uncaughtException 打死（2026-11-09 写死路径事故）。宁可不派，也不炸宿主。
+      // 注入了 spawnFn = 单测/嵌入式宿主，路径由调用方自负，这里不做磁盘校验。
+      const piBin = resolvePiBin(env);
+      if (!deps.spawnFn && !isExecutableFile(piBin)) {
+        log(`[skill-evolve] 未派生：找不到可执行的 pi（${piBin}）。设 SKILL_EVOLVE_PI_BIN 或先装好 pi`);
+        deps.telemetry.append({
+          kind: "skipped",
+          sessionId: input.sessionId,
+          why: "pi-not-found",
+          ownerPid: lock.owner?.pid ?? null,
+          trigger,
+        });
+        await releaseOnce();
+        return { status: "skipped", why: "pi-not-found", ownerPid: lock.owner?.pid ?? null };
+      }
+
       const indexFile = path.join(runDir, "00-session", "index.json");
       const sessionFile = input.sessionFile ?? carried?.sessionFile;
       let evidenceMode: RunRecord["evidenceMode"] = "telemetry-only";
@@ -199,7 +216,6 @@ export function createDispatcher(deps: DispatchDeps): Dispatcher {
         dispatchedAt: at,
         coverage,
       });
-      const piBin = resolvePiBin(env);
       const spawnFn: SpawnLike = deps.spawnFn ?? (spawn as unknown as SpawnLike);
       const child = spawnDetached(spawnFn, piBin, ["-p", "--no-session", "-ns", prompt], {
         cwd: deps.cwd,
@@ -207,6 +223,11 @@ export function createDispatcher(deps: DispatchDeps): Dispatcher {
         // stdout+stderr 落到 run 目录：子进程怎么死的，只有这份日志答得出来
         logFile: path.join(runDir, CHILD_LOG),
       });
+      // 兜底 listener：spawn 仍可能失败（权限、架构不匹配），没 listener 的 error 事件在 Node 里
+      // 会直接抛成 uncaughtException。真正的收尸仍由 watchRunChild 负责，这里只保证不炸宿主。
+      child.once("error", (error) => {
+        log(`[skill-evolve] 复盘子进程启动失败：${String(error)}`);
+      });
 
       record.pid = child.pid ?? null;
       await writeRunRecord(runDir, record, deps.queue);
@@ -258,6 +279,8 @@ export function createDispatcher(deps: DispatchDeps): Dispatcher {
         ...(deps.reviewModel ? { reviewModel: deps.reviewModel } : {}),
         ...(deps.supervisorSpawnFn ? { supervisorSpawnFn: deps.supervisorSpawnFn } : {}),
         ...(deps.alive ? { alive: deps.alive } : {}),
+        // 注入了 spawnFn = 单测/嵌入式宿主：路径由调用方自负，退出补发也不做磁盘校验
+        ...(deps.spawnFn ? { piBinExists: () => true } : {}),
         log,
       },
       at,

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

@@ -26,6 +26,8 @@ export interface DrainPendingOptions {
   reviewModel?: () => string;
   supervisorSpawnFn?: SupervisorSpawn;
   alive?: (pid: number) => boolean;
+  /** pi 可执行文件判定（dispatch 注入假 spawnFn 时直接传「都在」，单测不碰真磁盘） */
+  piBinExists?: (candidate: string) => boolean;
   log: (msg: string) => void;
 }
 
@@ -49,6 +51,7 @@ export function drainPending(pending: Map<string, PendingRounds>, options: Drain
           ...(options.reviewModel ? { reviewModel: options.reviewModel() } : {}),
           ...(options.supervisorSpawnFn ? { supervisorSpawnFn: options.supervisorSpawnFn } : {}),
           ...(options.alive ? { alive: options.alive } : {}),
+          ...(options.piBinExists ? { piBinExists: options.piBinExists } : {}),
           log: options.log,
         },
         at,

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/shutdown-dispatch.ts

@@ -13,7 +13,7 @@ import { acquireLockSync, releaseLockSync, writeOwnerSync } from "./lock.ts";
 import { buildPrompt, readPromptTemplateSync } from "./prompt.ts";
 import { spawnReviewSupervisor, type SupervisorSpawn } from "./review-spawn.ts";
 import { guardBusy } from "./single-flight.ts";
-import { CHILD_LOG, uniqueRunId, sessionHashOf, resolvePiBin, spawnDetached, type SpawnLike } from "./spawn-plan.ts";
+import { CHILD_LOG, isExecutableFile, uniqueRunId, sessionHashOf, resolvePiBin, spawnDetached, type SpawnLike } from "./spawn-plan.ts";
 import { writeRunRecordSync, type RunRecord } from "./runs.ts";
 import { writeSessionIndexSync } from "./session-index.ts";
 import type { TelemetryWriter } from "./telemetry.ts";
@@ -46,6 +46,8 @@ export interface ShutdownDeps {
   supervisorSpawnFn?: SupervisorSpawn;
   /** pid 存活判定（全局单飞闸用；单测注入，测试里不起真子进程） */
   alive?: (pid: number) => boolean;
+  /** pi 可执行文件判定（默认查真磁盘；单测注入避开机器差异） */
+  piBinExists?: (candidate: string) => boolean;
   log: (msg: string) => void;
 }
 
@@ -88,6 +90,23 @@ export function flushPendingSync(item: PendingRounds, deps: ShutdownDeps, now: n
   });
   if (occupant) return "skipped";
 
+  // 退出补发同样先验 pi 可执行：spawn 的 ENOENT 是异步 emit，没有 listener 就直接 uncaughtException，
+  // 那会把「正常退出」变成「崩溃退出」（2026-11-09 写死路径事故就是这条路径炸的）
+  const piBin = resolvePiBin(deps.env);
+  if (!(deps.piBinExists ?? isExecutableFile)(piBin)) {
+    deps.telemetry.appendSync({
+      kind: "skipped",
+      ts: now,
+      sessionId: item.sessionId,
+      why: "pi-not-found",
+      trigger: "shutdown",
+      ownerPid: null,
+      rounds: item.rounds,
+    });
+    deps.log(`[skill-evolve] 退出补发放弃：找不到可执行的 pi（${piBin}）`);
+    return "skipped";
+  }
+
   const runId = uniqueRunId(deps.evolutionDir, item.sessionId, now);
   const runDir = path.join(deps.evolutionDir, "runs", runId);
   const lock = acquireLockSync({
@@ -150,12 +169,16 @@ export function flushPendingSync(item: PendingRounds, deps: ShutdownDeps, now: n
       dispatchedAt: now,
       coverage: record.coverage,
     });
-    const child = spawnDetached(deps.spawnFn, resolvePiBin(deps.env), ["-p", "--no-session", "-ns", prompt], {
+    const child = spawnDetached(deps.spawnFn, piBin, ["-p", "--no-session", "-ns", prompt], {
       cwd: deps.cwd,
       env: { ...deps.env, SKILL_EVOLVE_CHILD: "1" },
       // 退出前补发这条路径最容易“静默失败”：日志落盘才知道子进程到底起没起来
       logFile: path.join(runDir, CHILD_LOG),
     });
+    // 异步 emit 的 error 没 listener 会直接炸进程；主进程马上要退出，这里只求不把退出变成崩溃
+    child.once("error", (error) => {
+      deps.log(`[skill-evolve] 退出补发子进程启动失败：${String(error)}`);
+    });
     childPid = child.pid ?? null;
 
     record.pid = childPid;

package/extensions/skill-evolve/lib/spawn-plan.ts

@@ -6,10 +6,38 @@
  */
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 
-/** pi 不能靠 PATH 找：GUI / 非交互环境里 PATH 常常没有它 */
-export const DEFAULT_PI_BIN = "/home/suveng/.pi/agent/bin/pi";
+/**
+ * 兜底 pi 路径：按**当前用户 home** 拼，绝不写死某个人的家目录。
+ *
+ * 2026-11-09 事故：v0.1.10 把 Linux 家目录 `/home/suveng/.pi/agent/bin/pi` 写成常量，
+ * 换到 macOS 上 spawn 直接 ENOENT；而 spawn 的 error 事件是**异步** emit 的，
+ * 那一刻还没人挂 listener，于是 uncaughtException 把整个 pi 进程打死。
+ */
+export const DEFAULT_PI_BIN = path.join(os.homedir(), ".pi", "agent", "bin", "pi");
+
+/** 可执行文件判定：不存在 / 无执行权限 / 是目录都算「不可用」，一律不抛 */
+export function isExecutableFile(candidate: string): boolean {
+  try {
+    if (!fs.statSync(candidate).isFile()) return false;
+    fs.accessSync(candidate, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** 在 PATH 里找 pi：GUI / 非交互启动的 pi 常常带着不完整的 PATH，所以只作第二选择 */
+function findOnPath(name: string, env: NodeJS.ProcessEnv, exists: (candidate: string) => boolean): string | null {
+  const dirs = (env.PATH ?? "").split(path.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    const candidate = path.join(dir, name);
+    if (exists(candidate)) return candidate;
+  }
+  return null;
+}
 
 export interface SpawnedChild {
   pid?: number;
@@ -20,8 +48,23 @@ export interface SpawnedChild {
 
 export type SpawnLike = (command: string, args: string[], options: Record<string, unknown>) => SpawnedChild;
 
-export function resolvePiBin(env: NodeJS.ProcessEnv = process.env): string {
-  return env.SKILL_EVOLVE_PI_BIN || env.PI_SUBAGENT_PI_BINARY || DEFAULT_PI_BIN;
+export interface ResolvePiBinOptions {
+  /** 单测注入的存在性判定（默认查真磁盘） */
+  exists?: (candidate: string) => boolean;
+  /** 可执行文件名（Windows 上是 pi.cmd / pi.exe，默认 "pi"） */
+  name?: string;
+}
+
+/**
+ * pi 路径解析顺序：显式环境变量 → home 下的 `.pi/agent/bin/pi` → PATH 里的 `pi` → 兜底常量。
+ * 返回的路径**不保证存在**（调用方要用 isExecutableFile 先验一次，别直接 spawn）。
+ */
+export function resolvePiBin(env: NodeJS.ProcessEnv = process.env, options: ResolvePiBinOptions = {}): string {
+  const explicit = env.SKILL_EVOLVE_PI_BIN || env.PI_SUBAGENT_PI_BINARY;
+  if (explicit) return explicit;
+  const exists = options.exists ?? isExecutableFile;
+  if (exists(DEFAULT_PI_BIN)) return DEFAULT_PI_BIN;
+  return findOnPath(options.name ?? "pi", env, exists) ?? DEFAULT_PI_BIN;
 }
 
 /** 复盘子进程的日志文件名（落在 run 目录下，与 run.json 同级） */

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） */