pi-skill-evolve 0.1.11 → 0.1.13

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,177 @@
+/**
+ * 重启恢复单测：这里的每一条断言都对应一次「用户看到已分析却永远没提案」的真实死法。
+ * 纪律是保守：能推状态就推，能重挂督导就重挂，**绝不重跑复盘**。
+ */
+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}已中断 — 没提案/);
+});
+
+test("一个工作区两个 pi 同时启动恢复：督导只起一个（另一个看到锁里已经挂上了）", async () => {
+  const { evolutionDir, write } = setup();
+  write("r-9", { status: "analyzed", pid: null, supervisorPid: null }, ["01-findings.json", "02-proposal.json"]);
+  let spawns = 0;
+  const spawnSupervisor = (options: SpawnSupervisorOptions): number => {
+    spawns += 1;
+    // 模拟真实现：spawn 之后立刻把 supervisorPid 写回 run.json（这就是后到者的判断依据）
+    const file = path.join(options.runDir, "run.json");
+    const raw = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
+    fs.writeFileSync(file, JSON.stringify({ ...raw, supervisorPid: process.pid }, null, 2));
+    return process.pid;
+  };
+  // 督导 pid 就是本进程 pid：重挂后它「活着」，这正是后到者的判断依据
+  const deps = base({ evolutionDir, spawnSupervisor, alive: (pid) => pid === process.pid });
+  const both = await Promise.all([recoverRuns(deps), recoverRuns(deps)]);
+  assert.equal(spawns, 1, "两个实例各起一个督导 = 双花 token + 双写 03-review");
+  const kinds = both.flat().map((action) => action.kind);
+  assert.ok(
+    kinds.includes("supervisor-respawned") || kinds.includes("respawn-blocked"),
+    `应当有人挂上、有人让位（实际 ${kinds.join(",")}）`,
+  );
+  assert.ok(!kinds.includes("interrupted"), "提案在、督导被重挂，不该判成中断");
+});

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");

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

@@ -0,0 +1,107 @@
+/**
+ * 督导运行目录单测：npm 包装形态下督导脚本在 node_modules 里，Node 的 --experimental-strip-types
+ * 会拒绝它（ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING）。这一层唯一的职责就是「先搬家再跑」，
+ * 所以测试只盯三件事：**该搬的搬**、**搬家后内容完整**、**搬不了就退回原路径**。
+ */
+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 {
+  ensureSupervisorRuntime,
+  needsCopy,
+  packageVersionOf,
+  RUNTIME_DIRNAME,
+  runtimeDirOf,
+  runtimeKey,
+} from "../lib/supervisor-runtime.ts";
+
+function tmpRoot(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-runtime-"));
+}
+
+/** 造一份「装在 node_modules 里」的包：lib/ 两个文件 + 一个测试文件（不该被拷） */
+function fakePackage(): { root: string; script: string } {
+  const root = path.join(tmpRoot(), "node_modules", "pi-skill-evolve");
+  const lib = path.join(root, "extensions", "skill-evolve", "lib");
+  fs.mkdirSync(lib, { recursive: true });
+  fs.writeFileSync(path.join(lib, "review-supervisor.ts"), "export const a = 1;\n");
+  fs.writeFileSync(path.join(lib, "runs.ts"), "export const b = 2;\n");
+  fs.writeFileSync(path.join(lib, "runs.test.ts"), "test('x', () => {});\n");
+  fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "pi-skill-evolve", version: "0.1.12" }));
+  return { root, script: path.join(lib, "review-supervisor.ts") };
+}
+
+test("只有 node_modules 里的脚本需要搬家", () => {
+  assert.equal(needsCopy("/repo/.pi/npm/node_modules/pi-skill-evolve/extensions/skill-evolve/lib/review-supervisor.ts"), true);
+  assert.equal(needsCopy("C:\\repo\\node_modules\\pkg\\lib\\review-supervisor.ts"), true);
+  assert.equal(needsCopy("/repo/.pi/extensions/skill-evolve/lib/review-supervisor.ts"), false);
+});
+
+test("本地扩展原路径直接用，一个文件都不拷", () => {
+  const evolutionDir = tmpRoot();
+  const script = "/repo/.pi/extensions/skill-evolve/lib/review-supervisor.ts";
+  assert.equal(ensureSupervisorRuntime({ evolutionDir, scriptPath: script }), script);
+  assert.equal(fs.existsSync(path.join(evolutionDir, "runtime")), false);
+});
+
+test("node_modules 里的督导搬到 runtime 下，内容齐全且跳过测试文件", () => {
+  const { script } = fakePackage();
+  const evolutionDir = tmpRoot();
+  const entry = ensureSupervisorRuntime({ evolutionDir, scriptPath: script });
+  assert.notEqual(entry, script, "必须换成副本路径");
+  const key = runtimeKey(script, "0.1.12");
+  assert.equal(entry, path.join(runtimeDirOf(evolutionDir, key), "review-supervisor.ts"));
+  assert.equal(fs.readFileSync(entry, "utf8"), "export const a = 1;\n");
+  assert.equal(fs.existsSync(path.join(path.dirname(entry), "runs.ts")), true, "同目录的相对 import 必须一起搬");
+  assert.equal(fs.existsSync(path.join(path.dirname(entry), "runs.test.ts")), false);
+  assert.equal(fs.existsSync(path.join(path.dirname(entry), ".ready")), true);
+});
+
+test("重复调用复用同一份副本，不重复拷贝", () => {
+  const { script } = fakePackage();
+  const evolutionDir = tmpRoot();
+  const first = ensureSupervisorRuntime({ evolutionDir, scriptPath: script });
+  const stamp = fs.statSync(first).mtimeMs;
+  const second = ensureSupervisorRuntime({ evolutionDir, scriptPath: script });
+  assert.equal(second, first);
+  assert.equal(fs.statSync(second).mtimeMs, stamp, "第二次不该重写文件");
+});
+
+test("内容变了（size/mtime 变）就换新目录，旧目录被清掉", () => {
+  const { script } = fakePackage();
+  const evolutionDir = tmpRoot();
+  const first = ensureSupervisorRuntime({ evolutionDir, scriptPath: script });
+  fs.writeFileSync(script, "export const a = 123456;\n");
+  const future = new Date(Date.now() + 5000);
+  fs.utimesSync(script, future, future);
+  const second = ensureSupervisorRuntime({ evolutionDir, scriptPath: script });
+  assert.notEqual(second, first);
+  assert.equal(fs.existsSync(first), false, "旧版本副本要清掉");
+  assert.equal(fs.readFileSync(second, "utf8"), "export const a = 123456;\n");
+});
+
+test("搬不了（目标目录建不出来）就退回原路径，只记日志不抛", () => {
+  const { script } = fakePackage();
+  const blocked = path.join(tmpRoot(), "file-not-dir");
+  fs.writeFileSync(blocked, "x");
+  const logs: string[] = [];
+  const entry = ensureSupervisorRuntime({
+    evolutionDir: path.join(blocked, "sub"),
+    scriptPath: script,
+    log: (msg) => logs.push(msg),
+  });
+  assert.equal(entry, script);
+  assert.match(logs.join("\n"), /督导运行目录准备失败/);
+});
+
+test("缓存键带版本与入口文件指纹，包版本读得到就直接用", () => {
+  const { script } = fakePackage();
+  assert.equal(packageVersionOf(script), "0.1.12");
+  const key = runtimeKey(script, "0.1.12");
+  assert.match(key, /^lib-0\.1\.12-\d+-\d+$/);
+  assert.equal(runtimeKey(script), key, "不传版本时从最近的 package.json 取");
+  assert.equal(RUNTIME_DIRNAME, "supervisor");
+  assert.equal(packageVersionOf(path.join(tmpRoot(), "lonely", "x.ts")), "", "找不到 package.json 就是空串");
+});

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

@@ -313,6 +313,8 @@ test("pending：正在跑的 run 排最前，阶段 / 进程 / 最近输出 /
   assert.match(detail, /进程：pid 1234 · 已跑 1m 30s（上限 20 分钟）/);
   assert.match(detail, /最近输出：（还没有输出）/, "child.log 还没生成时明确说没有输出");
   assert.match(detail, /日志：tail -f \.pi\/evolution\/runs\/live\/child\.log/);
+  // 五段进度：分析在跑 ⇒ 分析/提案都该是「…」，评审判「等提案」而不是含糊的「在进行」
+  assert.match(detail, /流水线：派发✓ 分析… 提案… 评审· 采纳·/);
   assert.equal(state.pending[1]!.kind, "approval", "待批排在运行中之后");
 });
 

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

@@ -69,6 +69,17 @@ function detail(parts: Partial<RunDetail> = {}): RunDetail {
     findings: [{ skill: "demo", reason: "G", confidence: "high", lines: [578, 622] }],
     findingsTotal: 1,
     notes: "",
+    // 流水线固定在详情页顶部：夹具给一条「已驳回」的完整链路，断言单独在 test/pipeline.test.ts
+    pipeline: {
+      stages: [
+        { key: "dispatch", label: "派发", state: "done", detail: "复盘子进程 pid 65757 已退出", at: 1794133942865 },
+        { key: "analyze", label: "分析", state: "done", detail: "01-findings.json 已落盘", at: 1794134000000 },
+        { key: "propose", label: "提案", state: "done", detail: "improve → demo", at: 1794134050000 },
+        { key: "review", label: "评审", state: "done", detail: "rejected / revise", at: 1794134158913 },
+        { key: "apply", label: "采纳", state: "skipped", detail: "评审驳回，不会采纳", at: null },
+      ],
+      hint: "流程结束：卡在「采纳」— 评审驳回，不会采纳",
+    },
     ...parts,
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-skill-evolve",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "技能进化：采集会话中的技能曝光/加载，异步复盘、生成改进提案并独立评审，附本机 Web 管理面板",
   "keywords": [
     "pi-package",