@zhushanwen/subagent-core 0.7.1 → 0.9.0

package/src/execution/engine/__tests__/run-failure-worktree-cleanup.test.ts

@@ -39,9 +39,6 @@ function makeRecord(worktreeHandle?: WorktreeHandle): ExecutionRecord {
 
 function makeDeps(cleanup: ReturnType<typeof vi.fn>): FinalizeDeps {
   return {
-    manifestStore: {
-      writeManifest: vi.fn(async () => undefined),
-    } as unknown as FinalizeDeps["manifestStore"],
     worktreeManager: { cleanup } as unknown as FinalizeDeps["worktreeManager"],
     store: { archive: vi.fn() } as unknown as FinalizeDeps["store"],
     modelService: { getAgentDir: () => "/tmp/w3-test-agentdir" } as unknown as FinalizeDeps["modelService"],

package/src/execution/engine/client/__tests__/__fixtures__/fake-engine.mjs

@@ -255,9 +255,6 @@ if (MODE === "hang") {
           send({ id: runFrameId, result: runOutcomeAborted() });
         }
         break;
-      case "interact":
-        send({ id, result: { ok: true, delivered: true } });
-        break;
       case "read":
         send({
           id,

package/src/execution/engine/client/__tests__/engine-client-reap.test.ts

@@ -0,0 +1,212 @@
+// src/execution/engine/client/__tests__/engine-client-reap.test.ts
+//
+// [H1 U2 / 红线①收割链] 引擎退出链孤儿收割单测（设计
+// docs/design/subagent-chat-run-unification.md §3.3 红线① + §5 U2 验收「收割链各分支」）。
+//
+// 覆盖分支：
+//   - 非主动死亡（!intentionalKill && alreadyDead）POSIX → 复用 killProcessTree 负 pid
+//     组杀（fire-and-forget），且仅组杀一次（无外层逐 pid 兜底——grace 窗不被压缩）；
+//   - intentionalKill 路径跳过（主动 dispose 链已有两层杀——不叠加、优雅窗零压缩）；
+//   - 引擎进程仍活（握手失败重建路径）不触发收割（下方既有组杀兜底承接，行为不变）；
+//   - Windows 通道：置死前 mirror.snapshot 过滤活孤儿（state==="running" && !killed——
+//     死 pid 与 killed 项不进清单）后逐 pid **异步 spawn** taskkill（无 spawnSync——
+//     同步逐个会冻结 onEngineExit 回调、推迟 pending reject）；
+//   - 收割插入点 = mirror.killAll() 置死清空之前（Windows 通道依赖快照活项）。
+//
+// 平台分派说明：Windows 通道经私有方法 reapOrphansViaMirrorSnapshot 直调覆盖
+//（process.platform 判据在 vitest worker 内不可 stub——一行字面分派由 U4 真机 Windows
+// 验收覆盖）；POSIX 分支用本机真实平台（darwin/linux）断言。
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
+
+// killProcessTree spy（POSIX 组杀断言）；waitForChildExit 保留真实现（killAll 消费）。
+const { killProcessTreeSpy } = vi.hoisted(() => ({ killProcessTreeSpy: vi.fn() }));
+vi.mock("../reaper.ts", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../reaper.ts")>();
+  return { ...actual, killProcessTree: (...args: unknown[]) => killProcessTreeSpy(...(args as [])) };
+});
+
+// node:child_process spawn spy（Windows 通道 taskkill 断言；本文件不走 ensureConnected，
+// 引擎 CLI spawn 不被触发）。
+const { spawnSpy, spawnSyncSpy } = vi.hoisted(() => ({
+  spawnSpy: vi.fn(() => ({
+    unref: vi.fn(),
+    on: vi.fn(),
+    pid: 424242,
+  })),
+  spawnSyncSpy: vi.fn(() => ({ status: 0, error: undefined })),
+}));
+vi.mock("node:child_process", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("node:child_process")>();
+  return { ...actual, spawn: spawnSpy, spawnSync: spawnSyncSpy };
+});
+
+import { EngineClient } from "../engine-client.ts";
+import type { MirrorEntry } from "../mirror.ts";
+
+function makeClient(): EngineClient {
+  return new EngineClient({
+    engineId: "fake",
+    command: process.execPath,
+    args: ["-e", ""],
+    hostKind: "test",
+    hostVersion: "test-host-1.0",
+    dataDir: "/tmp/engine-client-reap-test",
+    envPrefixes: [],
+  });
+}
+
+/** 塞一个已死的假引擎 child（exitCode 非 null = alreadyDead 判据命中）。 */
+function plantDeadChild(client: EngineClient, pid: number): void {
+  (client as unknown as { child: unknown }).child = {
+    pid,
+    exitCode: 1,
+    signalCode: null,
+    removeAllListeners: vi.fn(),
+    on: vi.fn(),
+  };
+}
+
+/** 塞一个活着的假引擎 child（alreadyDead 不命中——既有组杀兜底路径）。 */
+function plantLiveChild(client: EngineClient, pid: number): void {
+  (client as unknown as { child: unknown }).child = {
+    pid,
+    exitCode: null,
+    signalCode: null,
+    removeAllListeners: vi.fn(),
+    on: vi.fn(),
+  };
+}
+
+/** 在途请求 pending 直插（pending reject 时序断言用）。 */
+function plantPendingRequest(client: EngineClient, id: number): { reject: ReturnType<typeof vi.fn> } {
+  const pending = { resolve: vi.fn(), reject: vi.fn(), timer: undefined };
+  (client as unknown as { pending: Map<number, typeof pending> }).pending.set(id, pending);
+  return pending;
+}
+
+function mirrorEntry(pid: number, state: "running" | "exited", killed: boolean): MirrorEntry {
+  return { pid, recordId: `sa-${pid}`, state, killed, updatedAt: Date.now() };
+}
+
+describe("红线①收割链：非主动死亡路径（POSIX 组杀）", () => {
+  beforeEach(() => {
+    killProcessTreeSpy.mockClear();
+    spawnSpy.mockClear();
+    spawnSyncSpy.mockClear();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("引擎意外死（alreadyDead + !intentionalKill）→ teardownProcess 内 mirror.killAll 之前组杀引擎 pid", () => {
+    const client = makeClient();
+    plantDeadChild(client, 4321);
+    client.mirror.recordSpawned(9100, "sa-a"); // 死前 spawn 的任务子进程（活孤儿）
+
+    (client as unknown as { teardownProcess: (d: string) => void }).teardownProcess("signal SIGKILL");
+
+    // POSIX：复用 killProcessTree 负 pid 组杀（目标 = 引擎 pid，组内含任务子进程——
+    // 不依赖镜像）
+    expect(killProcessTreeSpy).toHaveBeenCalledTimes(1);
+    expect(killProcessTreeSpy).toHaveBeenCalledWith(
+      4321,
+      expect.stringContaining("reap orphaned children"),
+      { engineId: "fake" },
+    );
+    // 收割插入点在镜像置死之前：killAll 后快照已清（此处仅验证组杀发生在 teardown 内
+    // 且镜像最终被置死清空）
+    expect(client.mirror.size).toBe(0);
+  });
+
+  it("无外层逐 pid 兜底：组杀仅一次（5s grace 窗不被同步校验压缩）", () => {
+    const client = makeClient();
+    plantDeadChild(client, 4321);
+    for (let i = 0; i < 5; i++) client.mirror.recordSpawned(9000 + i, `sa-${i}`); // 多个活孤儿
+
+    (client as unknown as { teardownProcess: (d: string) => void }).teardownProcess("signal SIGKILL");
+
+    // 升级链（SIGTERM → 5s grace → SIGKILL）内建覆盖残余职责：不逐 pid 补杀
+    expect(killProcessTreeSpy).toHaveBeenCalledTimes(1);
+    expect(spawnSpy).not.toHaveBeenCalled();
+  });
+
+  it("intentionalKill 路径跳过收割（主动 dispose 链已有两层杀——不叠加、优雅窗零压缩）", () => {
+    const client = makeClient();
+    plantDeadChild(client, 4321);
+    client.mirror.recordSpawned(9100, "sa-a");
+    (client as unknown as { intentionalKill: boolean }).intentionalKill = true;
+
+    (client as unknown as { teardownProcess: (d: string) => void }).teardownProcess("after intentional kill");
+
+    expect(killProcessTreeSpy).not.toHaveBeenCalled();
+    expect(spawnSpy).not.toHaveBeenCalled();
+    expect(client.mirror.size).toBe(0); // 置死清空照常
+  });
+
+  it("引擎进程仍活（握手失败重建路径）→ 不触发收割分支（既有组杀兜底承接，行为不变）", () => {
+    const client = makeClient();
+    plantLiveChild(client, 4321);
+
+    (client as unknown as { teardownProcess: (d: string) => void }).teardownProcess("handshake failed");
+
+    // alreadyDead 不命中 → 收割链跳过；活进程组杀由 teardown 既有兜底承接（reason 原样）
+    expect(killProcessTreeSpy).toHaveBeenCalledTimes(1);
+    expect(killProcessTreeSpy).toHaveBeenCalledWith(4321, "handshake failed", { engineId: "fake" });
+  });
+});
+
+describe("红线①收割链：Windows 通道（镜像快照过滤活孤儿 + 异步 taskkill）", () => {
+  beforeEach(() => {
+    killProcessTreeSpy.mockClear();
+    spawnSpy.mockClear();
+    spawnSyncSpy.mockClear();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("置死前快照过滤活孤儿：仅 state=running && !killed 进 taskkill 清单（历史死 pid 与 killed 项排除）", () => {
+    const client = makeClient();
+    plantDeadChild(client, 4321);
+    client.mirror.recordSpawned(9100, "sa-live-orphan"); // 活孤儿 → 进清单
+    client.mirror.recordSpawned(9101, "sa-exited");
+    client.mirror.recordStateChanged({ pid: 9101, recordId: "sa-exited", state: "exited", killed: false });
+    client.mirror.recordSpawned(9102, "sa-killed");
+    client.mirror.recordStateChanged({ pid: 9102, recordId: "sa-killed", state: "exited", killed: true });
+
+    (client as unknown as { reapOrphansViaMirrorSnapshot: (d: string) => void }).reapOrphansViaMirrorSnapshot(
+      "signal SIGKILL",
+    );
+
+    expect(spawnSpy).toHaveBeenCalledTimes(1);
+    expect(spawnSpy).toHaveBeenCalledWith("taskkill", ["/PID", "9100", "/T", "/F"], { stdio: "ignore" });
+    expect(killProcessTreeSpy).not.toHaveBeenCalled(); // win32 不复用引擎树杀（树根已死 = 空操作）
+  });
+
+  it("taskkill 异步 spawn 不阻塞 teardown（pending reject 在同步段完成——Continuation 失败通知链源头不被推迟）", () => {
+    const client = makeClient();
+    plantDeadChild(client, 4321);
+    client.mirror.recordSpawned(9100, "sa-live-orphan");
+    const pending = plantPendingRequest(client, 7);
+
+    // Windows 通道直调 + teardown 全流程（快照 → 异步 spawn → killAll → pending reject）
+    (client as unknown as { reapOrphansViaMirrorSnapshot: (d: string) => void }).reapOrphansViaMirrorSnapshot(
+      "signal SIGKILL",
+    );
+    (client as unknown as { teardownProcess: (d: string) => void }).teardownProcess("signal SIGKILL");
+
+    // spawn 是异步 fire-and-forget（返回即继续，无同步等待）；spawnSync 零调用——
+    // 逐个同步 N×10s 上界会冻结 onEngineExit 同步回调与宿主事件循环
+    expect(spawnSpy).toHaveBeenCalled();
+    expect(spawnSyncSpy).not.toHaveBeenCalled();
+    expect(pending.reject).toHaveBeenCalledTimes(1); // 同步段完成（engine_crashed）
+  });
+});

package/src/execution/engine/client/__tests__/mirror.test.ts

@@ -4,8 +4,14 @@
 //   3. 置死后清空，isResumable 回落「无句柄」；
 //   killed 必含判据 = `entry !== undefined && !entry.killed`。
 
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it } from "vitest";
 
+import {
+  DialogGlobalQueue,
+  registerActiveDialogQueue,
+  type UiRequest,
+  type UiResponse,
+} from "../../../dialog-queue.ts";
 import { SpawnedChildrenMirror } from "../mirror.ts";
 
 describe("SpawnedChildrenMirror", () => {
@@ -65,3 +71,69 @@ describe("SpawnedChildrenMirror", () => {
     expect(mirror.isResumable("rec-2")).toBe(true);
   });
 });
+
+// ── [SR-4 接线] 子进程退出 → 取消该 pid 挂起的 dialog ──
+//
+// 原绑定点（宿主 spawn pi 子进程时代的 session-runner child close）随协议化消失；
+// 新链路 = 引擎 host/childStateChanged(exited) → 本镜像 → notifyChildProcessExited。
+describe("SpawnedChildrenMirror — 子进程退出取消挂起 dialog（SR-4 接线）", () => {
+  afterEach(() => {
+    registerActiveDialogQueue(undefined);
+  });
+
+  /** 入队一个永不 settle 的 dialog（绑定 pid），返回其结果观察 promise。 */
+  function enqueuePending(queue: DialogGlobalQueue, pid: number, id: string): Promise<UiResponse> {
+    const req: UiRequest = { method: "select", id, title: `q-${id}` };
+    return queue.enqueue(req, () => new Promise<UiResponse>(() => {}), { child: { pid } });
+  }
+
+  it("state=exited → 该 pid 的挂起 dialog resolve cancelled", async () => {
+    const queue = new DialogGlobalQueue();
+    registerActiveDialogQueue(queue);
+    const pending = enqueuePending(queue, 101, "req-1");
+
+    const mirror = new SpawnedChildrenMirror();
+    mirror.recordSpawned(101, "rec-1");
+    mirror.recordStateChanged({ pid: 101, recordId: "rec-1", state: "exited", killed: true, exitCode: 0 });
+
+    await expect(pending).resolves.toEqual({ cancelled: true });
+  });
+
+  it("state=running 不触发取消（进程仍在跑，dialog 继续排队）", async () => {
+    const queue = new DialogGlobalQueue();
+    registerActiveDialogQueue(queue);
+    let settled = false;
+    void enqueuePending(queue, 102, "req-2").then(() => {
+      settled = true;
+    });
+
+    const mirror = new SpawnedChildrenMirror();
+    mirror.recordStateChanged({ pid: 102, recordId: "rec-2", state: "running", killed: false });
+    await Promise.resolve();
+
+    expect(settled).toBe(false);
+  });
+
+  it("killAll（引擎进程消亡）→ 逐 pid 取消各自挂起 dialog", async () => {
+    const queue = new DialogGlobalQueue();
+    registerActiveDialogQueue(queue);
+    const p1 = enqueuePending(queue, 201, "req-a");
+    const p2 = enqueuePending(queue, 202, "req-b");
+
+    const mirror = new SpawnedChildrenMirror();
+    mirror.recordSpawned(201, "rec-a");
+    mirror.recordSpawned(202, "rec-b");
+    mirror.killAll();
+
+    await expect(p1).resolves.toEqual({ cancelled: true });
+    await expect(p2).resolves.toEqual({ cancelled: true });
+  });
+
+  it("未登记队列（headless / 无 UI 通道宿主）→ exited 为 no-op，不抛", () => {
+    const mirror = new SpawnedChildrenMirror();
+    mirror.recordSpawned(301, "rec-3");
+    expect(() =>
+      mirror.recordStateChanged({ pid: 301, recordId: "rec-3", state: "exited", killed: true }),
+    ).not.toThrow();
+  });
+});

package/src/execution/engine/client/__tests__/protocol-closure.test.ts

@@ -7,6 +7,7 @@
 // UiRequest / UiResponse / UiRequestHandler / UiMethod 的 core 侧出口 =
 // execution/dialog-queue.ts 的 SDK 再导出（W7 已切换，SSOT = SDK ui-types）——
 // 本断言的 Core* 别名现在与 Sdk* 同源，保留断言形态防未来回退为本地定义后漂移。
+// [H1 U5/U6] InteractAction / InteractResult 断言对已随 chat 域 interact 面退役删除。
 
 import { describe, expect, it } from "vitest";
 
@@ -17,8 +18,6 @@ import type {
   AgentOutcome as SdkAgentOutcome,
   EngineCapabilities as SdkEngineCapabilities,
   EngineHandleData as SdkEngineHandleData,
-  InteractAction as SdkInteractAction,
-  InteractResult as SdkInteractResult,
   ProbeReport as SdkProbeReport,
   SessionView as SdkSessionView,
   UiRequest as SdkUiRequest,
@@ -37,8 +36,6 @@ import type {
   AgentOutcome as CoreAgentOutcome,
   EngineCapabilities as CoreEngineCapabilities,
   EngineHandleData as CoreEngineHandleData,
-  InteractAction as CoreInteractAction,
-  InteractResult as CoreInteractResult,
   ProbeReport as CoreProbeReport,
   SessionView as CoreSessionView,
 } from "../../types.ts";
@@ -54,8 +51,6 @@ type _CoreSdkAgentEvent = AssertMutuallyAssignable<CoreAgentEvent, SdkAgentEvent
 type _CoreSdkAgentOutcome = AssertMutuallyAssignable<CoreAgentOutcome, SdkAgentOutcome>;
 type _CoreSdkEngineCapabilities = AssertMutuallyAssignable<CoreEngineCapabilities, SdkEngineCapabilities>;
 type _CoreSdkEngineHandleData = AssertMutuallyAssignable<CoreEngineHandleData, SdkEngineHandleData>;
-type _CoreSdkInteractAction = AssertMutuallyAssignable<CoreInteractAction, SdkInteractAction>;
-type _CoreSdkInteractResult = AssertMutuallyAssignable<CoreInteractResult, SdkInteractResult>;
 type _CoreSdkProbeReport = AssertMutuallyAssignable<CoreProbeReport, SdkProbeReport>;
 type _CoreSdkSessionView = AssertMutuallyAssignable<CoreSessionView, SdkSessionView>;
 type _CoreSdkWorktreeHandle = AssertMutuallyAssignable<CoreWorktreeHandle, SdkWorktreeHandle>;
@@ -75,8 +70,6 @@ const _assertions: Array<true> = [
   true as _CoreSdkAgentOutcome,
   true as _CoreSdkEngineCapabilities,
   true as _CoreSdkEngineHandleData,
-  true as _CoreSdkInteractAction,
-  true as _CoreSdkInteractResult,
   true as _CoreSdkProbeReport,
   true as _CoreSdkSessionView,
   true as _CoreSdkWorktreeHandle,
@@ -89,7 +82,7 @@ const _assertions: Array<true> = [
 
 describe("协议契约类型双向可赋值（编译期断言的运行时锚）", () => {
   it("全部断言成立（漂移会在 tsc --noEmit 报 never → 本文件编译失败）", () => {
-    expect(_assertions).toHaveLength(14);
+    expect(_assertions).toHaveLength(12);
     expect(_assertions.every((v) => v === true)).toBe(true);
   });
 });

package/src/execution/engine/client/__tests__/remote-engine.test.ts

@@ -15,6 +15,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { EngineClient } from "../engine-client.ts";
 import { RemoteEngine, type RemoteEngineManifestSnapshot } from "../remote-engine.ts";
 import { SubagentStream } from "../../../stream-sink.ts";
+import { getSubagentSessionDir } from "../../../path-encoding.ts";
 import { isProcessAlive } from "../pid-file.ts";
 import { getLogger, type UiRequest } from "@zhushanwen/subagent-engine-sdk";
 
@@ -253,6 +254,49 @@ describe("RemoteEngine run 帧映射", () => {
     await cleanup();
   });
 
+  it("ctx.sessionRootId → wire ctx.sessionRootId 逐字保真；缺省不传 → wire 无该键（F6 additive）", async () => {
+    // 正向：根 session id 上 wire（pi 引擎 relay 归属键 SESSION_ID 的权威来源）
+    const withRoot = makeEngine();
+    const { ctx: ctxRoot, events: eventsRoot } = makeCtx({ sessionRootId: "root-sess-f6" });
+    await withRoot.engine.run({ prompt: "p" }, ctxRoot);
+    expect(extractRunParams(eventsRoot).ctx.sessionRootId).toBe("root-sess-f6");
+
+    // 负向：缺省 → wire ctx 不出现该键（undefined 不上 wire，旧引擎 additive 兼容）
+    const bare = makeEngine();
+    const { ctx: ctxBare, events: eventsBare } = makeCtx();
+    await bare.engine.run({ prompt: "p" }, ctxBare);
+    expect(extractRunParams(eventsBare).ctx).not.toHaveProperty("sessionRootId");
+
+    await withRoot.cleanup();
+    await bare.cleanup();
+  });
+
+  it("[Option C] wire ctx.sessionDir = getSubagentSessionDir(env 同源推导)；ctx 显式注入优先", async () => {
+    // stub env 固定推导输入（测试进程可能已带这两键——stub 后期望值确定）
+    vi.stubEnv("PI_CODING_AGENT_DIR", join(dataDir, "agent-dir"));
+    vi.stubEnv("PI_SUBAGENT_ROOT_CWD", join(dataDir, "root-cwd"));
+    try {
+      // 正向：env 同源推导值上 wire（宿主单一权威 getSubagentSessionDir，引擎不自推导）
+      const derived = makeEngine();
+      const { ctx, events } = makeCtx();
+      await derived.engine.run({ prompt: "p" }, ctx);
+      expect(extractRunParams(events).ctx.sessionDir).toBe(
+        getSubagentSessionDir(join(dataDir, "agent-dir"), join(dataDir, "root-cwd")),
+      );
+
+      // 宿主编排层显式注入（ctx.sessionDir）优先于 env 推导
+      const injected = makeEngine();
+      const { ctx: ctxInj, events: eventsInj } = makeCtx({ sessionDir: "/explicit/session-dir" });
+      await injected.engine.run({ prompt: "p" }, ctxInj);
+      expect(extractRunParams(eventsInj).ctx.sessionDir).toBe("/explicit/session-dir");
+
+      await derived.cleanup();
+      await injected.cleanup();
+    } finally {
+      vi.unstubAllEnvs();
+    }
+  });
+
   it("poolResolved / handleReady → RunContext 回调（journal 路径权威 + 运行中句柄回填）", async () => {
     const pools: string[] = [];
     const readies: Array<{ sessionRef: Record<string, string>; poolKey: string }> = [];
@@ -393,7 +437,7 @@ describe("gate 位多声明 run 期判定（W3 契约⑤接线：manifest vs ini
   });
 });
 
-describe("interact / read / probe / dispose 门面", () => {
+describe("read / probe / dispose 门面（[H1 U6] interact 断言随 interact 面退役删除）", () => {
   it("read 协议帧携带 dataDir（必填：存量池时代相对 dbPath 定位）", async () => {
     const { engine, cleanup } = makeEngine();
     const view = await engine.read({
@@ -411,21 +455,11 @@ describe("interact / read / probe / dispose 门面", () => {
     await cleanup();
   });
 
-  it("probe → ProbeReport；interact → delivered；dispose → client 停机（幂等）", async () => {
+  it("probe → ProbeReport；dispose → client 停机（幂等）", async () => {
     const { engine, cleanup } = makeEngine();
     const report = await engine.probe();
     expect(report.ok).toBe(true);
     expect(report.engineVersion).toBe("fake-1.0.0");
-    const interact = await engine.interact({
-      data: {
-        v: 1,
-        engineId: "fake",
-        sessionRef: { sessionId: "s-1" },
-        poolKey: "shared",
-        adapterVersion: "fake-adapter",
-      },
-    }, { kind: "message", payload: "hi" });
-    expect(interact).toEqual({ ok: true, delivered: true });
     await engine.dispose();
     await expect(engine.dispose()).resolves.toBeUndefined(); // 幂等
     await cleanup();