pi-skill-evolve 0.1.10 → 0.1.12

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

@@ -15,7 +15,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { pathToFileURL } from "node:url";
+import { pathToFileURL, fileURLToPath } from "node:url";
 import { loadHardRules, scanText, type CompiledRules, type HardRuleHit } from "./hard-rules.ts";
 import { buildReviewPrompt } from "./review-prompt.ts";
 import { classifyChange } from "./classify-action.ts";
@@ -270,7 +270,23 @@ async function main(): Promise<void> {
   }
 }
 
-const invokedDirectly = process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href;
+/**
+ * 「是不是被当脚本直接跑」判定：必须比**真实路径**。
+ * macOS 的 `/tmp` 是 `/private/tmp` 的软链，直接比 `import.meta.url` 与 `pathToFileURL(argv[1])`
+ * 会得出 false —— 督导被搬进工作区 runtime 目录后若那里恰好带软链，就会「起来但什么都不做」（静默不跑）。
+ */
+export function isDirectInvocation(argv1: string | undefined, moduleUrl: string): boolean {
+  if (!argv1) return false;
+  try {
+    const same = fs.realpathSync(argv1) === fs.realpathSync(fileURLToPath(moduleUrl));
+    if (same) return true;
+  } catch {
+    // 路径解析不了就退回字符串比较（行为与旧版一致）
+  }
+  return pathToFileURL(argv1).href === moduleUrl;
+}
+
+const invokedDirectly = isDirectInvocation(process.argv[1], import.meta.url);
 if (invokedDirectly) {
   void main().catch((error: Error) => {
     console.error(`[skill-evolve] 评审督导异常：${error.message}`);

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

@@ -132,6 +132,17 @@ test("纯函数：pi 路径优先级、runId 形态、去抖判据", () => {
   assert.equal(shouldDebounce(NOW - 90_000, NOW, 90_000), false);
 });
 
+test("纯函数：pi 路径在陌生机器上也解得出来（不写死别人的家目录）", () => {
+  // 2026-11-09 事故回归：常量必须跟当前用户 home 走，且 home 不存在时退到 PATH
+  assert.equal(DEFAULT_PI_BIN, path.join(os.homedir(), ".pi", "agent", "bin", "pi"));
+  const none = (): boolean => false;
+  assert.equal(resolvePiBin({}, { exists: none }), DEFAULT_PI_BIN);
+  const onPath = path.join("/opt/node/bin", "pi");
+  assert.equal(resolvePiBin({ PATH: ["/x", path.dirname(onPath)].join(path.delimiter) }, { exists: (p) => p === onPath }), onPath);
+  // home 下的优先于 PATH
+  assert.equal(resolvePiBin({ PATH: path.dirname(onPath) }, { exists: () => true }), DEFAULT_PI_BIN);
+});
+
 test("buildPrompt：带会话原文/索引/run 目录，并写清覆盖轮数", () => {
   const full = buildPrompt({ template: "模板", sessionFile: "/s.jsonl", indexFile: "/i.json", runDir: "/r", sessionId: "s1", skills: ["a", "b"], dispatchedAt: NOW });
   assert.equal(full.includes("会话原文：/s.jsonl"), true);

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, "派发✓ 分析✗ 提案· 评审· 采纳·");
+});