@zhushanwen/subagent-core 0.7.1 → 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__/conformance/registry-fork-filter.test.ts

@@ -2,23 +2,26 @@
 // bash 跨 session 可见性显式断言（R4 一刀语义钉住）+ 偏差 #4 探针（goal 守卫口径）。
 //
 // 设计权威源：chat-domain-v1x-liveness-governance.md §3.2 D4（翻档三连带——读侧
-// 过滤三口 + PENDING_LIFECYCLE 翻 process 档）+ 修订记录 v5-⑤（bash 跨 session
-// 可见性一刀钉成显式选择）+ 验收 A9② + impl-plan §5 偏差 #4（W4 交接：goal 守卫
-// 消费点未传基准，W6 实测裁决是否需 goal 侧两行传参）。
+// 过滤三口；分档常量已随 ext-simplify-12 删除，三类型 process 档成为无条件代码
+// 自然状态）+ 修订记录 v5-⑤（bash 跨 session 可见性一刀钉成显式选择）+ 验收 A9②
+// + impl-plan §5 偏差 #4（W4 交接：goal 守卫消费点未传基准，W6 实测裁决是否需
+// goal 侧两行传参）。
 //
 // 被测函数 = `extensions/universal/pending-notifications/src/state.ts` 的导出纯函数
 // （零依赖、不触 Pi 运行时——文件头注自证；经相对路径源码消费，subagent-core 无该
 // workspace 依赖声明，不加 phantom dep）。分工：
-//   - 过滤函数本体 / rebuild 投影的两口径行为：本套件钉语义（conformance 视角）；
+//   - 过滤函数本体 / pending_notifications 工具投影（entries 现算）的两口径行为：
+//     本套件钉语义（conformance 视角）；
 //   - 过滤①②③的**接线**（goal/subagent-workflow/pending-notifications 三消费点
 //     透传 currentSessionId）：W4 包内测试已承载（pi-pending-notifications
-//     __tests__ :523/:532、subagent-workflow pi-host.test :199-223）；
+//     __tests__、subagent-workflow pi-host.test）；
 //   - 后代判定口（读侧过滤②）的差集口径与①共用同一函数——本套件①的断言即其
 //     语义核心；接线透传由上述 W4 测试守护。
 //
 // 探针结论（偏差 #4，实测证据 = 「goal 守卫口径」describe）：**有虚增**——fork 后
-// 父 session 仍活跃的后台任务残留使 goal 守卫现状口径（无基准）幻 defer；确需的
-// 两行传参改动点列于该 describe 注释，留给主会话裁决（本单元不改 goal——红线）。
+// 父 session 仍活跃的后台任务残留使无基准口径幻 defer。该结论已由 d0b9a6faf
+// （2026-09-09，fix(goal): pass currentSessionId）关闭——goal 两处守卫现传
+// currentSessionId 基准，下方「无基准」形态仅作历史口径对照面保留。
 
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -27,13 +30,9 @@ import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
 // 相对路径源码消费（7 层上溯到仓库根）：state.ts 是零依赖纯函数（不触 Pi 运行时），
 // 无需为探针/契约测试给 subagent-core 添加 workspace 依赖声明。
-import {
-  PENDING_LIFECYCLE,
-  PENDING_TTL_MS,
-  countActiveFromEntries,
-  createRegistry,
-  rebuildFromEntries,
-} from "../../../../../../../extensions/universal/pending-notifications/src/state.ts";
+// [ext-simplify-12] import 面收窄到 countActiveFromEntries——历史的 registry/
+// session 档机器已整体删除，entries 是唯一状态源（跨包语义耦合面收敛到该函数）。
+import { countActiveFromEntries } from "../../../../../../../extensions/universal/pending-notifications/src/state.ts";
 
 import { runReconcileSweep } from "../../../round-supervisor/index.ts";
 
@@ -52,16 +51,13 @@ function registerEntry(
       name: id,
       registeredAt: 1_000,
       sessionId,
-      // bash 真实落盘无 expiresAt 键（写入侧省略，D16）；subagent/workflow 翻
-      // process 档后同理——overrides 仅用于 TTL 对照面。
+      // 真实落盘无 expiresAt 键（写入侧无条件省略）；overrides.expiresAt 模拟历史
+      // session 文件遗留的带 TTL 键 entry——差集读取侧刻意不读该键（对照面）。
       ...(overrides.expiresAt !== undefined ? { expiresAt: overrides.expiresAt } : {}),
     },
   };
 }
 
-/** 语义对照面的基准时刻（远超旧 1h TTL——钉「无 TTL 清理」而非「窗口内未到期」假绿）。 */
-const NOW = 10 * PENDING_TTL_MS + 1;
-
 let tmpDirs: string[] = [];
 
 afterEach(() => {
@@ -69,23 +65,23 @@ afterEach(() => {
   tmpDirs = [];
 });
 
-describe("[W6/D4 翻档] PENDING_LIFECYCLE 三类型全 process 档（跨时长无 TTL 清理的判据锚）", () => {
-  it("subagent/workflow 翻 process 档（bash 原生 process 档）——翻档事实钉住", () => {
-    expect(PENDING_LIFECYCLE).toEqual({ subagent: "process", workflow: "process", bash: "process" });
-  });
-
-  it("翻档后跨时长（远超旧 1h TTL）无 TTL 清理：三类型 register 均不进 expiredToFlush", () => {
-    const registry = createRegistry();
+describe("[W6/D4 翻档余义] 三类型跨时长无 TTL 清理（entries 差集现算）", () => {
+  it("翻档后跨时长（远超旧 1h TTL）无 TTL 清理：三类型 register 均仍 active", () => {
+    // NOW = 10 * 3_600_000 + 1：语义对照面基准时刻（旧 1h TTL = 3_600_000ms 的
+    // 10 倍 + 1ms，远超旧 1h TTL）。entries 差集不接收时间参数——差集语义刻意
+    // 不校验时间，NOW 仅标注对照语义：若旧 session 档 TTL 机器仍在，NOW 时刻
+    // bg-1/wf-1 早已被过期清理。
+    const NOW = 10 * 3_600_000 + 1;
+    // 护栏：钉住对照面确实覆盖「超 TTL」域而非「窗口内未到期」假绿。
+    expect(NOW - 1_000).toBeGreaterThan(3_600_000);
     const entries = [
-      registerEntry("bg-1", "subagent", "sess-root", { expiresAt: 1_000 + 1 }), // 远过去
+      registerEntry("bg-1", "subagent", "sess-root", { expiresAt: 1_000 + 1 }), // 历史遗留 TTL 键（读取侧不读）
       registerEntry("wf-1", "workflow", "sess-root", { expiresAt: 1_000 + 1 }),
       registerEntry("bt-1", "bash", "sess-root"), // 真实落盘形态：无 expiresAt 键
     ];
-    const result = rebuildFromEntries(registry, entries, "sess-root", NOW);
     // 旧 session 档语义（1h TTL + 跨 session 补注销）曾把长任务/跨重启注册静默
-    // 清除 → 守卫失明（事故环 4 放大器）；翻档后三类型全部续存。
-    expect(result.expiredToFlush).toEqual([]);
-    expect(result.activeIds).toEqual(["bg-1", "wf-1", "bt-1"]);
+    // 清除 → 守卫失明（事故环 4 放大器）；三类型全 process 档后差集一律续存。
+    expect(countActiveFromEntries(entries).ids).toEqual(["bg-1", "wf-1", "bt-1"]);
   });
 });
 
@@ -121,41 +117,45 @@ describe("[W6/R4 一刀] bash 跨 session 可见性显式断言（钉成显式
     expect(scoped.count).toBe(1); // 只数本 session 的任务
   });
 
-  it("旧行为显式登记：无基准口径（goal 守卫现状）父 bash 残留仍入计数（= defer 驱动）", () => {
+  it("旧行为显式登记：无基准对照面（历史形态）父 bash 残留仍入计数（= defer 驱动）", () => {
     const childEntries = [registerEntry("parent-bt", "bash", "sess-parent")];
     // 显式钉住「一刀的对照面」：不传基准 = 不过滤 = 子 session goal 仍为父 bash
     // 任务 defer。这是读侧过滤一刀**改变的旧行为**——保留此断言防止有人误以为
-    // 过滤是缺省语义（偏差 #4：goal 消费点现状即此口径，见探针结论）。
+    // 过滤是缺省语义（偏差 #4：goal 消费点历史形态即此口径，已由 d0b9a6faf 修复
+    // 传基准，见探针结论）。
     expect(countActiveFromEntries(childEntries).count).toBe(1);
   });
 });
 
-describe("[W6/D4 读侧过滤③] registry rebuild 投影（pending_notifications 工具读侧）", () => {
-  it("跨 session 残留不入 registry、不补 unregister entry（跳过不补注销——落盘收口归 core sweep）", () => {
-    const registry = createRegistry();
+describe("[W6/D4 读侧过滤③] pending_notifications 工具投影（entries 现算）", () => {
+  it("跨 session 残留不进差集、不产生任何写回（跳过不补注销——落盘收口归 core sweep / bte 对账通道）", () => {
     const entries = [
       registerEntry("parent-bg", "subagent", "sess-parent"),
       registerEntry("own-bg", "subagent", "sess-child"),
     ];
-    const result = rebuildFromEntries(registry, entries, "sess-child", NOW);
-    // 工具投影面（count/list）不虚报继承残留（A9②：count/list 不含继承残留）。
-    expect(result.activeIds).toEqual(["own-bg"]);
-    expect(registry.operations.has("parent-bg")).toBe(false);
+    // 工具投影面（count/list）不虚报继承残留（A9②：count/list 不含继承残留）——
+    // 现算后与读侧过滤①共用同一 countActiveFromEntries 扫描，「落盘了什么」与
+    // 「查询到什么」构造性一致。
+    const result = countActiveFromEntries(entries, { currentSessionId: "sess-child" });
+    expect(result.ids).toEqual(["own-bg"]);
     // 「跳过不补注销」：残留 entry 留在 session 文件（读侧①③口各自兜住差集消费
-    // 方），禁止 rebuild 写侧补发——跨 session 写达域缺口由 core 对账 sweep 收口。
-    expect(result.expiredToFlush).toEqual([]);
+    // 方），countActiveFromEntries 只读不写——跨 session 写达域缺口由 core 对账
+    // sweep 收口（bte 对账同理直接 appendEntry）。只读性实证：输入数组长度不变，
+    // 无补发的 unregister entry。
+    expect(entries).toHaveLength(2);
   });
 });
 
-describe("[W6/偏差 #4 探针] goal 守卫口径（无基准）× fork 残留——实测结论", () => {
+describe("[W6/偏差 #4 探针] goal 守卫口径（无基准）× fork 残留——实测结论（历史口径）", () => {
   // 偏差 #4（impl-plan §5，W4 交接）：W4 读侧过滤①的 currentSessionId 为可选参数，
   // goal 守卫消费点未传基准。本探针在 fork 场景实测该口径是否被父 session 注册
   // 残留虚增，结论二选一回写报告：
   //   (a) 无影响（其他机制覆盖）→ 偏差 #4 关闭，goal 零改动；
   //   (b) 有虚增 → 列出确需的两行传参改动点（不改 goal——红线），留主会话裁决。
   //
-  // **实测结论：(b) 有虚增。**
-  //   证据链：goal 守卫两处消费点现状均无基准调用——
+  // **实测结论：(b) 有虚增。已由 d0b9a6faf（2026-09-09）关闭——goal 现传
+  //   currentSessionId 基准，下方证据链与用例为无基准历史形态的对照面。**
+  //   证据链（历史口径，d0b9a6faf 前的 goal 守卫两处消费点均无基准调用）：
   //     `extensions/universal/goal/src/adapters/event-handlers/agent-end.ts:198`
   //       `const pendingOps = countActiveFromEntries(entries);`（defer 分支判据
   //        = `pendingOps.count > 0`）
@@ -166,21 +166,23 @@ describe("[W6/偏差 #4 探针] goal 守卫口径（无基准）× fork 残留
   //   用例 2 证明仅当父任务 record 已终态（core sweep 补注销落盘）才归零——
   //   「父任务仍活跃」窗口内无任何机制覆盖（W4 翻档后 U4 不再中性化）。
   //
-  //   确需的两行改动点（主会话裁决后由 goal 侧单元执行）：
+  //   已执行的修复（d0b9a6faf，即当时登记的两行传参改动点）：
   //     agent-end.ts:198 → `countActiveFromEntries(entries, { currentSessionId: ctx.sessionManager.getSessionId() })`
   //     agent-end.ts:294 → `countActiveFromEntries(ctx.sessionManager.getEntries(), { currentSessionId: ctx.sessionManager.getSessionId() })`
   //   （getSessionId 是 extension 侧既有取 sessionId 形态——pending-notifications
-  //   index.ts:216、subagent-workflow session-lifecycle.ts 同款先例。）
+  //   index.ts:216、subagent-workflow session-lifecycle.ts 同款先例；现行
+  //   agent-end.ts 守卫注释反向引用本探针作为传基准依据。）
 
-  it("用例 1：父 session 活跃 subagent 残留 → goal 现状口径（无基准）count>0 → defer 分支命中（虚增）", () => {
+  it("用例 1：父 session 活跃 subagent 残留 → 无基准对照面（历史形态）count>0 → defer 分支命中（虚增）", () => {
     // fork 时刻快照：父 session 派了后台子代理（record 仍 running-resumable），
     // 子 session 继承其 register 残留；goal 守卫读到的 entries = 本 session 文件
-    // 全量（含继承残留）。现状口径 = 无基准调用（agent-end.ts:198 逐字形态）。
+    // 全量（含继承残留）。历史形态 = 无基准调用（d0b9a6faf 前 agent-end.ts:198
+    // 逐字形态；现行已传基准，此对照面锁定「不传则虚增」的机制事实）。
     const childEntries = [
       registerEntry("parent-bg", "subagent", "sess-parent"),
       registerEntry("child-bg", "subagent", "sess-child"),
     ];
-    const pendingOps = countActiveFromEntries(childEntries); // ← goal 现状口径
+    const pendingOps = countActiveFromEntries(childEntries); // ← 无基准对照面（历史形态）
     // defer 分支判据（agent-end.ts:199 `if (pendingOps.count > 0)`）命中：
     // 父 session 的任务让子 session 的 goal 停发 continuation 并 notify
     // 「Goal waiting for 2 background task(s)」——计数含非本 session 任务 = 虚增。
@@ -209,9 +211,9 @@ describe("[W6/偏差 #4 探针] goal 守卫口径（无基准）× fork 残留
     });
     expect(result.reconciled).toEqual(["parent-bg"]);
 
-    // 落盘后 goal 守卫（无基准口径）重读 entries：计数归零——sweep 是现状口径的
-    // 唯一收敛通道，且只覆盖「record 可判定终态」的窗口；「父任务仍活跃」窗口
-    // （用例 1）无机制覆盖 → 虚增结论 (b) 成立。
+    // 落盘后 goal 守卫（无基准口径，历史形态）重读 entries：计数归零——sweep 是
+    // 无基准口径的唯一收敛通道，且只覆盖「record 可判定终态」的窗口；「父任务仍
+    // 活跃」窗口（用例 1）无机制覆盖 → 虚增结论 (b) 成立。
     const entriesAfter = readFileSync(sessionFile, "utf8")
       .trim()
       .split("\n")

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__/inflight-snapshot.test.ts

@@ -0,0 +1,180 @@
+// inflight-snapshot.test.ts —— core→壳在途事件出口 + EnginePort.inFlightSnapshot? 缺省语义
+//（u7a，设计权威源：docs/design/crash-forensics-and-watchdog.md §3.3 D5）。
+//
+// 三视角：
+//   ①使用者（壳层 reporter 视角）——setInFlightListener 注册后，core 状态迁移点
+//     （子进程注册/移除、idle timer arm）推来最新绝对计数快照；getInFlightSnapshot
+//     随时可拉（初始上报数据源）。
+//   ②构建者——计数 = 双谓词过滤（hasLiveProcessHandle && !hasIdleTimer，与
+//     notify-host hasRunningBackground 同源）：活句柄且无 armed idle timer 才算在途，
+//     Path A 保活（timer armed）不算——D5 防推迟恒真的核心裁决。
+//   ③观察者——EnginePort 可选成员向后兼容：pi 引擎不实现（undefined = 无在途），
+//     zcode 引擎实现（快照面在场）；出口监听者抛错不反噬 core。
+
+import { describe, expect, it, beforeEach, afterEach } from "vitest";
+import { EventEmitter } from "node:events";
+import type { ChildProcess } from "node:child_process";
+
+import {
+  armIdleTimer,
+  disarmIdleTimer,
+  _resetLifecycleState,
+} from "../../lifecycle-manager.ts";
+import {
+  getInFlightSnapshot,
+  notifyInFlightChanged,
+  setInFlightListener,
+  type InFlightSnapshot,
+} from "../inflight-snapshot.ts";
+import type { EnginePort } from "../port.ts";
+// W3 合并改写：inproc 引擎已删——句柄记账走 host/spawned-children 镜像（register +
+// reset 测试面）；「引擎无 inFlightSnapshot 可选成员」断言改桩（EnginePort 缺席形态）。
+import {
+  killRecordChildWithEscalation,
+  registerSpawnedChildForRecord,
+  _resetCoreSpawnedChildrenMirrorForTest,
+} from "../host/spawned-children.ts";
+import { createHostBridge } from "../host/host-bridge.ts";
+
+/** 最小 fake 子进程（EventEmitter + killed/pid 字段——hasLiveProcessHandle 消费面）。 */
+function makeFakeChild(): ChildProcess & EventEmitter {
+  const child = new EventEmitter() as ChildProcess & EventEmitter;
+  (child as { pid?: number }).pid = 4242;
+  (child as { killed: boolean }).killed = false;
+  return child;
+}
+
+beforeEach(() => {
+  _resetLifecycleState();
+  setInFlightListener(null);
+});
+
+afterEach(() => {
+  // 清理本测试注册的句柄镜像（W3 后记账在 host/spawned-children，reset 即清；close 事件
+  // 摘除路径已由「close 摘除自动触发通知」用例覆盖），防跨用例泄漏。
+  _resetCoreSpawnedChildrenMirrorForTest();
+  _resetLifecycleState();
+  setInFlightListener(null);
+});
+
+describe("getInFlightSnapshot：双谓词绝对计数（D5 求值位置 = 状态所在进程）", () => {
+  it("空态 → 0（无任何 subagent 的 session 初始上报数据源）", () => {
+    expect(getInFlightSnapshot()).toEqual({ inFlight: 0 });
+  });
+
+  it("注册活句柄 → 1；arm idle timer（Path A 保活）→ 0；disarm → 1", () => {
+    const id = "sa-inflight-arm";
+    registerSpawnedChildForRecord(id, makeFakeChild());
+    expect(getInFlightSnapshot().inFlight).toBe(1);
+
+    armIdleTimer(id, () => undefined, 60_000);
+    expect(getInFlightSnapshot().inFlight).toBe(0);
+
+    disarmIdleTimer(id);
+    expect(getInFlightSnapshot().inFlight).toBe(1);
+  });
+
+  it("killed 句柄不算活（hasLiveProcessHandle 的 !killed 子句）", () => {
+    const id = "sa-inflight-killed";
+    const child = makeFakeChild();
+    registerSpawnedChildForRecord(id, child);
+    // W3 镜像形态：killed 判据由镜像置死位承载（注册后改 child 引用字段不进镜像——
+    // 生产置死路径 = killRecordChildWithEscalation 杀链记账面 / 引擎反向通道）。
+    killRecordChildWithEscalation(id, "test");
+    expect(getInFlightSnapshot().inFlight).toBe(0);
+  });
+
+  it("多 record 混合形态：在途/保活/垂死并存时按谓词逐一过滤", () => {
+    const running = makeFakeChild();
+    const keepAlive = makeFakeChild();
+    const dying = makeFakeChild();
+    (dying as { killed: boolean }).killed = true;
+    registerSpawnedChildForRecord("sa-inflight-run", running);
+    registerSpawnedChildForRecord("sa-inflight-keep", keepAlive);
+    registerSpawnedChildForRecord("sa-inflight-dying", dying);
+    armIdleTimer("sa-inflight-keep", () => undefined, 60_000);
+    expect(getInFlightSnapshot().inFlight).toBe(1);
+  });
+});
+
+describe("notifyInFlightChanged：迁移点 → 壳层监听者（同步 fire-and-forget）", () => {
+  it("监听者收到最新快照（迁移时刻求值，非注册时刻）", () => {
+    const seen: InFlightSnapshot[] = [];
+    setInFlightListener((s) => seen.push({ ...s }));
+
+    notifyInFlightChanged();
+    expect(seen).toEqual([{ inFlight: 0 }]);
+
+    registerSpawnedChildForRecord("sa-inflight-notify", makeFakeChild());
+    notifyInFlightChanged();
+    expect(seen[seen.length - 1]).toEqual({ inFlight: 1 });
+  });
+
+  it("监听者抛错不反噬 core（壳层故障不打断生命周期主链）", () => {
+    setInFlightListener(() => {
+      throw new Error("shell reporter bug");
+    });
+    expect(() => notifyInFlightChanged()).not.toThrow();
+  });
+
+  it("无监听者时 no-op；注册覆盖语义（后注册者收到，先注册者不再收）", () => {
+    expect(() => notifyInFlightChanged()).not.toThrow();
+
+    const first: InFlightSnapshot[] = [];
+    const second: InFlightSnapshot[] = [];
+    setInFlightListener((s) => first.push(s));
+    setInFlightListener((s) => second.push(s));
+    notifyInFlightChanged();
+    expect(first).toEqual([]);
+    expect(second).toEqual([{ inFlight: 0 }]);
+  });
+
+  it("host-bridge armIdleTimer / disarmIdleTimer 委托点自动触发通知（迁移点接线证据）", () => {
+    // W3 镜像形态：register 本身不再通知（子进程终止经引擎反向通道），core 侧唯一挂
+    // notifyInFlightChanged 的委托面 = host-bridge 的 arm/disarm（u7a 迁移点新宿主）。
+    const seen: InFlightSnapshot[] = [];
+    setInFlightListener((s) => seen.push(s));
+    registerSpawnedChildForRecord("sa-inflight-auto", makeFakeChild());
+
+    const bridge = createHostBridge({
+      service: {} as Parameters<typeof createHostBridge>[0]["service"],
+      onIdleTimeout: () => undefined,
+    });
+    bridge.armIdleTimer("sa-inflight-auto", 60_000);
+    expect(seen.at(-1)).toEqual({ inFlight: 0 });
+
+    bridge.disarmIdleTimer("sa-inflight-auto");
+    expect(seen.at(-1)).toEqual({ inFlight: 1 });
+  });
+});
+
+describe("EnginePort.inFlightSnapshot? 可选成员缺省语义（D5：pi 不实现，zcode 实现）", () => {
+  it("未实现该成员的引擎桩 → undefined（= 无引擎侧在途面，pi 形态由 extension 聚合上报覆盖）", () => {
+    // 经 EnginePort 接口面访问（可选成员缺席的正当形态）；裸桩无此声明（W3 后 inproc
+    // pi 引擎已删，缺席形态以桩承载——zcode 真实现的断言移 zcode-subagent-cli 测试），
+    // 消费方必须走 port 类型——本身就是「缺席正当」契约的一部分。
+    const pi: EnginePort = { capabilities: () => ({ id: "pi-stub" }) } as unknown as EnginePort;
+    expect(pi.inFlightSnapshot).toBeUndefined();
+  });
+
+  it("实现该成员的引擎桩 → 同步快照；未初始化恒 0（空闲常驻≠在途——真实现断言在 zcode-subagent-cli 的 zcode-engine-inflight.test）", () => {
+    const engine: EnginePort = {
+      capabilities: () => ({ id: "zcode-stub" }),
+      inFlightSnapshot: () => ({ inFlight: 0 }),
+    } as unknown as EnginePort;
+    expect(typeof engine.inFlightSnapshot).toBe("function");
+    expect(engine.inFlightSnapshot?.()).toEqual({ inFlight: 0 });
+  });
+
+  it("未实现该成员的引擎对象仍满足 EnginePort（向后兼容，可选成员不强制）", () => {
+    // 结构化证据：EnginePort 的既有可选成员扩展先例（listModels/validateModel/dispose）
+    // 同款——缺席成员不破坏实现关系（裸桩承载缺席形态）。W3 后 inproc pi 引擎已删，
+    // id 不再由引擎身份推导断言（桩无 id 字面量），能力面 id 经 capabilities() 取。
+    const pi: EnginePort = { capabilities: () => ({ id: "pi-stub" }) } as unknown as EnginePort;
+    // EngineCapabilities 契约面无 id 成员（contract-types.ts）——运行期桩携带的 id 经
+    // 窄化读取断言（HEAD 既有类型红此处修复：pi.capabilities().id 直取 TS2339）。
+    expect((pi.capabilities() as unknown as { id: string }).id).toBe("pi-stub");
+    expect(typeof pi.capabilities).toBe("function");
+    expect(pi.inFlightSnapshot).toBeUndefined();
+  });
+});

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