pi-skill-evolve 0.1.10 → 0.1.11

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

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

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

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

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

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

package/extensions/skill-evolve/lib/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/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/package.json

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