pi-skill-evolve 0.1.11 → 0.1.13

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

@@ -0,0 +1,229 @@
+/**
+ * 重启 / `/reload` 之后的自动恢复。
+ *
+ * 为什么需要它：派发出去的两个子进程都是 detached 的，但**收尸逻辑在内存里**。
+ * 主进程一重启，`watchRunChild` 的 exit 回调就没了；督导若也被带走了（机器重启、
+ * 端口没放开被旧实例挡掉、面板手动清理），run 会永久停在 `dispatched` / `analyzed`，
+ * 用户看到的就是「已分析」但提案永远不出 —— 2026-11-09 的事故现场。
+ *
+ * 恢复只做三件保守的事，绝不重跑复盘（花 token 且会覆盖已有产物）：
+ * 1. 有 `01-findings.json` 却还写着 `dispatched` → 补成 `analyzed`（分析其实已经跑完）
+ * 2. 有 `02-proposal.json` 但没 `03-review.json`、督导进程已死 → 重挂一个督导接着评审
+ * 3. 其余情况只报告，不动手（复盘子进程还在跑就别打扰它）
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { withLock } from "./lock.ts";
+import { spawnReviewSupervisor, type SpawnSupervisorOptions } from "./review-spawn.ts";
+import { listRuns, updateRunStatus, type RunRecord } from "./runs.ts";
+import type { MutationQueue } from "./telemetry.ts";
+
+/** 只恢复最近这么多小时内派发的 run：更老的多半是用户已经不管的历史 */
+export const RECOVER_WINDOW_MS = 6 * 60 * 60 * 1000;
+
+/** 还在「半路」的状态：出终态的不该被碰 */
+const RESUMABLE = new Set(["dispatched", "analyzed", "proposed"]);
+
+export type RecoveryKind =
+  /** 分析产物在、状态落后：只补状态 */
+  | "advanced-analyzed"
+  /** 提案在、督导不在：重挂督导 */
+  | "supervisor-respawned"
+  /** 提案在、督导还在跑：不打扰 */
+  | "waiting-review"
+  /** 还没出提案，复盘子进程还活着 */
+  | "waiting-proposal"
+  /** 还没出提案，复盘子进程也没了：不重跑，等 stale 收尾 */
+  | "interrupted"
+  /** 已有评审结论：交给会话起点的入队 / 自动采纳 */
+  | "review-done"
+  /** 重挂被挡下（单飞闸占满 / 关着自动评审 / 起不来） */
+  | "respawn-blocked";
+
+export interface RecoveryAction {
+  runId: string;
+  kind: RecoveryKind;
+  detail: string;
+}
+
+export interface RecoverDeps {
+  evolutionDir: string;
+  cwd: string;
+  queue: MutationQueue;
+  now?: () => number;
+  env?: NodeJS.ProcessEnv;
+  alive?: (pid: number) => boolean;
+  /** 现读配置：自动评审关着就不重挂督导（用户手动关的不该被重启偷偷打开） */
+  autoReview?: () => boolean;
+  reviewModel?: () => string;
+  spawnSupervisor?: (options: SpawnSupervisorOptions) => number | null;
+  /** 本会话 ID：写进锁 owner.json，排查「谁在重挂」时有用 */
+  sessionId?: string;
+  log?: (msg: string) => void;
+  windowMs?: number;
+}
+
+/** 督导锁只护「起来 + 写 supervisorPid」这几毫秒，留 60 秒足够，锁主崩了也不会长期占住 */
+const SUPERVISOR_LOCK_MS = 60_000;
+
+/** 抢到锁后重新确认「这条 run 的督导确实不在」，防止两边都判死、抢完各起一个 */
+function supervisorStillGone(
+  runDir: string,
+  record: RunRecord,
+  alive: (pid: number) => boolean,
+): boolean {
+  const fresh = readRecord(runDir) ?? record;
+  const pid = fresh.supervisorPid;
+  return !(typeof pid === "number" && alive(pid));
+}
+
+function exists(runDir: string, name: string): boolean {
+  try {
+    return fs.statSync(path.join(runDir, name)).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/** 生产里就是读 run.json：坏数据当「没有」处理，宁可不动手 */
+function readRecord(runDir: string): RunRecord | null {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(runDir, "run.json"), "utf8")) as RunRecord;
+  } catch {
+    return null;
+  }
+}
+
+export async function recoverRuns(deps: RecoverDeps): Promise<RecoveryAction[]> {
+  const log = deps.log ?? (() => {});
+  const now = deps.now ?? (() => Date.now());
+  const alive = deps.alive ?? ((pid: number) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  const windowMs = deps.windowMs ?? RECOVER_WINDOW_MS;
+  const spawnSupervisor = deps.spawnSupervisor ?? spawnReviewSupervisor;
+  const actions: RecoveryAction[] = [];
+  const runsRoot = path.join(deps.evolutionDir, "runs");
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(runsRoot);
+  } catch {
+    return actions;
+  }
+  const cutoff = now() - windowMs;
+  for (const runId of entries.sort()) {
+    const runDir = path.join(runsRoot, runId);
+    const record = readRecord(runDir);
+    if (!record) continue;
+    if (!RESUMABLE.has(record.status ?? "")) continue;
+    if (typeof record.dispatchedAt === "number" && record.dispatchedAt < cutoff) continue;
+
+    const hasFindings = exists(runDir, "01-findings.json");
+    const hasProposal = exists(runDir, "02-proposal.json");
+    const hasReview = exists(runDir, "03-review.json");
+    const childAlive = typeof record.pid === "number" && alive(record.pid);
+    const supervisorAlive = typeof record.supervisorPid === "number" && alive(record.supervisorPid);
+
+    if (hasReview) {
+      actions.push({ runId, kind: "review-done", detail: "评审已落盘，等会话起点入队 / 自动采纳" });
+      continue;
+    }
+
+    // 1. 分析跑完了但状态没跟上：补状态（不重跑、不花 token）
+    if (record.status === "dispatched" && hasFindings) {
+      const ok = await updateRunStatus(deps.evolutionDir, runId, "analyzed", deps.queue);
+      actions.push({
+        runId,
+        kind: ok ? "advanced-analyzed" : "interrupted",
+        detail: ok ? "01-findings.json 已在，状态补成 analyzed（未重跑）" : "补状态失败：run.json 写不进去",
+      });
+      if (!ok) continue;
+    }
+
+    if (!hasProposal) {
+      if (childAlive) {
+        actions.push({ runId, kind: "waiting-proposal", detail: `复盘子进程 pid ${record.pid} 还活着，不打扰` });
+      } else {
+        actions.push({ runId, kind: "interrupted", detail: "还没出提案，复盘子进程已不在：不自动重跑，等 stale 收尾" });
+      }
+      continue;
+    }
+
+    // 2. 提案在、评审没做：重挂督导（这才是「后台任务丢了」的正解）
+    if (supervisorAlive) {
+      actions.push({ runId, kind: "waiting-review", detail: `督导 pid ${record.supervisorPid} 还在跑，等它出结论` });
+      continue;
+    }
+    if (deps.autoReview && !deps.autoReview()) {
+      actions.push({ runId, kind: "respawn-blocked", detail: "自动评审关着：停在待人工 /skill-evolve approve" });
+      continue;
+    }
+    // 3. 跨实例互斥：同一个工作区开两个 pi 时，两边 session_start 都会走到这里。
+    //    单飞闸只认「已经写进 run.json 的活 pid」，两边的 spawn 之间有空档，会各起一个督导（双花 token、双写 03-review）。
+    //    所以先用 locks/supervisor 抢一下，抢不到说明对面那份正在重挂，让它挂。
+    const spawned = await withLock(
+      {
+        evolutionDir: deps.evolutionDir,
+        name: "supervisor",
+        owner: { pid: process.pid, ts: now(), ...(deps.sessionId ? { sessionId: deps.sessionId } : {}) },
+        maxRuntimeMs: SUPERVISOR_LOCK_MS,
+        log,
+        ...(deps.now ? { now: deps.now } : {}),
+      },
+      () =>
+        // 抢到锁后再判一次：对面可能刚好在抢锁之前写完 supervisorPid
+        supervisorStillGone(runDir, record, alive)
+          ? spawnSupervisor({
+              runDir,
+              cwd: deps.cwd,
+              autoReview: true,
+              reviewModel: deps.reviewModel?.() ?? "inherit",
+              ...(deps.env ? { env: deps.env } : {}),
+              ...(deps.alive ? { alive: deps.alive } : {}),
+              log,
+            })
+          : "taken", 
+    );
+    if (!spawned.ok) {
+      actions.push({
+        runId,
+        kind: "respawn-blocked",
+        detail: `另一个 pi 实例正在重挂督导（locks/supervisor 被 pid ${spawned.owner?.pid ?? "?"} 持有）`,
+      });
+      continue;
+    }
+    const pid = spawned.value;
+    if (pid === "taken") {
+      actions.push({ runId, kind: "waiting-review", detail: "等到锁时督导已经在了（另一个实例刚挂上），不重复起" });
+      continue;
+    }
+    actions.push(
+      pid === null
+        ? { runId, kind: "respawn-blocked", detail: "督导没起来（单飞闸占满或 spawn 失败），下次会话起点还会再试" }
+        : { runId, kind: "supervisor-respawned", detail: `提案已在、督导原本不在：重挂 pid ${pid}` },
+    );
+  }
+  return actions;
+}
+
+/** 面板文案：一句话说清「重启后补了什么」 */
+export function renderRecovery(actions: RecoveryAction[]): string {
+  if (actions.length === 0) return "重启恢复：没有需要接手的 run";
+  const label: Record<RecoveryKind, string> = {
+    "advanced-analyzed": "补状态",
+    "supervisor-respawned": "重挂督导",
+    "waiting-review": "等评审",
+    "waiting-proposal": "等提案",
+    interrupted: "已中断",
+    "review-done": "评审完成",
+    "respawn-blocked": "未能重挂",
+  };
+  const lines = [`重启恢复：${actions.length} 条 run 被检查`];
+  for (const action of actions) lines.push(`  · ${action.runId}  ${label[action.kind]} — ${action.detail}`);
+  return lines.join("\n");
+}

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

@@ -13,6 +13,7 @@ import { fileURLToPath } from "node:url";
 import { patchRunRecordSync } from "./runs.ts";
 import { guardBusy } from "./single-flight.ts";
 import { spawnDetached } from "./spawn-plan.ts";
+import { ensureSupervisorRuntime, type RuntimeOptions } from "./supervisor-runtime.ts";
 import type { TelemetryWriter } from "./telemetry.ts";
 
 /** 督导脚本绝对路径：dispatch 与 shutdown-dispatch 两条路径共用 */
@@ -50,6 +51,13 @@ export interface SpawnSupervisorOptions {
   alive?: (pid: number) => boolean;
   /** 退出补发路径：主进程马上退，遥测只能同步写 */
   sync?: boolean;
+  /**
+   * 督导入口解析：默认走 supervisor-runtime 的「node_modules 里先搬家」逻辑。
+   * 单测注入它，避免真去拷源码目录。
+   */
+  resolveScript?: (options: RuntimeOptions) => string;
+  /** 包版本：参与运行目录的缓存键 */
+  version?: string;
 }
 
 /** 返回 pid；被单飞闸挡住或起不来返回 null（只记日志，绝不抛到主会话） */
@@ -74,7 +82,16 @@ export function spawnReviewSupervisor(options: SpawnSupervisorOptions): number |
   const env = { ...(options.env ?? process.env) };
   // 督导自己不是 pi 子代理：把「别再采集」的标记去掉，避免它起评审子进程时语义混乱
   delete env.SKILL_EVOLVE_CHILD;
-  const args = ["--experimental-strip-types", SUPERVISOR_SCRIPT, options.runDir];
+  // node_modules 里的 .ts 不能直接跑（ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING）：先搬到工作区的
+  // runtime 目录再起进程，否则按 npm 包安装时督导**每次**都崩在 import 阶段（2026-11-09 事故）
+  const resolveScript = options.resolveScript ?? ensureSupervisorRuntime;
+  const script = resolveScript({
+    evolutionDir: path.dirname(path.dirname(options.runDir)),
+    scriptPath: SUPERVISOR_SCRIPT,
+    ...(options.version ? { version: options.version } : {}),
+    ...(options.log ? { log: options.log } : {}),
+  });
+  const args = ["--experimental-strip-types", script, options.runDir];
   if (options.reviewModel && options.reviewModel !== "inherit") args.push(options.reviewModel);
   const spawnFn = options.spawnFn ?? (nodeSpawn as unknown as SupervisorSpawn);
   try {

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

@@ -14,7 +14,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
-import { acquireLock, acquireLockSync, isPidAlive, lockDir, readOwnerSync, releaseLock, releaseLockSync, shouldReclaim, writeOwnerSync } from "../lib/lock.ts";
+import { acquireLock, acquireLockSync, isPidAlive, lockDir, readOwnerSync, releaseLock, releaseLockSync, shouldReclaim, withLock, writeOwnerSync } from "../lib/lock.ts";
 
 const MAX = 20 * 60_000;
 const NOW = 1_760_000_000_000;
@@ -136,3 +136,40 @@ test("writeOwnerSync：把持有者换成子进程 pid，供 status 与孤儿判
   assert.deepEqual(readOwnerSync(lockDir(dir)), { pid: 4321, ts: NOW + 1, sessionId: "s1" });
   releaseLockSync(dir);
 });
+
+test("lockDir：不同名字的锁互不干扰（派发锁被占不影响督导锁）", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-lock-name-"));
+  const base = { evolutionDir: dir, owner: { pid: process.pid, ts: NOW }, maxRuntimeMs: MAX, now: () => NOW };
+  const dispatch = await acquireLock(base);
+  assert.equal(dispatch.ok, true);
+  const supervisor = await acquireLock({ ...base, name: "supervisor" });
+  assert.equal(supervisor.ok, true, "另一个名字的锁应当能独立抢到");
+  assert.equal(fs.existsSync(path.join(dir, "locks", "supervisor")), true);
+  await releaseLock(dir, () => {}, "supervisor");
+  await releaseLock(dir);
+  assert.equal(fs.existsSync(path.join(dir, "locks")), true, "locks 父目录留着，空的子目录删干净");
+  assert.deepEqual(fs.readdirSync(path.join(dir, "locks")), []);
+});
+
+test("withLock：忙时直接返回 why=busy 不执行；跑完一定释放（抛错也释放）", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-withlock-"));
+  const options = { evolutionDir: dir, name: "apply" as const, owner: { pid: process.pid, ts: NOW }, maxRuntimeMs: MAX, now: () => NOW };
+  const first = await withLock(options, async () => {
+    const inner = await withLock(options, () => "不该执行");
+    assert.equal(inner.ok, false);
+    assert.equal(inner.why, "busy");
+    return "done";
+  });
+  assert.equal(first.ok, true);
+  assert.equal(first.value, "done");
+  // 异常要往上抛（调用方自己决定记什么日志），但锁必须已经放掉
+  await assert.rejects(
+    withLock(options, () => {
+      throw new Error("模拟采纳中途崩");
+    }),
+    /模拟采纳中途崩/,
+  );
+  assert.equal(fs.existsSync(path.join(dir, "locks", "apply")), false, "抛错也要释放，否则下次永远 busy");
+  const again = await withLock(options, () => "又抢到了");
+  assert.equal(again.ok, true);
+});