@zhushanwen/subagent-core 0.5.1 → 0.7.0

package/src/execution/engine/__tests__/conformance/H9-test-disposition.md

@@ -0,0 +1,116 @@
+# W10 H9 测试面处置表（core 深路径测试三选一）
+
+> 实施计划 §2.10「core 测试逐文件三选一处置清单」的执行记录（W10，2026-09-09）。
+> 处置依据 = 文件 import 实测 + W5/W7 已迁件核对。处置后 core test 全绿
+> （2999 passed | 7 skipped；删除 48 文件 / 改写 5 文件 / 保留待 W11 同批改写 4 文件——保留的 4 文件已随 W3 收口（1 删 3 改写），见 §② 节尾回写注记）。
+
+## ① 已随引擎包迁移 —— 删除 core 重复副本（11 文件）
+
+W5/W7 已把自包含件迁入引擎包（pi-subagent-cli / zcode-subagent-cli `__tests__/`，
+两包 test 全绿），core 侧同名副本属重复实现测试，删除：
+
+| core 副本（已删） | 引擎包权威副本 |
+|---|---|
+| `src/__tests__/fr4-get-state-handshake.test.ts` | pi-subagent-cli `__tests__/get-state-handshake.test.ts` |
+| `execution/__tests__/get-state-handshake.test.ts` | 同上 |
+| `execution/__tests__/output-collector.test.ts` | pi `__tests__/output-collector.test.ts` |
+| `execution/__tests__/pi-invocation.test.ts` | pi `__tests__/pi-invocation.test.ts` |
+| `execution/__tests__/temp-prompt.test.ts` | pi `__tests__/temp-prompt.test.ts` |
+| `execution/__tests__/stdin-writer.test.ts` | pi `__tests__/stdin-writer.test.ts` |
+| `execution/__tests__/spawn-event-adapter.test.ts` | pi `__tests__/spawn-event-adapter.test.ts` |
+| `execution/__tests__/spawn-event-adapter-rpc.test.ts` | pi `__tests__/spawn-event-adapter-rpc.test.ts` |
+| `execution/__tests__/turn-limiter.test.ts` | pi `__tests__/turn-limiter.test.ts` |
+| `execution/__tests__/turn-limiter-semantics.test.ts` | pi `__tests__/turn-limiter-semantics.test.ts` |
+| `execution/__tests__/spawn-args.test.ts` | pi `__tests__/spawn-args.test.ts`（core 副本的 `MAX_FORK_DEPTH` 断言面由 `recursive-visibility-baseline`/`nested-visibility` 族承接） |
+
+## ① 随 SDK 原语迁移（1 文件）
+
+| core（已删） | 迁移落点 |
+|---|---|
+| `execution/engine/__tests__/paths.test.ts` | `subagent-engine-sdk/src/__tests__/paths.test.ts`（import 改 SDK 包内相对路径，5 用例全绿） |
+
+## ② 改写为镜像/协议等价断言 —— 已完成（5 文件）
+
+| 文件 | 改写内容 |
+|---|---|
+| `src/orchestration/__tests__/execute-agent-call.test.ts` | output-collector 深路径 import → `@zhushanwen/pi-subagent-cli` 公共导出面（25 用例绿） |
+| `execution/__tests__/subprocess-agent-runner-routing.test.ts` | `getChildByRecord` 深路径 → core 侧镜像 `host/spawned-children.ts coreSpawnedChildrenMirror().getChildByRecord`（pid 同构判据）；「退出后按句移除」断言移至 protocol-blackbox childStateChanged 用例（inproc 双模不回灌该通道，文件内已注记） |
+| `execution/__tests__/chat-engine-routing.test.ts` | 同上（镜像面改写） |
+| `execution/engine/__tests__/common/capability-gate.test.ts` | PiEngine/ZcodeEngine 内建构造 → 读两引擎包 package.json manifest `xyz-agent.subagentEngine.capabilities`（同步成员唯一源；11 用例绿） |
+| `execution/engine/__tests__/conformance/contract.{probe,abort,read-degradation,agent-events}.test.ts` + `golden-replay.{pi,zcode}.test.ts` + `engine-conformance.live.test.ts` | conformance 契约套件整体协议黑盒化：RemoteEngine × fake 引擎 CLI / golden 语料改引擎包 `__golden__/` + 公共导出面 / live 门改「协议客户端 × 引擎包 CLI」形态（A2 真机形态本身） |
+
+## ② 改写被阻塞 —— 保留 + W10 处置注记，W11 同批改写（4 文件）[v1.x W3 已收口，见节尾回写注记]
+
+`src/__tests__/append-system-prompt-assembly.test.ts`、`execution/__tests__/explicit-agent-ref-guard.test.ts`、`execution/__tests__/delivery-methods.test.ts`、`execution/__tests__/gc-timer.test.ts`。
+
+阻塞原因（同根）：这些文件 `vi.mock("…engines/pi/session-runner.ts")` 拦截的**是 core 生产代码的 inproc 深路径 import**（subagent-service / lifecycle 谓词等消费点在生产侧）——mock 目标改指引擎包或镜像需生产 import 先改线，而 W6 已把改线收敛到 W11 收口（`subagent-service.ts` W7 注 + `lifecycle-predicates.test.ts` 仍深 import spawnedChildren 同证）。W11 删内建当轮必须同批改写这 4 个文件（每文件头部已留 `[W10 处置注记]`）。
+
+> **[v1.x W3 已收口 —— 回写注记（2026-09-09）]** 上方 4 文件已随 commit `0df9ef8b3`（W3 删 inproc pi 引擎 + chat 协议化改线）处理完毕：`append-system-prompt-assembly.test.ts` 删除，其余 3 文件改写为协议等价断言（`explicit-agent-ref-guard.test.ts` / `delivery-methods.test.ts` / `gc-timer.test.ts`，现头注 `[W3 改写]` 可核）。原 `[W10 处置注记]` 已被 `[W3 改写]` 头注取代，W11 对这 4 文件无剩余改写面。本节标题、阻塞原因与文首统计行保留作 W10 时点历史（[HISTORICAL] 纪律），现行状态以本注记为准。
+
+## ③ 声明废弃 —— 删除（34 文件 + 1 helper）
+
+统一理由（按文件另有侧重）：**被测行为 = 内建 pi/zcode inproc 编排实现**，协议化终态下该实现归引擎进程（W11 删除 core `engines/pi|zcode`）；行为面承接：
+
+- **引擎内部行为**（spawn 参数/dispatch/LRU/心跳/EPIPE/收敛）→ `@zhushanwen/pi-subagent-cli` / `zcode-subagent-cli` 包内测试（W5/W7 迁移件，两包全绿）；
+- **协议契约面**（run/cancel/read/反向通道/错误帧/结构等价）→ W10 新协议黑盒套件 `conformance/protocol-blackbox.test.ts` + `client/__tests__/*`（W2）；
+- **收割/杀链语义**（R9-1 口径：一代子进程 + 组内后代）→ SDK kill-chain 单测 + A3 真机门；
+- **inproc 双模过渡态**（XYZ_SUBAGENT_ENGINE_MODE）本身 = DoD#5 删除对象，不保留锚定测试。
+
+| 已删文件 | 侧重理由 |
+|---|---|
+| `src/__tests__/session-runner.test.ts` | 引擎内部（pi spawn-runner） |
+| ask-user-transit-e2e / ui-request-handler | ui 请求链引擎内部面（pi 包 ui-channels/ui-request-queue 测试 + W10 反向通道用例） |
+| chatmode-first-round-closure-spawn / run-and-finalize-chatmode / run-spawn-chatmode-settled | chat 轮次收敛编排（pi 包 spawn-runner；chat 域 HostBridge 编排 W7 已登记 stage-3 gap） |
+| descendant-sweep / descendant-sweep-guards / kill-all-escalation / service-kill-escalation / spawned-children | 收割/杀链（SDK kill-chain + A3 真机门；镜像面 = protocol-blackbox） |
+| epipe-fallback / session-runner-epipe | EPIPE 兜底（pi 包 stdin-writer/spawn-runner 测试） |
+| keep-alive-no-progress / settled-watchdog / timeout-integration | 进度/超时判据（ADR-0047 域）。**处置改写（2026-09-09，Gate B 后纠正）**：原「pi 包 + A8 真机门」承接声称不成立——pi 包内无等价测试（grep keep-alive/no-progress/settled-watchdog/timeout-integration 零命中），Gate B 时点 A8 真机门为 blocked/manual、不构成承接证据；该三测试的行为面**随 keep-alive 协议化偏差登记**（impl-plan §5 2026-09-09 行：workflow 域单次 run 口径 agent_end 即终结，后台后代保活编排未随迁移），**不声称已承接** |
+| recursive-visibility-env / start-sync-model-guard / session-runner-schema-env | 引擎内 env 注入面（pi 包 spawn-args/relay-env 测试；W12 env 契约单测） |
+| rpc-mode / run-spawn-rpc-mode / run-spawn-integration / run-spawn-resume / run-spawn-edges / run-and-finalize-anchoring / run-spawn-stdout-callback-throw / spawn-worktree-guidance | run 全链编排（pi 包 spawn-runner/protocol-e2e；协议面 = W10 黑盒套件） |
+| session-runner-branch-cache-lru / session-runner-close-prune / session-runner-dispatch / session-runner-heartbeat-idle-fallback / session-runner-lifecycle-helpers | session-runner 内部机制（pi 包） |
+| max-turns-to-watchdog-ms | turn limiter 换算（pi 包 turn-limiter 测试） |
+| subagent-service-message-close | message-close 编排（chat 域 stage-3 gap 承接） |
+| worktree-pid-registration.integration | pid 注册集成（镜像面承接；worktree 面归 W12 回归） |
+| execution-runtime-face / engine-model-validation / session-view-service-zcode-dbpath | zcode 引擎内部（zcode 包 zcode-engine-* / reader / zcode-session-db-isolation 测试） |
+| `helpers/session-runner-mocks.ts` | 消费者全部随上表删除（spawn-mock.ts 保留——3 个存活壳侧行为测试仍消费） |
+
+## 未入清单的既有深路径引用（W11 处置面，W10 显式登记）[v1.x W3 已收口，见节尾回写注记]
+
+以下文件经 `vi.mock` 字符串路径引用 `engines/pi|zcode`（非值 import，grep 字符串命中），
+不在 §2.10 三选一清单内、本次未动，W11 删内建时同批核处：
+`recursive-visibility-baseline` / `nested-visibility-env-propagation` / `execute-nesting` / `execute-and-await-worktree` / `collect-coordinator-service` / `collect-mixed-dispatch` / `get-record-for-action-restart` / `stream-sink-retirement` / `subagent-agent-runner.test` / `subagent-service-{multiproc-guard,notify-gate,parent-guard,recovery-bounds}` / `sync-collect-recovery` / `helpers/{spawn-mock,subagent-service-mocks}` / `lifecycle-predicates.test`（归 W6/W11）。
+
+> **[v1.x W3 已收口 —— 回写注记（2026-09-09）]** 上节登记的 17 项（14 测试 + 2 helper + `lifecycle-predicates.test`）已全部随 commit `0df9ef8b3`（W3 删 inproc pi 引擎 + chat 协议化改线）处理完毕：节内所列文件在该 commit 全部为改写（M），无一保留原深路径 mock；其中 `subagent-agent-runner.test` 系 `subprocess-agent-runner.test.ts` 的简写登记，同在该 commit 改写。`vi.mock(…engines/pi|zcode)` 深路径命中现全 core 树清零（grep 实测：残留仅注释/用例描述文本，无模块路径引用）；`[W3]`/`[W3 改写]` 标记 17 项中 14 项可核（标记散布文件头部注记与用例旁注，非全在文件头），余 3 项（`execute-and-await-worktree` / `subagent-service-multiproc-guard` / `subagent-service-parent-guard`）无标记但同 commit 已删深路径 mock（diff 可核）。W11（commit `6d5f6747d`）对该面无剩余核处义务。原节登记保留作 W10 时点历史（[HISTORICAL] 纪律），现行状态以本注记为准。
+
+
+## 主会话修正（2026-09-09，W10 修复轮）
+
+- `engine/__tests__/common/session-view-service-zcode-dbpath.test.ts` 原列 §2.10 清单①（随 zcode 包迁移/W5），但 W5 未迁（它测的是 core 壳侧 session-view-service 白名单分支，非引擎内部行为）、W10 批次误删——已按原样恢复（8 用例绿）。该文件深路径 import（engines/zcode/{reader,constants,db-path}）在 **W11 H1 改写当轮**随 session-view-service 协议化同批改写为协议等价断言（或由 zcode 包 e2e 接替后删除）；在此之前保留为 A plan（zcode-session-db-isolation）生产链验收证据。
+- ①类清单中「测 core 壳侧模块」的文件（本件与 execution-runtime-face / engine-model-validation）处置归属应为「W11 H1/H2 同批」而非「随引擎包迁移」——后续处置以本节为准。
+
+
+## W6 承接回写（2026-09-09，chat-domain v1.x 轮次活性治理）
+
+> 设计权威源：`docs/design/chat-domain-v1x-liveness-governance.md` §3.2 D2/D5 + §5 W6 行。
+> 本节回写 §③ 行「keep-alive-no-progress / settled-watchdog / timeout-integration」的
+> 处置改写注记（该行「不声称已承接」状态自本节起 supersede）——三测试行为面已随
+> W4/W6 落地，承接落点如下。原注记保留作历史，不删（[HISTORICAL] 纪律）。
+
+| 原测试 | 承接落点 | 状态 |
+|---|---|---|
+| keep-alive-no-progress | **W4 轮次活性监督器**（keep-alive 编排归属裁决 A：core 编排层持有「轮次活性权威」，`execution/round-supervisor/`——no-progress 判定域按设计 D2 域分类收窄：run 域 resumable 无驱动任务归监督器三态；chat 域 idle 稳态豁免归 settled-watchdog/idle 机制）+ conformance 协议黑盒场景链 `conformance/round-liveness-supervisor.test.ts`（SIGTERM crash → 纳管 → 该唤醒 → 该放弃全链 / boot 分区 / 通知对账 / 重建不解管）+ W4 判定矩阵单测 `execution/__tests__/round-supervisor.test.ts` | 已承接（W6 回写） |
+| settled-watchdog | **含生产接线归属**：两段守护行为面 = 既有 core 原语套件（`execution/__tests__/subagent-service-recovery-bounds.test.ts`：armSettledWatchdog / mid-round no-progress / settled 硬顶 / 双 disarm 回收面）。**生产接线归属（D5「删件不同批重接 = 失守」约束）**：W4 已立协议事件 API 三入口——`execution/settled-watchdog.ts` 的 `refreshFromProtocolEvent`（协议事件行到达刷新中段）/ `noteRoundSettledFromProtocol`（settled 相位中段让位收尾段）/ `disarmRoundFromProtocol`（idle 相位/close/终态两段一并清），零新语义薄委托、与存量原语幂等并存；**W3 删 `engines/pi/session-runner.ts` 时必须同批把存量 arm/refresh/kill 接线（arm 点 = 轮开始；refresh 源 = host/streamDelta + host/roundLifecycle；kill/终态 = 既有杀链）换到这三个入口**——接线未重接完成前 W3 不得删件 | 已承接（协议事件面已立 + W3 重接认领） |
+| timeout-integration | live conformance 门（`conformance/engine-conformance.live.test.ts`，`ENGINE_CONFORMANCE_LIVE=1 PI_LIVE_MODEL=<模型>`；设计验收 A7）——超时/abort/收敛行为在真机引擎 + 真实进程生命周期下验证；单测不再锚定 inproc 实现（原 timeout-integration 的「abort 超时强杀集成」语义由 W7 runtime 三级阶梯测试 + 本 live 门共同承载） | 已承接（live 门） |
+
+**W6 同批新增语义钉住**（conformance 领地，均绿于 `pnpm --filter @zhushanwen/subagent-core test`）：
+
+- 引擎中途 SIGTERM → run 终态 failed（**D5 前置闸：本用例先于 W3 删 `engines/pi/session-runner.ts` 旧 143 误分类器存在并保持绿**，P2 探针的 conformance 承载）→ `conformance/engine-crash.test.ts`；
+- chat 轮次协议 v1.x（host/roundLifecycle 三相位 × runId|recordId 关联键回执链 + recordId 键 delta 分路 + conversation gate 负向 A6）→ `conformance/chat-round-protocol.test.ts`；
+- 翻档事实（三类型全 process 档、跨时长无 TTL 清理）+ fork 读侧过滤①③两口径 + **bash 跨 session 可见性显式断言**（R4 一刀钉成显式选择）+ 偏差 #4 探针（goal 守卫口径实测）→ `conformance/registry-fork-filter.test.ts`。
+
+**goal 熔断（W5）处置**：**由 extension 侧单测承载，不重复造**——`extensions/universal/goal` 393 例已覆盖双维度熔断（circuit-breaker 6 + liveness 17：50 次封顶必停发、第 5 轮起间隔 ×2、恢复清零退避不重置总数、defer 通知去重）；设计验收 A10（实机熔断场景）仍归 Gate B 真机剧本，不在 conformance 重复。
+
+## 一致性审查批 2 修复回写（2026-09-09，F-2 首轮 arm 重接）
+
+上方 W6 承接回写节「settled-watchdog」行声称的「W3 重接」**当时失实**（一致性审查批 2 F-2 证实）：W3 实际只重接了热路径续聊轮（`deliverChatMessage` 的 arm 调用点），`kickOffChatRound`（spawn 首轮 + 冷续 resume 轮）内无任何 arm 调用——:1382 注释声称「首轮调用点在 kickOffChatRound 的 run 派发后」不存在，被删的 inproc stdout-pump 是首轮唯一中段守护，协议化后引擎侧 spawn-runner 仅 turn 计数无墙钟 → **首轮 wedged 无熔断**（LC-1 场景①重新敞开）。H9 行「已承接」按当时状态属过度声称。
+
+**修复后真实状态**（本行 supersede 上方 W6 行的承接声明）：`kickOffChatRound` 在 run 派发前（pool acquire 成功后）补 `armMidRoundNoProgress`，与热路径 arm 复用同一守护实例语义（同一 `onHotPathSettledWatchdogTimeout` 处置闭包）；refresh 源核实齐备——首轮 runId 键 `ctx.onEvent` 协议事件行（含 text_delta，引擎侧 spawn-runner 对 text_delta 同时走 onEvent/onDelta 两通道）+ `ctx.onRoundLifecycle` settled 相位交棒（`noteRoundSettledFromProtocol`，首轮 runId 键经同一 handleChatRoundPhase 收敛，本批测试核实生效）。承接测试：`execution/__tests__/chat-round-first-round-watchdog.test.ts`（首轮 arm / 冷续轮静默 30min 熔断 / 中段事件行刷新 / settled 交棒不继承中段计时）。

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

@@ -0,0 +1,377 @@
+// fake-engine-protocol.mjs —— W10 协议黑盒套件的 fake 引擎 CLI（conformance 专用，
+// 与 W2 client/__tests__ 的 fake-engine.mjs 分工：后者测 EngineClient 连接域语义，
+// 本件是协议基线回放器——按 fixture（schemaVersion 1）回放帧序列）。
+//
+// 形态对齐协议 v1（stdout 独占 NDJSON；stdin 帧驱动）：
+// - FAKE_PROTOCOL_FIXTURE：fixture JSON 路径（必填）；本件 = 该 fixture 的回放引擎；
+// - 正向方法（10 个）：initialize / probe / run / cancel / interact / read /
+//   listModels / validateModel / dispose / ping——结果取 fixture 对应段；
+// - 反向通道（8 个）：host/log / host/askUser / host/permission / host/streamDelta /
+//   host/poolResolved / host/handleReady / host/childSpawned / host/childStateChanged
+//   ——run 期间按 fixture.run.script 逐动作播放；
+// - 错误帧：FAKE_PROTOCOL_ERROR=run_failed（run 回错误帧）| unknown_method（对任意
+//   未知名方法回 engine_method_unknown——不在 v1 错误码表内的码也必须原样透传，
+//   断言的是帧形态而非码表）；FAKE_PROTOCOL_VERSION 越界 → initialize 回
+//   engine_protocol_mismatch；
+// - childSpawned 的 pid = 真 spawn 一个同组长眠 node 子进程（供 POSIX kill(-pid,0)
+//   组探测断言与 killAll 收割断言——范围口径 R9-1：一代子进程 + 组内后代）。
+//
+// [W6 conformance 增量] 追加面（全部 env 开关驱动，缺省关闭——既有回放行为不变）：
+// - FAKE_PID_FILE：启动时写自身 pid（SIGTERM 用例的 kill 定位锚——core 侧 pidfile
+//   归 EngineClient 所有，fake 侧不触碰，路径自建自删归测试）；
+// - FAKE_CAPABILITIES_CONVERSATION：覆写 initialize 应答的
+//   capabilities.conversation（chat 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）。
+
+import { spawn } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { createInterface } from "node:readline";
+
+const fixturePath = process.env.FAKE_PROTOCOL_FIXTURE;
+if (!fixturePath) {
+  process.stderr.write("fake-engine-protocol: FAKE_PROTOCOL_FIXTURE is required\n");
+  process.exit(1);
+}
+const fixture = JSON.parse(readFileSync(fixturePath, "utf8"));
+
+const MODE = process.env.FAKE_PROTOCOL_ERROR ?? "none"; // none | run_failed | unknown_method
+const PROTOCOL_VERSION = Number(process.env.FAKE_PROTOCOL_VERSION ?? fixture.protocolVersion ?? 1);
+
+// [W6] SIGTERM 用例的进程定位锚（测试自建自删；写失败不阻断回放主路径）。
+if (process.env.FAKE_PID_FILE) {
+  try {
+    writeFileSync(process.env.FAKE_PID_FILE, String(process.pid), "utf8");
+  } catch {
+    // 定位锚写失败只影响依赖它的用例（该用例 waitFor pidfile 会超时显式红），
+    // 不影响其余回放行为。
+  }
+}
+
+// [W6] 数据面应答回声记账：请求 id → 回声 label（帧②到达时回发 host/log）。
+const ackEchoLabels = new Map();
+
+let grandchildren = []; // 同组长眠子进程（killAll 收割断言对象）
+
+function send(frame) {
+  process.stdout.write(`${JSON.stringify(frame)}\n`);
+}
+function reverseRequest(id, method, params) {
+  send({ id, method, params });
+}
+
+let nextRequestId = 100;
+
+async function playRunScript(runId, script) {
+  for (const action of script) {
+    if (cancelledRuns.has(runId)) return;
+    switch (action.op) {
+      case "log":
+        reverseRequest(`rev-log-${nextRequestId++}`, "host/log", {
+          level: action.level ?? "info",
+          component: action.component ?? "fake",
+          message: action.message ?? "",
+        });
+        break;
+      case "poolResolved":
+        reverseRequest(`rev-pool-${nextRequestId++}`, "host/poolResolved", {
+          runId,
+          poolKey: action.poolKey ?? "shared",
+        });
+        break;
+      case "handleReady":
+        reverseRequest(`rev-ready-${nextRequestId++}`, "host/handleReady", {
+          runId,
+          sessionRef: action.sessionRef ?? { sessionId: "sess-fixture" },
+          poolKey: action.poolKey ?? "shared",
+        });
+        break;
+      case "childSpawned": {
+        const grandchild = spawn(
+          process.execPath,
+          ["-e", "setInterval(() => {}, 1000)"],
+          { detached: false, stdio: "ignore" },
+        );
+        grandchildren.push(grandchild);
+        reverseRequest(`rev-child-${nextRequestId++}`, "host/childSpawned", {
+          pid: grandchild.pid,
+          recordId: action.recordId ?? runId,
+        });
+        break;
+      }
+      case "childStateChanged":
+        reverseRequest(`rev-childst-${nextRequestId++}`, "host/childStateChanged", {
+          pid: grandchildren[grandchildren.length - 1]?.pid,
+          recordId: action.recordId ?? runId,
+          state: action.state ?? "exited",
+          killed: action.killed ?? false,
+          ...(action.exitCode !== undefined ? { exitCode: action.exitCode } : {}),
+          ...(action.signal !== undefined ? { signal: action.signal } : {}),
+        });
+        break;
+      case "streamDelta": {
+        // [W6] action.recordId 有值 = 续聊轮 recordId 键 delta（关联键分路——
+        // D1-A：interact 发起的轮无 runId，经 handle.sessionRef 的 recordId 关联）。
+        const streamReqId = `rev-stream-${nextRequestId++}`;
+        if (action.recordId !== undefined) {
+          ackEchoLabels.set(streamReqId, `streamDelta recordId=${action.recordId}`);
+          reverseRequest(streamReqId, "host/streamDelta", {
+            recordId: action.recordId,
+            delta: action.delta ?? "",
+          });
+        } else {
+          reverseRequest(streamReqId, "host/streamDelta", {
+            runId,
+            delta: action.delta ?? "",
+          });
+        }
+        break;
+      }
+      case "stderr":
+        // [W6] 引擎 stderr 写点（engine_crashed stderr 尾窗的实证面——同步写，
+        // 后续动作可用 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,
+          request: action.request ?? {},
+        });
+        break;
+      case "askUser":
+        reverseRequest(`rev-ask-${nextRequestId++}`, "host/askUser", {
+          runId,
+          request: action.request ?? {},
+        });
+        break;
+      case "emit":
+        send({ method: "event", params: { runId, seq: action.seq, event: action.event } });
+        break;
+      case "hang":
+        // 挂起至 cancel 收敛（无 cancel 则永久挂起——core 3s 收敛窗口超时杀链面）
+        await new Promise((resolveHang) => {
+          hangingRuns.set(runId, resolveHang);
+        });
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+const KNOWN_METHODS = new Set([
+  "initialize", "probe", "run", "cancel", "interact", "read",
+  "listModels", "validateModel", "dispose", "ping",
+]);
+
+const askUserResults = new Map(); // 反向请求 id → 最终结果帧②（交互面两阶段）
+const hangingRuns = new Map(); // runId → settle()——cancel 收敛用（hang 动作挂起时登记）
+const cancelledRuns = new Set(); // cancel 已收敛的 runId——后续脚本动作全部跳过
+
+createInterface({ input: process.stdin }).on("line", (line) => {
+  if (line.trim() === "") return;
+  let frame;
+  try {
+    frame = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  // 帧②（core 对反向请求的应答）：askUser 最终结果到达——回放层记录后继续。
+  // [W6] 数据面（roundLifecycle / recordId-delta）应答到达 → 回发 host/log 回声
+  // （core 侧「宿主确认收到」回执链闭合的观测锚；NDJSON 单连接有序，回声先于
+  // run 应答帧到达）。
+  if (typeof frame.id === "string") {
+    const echoLabel = ackEchoLabels.get(frame.id);
+    if (echoLabel !== undefined) {
+      ackEchoLabels.delete(frame.id);
+      reverseRequest(`rev-ack-${nextRequestId++}`, "host/log", {
+        level: "debug",
+        component: "fake",
+        message: `ack ${echoLabel}`,
+      });
+    }
+    askUserResults.set(frame.id, frame.result ?? { unsupported: frame.error !== undefined });
+    return;
+  }
+
+  const { id, method, params } = frame;
+  if (MODE === "unknown_method" && !KNOWN_METHODS.has(method)) {
+    send({
+      id,
+      error: {
+        code: "engine_method_unknown",
+        message: `method "${method}" is not part of protocol v1`,
+        recovery: "Upgrade the engine package or align the protocol version.",
+      },
+    });
+    return;
+  }
+
+  switch (method) {
+    case "initialize": {
+      if (PROTOCOL_VERSION !== fixture.protocolVersion) {
+        send({
+          id,
+          error: {
+            code: "engine_protocol_mismatch",
+            message: `engine speaks protocol v${PROTOCOL_VERSION}, core requested/handshake produced v${fixture.protocolVersion}`,
+            recovery: "Align the engine package version with the host.",
+            data: { engineVersion: PROTOCOL_VERSION, coreVersion: fixture.protocolVersion },
+          },
+        });
+        return;
+      }
+      {
+        // [W6] chat gate 负向：env 覆写 capabilities.conversation（旧形态引擎
+        // manifest 无该 gate 位 → chat 请求同步拒的 initialize 面实证）。
+        const initResult = fixture.initialize.result;
+        const convOverride = process.env.FAKE_CAPABILITIES_CONVERSATION;
+        const result =
+          convOverride !== undefined && initResult.capabilities !== undefined
+            ? {
+                ...initResult,
+                capabilities: { ...initResult.capabilities, conversation: convOverride },
+              }
+            : initResult;
+        send({ id, result });
+      }
+      return;
+    }
+    case "probe":
+      if (process.env.FAKE_PROBE_FAIL === "1" && fixture.probeFailure !== undefined) {
+        send({ id, result: fixture.probeFailure });
+      } else {
+        send({ id, result: fixture.probe.result });
+      }
+      return;
+    case "listModels":
+      send({ id, result: fixture.listModels.result });
+      return;
+    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;
+    case "ping":
+    case "dispose":
+      send({ id, result: { ok: true } });
+      if (method === "dispose") {
+        for (const g of grandchildren) g.kill("SIGTERM");
+        setImmediate(() => process.exit(0));
+      }
+      return;
+    case "cancel": {
+      // 受理应答 + 收敛在途挂起 run（3s 收敛窗口语义）：挂起中的 playRunScript
+      // 以 cancelResult 终态应答回收（协议 cancel 契约：引擎须在窗口内收敛终态）。
+      send({ id, result: { ok: true } });
+      const runId = params?.runId;
+      const settle = hangingRuns.get(runId);
+      if (settle !== undefined) {
+        hangingRuns.delete(runId);
+        cancelledRuns.add(runId);
+        settle(); // 收敛：挂起解除，run 以 cancelResult 终态应答（脚本余项跳过）
+      }
+      return;
+    }
+    case "run": {
+      if (MODE === "run_failed") {
+        send({
+          id,
+          error: {
+            code: "engine_run_failed",
+            message: "scripted run failure (redacted)",
+            recovery: "Inspect the task and retry.",
+          },
+        });
+        return;
+      }
+      const runId = params?.runId ?? "run-smoke-1";
+      // [W6] env 注入 script 前置段（沿 FAKE_RUN_HANG 先例；顺序 = 注入段 → fixture 段）。
+      const injected = [];
+      if (process.env.FAKE_RUN_STDERR_HANG === "1") {
+        injected.push(
+          { op: "stderr", text: process.env.FAKE_STDERR_SAMPLE ?? "" },
+          { op: "log", level: "info", component: "fake", message: "stderr-flushed" },
+          { 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" });
+      }
+      const script = [...injected, ...(process.env.FAKE_RUN_HANG === "1"
+        ? [{ op: "poolResolved", poolKey: "shared" }, { op: "hang" }]
+        : []), ...fixture.run.script];
+      playRunScript(runId, script)
+        .then(() => send({ id, result: cancelledRuns.has(runId)
+          ? (fixture.run.cancelResult ?? {
+              handle: fixture.run.result.handle,
+              outcome: { content: "", error: "engine_run_failed: cancelled (fake)", exitCode: null, engineId: fixture.engineId },
+            })
+          : fixture.run.result }))
+        .catch((err) => {
+          send({ id, error: { code: "engine_run_failed", message: String(err), recovery: "Inspect the engine logs." } });
+        });
+      return;
+    }
+    default:
+      send({
+        id,
+        error: {
+          code: "engine_method_unknown",
+          message: `unhandled method "${String(method)}"`,
+          recovery: "Align protocol versions.",
+        },
+      });
+  }
+});
+
+// stdin EOF（宿主死亡）→ 自灭 + 收割同组后代（R9-1：一代子进程 + 组内后代零残留；
+// 引擎自身 detached 后代不在收割覆盖范围——设计 §3.9 已接受代价）。
+process.stdin.on("end", () => {
+  for (const g of grandchildren) g.kill("SIGKILL");
+  process.exit(0);
+});