pi-skill-evolve 0.1.11 → 0.1.12

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

@@ -0,0 +1,127 @@
+/**
+ * 督导运行目录：把督导要用的 `.ts` 拷到 `node_modules` 之外再跑。
+ *
+ * 2026-11-09 事故：`node --experimental-strip-types` 对 **node_modules 下的 .ts 一律拒绝**
+ * （`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`）。扩展按本地 `.pi/extensions/*.ts` 装时一切正常，
+ * 一旦按 npm 包装进 `.pi/npm/node_modules/`，评审督导一启动就崩在 import 那一步 ——
+ * 结果 `autoReview` / `autoApply` 全成了装饰品，用户只看到 run 停在 analyzed。
+ *
+ * 解法：首次使用时把督导的源目录整份复制到 `<evolutionDir>/runtime/supervisor/<key>/`（普通目录，
+ * 类型剥离不再受限），再从那里起进程。`key` 由版本 + 入口文件 mtime/size 组成，升级自动换目录，
+ * 旧目录顺手清掉；拷贝失败（只读盘等）就退回原路径，行为不比现在更差。
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/** 运行目录名：`<evolutionDir>/runtime/supervisor/` */
+export const RUNTIME_DIRNAME = "supervisor";
+
+/** 缓存键里的稳定前缀：node_modules 路径太长，只留可读的一段 */
+const KEY_PREFIX = "lib";
+
+/** 只拷源码：测试、fixture、日志都不该跟着搬 */
+const COPY_FILTER = (src: string): boolean => !/(\.test\.|\.spec\.|\.log$|\.json\.tmp)/.test(src);
+
+export interface RuntimeOptions {
+  /** `.pi/evolution`：运行目录挂在它下面，随工作区走，不污染 node_modules */
+  evolutionDir: string;
+  /** 包内督导入口绝对路径（review-spawn 的 SUPERVISOR_SCRIPT） */
+  scriptPath: string;
+  /** 包版本：参与缓存键，升级后自动重建 */
+  version?: string;
+  log?: (msg: string) => void;
+}
+
+/** 只有 node_modules 里的 .ts 需要搬家；本地 `.pi/extensions` 安装原路径直接用 */
+export function needsCopy(scriptPath: string): boolean {
+  return /[\\/]node_modules[\\/]/.test(scriptPath);
+}
+
+/** 缓存键：版本 + 入口文件大小/mtime —— 内容一变就换目录，不需要手工清缓存 */
+export function runtimeKey(scriptPath: string, version?: string): string {
+  const parts: string[] = [KEY_PREFIX];
+  const label = version ?? packageVersionOf(scriptPath);
+  if (label && /^[0-9A-Za-z._-]+$/.test(label)) parts.push(label);
+  try {
+    const stat = fs.statSync(scriptPath);
+    parts.push(String(stat.size), String(Math.trunc(stat.mtimeMs)));
+  } catch {
+    parts.push("unknown"); // 读不到 stat 也不抛：目录照样能建，只是键退化成常量
+  }
+  return parts.join("-");
+}
+
+/** 包版本：找不到 package.json 就返回空串（只影响缓存键的写法，不影响能否跑） */
+export function packageVersionOf(scriptPath: string): string {
+  let dir = path.dirname(scriptPath);
+  for (let i = 0; i < 6; i += 1) {
+    try {
+      const raw = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")) as { version?: unknown };
+      if (typeof raw.version === "string") return raw.version;
+      return "";
+    } catch {
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return "";
+}
+
+/** 目标目录（导出给面板 / 测试用，不产生副作用） */
+export function runtimeDirOf(evolutionDir: string, key: string): string {
+  return path.join(evolutionDir, "runtime", RUNTIME_DIRNAME, key);
+}
+
+/**
+ * 返回**可以直接 spawn 的督导入口路径**：
+ * node_modules 里 → 复制后的副本；其它位置 → 原路径。
+ */
+export function ensureSupervisorRuntime(options: RuntimeOptions): string {
+  const { scriptPath } = options;
+  if (!needsCopy(scriptPath)) return scriptPath;
+  const key = runtimeKey(scriptPath, options.version);
+  const target = runtimeDirOf(options.evolutionDir, key);
+  const entry = path.join(target, path.basename(scriptPath));
+  // 已经有完整副本（.ready 与入口都在）就直接复用：督导每次派发都要解析一次路径，不能每次都拷 700KB
+  if (fs.existsSync(path.join(target, ".ready")) && fs.existsSync(entry)) return entry;
+  const source = path.dirname(scriptPath);
+  try {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    // 先拷到临时目录再 rename：两个 run 同时派发时不会读到半份源码
+    const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
+    fs.rmSync(tmp, { recursive: true, force: true });
+    fs.cpSync(source, tmp, { recursive: true, filter: COPY_FILTER });
+    fs.writeFileSync(path.join(tmp, ".ready"), `${key}\n`, "utf8");
+    try {
+      fs.renameSync(tmp, target);
+    } catch (error) {
+      // 另一个进程刚好建好了同一个 key：以它的为准，清掉自己这份临时目录
+      fs.rmSync(tmp, { recursive: true, force: true });
+      if (!fs.existsSync(entry)) throw error;
+    }
+    pruneOldRuntimes(path.dirname(target), key);
+    return entry;
+  } catch (error) {
+    options.log?.(`[skill-evolve] 督导运行目录准备失败（回退到原路径，评审仍会失败）：${String(error)}`);
+    return scriptPath;
+  }
+}
+
+/** 清掉同一个父目录下的旧 key：升级后旧副本没人用，留着只会占空间 */
+function pruneOldRuntimes(parent: string, keep: string): void {
+  let names: string[];
+  try {
+    names = fs.readdirSync(parent);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (name === keep || name.includes(".tmp-")) continue;
+    try {
+      fs.rmSync(path.join(parent, name), { recursive: true, force: true });
+    } catch {
+      // 别的进程正在用（Windows 上 rename 会撞）：下次再清
+    }
+  }
+}

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

@@ -8,6 +8,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { QueueItem } from "../queue.ts";
+import { buildPipeline, renderPipelineLine } from "../pipeline.ts";
 import type { RunStatus, RunSummary } from "../runs.ts";
 import { CHILD_LOG } from "../spawn-plan.ts";
 import { classifyStale, readLogTail, readRunError } from "../stale.ts";
@@ -80,6 +81,17 @@ function runningItem(
     mtime === null
       ? "最近输出：（还没有输出）"
       : `最近输出：${Math.max(0, Math.round((now - mtime) / 1000))}s 前 · 末行：${lastLine.length > 0 ? lastLine : "（还没有输出）"}`;
+  // 五段进度：光写「复盘产出中」看不出是卡在分析还是卡在提案（用户 2026-11-09 的真实困惑）
+  const pipeline = renderPipelineLine(
+    buildPipeline({
+      runDir: path.join(evolutionDir, "runs", run.runId),
+      status: run.status,
+      pid: run.pid,
+      supervisorPid: run.supervisorPid,
+      dispatchedAt: run.dispatchedAt,
+      alive,
+    }),
+  );
   return {
     runId: run.runId,
     kind: "running",
@@ -88,6 +100,7 @@ function runningItem(
     at: run.dispatchedAt,
     detail: [
       `阶段：${reviewing ? "评审中" : "复盘产出中"}`,
+      `流水线：${pipeline}`,
       `进程：pid ${run.pid} · 已跑 ${duration(now - (run.dispatchedAt ?? now))}（上限 ${Math.round(maxRuntimeMs / 60_000)} 分钟）`,
       progressLine,
       `日志：tail -f .pi/evolution/runs/${run.runId}/${CHILD_LOG}`,

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

@@ -6,6 +6,7 @@
  *
  * 六块各自的空态都要写明「缺的是哪个文件」—— 一句「暂无数据」会让人以为页面坏了。
  */
+import { renderPipelineLine, type Pipeline, type PipelineStage } from "../pipeline.ts";
 import type { WebState } from "./data.ts";
 import { DIFF_PREVIEW_LINES, renderDiffLines, parseDiffLines } from "./diff-lines.ts";
 import type { RunBlocking, RunDetail, RunPassing } from "./run-detail.ts";
@@ -210,6 +211,41 @@ ${more}
 </section>`;
 }
 
+/** 五段格子的短状态词：格子窄，只用四个字以内 */
+const STAGE_WORD: Record<PipelineStage["state"], string> = {
+  done: "完成",
+  running: "进行中",
+  waiting: "等待",
+  blocked: "卡住",
+  failed: "失败",
+  skipped: "跳过",
+};
+
+/**
+ * 流水线：页面顶部那一排。放在概要**之前**是因为用户点进详情页的第一个问题永远是
+ * 「它现在到哪一步了」，而不是「pid 是多少」。每格给状态词 + 明细，卡住的那格直接写出下一步谁接手。
+ */
+function pipelineSection(pipeline: Pipeline): string {
+  const cells = pipeline.stages
+    .map((stage) => {
+      const at = stage.at === null ? "" : `<span class="pt">${escapeHtml(formatStamp(stage.at))}</span>`;
+      return `<li class="stage s-${stage.state}">
+<span class="pl">${escapeHtml(stage.label)}</span>
+<span class="ps">${escapeHtml(STAGE_WORD[stage.state])}</span>
+<span class="pd">${escapeHtml(stage.detail)}</span>
+${at}
+</li>`;
+    })
+    .join("\n");
+  return `<section>
+<h2>流水线</h2>
+<p class="hint">${escapeHtml(renderPipelineLine(pipeline))} · ${escapeHtml(pipeline.hint)}</p>
+<ol class="pipe">
+${cells}
+</ol>
+</section>`;
+}
+
 export interface RenderRunOptions {
   /** 状态栏要的数字（shell.ts 的 statusBar 唯一依赖） */
   state: WebState;
@@ -221,6 +257,7 @@ export function renderRunPage(detail: RunDetail, options: RenderRunOptions): str
   const back = options.back ?? { view: "pending", label: "待处理" };
   const body = `<main class="run">
 <p class="hint"><a href="/?view=${escapeHtml(back.view)}">← 回${escapeHtml(back.label)}</a></p>
+${pipelineSection(detail.pipeline)}
 ${overview(detail)}
 ${diffSection(detail)}
 ${candidateSection(detail)}

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

@@ -14,7 +14,10 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ServerResponse } from "node:http";
 import { readVerify } from "../apply.ts";
+import { loadConfig } from "../config.ts";
+import { buildPipeline, type Pipeline } from "../pipeline.ts";
 import { readProposalSummary } from "../proposal.ts";
+import { readQueue } from "../queue.ts";
 import type { RunRecord } from "../runs.ts";
 import { asNumber, asRecord, asText, readJson, reasonLabel } from "./json-read.ts";
 import { sendText, TEXT_TYPE } from "./http.ts";
@@ -95,6 +98,8 @@ export interface RunDetail {
   findings: RunFinding[];
   findingsTotal: number;
   notes: string;
+  /** 五段流水线（派发→分析→提案→评审→采纳）：页面顶部那排格子 */
+  pipeline: Pipeline;
 }
 
 function readTextFile(file: string): string | null {
@@ -229,6 +234,20 @@ export function readRunDetail(evolutionDir: string, runId: string): RunDetail |
   const reviewAt = asNumber(asRecord(readJson<unknown>(path.join(runDir, "03-review.json")))?.reviewedAt);
   const stamps = [decision, verifyAt, reviewAt].filter((value): value is number => value !== null);
   const hasChildLog = exists(path.join(runDir, "child.log"));
+  // 流水线：pid 存活按 run.json 记的两个 pid，队列状态按 queue.json（不在队列 = null）
+  // 开关来自 config.json —— 面板只读，读配置也只是想知道「为什么这步被跳过了」
+  const config = loadConfig(evolutionDir);
+  const queued = readQueue(evolutionDir).find((item) => item.runId === runId)?.status ?? null;
+  const pipeline = buildPipeline({
+    runDir,
+    status: asText(record?.status, ""),
+    pid: asNumber(record?.pid),
+    supervisorPid: asNumber(record?.supervisorPid),
+    dispatchedAt: asNumber(record?.dispatchedAt),
+    queued,
+    autoReview: config.autoReview,
+    autoApply: config.autoApply,
+  });
   return {
     runId,
     status: asText(record?.status, "（无 run.json）"),
@@ -245,6 +264,7 @@ export function readRunDetail(evolutionDir: string, runId: string): RunDetail |
     ...review,
     ...gates,
     ...findings,
+    pipeline,
   };
 }
 

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

@@ -113,6 +113,24 @@ 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 }
+/* 流水线：五格等宽，颜色只表达状态（绿=完成、黄=在跑、蓝=卡住待人、红=失败、灰=等待/跳过）。
+   窄屏自动折成两行，不横向滚动 —— 状态必须一屏看全。 */
+.pipe { display: flex; flex-wrap: wrap; gap: 8px; margin: 8px 0 0; padding: 0; list-style: none }
+.pipe .stage { flex: 1 1 150px; min-width: 140px; padding: 8px 10px; border: 1px solid var(--line);
+  border-top: 2px solid var(--line); border-radius: 6px; background: var(--panel) }
+.pipe .pl { display: block; color: var(--muted); font-size: 12px }
+.pipe .ps { display: block; font-size: 13px; font-weight: 600 }
+.pipe .pd { display: block; margin-top: 2px; color: #aeb7c4; font-size: 12px; line-height: 1.45 }
+.pipe .pt { display: block; margin-top: 4px; color: #5d6675; font-size: 12px }
+.pipe .s-done { border-top-color: var(--green) }
+.pipe .s-done .ps { color: var(--green) }
+.pipe .s-running { border-top-color: var(--yellow) }
+.pipe .s-running .ps { color: var(--yellow) }
+.pipe .s-blocked { border-top-color: var(--blue) }
+.pipe .s-blocked .ps { color: var(--blue) }
+.pipe .s-failed { border-top-color: var(--red) }
+.pipe .s-failed .ps { color: var(--red) }
+.pipe .s-waiting .ps, .pipe .s-skipped .ps { color: var(--muted) }
 /* 评审结论摘要：详情页里唯一「大一号」的正文，用户上来先读这一句 */
 .verdict-summary { margin: 6px 0; font-size: 15px; font-weight: 600; color: var(--fg) }
 a.run { color: #c8d3e6; border-bottom: 1px dashed #45505f }

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

@@ -0,0 +1,141 @@
+/**
+ * 流水线渲染单测：五段各挑一次真实故障当用例 —— 缺 01 / 有提案没督导 / 驳回 / 采纳完 / 自动关着。
+ * 断言只压「状态 + 下一步」，不锁具体措辞（文案会改，状态语义不该改）。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { buildPipeline, pipelineProgress, renderPipelineLine, type PipelineInput } from "../lib/pipeline.ts";
+
+function runDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-pipeline-"));
+}
+
+function write(dir: string, name: string, content: string): void {
+  fs.writeFileSync(path.join(dir, name), content);
+}
+
+function input(dir: string, patch: Partial<PipelineInput> = {}): PipelineInput {
+  return {
+    runDir: dir,
+    status: "analyzed",
+    pid: null,
+    supervisorPid: null,
+    dispatchedAt: 1_800_000_000_000,
+    ...patch,
+  };
+}
+
+const stateOf = (pipeline: ReturnType<typeof buildPipeline>, key: string): string =>
+  pipeline.stages.find((stage) => stage.key === key)?.state ?? "missing";
+
+test("只有 run.json（分析没出结论、子进程也死了）：分析等收尾，不提评审", () => {
+  const dir = runDir();
+  const pipeline = buildPipeline(input(dir, { status: "dispatched" }));
+  assert.equal(stateOf(pipeline, "dispatch"), "done");
+  assert.equal(stateOf(pipeline, "analyze"), "waiting");
+  assert.equal(stateOf(pipeline, "propose"), "waiting");
+  assert.equal(stateOf(pipeline, "review"), "waiting");
+  assert.equal(stateOf(pipeline, "apply"), "waiting");
+  assert.match(pipeline.hint, /下一步「分析」/);
+});
+
+test("分析在跑：分析=进行中，提案=进行中（同一子进程）", () => {
+  const dir = runDir();
+  const pipeline = buildPipeline(input(dir, { status: "dispatched", pid: 4242, alive: (pid) => pid === 4242 }));
+  assert.equal(stateOf(pipeline, "analyze"), "running");
+  assert.equal(stateOf(pipeline, "propose"), "running");
+  assert.match(pipeline.stages[0]!.detail, /4242 在跑/);
+});
+
+test("分析完成没提案：写明「多半判定不该改」，不是错误", () => {
+  const dir = runDir();
+  write(dir, "01-findings.json", "{}");
+  const pipeline = buildPipeline(input(dir));
+  assert.equal(stateOf(pipeline, "analyze"), "done");
+  assert.equal(stateOf(pipeline, "propose"), "waiting");
+  assert.match(pipeline.stages[2]!.detail, /没写提案/);
+  assert.match(pipeline.hint, /下一步「提案」/);
+});
+
+test("提案在、督导已死：评审判 blocked 且指向自动重挂（2026-11-09 事故现场）", () => {
+  const dir = runDir();
+  write(dir, "01-findings.json", "{}");
+  write(dir, "01-findings.json", "{}");
+  write(dir, "02-proposal.json", JSON.stringify({ type: "improve", skill: "demo" }));
+  const pipeline = buildPipeline(input(dir, { autoReview: true }));
+  assert.equal(stateOf(pipeline, "review"), "blocked");
+  assert.match(pipeline.stages[3]!.detail, /下次会话起点自动重挂/);
+  assert.match(pipeline.hint, /下一步「评审」/);
+});
+
+test("提案在、督导在跑：评审=进行中", () => {
+  const dir = runDir();
+  write(dir, "02-proposal.json", JSON.stringify({ type: "improve", skill: "demo" }));
+  const pipeline = buildPipeline(input(dir, { status: "proposed", supervisorPid: 777, alive: (pid) => pid === 777 }));
+  assert.equal(stateOf(pipeline, "review"), "running");
+  assert.match(pipeline.stages[1]!.detail, /01-findings.json/);
+});
+
+test("自动评审关着：评审=跳过而不是卡住", () => {
+  const dir = runDir();
+  write(dir, "01-findings.json", "{}");
+  write(dir, "02-proposal.json", "{}");
+  const pipeline = buildPipeline(input(dir, { autoReview: false }));
+  assert.equal(stateOf(pipeline, "review"), "skipped");
+  assert.match(pipeline.hint, /下一步「采纳」/);
+});
+
+test("评审驳回：采纳=跳过，hint 明说不会采纳", () => {
+  const dir = runDir();
+  write(dir, "01-findings.json", "{}");
+  write(dir, "02-proposal.json", "{}");
+  write(dir, "03-review.json", JSON.stringify({ status: "rejected", verdict: "revise" }));
+  const pipeline = buildPipeline(input(dir, { status: "rejected" }));
+  assert.equal(stateOf(pipeline, "review"), "done");
+  assert.match(pipeline.stages[3]!.detail, /rejected \/ revise/);
+  assert.equal(stateOf(pipeline, "apply"), "skipped");
+  assert.match(pipeline.hint, /驳回|不会采纳|结束/);
+});
+
+test("评审通过 + 队列 pending + 自动采纳开着：采纳=进行中", () => {
+  const dir = runDir();
+  write(dir, "03-review.json", JSON.stringify({ status: "approved", verdict: "accept" }));
+  const pipeline = buildPipeline(input(dir, { status: "approved", queued: "pending", autoApply: true }));
+  assert.equal(stateOf(pipeline, "apply"), "running");
+});
+
+test("评审通过但自动采纳关着：采纳=卡住等人工批准", () => {
+  const dir = runDir();
+  write(dir, "03-review.json", JSON.stringify({ status: "approved" }));
+  const pipeline = buildPipeline(input(dir, { status: "approved", queued: "pending", autoApply: false }));
+  assert.equal(stateOf(pipeline, "apply"), "blocked");
+  assert.match(pipeline.stages[4]!.detail, /等面板批准/);
+});
+
+test("采纳完成：五段全 done，hint 说走完", () => {
+  const dir = runDir();
+  write(dir, "01-findings.json", "{}");
+  write(dir, "02-proposal.json", "{}");
+  write(dir, "03-review.json", JSON.stringify({ status: "approved" }));
+  write(dir, "04-decision.json", "{}");
+  const pipeline = buildPipeline(input(dir, { status: "applied" }));
+  assert.equal(pipeline.stages.every((stage) => stage.state === "done"), true);
+  assert.match(pipeline.hint, /走完/);
+  assert.deepEqual(pipelineProgress(pipeline), { done: 5, total: 5 });
+});
+
+test("卡死状态：分析=失败，不再假装在跑", () => {
+  const dir = runDir();
+  const pipeline = buildPipeline(input(dir, { status: "stale" }));
+  assert.equal(stateOf(pipeline, "analyze"), "failed");
+  assert.deepEqual(pipelineProgress(pipeline), { done: 1, total: 5 });
+});
+
+test("一行进度与符号：派发✓ 分析✗ …", () => {
+  const dir = runDir();
+  const line = renderPipelineLine(buildPipeline(input(dir, { status: "stale" })));
+  assert.equal(line, "派发✓ 分析✗ 提案· 评审· 采纳·");
+});

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

@@ -0,0 +1,153 @@
+/**
+ * 重启恢复单测：这里的每一条断言都对应一次「用户看到已分析却永远没提案」的真实死法。
+ * 纪律是保守：能推状态就推，能重挂督导就重挂，**绝不重跑复盘**。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { recoverRuns, renderRecovery, RECOVER_WINDOW_MS } from "../lib/recover.ts";
+import type { SpawnSupervisorOptions } from "../lib/review-spawn.ts";
+
+const NOW = 1_800_000_000_000;
+const queue = (file: string, run: () => Promise<void>): Promise<void> => run();
+
+function setup(): { evolutionDir: string; write: (runId: string, record: Record<string, unknown>, files?: string[]) => string } {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-recover-"));
+  const evolutionDir = path.join(root, ".pi", "evolution");
+  fs.mkdirSync(path.join(evolutionDir, "runs"), { recursive: true });
+  const write = (runId: string, record: Record<string, unknown>, files: string[] = []): string => {
+    const runDir = path.join(evolutionDir, "runs", runId);
+    fs.mkdirSync(runDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(runDir, "run.json"),
+      JSON.stringify({ runId, status: "dispatched", dispatchedAt: NOW - 60_000, pid: null, supervisorPid: null, ...record }, null, 2),
+    );
+    for (const name of files) fs.writeFileSync(path.join(runDir, name), "{}");
+    return runDir;
+  };
+  return { evolutionDir, write };
+}
+
+function base(deps: Partial<Parameters<typeof recoverRuns>[0]> & { evolutionDir: string }) {
+  return {
+    cwd: "/repo",
+    queue,
+    now: () => NOW,
+    alive: () => false,
+    autoReview: () => true,
+    reviewModel: () => "inherit",
+    log: () => {},
+    ...deps,
+  } as Parameters<typeof recoverRuns>[0];
+}
+
+test("分析产物在但状态还写 dispatched：补成 analyzed，不重跑", async () => {
+  const { evolutionDir, write } = setup();
+  const runDir = write("r-1", { pid: 4242 }, ["01-findings.json"]);
+  const actions = await recoverRuns(base({ evolutionDir, alive: () => false }));
+  assert.deepEqual(actions.map((a) => a.kind), ["advanced-analyzed", "interrupted"]);
+  const record = JSON.parse(fs.readFileSync(path.join(runDir, "run.json"), "utf8")) as { status: string };
+  assert.equal(record.status, "analyzed");
+});
+
+test("提案在、督导已死：重挂一个督导接着评审", async () => {
+  const { evolutionDir, write } = setup();
+  const runDir = write("r-2", { status: "analyzed", pid: null, supervisorPid: 777 }, ["01-findings.json", "02-proposal.json"]);
+  const seen: SpawnSupervisorOptions[] = [];
+  const actions = await recoverRuns(
+    base({
+      evolutionDir,
+      alive: (pid) => pid !== 777, // 只有督导死了
+      spawnSupervisor: (options) => {
+        seen.push(options);
+        return 9999;
+      },
+    }),
+  );
+  assert.deepEqual(actions.map((a) => a.kind), ["supervisor-respawned"]);
+  assert.equal(actions[0]!.detail.includes("9999"), true);
+  assert.equal(seen.length, 1);
+  assert.equal(seen[0]!.runDir, runDir);
+  assert.equal(seen[0]!.autoReview, true, "重挂时明确开着评审");
+  assert.equal(seen[0]!.reviewModel, "inherit");
+});
+
+test("督导还活着：不重挂、不打扰", async () => {
+  const { evolutionDir, write } = setup();
+  write("r-3", { status: "analyzed", supervisorPid: 888 }, ["01-findings.json", "02-proposal.json"]);
+  let spawned = 0;
+  const actions = await recoverRuns(
+    base({
+      evolutionDir,
+      alive: (pid) => pid === 888,
+      spawnSupervisor: () => {
+        spawned += 1;
+        return 1;
+      },
+    }),
+  );
+  assert.deepEqual(actions.map((a) => a.kind), ["waiting-review"]);
+  assert.equal(spawned, 0);
+});
+
+test("自动评审关着：不偷偷打开，只报告待人工", async () => {
+  const { evolutionDir, write } = setup();
+  write("r-4", { status: "analyzed", supervisorPid: 1 }, ["02-proposal.json"]);
+  let spawned = 0;
+  const actions = await recoverRuns(
+    base({
+      evolutionDir,
+      autoReview: () => false,
+      spawnSupervisor: () => {
+        spawned += 1;
+        return 1;
+      },
+    }),
+  );
+  assert.deepEqual(actions.map((a) => a.kind), ["respawn-blocked"]);
+  assert.equal(spawned, 0);
+});
+
+test("复盘子进程还活着且没提案：等它，不插一脚", async () => {
+  const { evolutionDir, write } = setup();
+  write("r-5", { pid: 555 }, []);
+  const actions = await recoverRuns(base({ evolutionDir, alive: (pid) => pid === 555 }));
+  assert.deepEqual(actions.map((a) => a.kind), ["waiting-proposal"]);
+});
+
+test("已有 03-review.json：什么都不做，交给入队/自动采纳", async () => {
+  const { evolutionDir, write } = setup();
+  write("r-6", { status: "proposed" }, ["01-findings.json", "02-proposal.json", "03-review.json"]);
+  const actions = await recoverRuns(base({ evolutionDir }));
+  assert.deepEqual(actions.map((a) => a.kind), ["review-done"]);
+});
+
+test("终态与超窗 run 一律不碰", async () => {
+  const { evolutionDir, write } = setup();
+  write("r-applied", { status: "applied", pid: null }, ["01-findings.json", "02-proposal.json", "03-review.json"]);
+  write("r-old", { status: "analyzed", dispatchedAt: NOW - RECOVER_WINDOW_MS - 1 }, ["02-proposal.json"]);
+  write("r-stale", { status: "stale", pid: null }, ["01-findings.json"]);
+  const actions = await recoverRuns(base({ evolutionDir }));
+  assert.deepEqual(actions, []);
+  assert.equal(renderRecovery([]), "重启恢复：没有需要接手的 run");
+});
+
+test("坏 run.json 当没有，不崩", async () => {
+  const { evolutionDir } = setup();
+  const broken = path.join(evolutionDir, "runs", "r-broken");
+  fs.mkdirSync(broken, { recursive: true });
+  fs.writeFileSync(path.join(broken, "run.json"), "{not json");
+  assert.deepEqual(await recoverRuns(base({ evolutionDir })), []);
+});
+
+test("面板文案带 kinds 与明细", () => {
+  const text = renderRecovery([
+    { runId: "r-1", kind: "supervisor-respawned", detail: "重挂 pid 9" },
+    { runId: "r-2", kind: "interrupted", detail: "没提案" },
+  ]);
+  assert.match(text, /重启恢复：2 条 run 被检查/);
+  assert.match(text, /r-1 {2}重挂督导 — 重挂 pid 9/);
+  assert.match(text, /r-2 {2}已中断 — 没提案/);
+});

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

@@ -7,6 +7,9 @@ import assert from "node:assert/strict";
 import * as path from "node:path";
 import { SUPERVISOR_SCRIPT, spawnReviewSupervisor } from "../lib/review-spawn.ts";
 
+/** 测试里不搬家：直接返回包内入口（搬家用 supervisor-runtime.test.ts 单独覆盖） */
+const direct = ({ scriptPath }: { scriptPath: string }): string => scriptPath;
+
 function capture(): { calls: { command: string; args: string[]; options: Record<string, unknown> }[]; unrefs: number } {
   return { calls: [], unrefs: 0 };
 }
@@ -18,6 +21,7 @@ test("督导用 node + --experimental-strip-types 起，参数里带 runDir", ()
     cwd: "/repo",
     env: {},
     autoReview: true,
+    resolveScript: direct,
     spawnFn: (command, args, options) => {
       seen.calls.push({ command, args, options });
       return {
@@ -45,8 +49,8 @@ test("inherit 不追加 --model，显式模型追加在 runDir 之后", () => {
     explicitArgs.push(args);
     return { pid: 1 };
   };
-  spawnReviewSupervisor({ runDir: "/r", cwd: "/repo", env: {}, autoReview: true, reviewModel: "inherit", spawnFn });
-  spawnReviewSupervisor({ runDir: "/r", cwd: "/repo", env: {}, autoReview: true, reviewModel: "deepseek/deepseek-v3.2", spawnFn });
+  spawnReviewSupervisor({ runDir: "/r", cwd: "/repo", env: {}, autoReview: true, reviewModel: "inherit", spawnFn, resolveScript: direct });
+  spawnReviewSupervisor({ runDir: "/r", cwd: "/repo", env: {}, autoReview: true, reviewModel: "deepseek/deepseek-v3.2", spawnFn, resolveScript: direct });
   assert.deepEqual(inheritArgs[0], ["--experimental-strip-types", SUPERVISOR_SCRIPT, "/r"]);
   assert.deepEqual(explicitArgs[1], ["--experimental-strip-types", SUPERVISOR_SCRIPT, "/r", "deepseek/deepseek-v3.2"]);
 });
@@ -58,6 +62,7 @@ test("env 里去掉 SKILL_EVOLVE_CHILD，其他变量照旧带走", () => {
     cwd: "/repo",
     env: { SKILL_EVOLVE_CHILD: "1", PATH: "/usr/bin" },
     autoReview: true,
+    resolveScript: direct,
     spawnFn: (_command, _args, options) => {
       env = options.env as NodeJS.ProcessEnv;
       return { pid: 1 };
@@ -67,6 +72,27 @@ test("env 里去掉 SKILL_EVOLVE_CHILD，其他变量照旧带走", () => {
   assert.equal(env.PATH, "/usr/bin");
 });
 
+test("督导入口解析拿到 evolutionDir（node_modules 里要搬到工作区 runtime 下再跑）", () => {
+  const seen: { evolutionDir?: string; scriptPath?: string }[] = [];
+  spawnReviewSupervisor({
+    runDir: "/repo/.pi/evolution/runs/run-9",
+    cwd: "/repo",
+    env: {},
+    autoReview: true,
+    resolveScript: (options) => {
+      seen.push(options);
+      return "/tmp/copied/review-supervisor.ts";
+    },
+    spawnFn: (_c, args) => {
+      assert.equal(args[1], "/tmp/copied/review-supervisor.ts", "spawn 用的必须是解析后的路径");
+      return { pid: 7 };
+    },
+  });
+  assert.equal(seen.length, 1);
+  assert.equal(seen[0]!.evolutionDir, "/repo/.pi/evolution");
+  assert.equal(seen[0]!.scriptPath, SUPERVISOR_SCRIPT);
+});
+
 test("自动评审关着：一个进程都不起，只留一句「停在 proposed」日志", () => {
   const logs: string[] = [];
   let spawned = 0;
@@ -75,6 +101,7 @@ test("自动评审关着：一个进程都不起，只留一句「停在 propose
     cwd: "/repo",
     env: {},
     autoReview: false,
+    resolveScript: direct,
     log: (msg) => logs.push(msg),
     spawnFn: () => {
       spawned += 1;
@@ -94,6 +121,7 @@ test("起不来只记日志返回 null，不抛", () => {
     cwd: "/repo",
     env: {},
     autoReview: true,
+    resolveScript: direct,
     log: (msg) => logs.push(msg),
     spawnFn: () => {
       throw new Error("EMFILE");