@zhushanwen/subagent-core 0.8.0 → 0.9.0

package/src/execution/engine/__tests__/conformance/__fixtures__/engine-protocol/fake-engine-protocol.mjs

@@ -4,11 +4,13 @@
 //
 // 形态对齐协议 v1（stdout 独占 NDJSON；stdin 帧驱动）：
 // - FAKE_PROTOCOL_FIXTURE：fixture JSON 路径（必填）；本件 = 该 fixture 的回放引擎；
-// - 正向方法（10 个）：initialize / probe / run / cancel / interact / read /
-//   listModels / validateModel / dispose / ping——结果取 fixture 对应段；
+// - 正向方法（9 个）：initialize / probe / run / cancel / read / listModels /
+//   validateModel / dispose / ping——结果取 fixture 对应段（[H1 U5] interact 已随
+//   chat-run 统一退役）；
 // - 反向通道（8 个）：host/log / host/askUser / host/permission / host/streamDelta /
 //   host/poolResolved / host/handleReady / host/childSpawned / host/childStateChanged
-//   ——run 期间按 fixture.run.script 逐动作播放；
+//   ——run 期间按 fixture.run.script 逐动作播放（[H1 U5] 曾有的轮次相位通道已随
+//   chat-run 统一退役）；
 // - 错误帧：FAKE_PROTOCOL_ERROR=run_failed（run 回错误帧）| unknown_method（对任意
 //   未知名方法回 engine_method_unknown——不在 v1 错误码表内的码也必须原样透传，
 //   断言的是帧形态而非码表）；FAKE_PROTOCOL_VERSION 越界 → initialize 回
@@ -20,18 +22,16 @@
 // - FAKE_PID_FILE：启动时写自身 pid（SIGTERM 用例的 kill 定位锚——core 侧 pidfile
 //   归 EngineClient 所有，fake 侧不触碰，路径自建自删归测试）；
 // - FAKE_CAPABILITIES_CONVERSATION：覆写 initialize 应答的
-//   capabilities.conversation（chat gate 负向：旧形态引擎 manifest 无该位）；
+//   capabilities.conversation（resume 能力位 gate 负向：旧形态引擎 manifest 无该位）；
 // - 新 script op（env 注入 script，沿 FAKE_RUN_HANG 先例）：
 //     { op:"stderr", text }                    → 引擎 stderr 写点（engine_crashed
 //                                                的 stderr 尾 400 窗口实证）；
-//     { op:"roundLifecycle", keyedBy, key,
-//       phase, error?, anchor? }               → host/roundLifecycle 帧（三相位 ×
-//                                                runId|recordId 关联键分路）；
-//     streamDelta op 支持 action.recordId      → recordId 键 delta（续聊轮关联键）；
-// - 数据面应答回声：roundLifecycle / recordId-delta 帧的②应答到达时回发
-//   host/log("ack <label>")——core 侧断言「宿主确认收到」回执链闭合的观测锚；
-// - FAKE_RUN_LIFECYCLE=1 / FAKE_RUN_RECORD_DELTA=1 / FAKE_RUN_STDERR_HANG=1：
-//   run script 注入上述动作段（三相位 × 双键 / recordId 键 delta / stderr+hang）。
+//     streamDelta op 支持 action.recordId      → recordId 键 delta（chat 续聊轮关联键）；
+// - 数据面应答回声：recordId-delta 帧的②应答到达时回发 host/log("ack <label>")——
+//   core 侧断言「宿主确认收到」回执链闭合的观测锚；
+// - FAKE_RUN_RECORD_DELTA=1 / FAKE_RUN_STDERR_HANG=1：run script 注入上述动作段
+//   （recordId 键 delta / stderr+hang）。[H1 U5] FAKE_RUN_LIFECYCLE（轮次相位 ×
+//   双键注入段）已随通道退役删除。
 
 import { spawn } from "node:child_process";
 import { readFileSync, writeFileSync } from "node:fs";
@@ -119,8 +119,8 @@ async function playRunScript(runId, script) {
         });
         break;
       case "streamDelta": {
-        // [W6] action.recordId 有值 = 续聊轮 recordId 键 delta（关联键分路——
-        // D1-A：interact 发起的轮无 runId，经 handle.sessionRef 的 recordId 关联）。
+        // [W6] action.recordId 有值 = chat 续聊轮 recordId 键 delta（关联键分路——
+        // D1-A：续聊轮经 handle.sessionRef 的 recordId 关联）。
         const streamReqId = `rev-stream-${nextRequestId++}`;
         if (action.recordId !== undefined) {
           ackEchoLabels.set(streamReqId, `streamDelta recordId=${action.recordId}`);
@@ -141,24 +141,6 @@ async function playRunScript(runId, script) {
         // 后续动作可用 host/log 做到达锚）。
         process.stderr.write(action.text ?? "");
         break;
-      case "roundLifecycle": {
-        // [W6] host/roundLifecycle 帧（三相位 × runId|recordId 双关联键）。
-        // failed 相位必含 error{code,message}（isHostRoundLifecycleParams 判据）。
-        const lcReqId = `rev-lc-${nextRequestId++}`;
-        const keyed =
-          action.keyedBy === "recordId"
-            ? { recordId: action.key }
-            : { runId: action.key };
-        ackEchoLabels.set(lcReqId, `roundLifecycle ${action.key} ${action.phase}`);
-        reverseRequest(lcReqId, "host/roundLifecycle", {
-          ...keyed,
-          phase: action.phase,
-          ...(action.usage !== undefined ? { usage: action.usage } : {}),
-          ...(action.error !== undefined ? { error: action.error } : {}),
-          ...(action.anchor !== undefined ? { anchor: action.anchor } : {}),
-        });
-        break;
-      }
       case "permission":
         reverseRequest(`rev-perm-${nextRequestId++}`, "host/permission", {
           runId,
@@ -187,7 +169,7 @@ async function playRunScript(runId, script) {
 }
 
 const KNOWN_METHODS = new Set([
-  "initialize", "probe", "run", "cancel", "interact", "read",
+  "initialize", "probe", "run", "cancel", "read",
   "listModels", "validateModel", "dispose", "ping",
 ]);
 
@@ -205,9 +187,8 @@ createInterface({ input: process.stdin }).on("line", (line) => {
   }
 
   // 帧②（core 对反向请求的应答）：askUser 最终结果到达——回放层记录后继续。
-  // [W6] 数据面（roundLifecycle / recordId-delta）应答到达 → 回发 host/log 回声
-  // （core 侧「宿主确认收到」回执链闭合的观测锚；NDJSON 单连接有序，回声先于
-  // run 应答帧到达）。
+  // [W6] 数据面（recordId-delta）应答到达 → 回发 host/log 回声（core 侧「宿主
+  // 确认收到」回执链闭合的观测锚；NDJSON 单连接有序，回声先于 run 应答帧到达）。
   if (typeof frame.id === "string") {
     const echoLabel = ackEchoLabels.get(frame.id);
     if (echoLabel !== undefined) {
@@ -278,9 +259,6 @@ createInterface({ input: process.stdin }).on("line", (line) => {
     case "validateModel":
       send({ id, result: fixture.validateModel.result });
       return;
-    case "interact":
-      send({ id, result: fixture.interact.result });
-      return;
     case "read":
       send({ id, result: fixture.read.result });
       return;
@@ -327,18 +305,6 @@ createInterface({ input: process.stdin }).on("line", (line) => {
           { op: "hang" },
         );
       }
-      if (process.env.FAKE_RUN_LIFECYCLE === "1") {
-        injected.push(
-          // 三相位 × 双关联键（settled 带 usage；idle/failed 带 anchor；failed 带
-          // error{code,message}——isHostRoundLifecycleParams 的相位居留形状）。
-          { op: "roundLifecycle", keyedBy: "runId", key: "run-smoke-1", phase: "settled", usage: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 } },
-          { op: "roundLifecycle", keyedBy: "runId", key: "run-smoke-1", phase: "idle", anchor: { sessionRef: { sessionId: "sess-fixture" }, poolKey: "shared" } },
-          { op: "roundLifecycle", keyedBy: "runId", key: "run-smoke-1", phase: "failed", error: { code: "engine_run_failed", message: "round failed (scripted)", recovery: "Inspect the task and retry." } },
-          { op: "roundLifecycle", keyedBy: "recordId", key: "rec-chat-1", phase: "settled" },
-          { op: "roundLifecycle", keyedBy: "recordId", key: "rec-chat-1", phase: "idle", anchor: { sessionRef: { sessionId: "sess-chat-1" }, poolKey: "shared" } },
-          { op: "roundLifecycle", keyedBy: "recordId", key: "rec-chat-1", phase: "failed", error: { code: "engine_run_failed", message: "chat round failed (scripted)", recovery: "Inspect the task and retry." } },
-        );
-      }
       if (process.env.FAKE_RUN_RECORD_DELTA === "1") {
         injected.push({ op: "streamDelta", recordId: "rec-chat-1", delta: "chat-delta-not-routed-to-runId" });
       }

package/src/execution/engine/__tests__/conformance/__fixtures__/engine-protocol/smoke-run.fixture.json

@@ -68,11 +68,6 @@
       "canonicalRef": "fake/fake-1"
     }
   },
-  "interact": {
-    "result": {
-      "accepted": true
-    }
-  },
   "read": {
     "result": {
       "entries": [],

package/src/execution/engine/__tests__/conformance/engine-conformance.live.test.ts

@@ -38,7 +38,7 @@ import {
   RELAY_ENV_SOCKET,
   RELAY_PROTOCOL_VERSION,
   isRelayActive,
-} from "../../../relay-env.ts";
+} from "@zhushanwen/subagent-engine-sdk";
 import { assertAgentEventInvariants } from "./agent-event-invariants.ts";
 
 const LIVE = process.env["ENGINE_CONFORMANCE_LIVE"] === "1";

package/src/execution/engine/__tests__/conformance/protocol-blackbox.test.ts

@@ -1,7 +1,7 @@
 // protocol-blackbox.test.ts —— W10 协议黑盒套件（基线三层①的自动层）。
 //
 // 覆盖（impl-plan §2.10 / 设计 §4 探针挂钩①）：
-//   - 10 正向方法（initialize/probe/run/cancel/interact/read/listModels/
+//   - 9 正向方法（initialize/probe/run/cancel/read/listModels/
 //     validateModel/dispose/ping）× fake 引擎 CLI 往返；
 //   - 8 反向通道（host/log、host/askUser、host/permission、host/streamDelta、
 //     host/poolResolved、host/handleReady、host/childSpawned、host/childStateChanged）
@@ -137,8 +137,8 @@ function makeHarness(extraEnv: Record<string, string> = {}, routeRunId = fixture
   return h;
 }
 
-describe("协议黑盒：10 正向方法 × fake 引擎回放", () => {
-  it("initialize/probe/listModels/validateModel/interact/read/ping 往返（fixture 白名单比对）", async () => {
+describe("协议黑盒：9 正向方法 × fake 引擎回放", () => {
+  it("initialize/probe/listModels/validateModel/read/ping 往返（fixture 白名单比对）", async () => {
     const h = makeHarness();
     try {
       await h.client.ensureConnected();
@@ -162,12 +162,8 @@ describe("协议黑盒：10 正向方法 × fake 引擎回放", () => {
       )) as { canonicalRef: string };
       expect(validated.canonicalRef).toBe("fake/fake-1");
 
-      const interact = (await h.client.request(
-        "interact",
-        { handle: fixture.run.result.handle, action: { kind: "message", text: "hi" } },
-        { timeoutMs: 5_000 },
-      )) as { accepted: boolean };
-      expect(interact.accepted).toBe(true);
+      // [H1 U5] interact 方法已随 chat-run 统一退役（D5）——往返断言随之删除，
+      // fake 引擎对未知方法回 engine_method_unknown（unknown_method 模式覆盖）。
 
       const view = (await h.client.request(
         "read",

package/src/execution/engine/__tests__/engine-discovery-scan.test.ts

@@ -125,9 +125,6 @@ function stubEngine(id: string): EnginePort {
     run: async () => {
       throw new Error("unused");
     },
-    interact: async () => {
-      throw new Error("unused");
-    },
     read: async () => ({ engineId: id, turns: [], source: "outcome-only" }),
   };
 }

package/src/execution/engine/__tests__/engine-discovery.test.ts

@@ -32,9 +32,6 @@ function stubEngine(id: string): EnginePort {
     run: async () => {
       throw new Error("unused");
     },
-    interact: async () => {
-      throw new Error("unused");
-    },
     read: async () => ({ engineId: id, turns: [], source: "outcome-only" }),
   };
 }

package/src/execution/engine/__tests__/model-prompt.test.ts

@@ -33,9 +33,6 @@ function fakeEngine(id: string, models: Array<{ id: string; name?: string }> | n
     run: async () => {
       throw new Error("not used in this test");
     },
-    interact: async () => {
-      throw new Error("not used in this test");
-    },
     read: async () => ({ engineId: id, turns: [], source: "outcome-only" }),
     ...(models !== null ? { listModels: () => models } : {}),
   };

package/src/execution/engine/__tests__/registry.test.ts

@@ -53,7 +53,6 @@ function makeFakeEngine(id: string): EnginePort {
       Promise.resolve({ ok: true, engineVersion: "0.0.0-test", checks: [{ name: "stub", ok: true }] }),
     run: (_task: AgentCallOpts, _ctx: RunContext) =>
       Promise.reject(new Error("fake engine: run not implemented")),
-    interact: () => Promise.resolve({ ok: false, code: "engine_capability_unsupported", message: "stub" }),
     read: (_handle: Parameters<EnginePort["read"]>[0]): Promise<SessionView> =>
       Promise.resolve({ engineId: id, turns: [], source: "outcome-only" }),
   };

package/src/execution/engine/__tests__/routing.test.ts

@@ -40,7 +40,6 @@ function makeFakeEngine(id: string, probeOk: boolean): EnginePort {
             } satisfies ProbeReport,
       ),
     run: (_t: AgentCallOpts, _c: RunContext) => Promise.reject(new Error("fake: run not implemented")),
-    interact: () => Promise.resolve({ ok: false, code: "engine_capability_unsupported", message: "stub" }),
     read: (_h: Parameters<EnginePort["read"]>[0]): Promise<SessionView> =>
       Promise.resolve({ engineId: id, turns: [], source: "outcome-only" }),
   };

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);
   });
 });