@zhushanwen/subagent-core 0.7.1 → 0.9.0

package/src/execution/__tests__/get-record-for-action-restart.test.ts

@@ -1,12 +1,13 @@
 // src/execution/__tests__/get-record-for-action-restart.test.ts
 //
-// [M10] getRecordForAction 跨重启磁盘重建分支测试（subagent-service.ts L933-951）。
+// [M10] getRecordForAction 跨重启磁盘重建分支测试（cold-lookup.coldLookupForAction）。
 //
 // 背景：内存 miss → collectRecords(1000,"all",undefined).find(status==="running") →
-// createRecord({chatMode: true}) → register → 回填 sessionFile/round。代码注释
-// （L946-949）自设强制约束「改动此处必须带 S3 回归场景（跨重启 message 续聊验证）」
-// ——该 S3 场景此前不存在，分支零测试。该分支含多个仅此处独有的决策：
-//   - 无条件 chatMode: true（v4 A-3 跨重启恢复入口，V3 方案 A 方向）
+// createRecord({chatMode: 持久化值}) → register → 回填 sessionFile/round。
+// [H1 U6] 原「无条件 chatMode: true」（v4 A-3）已改水合保留持久化 chatMode
+//（D4/D5：升级置位迁 Continuation revive 格 + messageHandler gate 双写点）。
+// 该分支含多个仅此处独有的决策：
+//   - chatMode 水合保留（磁盘无持久化 → false；升级在 message 链 gate 化）
 //   - rootSessionFilter 传 undefined 后置校验（异树仍 throw not owned）
 //   - sessionFile/round 从磁盘重建结果回填（round 无磁盘持久化 → undefined）
 //
@@ -25,11 +26,10 @@ const { loggerMock } = vi.hoisted(() => ({
 }));
 vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
 
-// [W3 改写] 原 vi.mock(inproc pi 引擎目录/session-runner) 随删件消亡——deliverChatMessage 走
-// 协议 seam（registerFakePiEngine 替身；跨重启无活进程 = 引擎冷路径拒绝，续聊落
-// resumeColdRound 守卫链）。
+// [W3 改写 → H1 U6] deliverChatMessage 走协议 seam（registerFakePiEngine 替身）——
+// 每轮 = 新 run + resume 锚点，续聊守卫链归 Continuation（dispatchRoundGuarded）。
 
-import { writeFinalized } from "../finalized-marker.ts";
+import { writeFinalizedState } from "../state-marker.ts";
 import { registerFakePiEngine } from "./helpers/fake-engine-port.ts";
 import { clearEngines } from "../engine/registry.ts";
 import { ModelConfigService } from "../model-config-service.ts";
@@ -158,16 +158,17 @@ describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）",
     for (const k of IDENTITY_ENV_KEYS) delete process.env[k];
   });
 
-  it("内存 miss + 磁盘 running（无 .alive）→ 重建 record：chatMode 无条件 true、sessionFile 回填、register 进内存", () => {
-    // identity entry 故意不带 chatMode 字段——证明重建分支的无条件 chatMode:true
-    //（不依赖磁盘是否记录过对话模式标志）
+  it("内存 miss + 磁盘 running（无 .alive）→ 重建 record：chatMode 水合保留（无持久化为 false，[H1 U6]）、sessionFile 回填、register 进内存", () => {
+    // identity entry 故意不带 chatMode 字段——证明重建分支只水合持久化 chatMode
+    //（[H1 U6] 无条件置位已迁 Continuation revive 格 + gate；one-shot 跨重启重建
+    // false 后经 message 链 gate 升级置位）
     const file = writeSessionJsonl(sessionsDir, { id: "sa-restart-1", rootSessionId: "root-session" });
     expect(store.getMutable("sa-restart-1")).toBeUndefined(); // 前置：内存确无
 
     const record = service.chatActions.getRecordForAction("sa-restart-1");
 
-    // [v4 A-3] 无条件 chatMode=true（跨重启恢复入口）
-    expect(record.chatMode).toBe(true);
+    // [v4 A-3 → H1 U6] 水合保留：磁盘无 chatMode → false（升级在 message 链 gate 化）
+    expect(record.chatMode).toBe(false);
     // sessionFile 从磁盘重建结果回填
     expect(record.sessionFile).toBe(file);
     // round 从 found 回填：light 磁盘重建无 round（内存态字段，跨重启不恢复）→ undefined
@@ -204,9 +205,9 @@ describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）",
     expect(() => service.chatActions.getRecordForAction("sa-grand")).toThrow(/direct parent/);
   });
 
-  it(".finalized sidecar（closed 终态）不重建 → throw not found or not owned", () => {
+  it(".state sidecar（closed 终态）不重建 → throw not found or not owned", () => {
     const file = writeSessionJsonl(sessionsDir, { id: "sa-fin", rootSessionId: "root-session" });
-    writeFinalized(file); // sidecar 矩阵分支 2 → status=closed → find(status==="running") miss
+    writeFinalizedState(file); // sidecar 矩阵分支 2 → status=closed → find(status==="running") miss
 
     expect(() => service.chatActions.getRecordForAction("sa-fin")).toThrow(/not found or not owned/);
     expect(store.getMutable("sa-fin")).toBeUndefined(); // 未重建注册
@@ -221,12 +222,8 @@ describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）",
   it("[review round2] worktree record 跨重启重建 → hadWorktree 标记 + 续聊被拒（行动语言）", async () => {
     clearEngines();
     const fake = registerFakePiEngine();
-    // 跨重启无活进程 → 引擎冷路径拒绝 → 续聊落 resumeColdRound 守卫链
-    fake.interactMessageResult = {
-      ok: false,
-      code: "engine_session_not_resumable",
-      message: "no live process (cold path)",
-    };
+    // [H1 U6] 每轮 = 新 run + resume 锚点（旧 interact 冷路径替身注入随 interact 面退役），
+    // 续聊守卫链归 Continuation（dispatchRoundGuarded）。
     writeSessionJsonl(sessionsDir, {
       id: "sa-wt",
       rootSessionId: "root-session",
@@ -240,7 +237,7 @@ describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）",
     expect(record.worktreeHandle).toBeUndefined();
 
     // 冷路径续聊（无活进程）→ 续轮守卫拒绝，不 spawn 回落主 repo
-    await expect(service.chatActions.deliverChatMessage(record, "resume after restart", false)).rejects.toThrow(
+    await expect(service.chatActions.deliverChatMessage(record, "resume after restart")).rejects.toThrow(
       /worktree isolation.*lost when the parent process restarted/,
     );
   });
@@ -248,11 +245,6 @@ describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）",
   it("[review round2] 非 worktree record 跨重启重建 → 续聊不受 worktree 守卫拦截（向后兼容）", async () => {
     clearEngines();
     const fake = registerFakePiEngine();
-    fake.interactMessageResult = {
-      ok: false,
-      code: "engine_session_not_resumable",
-      message: "no live process (cold path)",
-    };
     // identity entry 无 worktree 字段（旧文件）→ found.worktree undefined → hadWorktree false
     writeSessionJsonl(sessionsDir, { id: "sa-nowt", rootSessionId: "root-session" });
 
@@ -261,6 +253,6 @@ describe("[M10] getRecordForAction 跨重启磁盘重建（S3 回归场景）",
 
     // 冷路径续聊不被 worktree 守卫拦截（resume 正常发起；后续 spawn 编排
     // 超出本用例关注点——runSpawn 在本文件是 no-op mock）
-    await expect(service.chatActions.deliverChatMessage(record, "resume normal", false)).resolves.toBeUndefined();
+    await expect(service.chatActions.deliverChatMessage(record, "resume normal")).resolves.toBeUndefined();
   });
 });

package/src/execution/__tests__/helpers/fake-engine-port.ts

@@ -1,33 +1,27 @@
 // src/execution/__tests__/helpers/fake-engine-port.ts
 //
-// [W3 chat 域收口] SubagentService 编排层测试共享的 pi EnginePort 替身。
+// [W3 chat 域收口 → H1 U6 定形] SubagentService 编排层测试共享的 pi EnginePort 替身。
 //
-// 背景：chat 域执行链路自 W3 起经协议客户端（registry 'pi' 的 cli 形态 port——
-// RemoteEngine）发往 pi-subagent-cli 引擎进程；原 inproc 链路的测试替身
-//（vi.mock session-runner / FakeChild stdout pump）随 inproc pi 引擎目录 删除消亡。
-// 本 helper 是协议 seam 的替身单源：测试经 registerEngine("pi", fake) 注入，
-// 拿到 fake 实例后驱动 run/interact/roundLifecycle，断言协议交互。
+// 背景：会话形态轮经协议客户端（registry 'pi' 的 cli 形态 port——RemoteEngine）发往
+// pi-subagent-cli 引擎进程；原 inproc 链路的测试替身随删件消亡。本 helper 是协议 seam
+// 的替身单源：测试经 registerEngine("pi", fake) 注入，拿到 fake 实例后驱动 run，
+// 断言协议交互。
 //
 // 消费方式（与 spawn-mock.ts 同款先例）：
 //   const fake = registerFakePiEngine();
 //   await service.execute({ task: "...", conversation: true });
-//   fake.runs[0].settle({ content: "round text" });   // 模拟首轮 agent_settled 应答
-//   fake.interacts[0]                                  // interact 受理断言
+//   fake.runs[0].settle({ content: "round text" });   // 模拟 agent_settled 应答
 //
-// 形态对照（协议语义，见 pi-subagent-cli chat-session.ts）：
-//   - run 应答时点 = 首轮 agent_settled（outcome = 本轮内容非会话终态）；
-//   - interact message 受理 = { ok: true, delivered: true }；冷路径 = engine_session_not_resumable；
-//   - interact cancel = { ok: true, delivered: true }（引擎侧 SIGTERM → settle → 杀链）；
-//   - roundLifecycle 相位由测试显式驱动（idle 帧先于 run 应答帧）。
+// 形态对照（[H1] chat-run 统一终态）：每轮 = 新 run + resume 锚点（ctx.resume），
+// run 应答时点 = agent_settled（outcome = 本轮内容非会话终态）；[H1 U6] interact 面
+// 与 recordId 键路由模拟面已随 chat 域退役删除。
 
-import type { EnginePort, EngineRunResult, RunContext, ChatRoundRoute } from "../../../execution/engine/port.ts";
+import type { EnginePort, EngineRunResult, RunContext } from "../../../execution/engine/port.ts";
 import type { AgentCallOpts } from "../../../orchestration/models/types.ts";
 import type {
   AgentOutcome,
   EngineCapabilities,
   EngineHandle,
-  InteractAction,
-  InteractResult,
   ProbeReport,
   SessionView,
 } from "../../../execution/engine/types.ts";
@@ -50,7 +44,7 @@ export class FakeRun {
     });
   }
 
-  /** 模拟 run 正常应答（首轮 agent_settled 口径；outcome 缺省 = 成功空轮）。 */
+  /** 模拟 run 正常应答（agent_settled 口径；outcome 缺省 = 成功空轮）。 */
   settle(outcome: Partial<AgentOutcome> = {}): void {
     this.resolve({
       handle: {
@@ -80,44 +74,22 @@ export class FakeRun {
     this.ctx.onEvent?.(event as never);
   }
 
-  /** 模拟 host/streamDelta（runId 键——首轮）。 */
+  /** 模拟 host/streamDelta（runId 键——run 作用域路由）。 */
   emitDelta(delta: string): void {
     this.ctx.stream?.onDelta(delta);
   }
 
-  /** 模拟 host/roundLifecycle（runId 键——首轮）。 */
-  emitLifecycle(phase: Record<string, unknown>): void {
-    this.ctx.onRoundLifecycle?.({ runId: this.ctx.taskId, ...phase } as never);
-  }
-
   /** 模拟 host/handleReady（运行中句柄回填）。 */
   emitHandleReady(sessionRef: Record<string, string>, poolKey = "shared"): void {
     this.ctx.onHandleReady?.({ sessionRef, poolKey });
   }
 }
 
-/** 一次 interact 调用的捕获（action 原样记录，供断言）。 */
-export interface FakeInteractCall {
-  handle: EngineHandle;
-  action: InteractAction;
-  result: InteractResult | Promise<InteractResult>;
-}
-
 export class FakePiEnginePort implements EnginePort {
   readonly id = "pi";
 
   /** run 调用捕获（按序）。 */
   readonly runs: FakeRun[] = [];
-  /** interact 调用捕获（按序；result = 受理时返回值）。 */
-  readonly interacts: FakeInteractCall[] = [];
-  /** recordId 键路由注册捕获（recordId → 注销函数）。 */
-  readonly chatRoutes = new Map<string, ChatRoundRoute>();
-  readonly chatRouteUnregisters: string[] = [];
-
-  /** interact message 的应答形态（默认受理；测试改写为冷路径拒绝等）。 */
-  interactMessageResult: InteractResult = { ok: true, delivered: true };
-  /** interact cancel / close 的应答形态。 */
-  interactControlResult: InteractResult = { ok: true, delivered: true };
 
   capabilities(): EngineCapabilities {
     // 与 pi-subagent-cli manifest 逐位一致（gate 同步面放行 pi 全参数——V4⑤ 反向守护）。
@@ -146,37 +118,10 @@ export class FakePiEnginePort implements EnginePort {
     return captured.promise;
   }
 
-  async interact(handle: EngineHandle, action: InteractAction): Promise<InteractResult> {
-    const result = action.kind === "message" ? this.interactMessageResult : this.interactControlResult;
-    this.interacts.push({ handle, action, result });
-    return result;
-  }
-
   async read(handle: EngineHandle): Promise<SessionView> {
+    void handle;
     return { engineId: "pi", turns: [], source: "outcome-only" };
   }
-
-  registerChatRoundRoute(recordId: string, route: ChatRoundRoute): () => void {
-    this.chatRoutes.set(recordId, route);
-    return () => {
-      if (this.chatRoutes.get(recordId) === route) {
-        this.chatRoutes.delete(recordId);
-        this.chatRouteUnregisters.push(recordId);
-      }
-    };
-  }
-
-  // ── 测试驱动面（recordId 键路由——interact 续聊轮的协议回流）──
-
-  /** 向指定 record 的 chat 路由发 recordId 键 delta。 */
-  emitRecordDelta(recordId: string, delta: string): void {
-    void this.chatRoutes.get(recordId)?.onStreamDelta?.(delta);
-  }
-
-  /** 向指定 record 的 chat 路由发 recordId 键 roundLifecycle 相位。 */
-  emitRecordLifecycle(recordId: string, phase: Record<string, unknown>): void {
-    void this.chatRoutes.get(recordId)?.onRoundLifecycle?.({ recordId, ...phase } as never);
-  }
 }
 
 /** 注册替身 pi 引擎进 registry（覆盖同 id 既有注册——测试隔离自负责清理）。 */

package/src/execution/__tests__/helpers/legacy-sidecar.ts

@@ -0,0 +1,33 @@
+// src/execution/__tests__/helpers/legacy-sidecar.ts
+//
+// 兼容期旧格式终态 sidecar fixture（`.finalized` / `.cancelled`）——L4 合并后生产
+// 只写 `.state`，但读侧仍兼容旧名（存量文件不迁移）。测试需要造旧格式文件验证兼容
+// 读路径，此处是唯一 fixture 入口（格式细节单源，避免各测试散落 fs.writeFileSync）。
+//
+// 形态 = 合并前两模块的写侧逐字等价：
+//   .finalized  内容 = reason 字符串（undefined → 空文件，v8.5 前格式）
+//   .cancelled  内容 = 单行 JSON tombstone {id, status, agent, startedAt, endedAt}
+
+import * as fs from "node:fs";
+
+/** 旧 .cancelled tombstone 形态（合并前 CancelledTombstone 逐字等价）。 */
+export interface LegacyCancelledTombstone {
+  id: string;
+  status: "cancelled";
+  agent: string;
+  startedAt: number;
+  endedAt: number;
+}
+
+/** 写旧格式 `.finalized`（测试 fixture；reason 缺省 = 空文件旧格式）。 */
+export function writeLegacyFinalizedSidecar(sessionFile: string, reason?: string): void {
+  fs.writeFileSync(`${sessionFile}.finalized`, reason ?? "", "utf-8");
+}
+
+/** 写旧格式 `.cancelled`（测试 fixture；完整 tombstone 形态）。 */
+export function writeLegacyCancelledSidecar(
+  sessionFile: string,
+  meta: LegacyCancelledTombstone,
+): void {
+  fs.writeFileSync(`${sessionFile}.cancelled`, `${JSON.stringify(meta)}\n`, "utf-8");
+}

package/src/execution/__tests__/helpers/subagent-service-mocks.ts

@@ -88,11 +88,15 @@ export function aliveStoreModule(actual: typeof import("../../alive-store.ts"))
   };
 }
 
-/** ../finalized-marker.ts mock 模块（避免真实 fs 写 sidecar）。 */
-export function finalizedMarkerModule() {
+/** ../state-marker.ts mock 模块（避免真实 fs 写 sidecar；读侧恒「无终态标记」，
+ *  对齐原 finalized-marker mock 的 no-finalized 语义）。 */
+export function stateMarkerModule() {
   return {
-    writeFinalized: vi.fn(),
-    readFinalized: vi.fn(() => false),
+    writeFinalizedState: vi.fn(),
+    writeCancelledState: vi.fn(),
+    readStateMarker: vi.fn(() => undefined),
+    statStateStamp: vi.fn(() => null),
+    STATE_SIDECAR_EXT: ".state",
   };
 }
 
@@ -107,7 +111,7 @@ export function manifestStoreModule() {
     writeManifest = vi.fn(async () => {});
     readManifest = vi.fn(async () => null);
     listAllSync = vi.fn(() => []);
-    recoverTmpFiles = vi.fn(async () => []);
+    sweepTmpFiles = vi.fn(async () => 0);
   }
   return { ManifestStore: vi.fn(function (_recordsDir: string) { return new FakeManifestStore(); }) };
 }

package/src/execution/__tests__/idle-gc.test.ts

@@ -4,6 +4,10 @@
 // 只归档不补注销（archive 不发 pending:unregister——注销统一交对账 sweep）、
 // WorkflowRun store 纳入（startedAt 锚终态化 + save）。fake timers 推进 GC
 // interval；RecordStore 用 mkdtemp 自建目录 + pi=null（archive 纯内存，零磁盘写）。
+//
+// [U2b / C1] markIdleArchived 归口：归档时 `.alive` 写权声明同步 release（D3a
+// release 出口②）——S6 验收锚点链的单元级断言（fake clock 推进 30 天 → 归档 →
+// marker 已删 → fork-from 探针放行 → 接管 acquire 重声明）。
 
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -11,6 +15,7 @@ import * as path from "node:path";
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+import { findForeignLiveInstance } from "../alive-store.ts";
 import { createRecord } from "../execution-record.ts";
 import { startIdleGc } from "../idle-gc.ts";
 import { RecordStore } from "../record-store.ts";
@@ -53,6 +58,61 @@ function makeRecord(id: string, overrides: Partial<ExecutionRecord> = {}): Execu
   return record;
 }
 
+describe("idle-GC 归口 markIdleArchived（U2b/C1——D3a release 出口②闭环链，S6 锚点）", () => {
+  it("fake clock 推进 30 天 → 归档 + `.alive` 已删 + fork-from 探针放行 + 接管 acquire 重声明（闭环链）", async () => {
+    const store = makeStore();
+    const sessionFile = path.join(tmpDir, "lease-session.jsonl");
+    fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+    const rec = makeRecord("bg-lease", {
+      startedAt: Date.now() - 31 * DAY_MS,
+      idleSince: Date.now() - 31 * DAY_MS,
+      sessionFile,
+    });
+    store.register(rec);
+    // 持有期声明在位（模拟 spawn 侧 acquireWriteLease 已声明写权的 resumable record）。
+    store.acquireWriteLease(sessionFile, rec.id);
+    expect(fs.existsSync(`${sessionFile}.alive`)).toBe(true);
+
+    stop = startIdleGc(store);
+    await vi.advanceTimersByTimeAsync(GC_INTERVAL_MS + 1);
+
+    // ① 归档生效（内存移除——record 磁盘仍 running 可接管，非终态化）。
+    expect(store.getMutable("bg-lease")).toBeUndefined();
+    // ② marker 已删（release 生效——归档 = 放弃持有 = 放弃写权声明）。
+    expect(fs.existsSync(`${sessionFile}.alive`)).toBe(false);
+    // ③ fork-from 放行：探针无 marker 即无声明，不再被残留声明拦。
+    expect(findForeignLiveInstance(sessionFile)).toBeUndefined();
+    // ④ message 接管 acquire 重声明：接管时统一 acquireWriteLease（接管链经
+    //    markResurrected 的 acquire-first，本处以 store 内部 acquire 动作直驱同语义）。
+    store.acquireWriteLease(sessionFile, "bg-lease");
+    const marker = JSON.parse(fs.readFileSync(`${sessionFile}.alive`, "utf-8")) as {
+      pid: number;
+      id: string;
+    };
+    expect(marker).toMatchObject({ pid: process.pid, id: "bg-lease" });
+    // 重声明后探针对本进程仍放行（self-pid 排除——自有声明不构成 foreign）。
+    expect(findForeignLiveInstance(sessionFile)).toBeUndefined();
+  });
+
+  it("锚窗内的 record 不归档且 `.alive` 不 release（无早释）", async () => {
+    const store = makeStore();
+    const sessionFile = path.join(tmpDir, "lease-fresh.jsonl");
+    fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+    const rec = makeRecord("bg-hold", {
+      startedAt: Date.now() - 1 * DAY_MS,
+      sessionFile,
+    });
+    store.register(rec);
+    store.acquireWriteLease(sessionFile, rec.id);
+
+    stop = startIdleGc(store);
+    await vi.advanceTimersByTimeAsync(GC_INTERVAL_MS + 1);
+
+    expect(store.getMutable("bg-hold")).toBeDefined();
+    expect(fs.existsSync(`${sessionFile}.alive`)).toBe(true);
+  });
+});
+
 describe("idle-gc record 锚扩展（W4）", () => {
   it("无 idleSince 的 resumable record 以 startedAt 为锚：超 30 天归档", async () => {
     const store = makeStore();

package/src/execution/__tests__/inflight-production-wiring.test.ts

@@ -0,0 +1,223 @@
+// src/execution/__tests__/inflight-production-wiring.test.ts
+//
+// [u7a 生产补挂] D5 在途推送的生产链路 wiring 测试（crash-forensics impl-plan §7 v6）。
+//
+// 背景：notifyInFlightChanged 此前唯一挂点 = host-bridge arm/disarm 委托，而
+// createHostBridge 全仓无生产调用点——生产迁移点（subagent-service 裸 arm/disarm/
+// 镜像置死、EngineClient 反向通道镜像）全部不推送，extension 监听者恒收不到帧，
+// runtime 侧 inflight 镜像恒 0（Gate B A4 BLOCKED 根因 a）。
+//
+// 三视角：
+//   ①使用者（extension reporter 视角）——注册 setInFlightListener 后，生产迁移点
+//     （idle 相位 arm / 续聊 disarm / 守护击杀 / dispose 批量回收 / 引擎反向通道
+//     childSpawned/childStateChanged）每一处都推来含该 record 贡献的绝对计数快照。
+//   ②构建者——推送携带的是双谓词过滤后的真实计数：活句柄 + 无 armed idle timer
+//     才计在途；镜像置死后计数即刻回落（EngineClient 镜像桥接投影）。
+//   ③观察者——EngineClient 镜像 → core 镜像的单向投影可从镜像面观察（core 镜像
+//     条目随反向通道事件出现/置死），壳层监听者异常不反噬主链（既有出口测试覆盖，
+//     此处不重复）。
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { EventEmitter } from "node:events";
+import type { ChildProcess } from "node:child_process";
+
+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 }));
+
+import { clearEngines } from "../engine/registry.ts";
+import { registerFakePiEngine, type FakePiEnginePort } from "./helpers/fake-engine-port.ts";
+import { createRecord } from "../execution-record.ts";
+import { ModelConfigService } from "../model-config-service.ts";
+import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
+import type { RecordStore } from "../record-store.ts";
+import { SubagentService, type PiLike } from "../subagent-service.ts";
+import { _resetLifecycleState, hasIdleTimer } from "../lifecycle-manager.ts";
+import {
+  registerSpawnedChildForRecord,
+  _resetCoreSpawnedChildrenMirrorForTest,
+} from "../engine/host/spawned-children.ts";
+import {
+  getInFlightSnapshot,
+  setInFlightListener,
+  type InFlightSnapshot,
+} from "../engine/inflight-snapshot.ts";
+import { EngineClient } from "../engine/client/engine-client.ts";
+
+const CTX_MODEL: ModelInfo = { id: "m", name: "M", provider: "p", reasoning: false };
+
+function makeEmptyRegistry(): ModelRegistryLike {
+  return { getAvailable: () => [], find: () => undefined, hasConfiguredAuth: () => true };
+}
+
+function makePi(): PiLike {
+  return {
+    appendEntry: vi.fn(),
+    events: { emit: vi.fn() },
+    sendMessage: vi.fn(),
+  } as unknown as PiLike;
+}
+
+/** 最小 fake 子进程（EventEmitter + killed/pid——hasLiveProcessHandle 消费面）。 */
+function makeFakeChild(pid = 4242): ChildProcess & EventEmitter {
+  const child = new EventEmitter() as ChildProcess & EventEmitter;
+  (child as { pid?: number }).pid = pid;
+  (child as { killed: boolean }).killed = false;
+  return child;
+}
+
+interface ServiceInternals {
+  store: RecordStore;
+}
+
+function setup(): {
+  agentDir: string;
+  service: SubagentService;
+  store: RecordStore;
+  fake: FakePiEnginePort;
+} {
+  const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "inflight-wiring-"));
+  clearEngines();
+  const fake = registerFakePiEngine();
+  const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
+  modelService.initModel({ modelRegistry: makeEmptyRegistry(), sessionId: "root-session", ctxModel: CTX_MODEL });
+  const service = new SubagentService({ cwd: agentDir, modelService });
+  service.initSession({ pi: makePi(), sessionId: "root-session" });
+  const store = (service as unknown as ServiceInternals).store;
+  return { agentDir, service, store, fake };
+}
+
+/** chatMode 续聊态 record（首轮已完成等待续聊——v4 B-1 折入 running）。 */
+function makeResumableRecord(id: string): ReturnType<typeof createRecord> {
+  const record = createRecord(id, {
+    agent: "general-purpose",
+    model: "test/model",
+    mode: "background",
+    task: "initial task",
+    slug: "chat",
+    startedAt: 1000,
+    rootSessionId: "root-session",
+    chatMode: true,
+  });
+  record.status = "running";
+  record.round = 1;
+  record.controller = new AbortController();
+  return record;
+}
+
+describe("u7a 生产迁移点 → 在途推送（wiring）", () => {
+  let agentDir: string;
+  let service: SubagentService;
+  let store: RecordStore;
+  let fake: FakePiEnginePort;
+  let seen: InFlightSnapshot[];
+
+  beforeEach(() => {
+    ({ agentDir, service, store, fake } = setup());
+    seen = [];
+    setInFlightListener((s) => seen.push({ ...s }));
+  });
+
+  afterEach(() => {
+    setInFlightListener(null);
+    service.dispose();
+    clearEngines();
+    _resetLifecycleState();
+    _resetCoreSpawnedChildrenMirrorForTest();
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
+  it("idle 相位 arm（生产路径 = handleChatRoundPhase → armChatIdleTimer）：活句柄翻入保活，推送 inFlight=0", async () => {
+    const handle = await service.execute({ task: "first round", slug: "t", ctxModel: CTX_MODEL, conversation: true });
+    const run = fake.runs[0]!;
+    // 引擎侧活句柄（生产经 EngineClient 反向通道桥接投影——此处直接落 core 镜像，
+    // 桥接本体在下方 EngineClient 套件独立验证）
+    registerSpawnedChildForRecord(handle.subagentId, makeFakeChild());
+    expect(getInFlightSnapshot().inFlight).toBe(1); // 前置：在途句柄在场
+
+    seen.length = 0;
+    run.emitLifecycle({ phase: "idle" });
+    expect(hasIdleTimer(handle.subagentId)).toBe(true); // idle 相位 = timer armed
+    expect(seen.at(-1)).toEqual({ inFlight: 0 }); // 保活不算在途（D5 谓词）
+  });
+
+  it("续聊投递 disarm（生产路径 = deliverChatMessage）：翻回正在执行，推送 inFlight=1", async () => {
+    const record = makeResumableRecord("sa-wiring-disarm");
+    store.register(record);
+    registerSpawnedChildForRecord(record.id, makeFakeChild());
+
+    seen.length = 0;
+    await service.chatActions.deliverChatMessage(record, "next round msg", false);
+
+    expect(fake.interacts[0]!.action).toEqual({ kind: "message", payload: "next round msg", interrupt: false });
+    expect(hasIdleTimer(record.id)).toBe(false);
+    expect(seen.at(-1)).toEqual({ inFlight: 1 }); // disarm 后该 record 计在途
+  });
+
+  it("dispose 批量回收：逐 record kill+disarm 后收敛推送终态 inFlight=0", async () => {
+    const record = makeResumableRecord("sa-wiring-dispose");
+    store.register(record);
+    registerSpawnedChildForRecord(record.id, makeFakeChild());
+    expect(getInFlightSnapshot().inFlight).toBe(1);
+
+    seen.length = 0;
+    service.dispose();
+    expect(seen.at(-1)).toEqual({ inFlight: 0 });
+    expect(getInFlightSnapshot().inFlight).toBe(0);
+  });
+});
+
+describe("u7a 数据面桥接：EngineClient 反向通道镜像 → core 镜像 + 推送", () => {
+  let dataDir: string;
+  let client: EngineClient;
+  let seen: InFlightSnapshot[];
+
+  beforeEach(() => {
+    dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "inflight-bridge-"));
+    // 不 connect（构造即被测面：镜像变更经 onChange 同步广播）——零子进程零 fs 写
+    client = new EngineClient({
+      engineId: "fake",
+      command: process.execPath,
+      args: ["-e", "process.exit(0)"],
+      hostKind: "test",
+      hostVersion: "test-host-1.0",
+      dataDir,
+      envPrefixes: [],
+    });
+    seen = [];
+    setInFlightListener((s) => seen.push({ ...s }));
+  });
+
+  afterEach(() => {
+    setInFlightListener(null);
+    client.dispose();
+    _resetCoreSpawnedChildrenMirrorForTest();
+    _resetLifecycleState();
+    fs.rmSync(dataDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
+  it("childSpawned → core 镜像落项 + 推送 inFlight=1；childStateChanged(exited) → 置死 + 推送 inFlight=0", () => {
+    client.mirror.recordSpawned(4242, "sa-bridge");
+    expect(seen.at(-1)).toEqual({ inFlight: 1 });
+    expect(getInFlightSnapshot().inFlight).toBe(1); // core 镜像已投影（计数数据源）
+
+    client.mirror.recordStateChanged({ pid: 4242, recordId: "sa-bridge", state: "exited", killed: true });
+    expect(seen.at(-1)).toEqual({ inFlight: 0 });
+    expect(getInFlightSnapshot().inFlight).toBe(0);
+  });
+
+  it("同 recordId 重 spawn 覆盖 + killedAll 整体置死（引擎回收语义投影）", () => {
+    client.mirror.recordSpawned(111, "sa-bridge-a");
+    client.mirror.recordSpawned(222, "sa-bridge-b");
+    expect(seen.at(-1)).toEqual({ inFlight: 2 });
+
+    client.mirror.killAll(); // 引擎 exit / killAll：逐项 killedAll 事件
+    expect(seen.at(-1)).toEqual({ inFlight: 0 });
+    expect(getInFlightSnapshot().inFlight).toBe(0);
+  });
+});