@zhushanwen/pi-subagent-workflow 7.3.4 → 8.0.0

package/src/execution/__tests__/session-reconstructor.test.ts

@@ -102,7 +102,7 @@ describe("reconstructFromFile", () => {
       expect(rec!.agent).toBe("worker");
       expect(rec!.mode).toBe("background");
       expect(rec!.task).toBe("do it");
-      expect(rec!.status).toBe("done");
+      expect(rec!.status).toBe("closed");
       expect(rec!.turns).toHaveLength(1);
       expect(rec!.turns[0].text).toBe("hello world");
       expect(rec!.turnCount).toBe(1);
@@ -284,7 +284,7 @@ describe("reconstructFromFile", () => {
       const rec = reconstructFromFile(filePath);
       expect(rec!.lastError).toBe("API timeout");
       expect(rec!.error).toBe("API timeout");
-      expect(rec!.status).toBe("failed"); // error stopReason → failed
+      expect(rec!.status).toBe("closed"); // error stopReason → failed
     });
 
     it("stopReason=aborted 无 errorMessage → lastError = 'aborted'", () => {
@@ -295,7 +295,7 @@ describe("reconstructFromFile", () => {
       ]);
       const rec = reconstructFromFile(filePath);
       expect(rec!.lastError).toBe("aborted");
-      expect(rec!.status).toBe("failed");
+      expect(rec!.status).toBe("closed");
     });
 
     it("前序 error 但最后 stop → lastError 清除（镜像 turn_end 语义），status=done", () => {
@@ -309,7 +309,7 @@ describe("reconstructFromFile", () => {
       ]);
       const rec = reconstructFromFile(filePath);
       expect(rec!.lastError).toBeUndefined(); // 后续 stop 清除了 error
-      expect(rec!.status).toBe("done");
+      expect(rec!.status).toBe("closed");
       expect(rec!.result).toBe("oops\n\nrecovered");
     });
   });

package/src/execution/__tests__/session-runner-epipe.test.ts

@@ -0,0 +1,178 @@
+// src/execution/__tests__/session-runner-epipe.test.ts
+//
+// [v4 A-1] session-runner 异步 stdin 'error' listener 测试。
+//
+// 背景：writeStdinLine 的 try/catch 只覆盖同步 write 抛错；子进程退出后内核回写 EPIPE
+// 以异步 stream 'error' event 到达，若无 listener 会让 Node 抛 unhandled 'error' 崩主进程（P1）。
+// runSpawn 在 spawn 后、首次 stdin 写入前注册 child.stdin.on('error') handler，合并
+// 同步/异步 EPIPE 计数（共用 stdin-writer 的 recordEpipeFailure）。
+//
+// 验收：① listener 存在 ② error 触发后 spawnedChildren 不含该 recordId
+//      ③ recordEpipeFailure 计数累加（同步/异步合并）
+
+import { spawn } from "node:child_process";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("node:child_process", async () => {
+  const { FakeChild } = await import("./helpers/spawn-mock.ts");
+  return {
+    spawn: vi.fn(() => new FakeChild()),
+    // buildEnvBlock 的 git branch 调用（execFile 异步）：默认 err-first 兜底 → catch → branch=""
+    execFile: vi.fn(
+      (
+        _cmd: string,
+        _args: readonly string[],
+        _opts: unknown,
+        cb: (err: Error | null, stdout?: string, stderr?: string) => void,
+      ) => cb(new Error("execFile not configured in this test")),
+    ),
+  };
+});
+
+vi.mock("node:fs", async () => {
+  const actual = await import("node:fs");
+  return {
+    default: {
+      ...actual,
+      mkdirSync: vi.fn(),
+      existsSync: vi.fn(() => false),
+      appendFileSync: vi.fn(),
+      writeFileSync: vi.fn(),
+      readdirSync: vi.fn(() => []),
+    },
+    mkdirSync: vi.fn(),
+    existsSync: vi.fn(() => false),
+    appendFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    readdirSync: vi.fn(() => []),
+    promises: actual.promises,
+  };
+});
+
+vi.mock("../alive-store.ts", () => ({ writeAliveMarker: vi.fn() }));
+
+vi.mock("../session-pending.ts", () => ({
+  readActivePendingFromSessionFile: vi.fn(() => ({ count: 0 })),
+}));
+
+vi.mock("../temp-prompt.ts", () => ({
+  writePromptToTempFile: vi.fn(async (agent: string) => {
+    const safeName = agent.replace(/[^\w.-]+/g, "_");
+    return { dir: `/tmp/fake-${safeName}`, filePath: `/tmp/fake-${safeName}/prompt-${safeName}.md` };
+  }),
+  cleanupTempPrompt: vi.fn(async () => {}),
+}));
+
+import {
+  EPIPE_FAILURE_THRESHOLD,
+  recordEpipeFailure,
+  resetAllEpipeFailures,
+} from "../stdin-writer.ts";
+import { runSpawn, spawnedChildren } from "../session-runner.ts";
+import { _resetLifecycleState } from "../lifecycle-manager.ts";
+import {
+  FakeChild,
+  lastSpawnedChild as lastSpawnedChildOf,
+  makeCtx,
+  makeOpts,
+  makeRecord,
+  waitForSpawn as waitForSpawnOf,
+} from "./helpers/spawn-mock.ts";
+
+const mockSpawn = vi.mocked(spawn);
+const lastSpawnedChild = (): FakeChild => lastSpawnedChildOf(mockSpawn);
+const waitForSpawn = (timeoutMs = 1000): Promise<void> => waitForSpawnOf(mockSpawn, timeoutMs);
+
+/** 构造 EPIPE errno 错误（模拟子进程退出后内核回写 EPIPE）。 */
+function epipeError(message = "write after end"): NodeJS.ErrnoException {
+  const err = new Error(message) as NodeJS.ErrnoException;
+  err.code = "EPIPE";
+  return err;
+}
+
+/** 手动 emit close 让 runSpawn 的 exitCode promise resolve（非 chatMode 默认 close resolve）。 */
+function settleRunSpawn(child: FakeChild): void {
+  child.stdout.end();
+  child.stderr.end();
+  child.emit("close", 0);
+}
+
+describe("[v4 A-1] session-runner 异步 stdin 'error' listener", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    _resetLifecycleState();
+    resetAllEpipeFailures();
+    spawnedChildren.clear();
+  });
+
+  afterEach(() => {
+    _resetLifecycleState();
+    resetAllEpipeFailures();
+    spawnedChildren.clear();
+  });
+
+  it("① spawn 后注册 child.stdin 'error' listener", async () => {
+    const record = makeRecord("sa-listener");
+    const promise = runSpawn(record, "Task: listener-exists", makeOpts(), makeCtx());
+
+    await waitForSpawn();
+    const child = lastSpawnedChild();
+
+    // listener 已注册——无 listener 时异步 EPIPE 会崩主进程（这是 A-1 修复的 P1）
+    expect(child.stdin.listenerCount("error")).toBeGreaterThan(0);
+
+    settleRunSpawn(child);
+    await promise;
+  });
+
+  it("②③ async stdin 'error' → 移出 spawnedChildren + recordEpipeFailure 计数递增", async () => {
+    const record = makeRecord("sa-async-epipe");
+    const promise = runSpawn(record, "Task: async-epipe", makeOpts(), makeCtx());
+
+    await waitForSpawn();
+    const child = lastSpawnedChild();
+
+    // runSpawn 已把 child 注册进 spawnedChildren
+    expect(spawnedChildren.has(record.id)).toBe(true);
+
+    // 发一次异步 stdin 'error'（count 0→1，未达阈值，handler 只 warn 不 throw）
+    child.stdin.emit("error", epipeError());
+
+    // ② spawnedChildren 已移除该 recordId（标记 dead）
+    expect(spawnedChildren.has(record.id)).toBe(false);
+
+    // ③ 计数累加：handler 调 recordEpipeFailure 设为 1；此处再调一次应返回 2
+    //    （若 handler 未运行，counter 仍为 0，本次调用只会返回 1）
+    expect(recordEpipeFailure(record.id)).toBe(2);
+
+    settleRunSpawn(child);
+    await promise;
+  });
+
+  it("③ 同步预置计数 + 异步 stdin 'error' 合并计数（handler 不 throw，防 listener 内 throw 崩进程）", async () => {
+    const record = makeRecord("sa-threshold");
+    const promise = runSpawn(record, "Task: threshold", makeOpts(), makeCtx());
+
+    await waitForSpawn();
+    const child = lastSpawnedChild();
+
+    // 预置 count=1（模拟 deliverMessage 同步路径已计 1 次失败——证明共用同一计数器）
+    expect(recordEpipeFailure(record.id)).toBe(1);
+
+    // [v4 A-1 裁决] async handler 内不 throw（stream 'error' listener 内 throw 会经 emit
+    // 传播为 uncaughtException 崩主进程，违背 A-1 防崩）——达阈值 throw 留同步路径。
+    // emit 不抛错：
+    expect(() => child.stdin.emit("error", epipeError())).not.toThrow();
+
+    // handler 调 recordEpipeFailure → count=2（达阈值但 async 不 throw）；此处再调返回 3
+    expect(recordEpipeFailure(record.id)).toBe(3);
+    expect(EPIPE_FAILURE_THRESHOLD).toBe(2);
+
+    // handler 已移出 spawnedChildren（标记 dead，下次 deliverMessage 检测走冷路径）
+    expect(spawnedChildren.has(record.id)).toBe(false);
+
+    settleRunSpawn(child);
+    await promise;
+  });
+});

package/src/execution/__tests__/session-runner-schema-env.test.ts

@@ -28,6 +28,7 @@ vi.mock("node:child_process", async () => {
   class FakeChild extends EventEmitter {
     pid = 12345;
     stdout = new PassThrough();
+    stdin = new PassThrough(); // runSpawn 注册 stdin EPIPE handler（session-runner），FakeChild 必须提供
     stderr = new PassThrough();
     killed = false;
     killSignal: string | undefined;
@@ -40,7 +41,15 @@ vi.mock("node:child_process", async () => {
 
   return {
     spawn: vi.fn(() => new FakeChild()),
-    execFileSync: vi.fn(() => ""),
+    // buildEnvBlock 用 execFile 异步取 git branch：默认 err-first 兜底（catch → branch=""）
+    execFile: vi.fn(
+      (
+        _cmd: string,
+        _args: readonly string[],
+        _opts: unknown,
+        cb: (err: Error | null, stdout?: string, stderr?: string) => void,
+      ) => cb(new Error("execFile not configured in this test")),
+    ),
   };
 });
 
@@ -76,9 +85,10 @@ vi.mock("../temp-prompt.ts", () => ({
   cleanupTempPrompt: vi.fn(async () => {}),
 }));
 
-import { execFileSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 
+import { waitForSpawn } from "./helpers/spawn-mock.ts";
 import { createRecord } from "../execution-record.ts";
 import {
   applySchemaEnvToChildEnv,
@@ -88,7 +98,6 @@ import {
 } from "../session-runner.ts";
 
 const mockSpawn = vi.mocked(spawn);
-const mockExec = vi.mocked(execFileSync);
 const mockExistsSync = vi.mocked(fs.existsSync);
 
 interface FakeChild {
@@ -111,20 +120,6 @@ function getLastSpawnEnv(): Record<string, string | undefined> {
   return mockSpawn.mock.calls.at(-1)?.[2]?.env as Record<string, string | undefined> ?? {};
 }
 
-/**
- * 等待 runSpawn 内部调到 spawn。
- * runSpawn 是 async，spawn 在 writePromptToTempFile await 之后才调。
- */
-async function waitForSpawn(timeoutMs = 1000): Promise<void> {
-  const start = Date.now();
-  while (mockSpawn.mock.results.length === 0) {
-    if (Date.now() - start > timeoutMs) {
-      throw new Error(`spawn was not called within ${timeoutMs}ms`);
-    }
-    await new Promise((r) => setTimeout(r, 5));
-  }
-}
-
 // ── 公共 fixture ──
 
 function makeRecord() {
@@ -238,7 +233,6 @@ describe("runSpawn schemaEnv childEnv 注入 (T3.9/T3.11)", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockExistsSync.mockReturnValue(false);
-    mockExec.mockReturnValue("");
   });
 
   afterEach(() => {
@@ -254,7 +248,7 @@ describe("runSpawn schemaEnv childEnv 注入 (T3.9/T3.11)", () => {
     const ctx = makeCtx();
 
     const resultPromise = runSpawn(record, "test task", opts, ctx);
-    await waitForSpawn();
+    await waitForSpawn(mockSpawn);
     const childEnv = getLastSpawnEnv();
     // BC-6: schemaEnv 未传入 → PI_WORKFLOW_SCHEMA 应为 process.env 原值（我们的代码不注入）
     expect(childEnv.PI_WORKFLOW_SCHEMA).toBe(process.env.PI_WORKFLOW_SCHEMA);
@@ -272,7 +266,7 @@ describe("runSpawn schemaEnv childEnv 注入 (T3.9/T3.11)", () => {
     const ctx = makeCtx();
 
     const resultPromise = runSpawn(record, "test task", opts, ctx);
-    await waitForSpawn();
+    await waitForSpawn(mockSpawn);
     const childEnv = getLastSpawnEnv();
     expect(childEnv.PI_WORKFLOW_SCHEMA).toBe(schemaJson);
 
@@ -303,7 +297,7 @@ describe("runSpawn schemaEnv childEnv 注入 (T3.9/T3.11)", () => {
     const ctx = makeCtx();
 
     const resultPromise = runSpawn(record, "test task", opts, ctx);
-    await waitForSpawn();
+    await waitForSpawn(mockSpawn);
     const childEnv = getLastSpawnEnv();
     // fork depth env 应存在
     expect(childEnv.PI_SUBAGENT_FORK_DEPTH).toBe("1");

package/src/execution/__tests__/session-start-reaper.test.ts

@@ -82,6 +82,8 @@ vi.mock("../subagent-service.ts", () => ({
     initSession = mockInitSession;
     // W3: index.ts session_start 注入 UI handler 时调用
     setUiRequestHandler = mockSetUiRequestHandler;
+    startGcTimer = vi.fn();
+    recoverManifestTmpFiles = vi.fn(async () => ({ deleted: 0, recovered: 0 }));
     constructor(init: unknown) {
       capturedConstructorArg.current = init;
     }
@@ -167,14 +169,14 @@ describe("session_start worktree reaper", () => {
     vi.clearAllMocks();
   });
 
-  it("session_start 触发 WTM.scan 调用", () => {
+  it("session_start 触发 WTM.scan 调用", async () => {
     const { pi, getSessionStartHandler } = createMockPi();
     subagentsExtension(pi);
 
     const handler = getSessionStartHandler();
     expect(handler).toBeDefined();
 
-    handler!(
+    await handler!(
       { type: "session_start", reason: "startup" },
       createMockCtx(),
     );
@@ -184,7 +186,7 @@ describe("session_start worktree reaper", () => {
     expect(mockScan).toHaveBeenCalledWith();
   });
 
-  it("scan 抛错不阻断 session_start", () => {
+  it("scan 抛错不阻断 session_start", async () => {
     mockScan.mockImplementation(() => {
       throw new Error("git not found");
     });
@@ -196,23 +198,23 @@ describe("session_start worktree reaper", () => {
     expect(handler).toBeDefined();
 
     // 不应抛错
-    expect(() => {
+    await expect(
       handler!(
         { type: "session_start", reason: "startup" },
         createMockCtx(),
-      );
-    }).not.toThrow();
+      )
+    ).resolves.toBeUndefined();
 
     // service 仍然被注册（启动未被阻断）
     expect(mockSetSubagentService).toHaveBeenCalled();
   });
 
-  it("mainSessionFile 被缓存并传给 SubagentService", () => {
+  it("mainSessionFile 被缓存并传给 SubagentService", async () => {
     const { pi, getSessionStartHandler } = createMockPi();
     subagentsExtension(pi);
 
     const handler = getSessionStartHandler();
-    handler!(
+    await handler!(
       { type: "session_start", reason: "startup" },
       createMockCtx(),
     );