@zhushanwen/subagent-core 0.4.0 → 0.6.0

package/src/execution/subagent-service.ts

@@ -1,87 +1,85 @@
-// 执行编排 + 记录 + 通知领域 Service。
-// 上游：subagent-tool（execute/query/cancel）、TUI（onChange/listRunning/collectRecords）。
+// 执行编排 + 记录领域 Service（D4 按变化轴拆分后的编排核：execute/executeAndAwait 入口、
+// record 生命周期、cancel）。通知簇 → notify-host.ts；轮次结算闭包 → round-settlement.ts；
+// 冷路径复活 → cold-resurrect.ts。
+// 上游：subagent-tool（execute/query/cancel）、TUI（onChange/collectRecords）。
 // session_start 时经 initSession 注入 pi；modelRegistry/entries 归 ModelConfigService.initModel。
 
 import { AsyncLocalStorage } from "node:async_hooks";
-import * as fs from "node:fs";
 
 import { getLogger } from "../core/logger.ts";
 
 import type { ExtensionMode } from "./host-mode.ts";
 
 import type { AgentResult as WorkflowAgentResult } from "../orchestration/models/types.ts";
-import { displayAgentName } from "../shared/agent-ref.ts";
 import { MAX_TIMER_DELAY_MS } from "../shared/timer-delay.ts";
 // D-A10: workflow 侧 AgentResult 映射（executeAndAwait 出口）
 import { mapToWorkflowAgentResult } from "./agent-result-mapper.ts";
-import { removeAliveMarker, findForeignLiveInstance, writeAliveMarker } from "./alive-store.ts";
+import { removeAliveMarker } from "./alive-store.ts";
 import { bestEffort } from "./best-effort.ts";
+import { CollectCoordinator } from "./collect-coordinator.ts";
+import { DEFAULT_COLLECT_SYNC } from "./config.ts";
 // [V2 决策 3] lifecycle-manager idle timer：chatMode 统一投递新 turn disarm（防误杀活进程）。
-// [M3] hasIdleTimer：piAdapter.hasRunningBackground 排除等待续聊（timer armed）的 record。
-// [T4②] DEFAULT_IDLE_TIMEOUT_MS：deliverMessage 非 EPIPE 失败 re-arm 的防御性兜底时长。
-import {
-  acquireActivateLock,
-  armIdleTimer,
-  disarmIdleTimer,
-  hasIdleTimer,
-  DEFAULT_IDLE_TIMEOUT_MS,
-} from "./lifecycle-manager.ts";
+// [T4②] DEFAULT_IDLE_TIMEOUT_MS：assertIdleTimeoutMsSafe 错误文案的缺省时长基准。
+// （[M3] hasIdleTimer / hasLiveProcessHandle 的 piAdapter.hasRunningBackground 过滤随通知簇
+// 在 notify-host.ts 消费，不经本文件。）
+import { disarmIdleTimer, DEFAULT_IDLE_TIMEOUT_MS } from "./lifecycle-manager.ts";
 import { type ConcurrencyPool,DefaultConcurrencyPool } from "./concurrency-pool.ts";
 import type { DialogGlobalQueue, UiRequestHandler } from "./dialog-queue.ts";
+import { COLD_LOOKUP_SCAN_LIMIT, coldLookupForAction, type ColdResurrectDeps } from "./cold-resurrect.ts";
 import {
   completeRecord,
   createRecord,
-  getFullTextFrom,
-  nextRoundBaseTurnIndex,
   project,
-  resurrectClosed,
   snapshot,
   tryTransition,
 } from "./execution-record.ts";
 import { doFinalizeRecord, doFinalizeRoundToIdle } from "./finalize-record.ts";
-import { getEngineDataDir } from "./engine/common/data-dir.ts";
-import { EngineError } from "./engine/common/errors.ts";
-import { JournalWriter } from "./engine/common/event-journal.ts";
-import { resolveJournalPath } from "./engine/paths.ts";
+import { assertTaskShapeSupported } from "./engine/common/capability-gate.ts";
+import { ExecutionNestingContext } from "./engine/common/nesting-guard.ts";
+import { JOURNAL_INITIAL_POOL_KEY, wireEventJournal } from "./engine/common/journal-wiring.ts";
 import { executeOptionsToEngineTaskSpec } from "./engine/host-task-spec.ts";
+import { PiEngine } from "./engine/engines/pi/pi-engine.ts";
+import { PI_POOL_KEY } from "./engine/engines/pi/pi-engine.ts";
+import type { ChatRoundTicket, PiEngineService } from "./engine/engines/pi/pi-engine.ts";
 import type { EnginePort, RunContext } from "./engine/port.ts";
-import { DEFAULT_ENGINE_ID, getEngine } from "./engine/registry.ts";
-import { type EngineRouteResult, resolveEngineRouting, routeEngine } from "./engine/routing.ts";
+import { DEFAULT_ENGINE_ID, getEngine, listEngines } from "./engine/registry.ts";
+import { validateModelForEngine, withCrossEngineHint } from "./engine/model-validation.ts";
+import { type EngineRouteResult, routeEngineForHost } from "./engine/routing.ts";
 import type { AgentOutcome } from "./engine/types.ts";
 import { ManifestStore } from "./manifest-store.ts";
 import type { ModelConfigService } from "./model-config-service.ts";
 import type { AgentConfig, ModelInfo, ResolvedModel } from "./model-resolver.ts";
-import type { BgNotifyRecord, BgNotifier, NotifierHost } from "./notifier.ts";
-import { createNotifier } from "./notifier.ts";
+import { type NotifyHost, type PiLike, createNotifyHost } from "./notify-host.ts";
+// [T4④ / PS-5] flush 被门拦时的未投递 pending 落盘账本（persistUndeliveredNotificationsForReplay 消费）
+import type { BatchBudgetParams, BgNotifyRecord } from "./notifier.ts";
 import { getBoundNotifyLedger, NOTIFY_LEDGER_CUSTOM_TYPE } from "./notify-ledger.ts";
 import { getSubagentRecordsDir, getSubagentSessionDir } from "./path-encoding.ts";
+import { createRoundSettler } from "./round-settlement.ts";
 import type { StatusFilter } from "./record-store.ts";
 import { RecordStore } from "./record-store.ts";
+// [E1 恢复批语义修复 / S11] 恢复批补发映射 + getFullRecord miss 成员兜底落标数据源
+//（变化轴拆分，实现与语义注释见 sync-rebuild.ts）
+import { bufferedMemberFallbackRecord, syncRebuildToNotifyMember } from "./sync-rebuild.ts";
 import { MAX_FORK_DEPTH } from "./session-context-resolver.ts";
 import {
-  getChildByRecord,
   killAllSpawnedChildren,
   killRecordChildWithEscalation,
   registerSpawnedChildForRecord,
   runSpawn,
-  spawnedChildren,
   type SessionRunnerContext,
   type SpawnResumeOpts,
-} from "./session-runner.ts";
+} from "./engine/engines/pi/session-runner.ts";
+// [u-t2a T2②/T2③] settled watchdog：chatMode 轮 settled 等待固定硬上限（10min），
+// 双挂载点之一在编排层热路径（deliverChatMessage，prompt 发出后），disarm 站点散布
+// cancel/close/终态化路径（原语幂等，见 settled-watchdog.ts 头注释）。
 import {
-  armSettledWatchdog,
+  armMidRoundNoProgress,
   disarmSettledWatchdog,
-  SETTLED_WATCHDOG_TIMEOUT_MS,
+  type SettledWatchdogFireInfo,
 } from "./settled-watchdog.ts";
-import { isIdle, isResumable, hasLiveProcessHandle } from "./lifecycle-predicates.ts";
+import { isIdle, isResumable } from "./lifecycle-predicates.ts";
 import { startIdleGc } from "./idle-gc.ts";
-import {
-  clearEpipeFailure,
-  EPIPE_FAILURE_THRESHOLD,
-  recordEpipeFailure,
-  resetAllEpipeFailures,
-  sendPromptCommand,
-} from "./stdin-writer.ts";
+import { resetAllEpipeFailures } from "./engine/engines/pi/stdin-writer.ts";
 import type { StreamSink, SubagentStream } from "./stream-sink.ts";
 import { createBackgroundStream } from "./stream-sink.ts";
 import { writeCancelledTombstone } from "./tombstone-store.ts";
@@ -98,19 +96,45 @@ import type {
   SubagentRecord,
 } from "./types.ts";
 import { ForkDepthExceededError } from "./types.ts";
-import { isReconnectableFinalReason, ResurrectDeniedError } from "./types.ts";
 import { DEFAULT_AGENT_NAME } from "./types.ts";
 import { registerGlobalObservability, UiRequestObservability } from "./ui-request-observability.ts";
 import { WorktreeManager } from "./worktree-manager.ts";
+import { toErrorMessage } from "../core/error-message.ts";
 
 const logger = getLogger("subagents");
 
-/** SP-2 冷路径按 id 查 record 的 collectRecords 扫描上限（全扫兜底的容量 cap）。 */
-const COLD_LOOKUP_SCAN_LIMIT = 1000;
+/** [D4 查询面聚合] 读模型轴（record 快照读取 + store 订阅）——Service 上的
+ *  `service.queries` 消费面。变化轴：改查询投影 / 过滤 / 订阅语义，只动 queries 组；
+ *  Service 本体保留编排核（execute/executeAndAwait/cancel）与生命周期面。 */
+export interface SubagentQueries {
+  /** 按 id 查内存 running record 的只读快照（G3-002 修复）。不存在返回 undefined。 */
+  findRecord(id: string): RecordSnapshot | undefined;
+  /** [v8.5 A1/B] 全态查找：任意状态 × 任意归属的 record 快照（message 拒绝文案分流
+   *  与 fork-from 源解析共用）。id 在内存与磁盘均不存在返回 undefined。 */
+  lookupRecordAnyState(id: string): SubagentRecord | undefined;
+  /** 合并内存 + 磁盘 record（/subagents list + tool list 消费，按 rootSessionId 过滤）。 */
+  collectRecords(limit: number, statusFilter?: StatusFilter): SubagentRecord[];
+  /** [perf] 单 record 详情懒加载（全量：eventLog/displayItems/result/turns/tokens）。 */
+  getFullRecord(id: string): SubagentRecord | undefined;
+  /** 订阅 store 变更（widget/list requestRender）。返回取消订阅。 */
+  onChange(listener: () => void): () => void;
+}
 
-// [v4 A-1] EPIPE 连续失败计数器已迁移到 stdin-writer.ts（stdin 错误域，避免 session-runner
-// 反向 import 本文件 helper 产生循环依赖）。同步路径（deliverMessage）与异步路径
-//（session-runner child.stdin.on('error')）共用 stdin-writer 的同一计数器。
+/** [D4 对话 action 面聚合] chat 域 message/close action 轴（M2-B3，原 Service 同节三方法）
+ *  ——Service 上的 `service.chatActions` 消费面。变化轴：改对话域归属校验 / close 分流 /
+   投递编排，只动 chatActions 组。 */
+export interface SubagentChatActions {
+  /** 按 id 查 record 并做归属校验（message/close action 的统一入口）。 */
+  getRecordForAction(id: string, opts?: { allowReconnect?: boolean }): ExecutionRecord;
+  /** close action 的统一行为分流（running 子态 × force）。 */
+  closeSubagent(record: ExecutionRecord, force: boolean): Promise<void>;
+  /** chatMode 统一投递入口（message action，经引擎交互面执行）。 */
+  deliverChatMessage(record: ExecutionRecord, text: string, interrupt: boolean): Promise<void>;
+}
+
+// [v4 A-1] EPIPE 连续失败计数器在 stdin-writer.ts（stdin 错误域，避免 session-runner
+// 反向 import 本文件 helper 产生循环依赖）。同步路径（PiEngine 热路径投递，D2 协议知识
+// 下沉后）与异步路径（session-runner child.stdin.on('error')）共用 stdin-writer 的同一计数器。
 
 /** dispose 后注入的 stub UI 请求 handler。
  *
@@ -129,48 +153,13 @@ const COLD_LOOKUP_SCAN_LIMIT = 1000;
  * 没真正解决。 */
 const disposedUiRequestStub: UiRequestHandler = () => Promise.resolve({ cancelled: true });
 
-/** Pi ExtensionAPI 的最小接口（duck-typed）。
- *  subagent-service 直接调 pi.sendMessage 发 background 完成通知（BgNotifier 滑动窗口合并），
- *  不委托 pending-notifications EventBus 中继——后者只管 registry 不参与通知发送。 */
-interface PiLike {
-  appendEntry(customType: string, data?: unknown): void;
-  events: { emit(channel: string, data: unknown): void };
-  sendMessage(
-    message: { customType: string; content: string; display: boolean; details?: unknown },
-    options?: { triggerTurn?: boolean; deliverAs?: "steer" | "followUp" | "nextTurn" }, // g4-allow: 类型注解——PiLike 接口形状（pi.sendMessage 签面子集），非投递调用
-  ): void;
-  /** 订阅 pi 事件（D8：notifier 的 settled 边沿订阅用 'agent_settled'）。
-   *  pi 0.84.4 的 on 返回 void 且无 off——退订语义由调用侧 disposed 标志包装兑现。
-   *  可选：旧测试 mock pi 可能未实现 on，缺省时 notifier 退化为内核退避路径。 */
-  on?(event: "agent_settled", handler: () => void): void;
-}
-
 /** UI streaming sink 的最小接口（ctx.ui.setWidget 的 duck-typed 子集）。
  *  session_start 时从 ctx.ui 注入，background 执行期间用于把合并后的 text_delta
  *  通过 setWidget 通道转发到 RPC stdout（不经 sendMessage 的持久化路径）。 */
 export type { StreamSink } from "./stream-sink.ts";
 
-/** pending-notifications 注册/注销 helper（避免重复代码）。
- *  name 是 GUI pending 通知的显示名——取 basename 短名（displayAgentName），
- *  完整路径仍走 record.agent（env 注入 / 持久化）。 */
-function emitPendingRegister(pi: PiLike | null, id: string, name?: string): void {
-  pi?.events.emit("pending:register", {
-    id,
-    type: "subagent",
-    name: name ? displayAgentName(name) : id,
-  });
-}
-
-function emitPendingUnregister(
-  pi: PiLike | null,
-  id: string,
-  reason: string,
-): void {
-  pi?.events.emit("pending:unregister", {
-    id,
-    reason,
-  });
-}
+// pi 依赖端口类型 re-export：测试侧 mock PiLike 历来从本模块取（与 StreamSink 同构的门面模式）
+export type { PiLike } from "./notify-host.ts";
 
 /**
  * Service 构造参数（进程级）。
@@ -204,8 +193,12 @@ export interface SubagentServiceSessionInit {
    *  initSession 读取后存入 this.sessionMode，buildSessionRunnerContext 透传给 session-runner。 */
   mode?: ExtensionMode;
   /** UI 请求 handler（session 级覆盖进程级）。
-   *  initSession 读取后覆盖 this.uiRequestHandler（setUiRequestHandler 的 session 级等价入口）。 */
-  uiRequestHandler?: UiRequestHandler;
+   *  [D4-④ UI 接线外提] 本字段是 handler 的唯一注入入口（原 setUiRequestHandler 方法已删）。
+   *  三态语义：undefined = 不动（保留进程级构造/上次值，供不注入 handler 的调用方）；
+   *  null = 显式清空（承载原 setUiRequestHandler(undefined) 语义——headless 的
+   *  createUiRequestHandlerForMode 返回 undefined 时壳侧传 null）；值 = 注入并重置
+   *  缺失告警去重。 */
+  uiRequestHandler?: UiRequestHandler | null;
   /** L2 跨子进程全局 dialog 串行队列（进程单例）。透传给 session-runner，
    *  child close 时调 rejectChildDialogs 清理 pending（SR-4 防全局死锁）。 */
   dialogQueue?: DialogGlobalQueue;
@@ -223,14 +216,14 @@ const MS_PER_SECOND = 1000;
 const SECONDS_PER_MINUTE = 60;
 
 /** [T4① / PS-2] notify 门拦截集：disposeAllRecords 因这两类原因关闭的 record，其迟到的
- *  kickOffBackground.then 完成回注不得注入新 session——/new、/fork 的决策（[v4 A-6]）
+ *  轮次完成回注不得注入新 session——/new、/fork 的决策（[v4 A-6]）
  *  是「被关 record 的告知改由 list 的 closedReason 表达」，不主动通知；旧门只排除
  *  cancelled，parent-new/parent-fork 放行 → 新对话被「Subagent X failed: closed due to
  *  parent-new」的僵尸回执 triggerTurn 唤醒，已废弃会话的通知注入新上下文。 */
 const NOTIFY_BLOCKED_CLOSED_REASONS: ReadonlySet<ClosedReason> = new Set(["parent-new", "parent-fork"]);
 
 /**
- * [T4① / PS-2] kickOffBackground.then 完成回注的 notify 门（按 closedReason 白名单放行）。
+ * [T4① / PS-2] 轮次完成回注的 notify 门（按 closedReason 白名单放行）。
  *
  * cancelled（cancelBackground 自己 notify）与 parent-new/parent-fork（编排性关闭，
  * 告知由 list 的 closedReason 表达）不放行；其余（undefined = 本路径抢到 CAS 尚未
@@ -255,6 +248,11 @@ const ENV_SELF_RECORD_ID = "PI_SUBAGENT_SELF_RECORD_ID";
 const ENV_DEPTH = "PI_SUBAGENT_DEPTH";
 const ENV_ROOT_CWD = "PI_SUBAGENT_ROOT_CWD";
 
+/** [v2 D4] E1 等待分支 settled 有界重扫上限。无上限重扫 = 泄漏（设计 §3.3 D4 被否
+ *  谱系）；8 次覆盖重启后主 agent 对 resumable 成员的典型续跑轮次，达限仍有
+ *  running → disposed，交下次 session_start 收敛。 */
+const SETTLED_RESCAN_LIMIT = 8;
+
 /** resolveIdentity 的产物——一次确定、写入 record 后不再变。 */
 interface ResolvedIdentity {
   agent: string;
@@ -303,16 +301,12 @@ export class SubagentService {
    *  （collectRecords filter 用，与 createRecordForMode 的 rootSessionId 盖章同源——子进程
    *  因此看到整棵 ROOT 树）。设计见 recursive-subagent-visibility.md 决策 3。 */
   private sessionRootId: string | null = null;
-  /** 进程级执行上下文基线（不依赖 ALS 贯穿——pi RPC mode 的 stdin JSONL 是事件回调式
-   *  （attachJsonlLineReader stream.on("data")），每个命令是独立异步链，initSession 里
-   *  execCtxAls.enterWith 的 store 不会贯穿到后续 tool 调用事件（实测：递归第二层
-   *  parentRecordId/depth 丢失而 rootSessionId 正确——rootSessionId 是实例字段所以不受影响）。
-   *  基线 = 本进程自己的身份（initSession 从 env 读取，与 sessionRootId 同机制）：
-   *  读 ALS store 失败时兜底，保证「本进程派发的 subagent 都是本进程记录的孩子」
-   *  这一跨进程树形关系成立。
-   *  initSession 设置：有 env PI_SUBAGENT_SELF_RECORD_ID → {recordId: env 值, depth: env DEPTH}；
-   *  无 env（根进程）→ null（顶层）。 */
-  private execCtxBaseline: { recordId: string | undefined; depth: number } | null = null;
+  /**
+   * [D3-⑤ 嵌套防护合一] 进程内执行嵌套上下文（原 execCtxAls 私有字段下沉公共层
+   * common/nesting-guard.ts ExecutionNestingContext——机制注释含 ALS 断裂基线兜底）。
+   * 实例 per-Service：基线随宿主进程身份而异（initSession 从 env 建立）。
+   */
+  private readonly execNesting = new ExecutionNestingContext();
   /** fork 深度基线（同 ALS 断裂问题：forkDepthAls.getStore() 兜底用）。根进程=0。 */
   private forkDepthBaseline = 0;
   /** [MF-3] 所属根进程 cwd（sessions/records 落盘目录编码键）。
@@ -328,32 +322,109 @@ export class SubagentService {
   getStreamSink(): StreamSink | null { return this.streamSink; }
   private _disposed = false;
   private _seq = 0;
-  /** background 完成通知器（滑动窗口合并 + 去重）。session_start revive，shutdown dispose。 */
-  private readonly notifier: BgNotifier;
+  /** [D4-①] 通知簇 host 面（notifyComplete/notifyClosed/pending 注册注销 + notifier
+   *  实例封装，原私有通知簇四方法与模块函数的搬移落点——notify-host.ts）。
+   *  deps 惰性求值（pi/session 级状态运行时可变），行为与原 constructor 内
+   *  createNotifier(this.piAdapter()) 逐字节等价。session_start revive，shutdown dispose。
+   *  [sync-collect 合并] toNotifyRecord/notify/notifyBatch 随批路由需要由 host 导出
+   *  （collectCoordinator 闭包与 E9/E1 直发路径消费，见 notify-host.ts 接口注释）。 */
+  private readonly notifyHost: NotifyHost = createNotifyHost({
+    getPi: () => this.pi,
+    listRunning: () => this.store.listRunning(),
+    getIsIdle: () => this.isIdleFn,
+  });
+
+  /** collectCoordinator（subagent-sync-collect U2）：sync 批缓冲 + 闭合检测 + flush 分流。 */
+  private readonly collectCoordinator: CollectCoordinator;
+  /** [E9] dispose 时已转 async 写账的成员 id（revive 后 flushBatch 防御过滤用）。
+   *  背景：dispose 后同进程 revive（/resume /fork /new）时协调器内部缓冲仍持有已转换
+   *  成员快照（协调器无 drain API，U5 领地不含 collect-coordinator.ts）——若后续新
+   *  sync 成员触发闭合，陈旧快照会随批重投（新成员集新 hash，账本跨键不拦）→ 双重
+   *  通知。flushBatch 闭包按本集过滤，陈旧成员零重投。id 唯一 per spawn，无误伤面。 */
+  private readonly e9ConvertedIds = new Set<string>();
+  /** [v2 D4] E1 等待分支的 settled 有界重扫状态（null = 未注册）。disposed 后保持
+   *  非 null——同 session 内不再重复注册（补发完成/达限后 settled 边沿已无事可做，
+   *  单注册即单重扫）；initSession（revive）置 null 允许新 session 重新注册。
+   *  pi.on 无 off（见 armSettledRescan）：旧 handler 闭包捕获旧 state，未 disposed 时
+   *  遇 settled 边沿仍会执行，扫描 this.mainSessionFile 当前值（handler 不绑定注册时
+   *  的文件域）；dispose 的惰化处置见 dispose()。 */
+  private settledRescanState: { disposed: boolean; scans: number } | null = null;
   /** [MF#4][MF#2] fork 深度按 async 调用链传递（AsyncLocalStorage），替代共享可变计数器。
    *  主 session=0；fork 进入子 session 期间推进为子深度，供嵌套 fork 经 ALS 读到自身深度作为
    *  parentForkDepth。并发 background fork 各自独立调用链，不再互相压低深度值。
    *  [MF#2] 旧实现用单实例字段跨执行链共享 → 并发下 A 还原深度后 B 读到被压低值 → 护栏失效。 */
   private readonly forkDepthAls = new AsyncLocalStorage<number>();
 
-  /** subagent 执行上下文按 async 调用链传递（当前正在跑的 record 身份 + 递归深度）。
-   *  B run() 期间包此 ALS，B 内创建 C 时 createRecordForMode 读到 B 的 recordId/depth，
-   *  据此设 C.parentRecordId=B.id、C.depth=B.depth+1。主 session 链上无 store → 顶层。
-   *  与 forkDepthAls 独立：后者只数 fork 链（fork=true 才递增），本 ALS 数所有 subagent 嵌套。 */
-  private readonly execCtxAls = new AsyncLocalStorage<{ recordId: string | undefined; depth: number }>();
-
-  /** [review MF1] record 级在途 resume 守卫。resumeRound 全部守卫通过后 add，
-   *  runAndFinalize 结束（finally，覆盖轮次完成 / MF-6 失败回退 / abort / 终态化所有分支）时
-   *  delete（幂等：execute() 新建 record 不在集合，no-op）。窗口 = resume 发起（含 pool.acquire
-   *  排队）→ 本轮 runAndFinalize 收尾。窗口内同 record 再次到达 resumeRound（冷路径重入 /
-   *  EPIPE 兜底）直接 throw——防两个 pi 子进程以 --session 同一 JSONL 双写 + 前一个脱离
-   *  kill 记账成孤儿（deliverMessage 冷路径的 acquireActivateLock 只覆盖 resumeRound 同步段，
-   *  锁释放在子进程注册（session-runner spawnedChildren.set）之前，锁空洞由此守卫兜住；
-   *  EPIPE 兜底不持锁，同样被覆盖）。child 注册完成后 deliverMessage 走热路径，不经此守卫。 */
+  // [D3-⑤] subagent 执行上下文（record 身份 + 递归深度）的 ALS 传递已下沉公共层
+  // （execNesting 字段，common/nesting-guard.ts）——「B run() 期间挂身份，B 内创建 C
+  // 时读到 B」的机制与 ALS 断裂基线兜底注释见该文件。与 forkDepthAls 独立：后者只数
+  // fork 链（fork=true 才递增），嵌套上下文数所有 subagent 嵌套。
+
+  /** [review MF1] record 级在途 resume 守卫。冷路径续轮（resumeChatRound）全部守卫通过后
+   *  add，runAndFinalize 结束（finally，覆盖轮次完成 / MF-6 失败回退 / abort / 终态化所有
+   *  分支）时 delete（幂等：execute() 新建 record 不在集合，no-op）。窗口 = resume 发起
+   *  （含 pool.acquire 排队）→ 本轮 runAndFinalize 收尾。窗口内同 record 再次到达续轮
+   *  （冷路径重入 / EPIPE 兜底）直接 throw——防两个 pi 子进程以 --session 同一 JSONL 双写 +
+   *  前一个脱离 kill 记账成孤儿（冷路径的 acquireActivateLock 只覆盖续轮同步段，锁释放
+   *  在子进程注册（session-runner spawnedChildren.set）之前，锁空洞由此守卫兜住；EPIPE
+   *  兜底不持锁，同样被覆盖）。child 注册完成后投递走热路径，不经此守卫。 */
   private readonly resumesInFlight = new Set<string>();
 
+  /** chat 域 pi 引擎实例（D2 单轨：chat 域执行/投递统一经 EnginePort）。per-service DI——
+   *  getService 经适配器绑本实例；registry 全局 'pi' 单例绑进程级 getSubagentService()，
+   *  直构 Service 的测试场景解析不到本实例。不能 import registration.ts（其 import 本文件
+   *  → 循环依赖），直接构造 PiEngine（pi-engine 不反向依赖本文件）。 */
+  private readonly chatPiEngine: PiEngine = new PiEngine({ getService: () => this.piEngineServiceAdapter() });
+
+  /** chat 域轮次交接包（executeViaEngine / 冷路径续轮挂载 → PiEngine.run 经 taskId 消费）。 */
+  private readonly chatRoundTickets = new Map<string, ChatRoundTicket>();
+
+  /** [D4-②] 轮次结算回调（原 buildSessionRunnerContext 内的 onRoundSettled 业务闭包
+   *  搬移至 round-settlement.ts；deps 回调闭包惰性求值，session-runner agent_settled 时消费）。 */
+  private readonly settleRound = createRoundSettler({
+    notifyComplete: (record) => this.collectCoordinator.route(record),
+    reportRecordTransition: (record) => this.store.reportRecordTransition(record),
+    closeAfterRoundSettled: (record) => this.closeAfterRoundSettled(record),
+  });
+
+  /** [D4-③] 冷路径复活依赖（原四件 private 方法的搬移落点——cold-resurrect.ts；
+   *  deps 闭包惰性求值：sessionRootId / execNesting 基线运行时可变）。 */
+  private readonly coldResurrectDeps: ColdResurrectDeps = {
+    findLightById: (id) => this.store.findLightById(id),
+    collectRecords: (limit, statusFilter, rootFilter) =>
+      this.store.collectRecords(limit, statusFilter, rootFilter),
+    register: (record) => this.store.register(record),
+    reportRecordTransition: (record) => this.store.reportRecordTransition(record),
+    getSessionRootId: () => this.sessionRootId,
+    getBaselineRecordId: () => this.execNesting.baseline()?.recordId ?? undefined,
+  };
+
+  /** [D4 查询面聚合] 读模型消费面（壳 interface/ 视图与 tool 查询经此访问；
+   *  纯委托——方法本体保留 private 实现不重写，行为逐字节等价）。 */
+  readonly queries: SubagentQueries = {
+    findRecord: (id) => this.findRecord(id),
+    lookupRecordAnyState: (id) => this.lookupRecordAnyState(id),
+    collectRecords: (limit, statusFilter) => this.collectRecords(limit, statusFilter),
+    getFullRecord: (id) => this.getFullRecord(id),
+    onChange: (listener) => this.onChange(listener),
+  };
+
+  /** [D4 对话 action 面聚合] chat 域 message/close 消费面（壳 subagent-actions 经此访问；
+   *  纯委托同上。PiEngineService 适配器不经此——引擎边界走 piEngineServiceAdapter）。 */
+  readonly chatActions: SubagentChatActions = {
+    getRecordForAction: (id, opts) => this.getRecordForAction(id, opts),
+    closeSubagent: (record, force) => this.closeSubagent(record, force),
+    deliverChatMessage: (record, text, interrupt) => this.deliverChatMessage(record, text, interrupt),
+  };
+
   private readonly manifestStore: ManifestStore;
 
+  /**
+   * [D6 #7a] records 目录（与 manifestStore 同源同一推导）——屏障失败 warn 带 manifest
+   * 文件路径用（ManifestStore.dir 私有，此处不破封装另存同源值；漂移由构造点同语句保证不发生）。
+   */
+  private readonly recordsDir: string;
+
   /**
    * [T1/PS-9] subagent sessionDir（getSubagentSessionDir 推导，与 store 同源同一 rootCwd）。
    * 传给 doFinalizeRecord 的 FinalizeDeps.sessionDir——record.sessionFile 缺失时 finalize
@@ -378,9 +449,83 @@ export class SubagentService {
     const sessionsDir = getSubagentSessionDir(this.modelService.getAgentDir(), this.rootCwd);
     const recordsDir = getSubagentRecordsDir(this.modelService.getAgentDir(), this.rootCwd);
     this.sessionsDir = sessionsDir;
+    this.recordsDir = recordsDir;
     this.manifestStore = new ManifestStore(recordsDir);
     this.store = new RecordStore(sessionsDir, this.manifestStore, this.pi ?? undefined);
-    this.notifier = createNotifier(this.piAdapter());
+    // collectCoordinator（subagent-sync-collect U2）：notifyComplete 唯一路由入口——
+    // async 直通（字节不变）/ sync 批缓冲 + 闭合检测。[U3 接线点] 已接线：flush =
+    // manifest 屏障（await 全部落盘）→ notifier.notifyBatch 单条批投递（幂等键
+    // sync-batch:<hash> + 闭合触发排程合批 flush：同宏任务去抖窗口收纳背靠背
+    // route——U8 拆批盲窗修复 → ledger 写账 → attemptDeliver 边沿投递）+
+    // batchFinalized 落标（出口①，见下方闭包注释）。屏障先于写账 = 「通知可达 ⇒
+    // 索引就位」的构造性保证（时序竞态修复，见 flushBatch 闭包注释）。
+    // [U8] 排程与 E9/E1 交互：dispose 经 convertPendingSyncBufferToAsync 先取消挂起
+    // 排程（取消而非同步 flush——双通道并发写账防护，见该函数注释）；E1 只在
+    // session_start 编排处运行（此前 dispose 已取消排程，补发直走 notifyBatch 不经
+    // 协调器），异常时序相撞由账本 sync-batch:<hash> 幂等拒绝兜底。
+    // [D4-① 合并] notifier 实例封装在 notifyHost 内（createNotifyHost 装配），本类
+    // 经 this.notifyHost.notify / notifyBatch / toNotifyRecord 出口消费。
+    this.collectCoordinator = new CollectCoordinator({
+      notifyAsync: (record) => {
+        const notify = this.notifyHost.toNotifyRecord(record);
+        if (notify) this.notifyHost.notify(notify);
+      },
+      toNotifyRecord: (record) => this.notifyHost.toNotifyRecord(record),
+      // 闭合判定数据源：listAllActive（原始 ExecutionRecord 内存态，携带 collectMode/
+      // batchFinalized 原始值）。[U3 修正] 原接 collectRecords——其经 recordToSubagent
+      // 投影丢 collectMode（U2 披露的投影缺口）→ 真链上闭合判定恒立即闭合、跨轮续累
+      // 失效（真链 trace 实证）。非终态 sync 成员必在内存（archive 只删终态；磁盘重建
+      // 残留属孤儿恢复域），内存视图语义完整。
+      listRecords: (limit) => this.store.listAllActive().slice(0, limit),
+      flushBatch: async (members) => {
+        // [E9 防御过滤] 排除 dispose 时已转 async 写账的成员（同进程 revive 后协调器
+        // 缓冲残留的陈旧快照，见 e9ConvertedIds 字段注释）；全被排除 → 空批零副作用
+        // 返回（成员已单独写账+落标，无需再动）。
+        const live = members.filter((m) => !this.e9ConvertedIds.has(m.id));
+        if (live.length === 0) return;
+        // 成员全量快照：getFullRecord 冷路径重建（成员在 notifyComplete 前已 archive，
+        // 内存无；闭合判定 hasRunningSync 的 listRecords 扫描已建 idToFile 索引，此处
+        // 命中）。快照在屏障前一次取定，屏障写与落标共用同一份（manifest 与落标 entry
+        // 字段同源）。
+        // [S11] getFullRecord 不可达（子 session 文件缺失/已 GC 的窗口）的成员改用
+        // 缓冲快照兜底落标，不再跳过——该成员仍随 live 进批写账（成员集 hash 含它），
+        // 跳过落标的旧行为会在重启后让 E1 重新收集它（无标记候选），以异成员集 hash
+        // 重新补发 → 同成员双投递（异 hash 不触发账本 sync-batch 幂等；旧注释「该
+        // 窗口下 E1 本也收不到该成员」不成立：E1 走主 session 文件末条 entry 扫描，
+        // 与 getFullRecord 的 manifest/子文件通路相互独立，manifest 屏障 best-effort
+        // 写失败同样制造此窗口）。
+        const fulls: SubagentRecord[] = [];
+        const fullMissed: BgNotifyRecord[] = [];
+        for (const m of live) {
+          const full = this.store.getFullRecord(m.id);
+          if (full) fulls.push(full);
+          else fullMissed.push(m);
+        }
+        // [时序屏障] 成员 manifest 写先于写账并 await 全部落盘——「通知可达 ⇒ 索引
+        // 就位」的构造性保证（by construction）：批通知的指针行消费依赖
+        // records/<sa-id>.json 反查索引，fire-and-forget 下「通知送达时已落盘」只是
+        // 大概率成立（探针实测 mtime 相对 notify entry ±2/3ms 方向不定）。写失败仍
+        // best-effort（debug 不阻断写账投递，语义与 doFinalizeRecord Step 4 一致）。
+        await this.writeSyncBatchManifestBarrier(fulls);
+        // 单条批投递：accepted=false（同成员集批已在账——E1 重建重发/重复 flush）或
+        // 空批/dispose → 零副作用返回，不落标（设计 §3.1.3 出口①绑「写账成功」）。
+        const accepted = this.notifyHost.notifyBatch(live, this.getCollectSyncBudget());
+        if (!accepted) return;
+        // batchFinalized 纯落标（设计 §3.1.3 两出口之一：批闭合 flush 写账成功后）。
+        // collectMode/batchFinalized 显式覆写在 appendBatchFinalizedEntry 内（防非
+        // entry 源重建丢标记）；末条 entry 带标记 → E1 重建扫描（collectMode=sync 且
+        // 无标记才收）据此排除，防双重通知。源序「写账先于落标」不变（v1 幂等窗口
+        // 语义）；manifest 已在屏障提前写，幂等窗口内崩溃时索引更早已就位。
+        for (const full of fulls) {
+          this.appendBatchFinalizedEntry(full);
+        }
+        // [S11] miss 成员兜底落标（缓冲快照 → 最小标记 entry，映射见 sync-rebuild.ts），
+        // 与 fulls 同出口①语义（写账成功后统一补标）。
+        for (const m of fullMissed) {
+          this.appendBatchFinalizedEntry(bufferedMemberFallbackRecord(m, this.sessionRootId ?? undefined));
+        }
+      },
+    });
     // #11：注册进程级 observability 单例——ui-request-queue.handleUiRequest 经
     // globalThis 桥接（notifyMissingHandlerGlobal）调到同一实例，共享
     // warnedMissingHandlerSessions 去重集合。未注册时 queue 走 fallback warn（不去重）。
@@ -389,20 +534,6 @@ export class SubagentService {
 
   // ── 生命周期（index.ts 调）──────────────────────────────
 
-  /** 覆盖 UI 请求 handler（W3: index.ts session_start 时按 mode 注入 handler 后调）。
-   *  委托 uiObservability 重置缺失告警去重——新 handler 就位后允许重新 warn。 */
-  setUiRequestHandler(handler: UiRequestHandler | undefined): void {
-    this.uiRequestHandler = handler;
-    this.uiObservability.resetMissingHandlerWarnings();
-  }
-
-  /** session-runner handleUiRequest 在 handler 缺失时调用（FR-9 可观测性）。
-   *  委托 uiObservability：按 session 去重，同一 session 的多次 UI 请求只 warn 一次。
-   *  W2: console.warn 兜底。W3 接入 pi.appendEntry("subagent:ui-request-missing-handler", ...)。 */
-  notifyMissingHandler(sessionId: string): void {
-    this.uiObservability.notifyMissingHandler(sessionId);
-  }
-
   /** session_start 注入 pi + revive（modelRegistry/entries 归 ModelConfigService.initModel）。 */
   initSession(init: SubagentServiceSessionInit): void {
     this.pi = init.pi;
@@ -415,10 +546,12 @@ export class SubagentService {
     this.mainSessionFile = init.mainSessionFile;
     this.streamSink = init.streamSink ?? null;
     this.isIdleFn = init.isIdle;
-    // 读取 mode（W4 守卫透传给 session-runner）+ session 级 handler 覆盖。
+    // 读取 mode（W4 守卫透传给 session-runner）+ session 级 handler 覆盖
+    //（[D4-④] initSession.uiRequestHandler 是唯一注入入口；三态语义见接口注释——
+    //null = 显式清空，承载原 setUiRequestHandler(undefined) 语义）。
     this.uiObservability.setMode(init.mode);
     if (init.uiRequestHandler !== undefined) {
-      this.uiRequestHandler = init.uiRequestHandler;
+      this.uiRequestHandler = init.uiRequestHandler ?? undefined;
       this.uiObservability.resetMissingHandlerWarnings();
     }
     // SR-4：注入 L2 dialog 队列（child close 清理路径）。undefined 时 buildSessionRunnerContext
@@ -436,8 +569,15 @@ export class SubagentService {
     this.initExecContextBaseline(envRoot, init.sessionId);
     // revive（dispose 的逆操作：/resume /fork /new 后复活）
     this._disposed = false;
+    // [v2 D4] settled 重扫状态随 revive 重置：新 session 的 E1 若再判「仍有 running」
+    // 可重新注册。旧 handler 闭包捕获旧 state：正常时序（session_shutdown →
+    // session_start）下已随 dispose() 惰化；未经 dispose 的时序残留仍会在 settled
+    // 边沿执行——其扫描 this.mainSessionFile 当前值（非注册时的旧文件），行为等价于
+    // 新 session 多注册一次扫描，由账本 sync-batch:<hash> 幂等 + batchFinalized 候选
+    // 过滤收敛，无跨 session 污染面。
+    this.settledRescanState = null;
     this.store.revive();
-    this.notifier.revive();
+    this.notifyHost.revive();
     // 孤儿终态恢复（放 initSession 末尾：setPi 已注入（appendEntry 可用）、
     // sessionRootId 已建立（过滤当前根的 record）；单扫描者判据见 recoverOrphansIfRootProcess）
     this.recoverOrphansIfRootProcess();
@@ -462,7 +602,7 @@ export class SubagentService {
 
   /**
    * [递归可见性] exec 上下文基线：子进程读 env PI_SUBAGENT_SELF_RECORD_ID / DEPTH
-   * 建立身份基线后，createRecordForMode 读 execCtxAls 自动正确（孙挂到子名下）。
+   * 建立身份基线后，createRecordForMode 读嵌套上下文自动正确（孙挂到子名下）。
    * enterWith 贯穿整个 session 生命周期（与 forkDepthAls 同构，决策 4）。
    */
   private initExecContextBaseline(envRoot: string | undefined, sessionId: string): void {
@@ -470,13 +610,14 @@ export class SubagentService {
     if (envSelfRecord !== undefined && envSelfRecord !== "") {
       const envNestingDepth = Number.parseInt(process.env[ENV_DEPTH] ?? "0", 10);
       const nestingDepth = Number.isNaN(envNestingDepth) ? 0 : envNestingDepth;
-      // [ALS 断裂修复] 基线兜底：enterWith 在 pi 事件回调模型下不可靠（见 execCtxBaseline 注释），
-      // 基线是 createRecordForMode / 护栏读 ALS store 失败时的权威回退。
-      this.execCtxBaseline = { recordId: envSelfRecord, depth: nestingDepth };
-      this.execCtxAls.enterWith({ recordId: envSelfRecord, depth: nestingDepth });
+      // [ALS 断裂修复] 基线兜底：enterWith 在 pi 事件回调模型下不可靠（机制注释见
+      // common/nesting-guard.ts ExecutionNestingContext），基线是 createRecordForMode /
+      // 护栏读 ALS store 失败时的权威回退。
+      this.execNesting.setBaseline({ recordId: envSelfRecord, depth: nestingDepth });
+      this.execNesting.enterWith({ recordId: envSelfRecord, depth: nestingDepth });
       if (process.env.XYZ_AGENT_DEBUG) {
         logger.debug(
-          `[subagents] execCtxAls initialized: recordId=${envSelfRecord} depth=${nestingDepth} rootSessionId=${envRoot ?? sessionId}`,
+          `[subagents] execNesting initialized: recordId=${envSelfRecord} depth=${nestingDepth} rootSessionId=${envRoot ?? sessionId}`,
         );
       }
     }
@@ -493,7 +634,7 @@ export class SubagentService {
    *（hours-long wave 必然命中）→ 活记录被无关进程盖 .finalized sidecar，closed entry
    * 写进别的进程的 session 文件（跨进程互写，无任何锁）。子进程身份判据 = env
    * PI_SUBAGENT_SELF_RECORD_ID（父 spawn 时注入的「子进程自己的 record id」，仅子进程
-   * 非空）——与 execCtxBaseline 同源。根进程恢复语义不变。
+   * 非空）——与 execNesting 基线同源。根进程恢复语义不变。
    */
   private recoverOrphansIfRootProcess(): void {
     const isChildProcess = (process.env[ENV_SELF_RECORD_ID] ?? "") !== "";
@@ -504,23 +645,26 @@ export class SubagentService {
     }
   }
 
-  /** 孤儿终态恢复委托（RecordStore.recoverOrphanRecords 的唯一公开入口，维持 store
-   *  private 封装——与 recoverManifestTmpFiles 同模式）。判定语义见 store 侧注释。
+  /** 孤儿终态恢复委托（RecordStore.recoverOrphanRecords 的唯一调用入口，维持 store
+   *  private 封装——与 recoverManifestTmpFiles 同模式；[D4] public 面收窄：唯一调用方
+   *  是 initSession，转 private）。判定语义见 store 侧注释。
+   *  mainSessionFile 随调用透传（v2 D3 覆写 merge 数据源：主文件末条 entry 的批域
+   *  标记与轮终 result/model；initSession 先赋值后恢复，时序就绪）。
    *  随后跑 entry-born 孤儿恢复（无子文件锚的 register-only record，spawn 窗口期死亡，
    *  E2E 实测缺口）——主 session 文件经 getMainSessionFile 注入（构造期可空）。 */
-  recoverOrphanRecords(): void {
+  private recoverOrphanRecords(): void {
     try {
-      this.store.recoverOrphanRecords(this.sessionRootId ?? undefined);
+      this.store.recoverOrphanRecords(this.sessionRootId ?? undefined, this.mainSessionFile);
     } catch (err) {
       logger.warn("[subagents] orphan recovery failed", {
-        reason: err instanceof Error ? err.message : String(err),
+        reason: toErrorMessage(err),
       });
     }
     try {
       this.store.recoverEntryOnlyOrphans(this.mainSessionFile, this.sessionRootId ?? undefined);
     } catch (err) {
       logger.warn("[subagents] entry-only orphan recovery failed", {
-        reason: err instanceof Error ? err.message : String(err),
+        reason: toErrorMessage(err),
       });
     }
   }
@@ -594,7 +738,7 @@ export class SubagentService {
         });
       }
       // pending-notifications 注销
-      emitPendingUnregister(this.pi, record.id, "closed");
+      this.notifyHost.emitPendingUnregister(record.id, "closed");
       count++;
     }
     return count;
@@ -634,35 +778,309 @@ export class SubagentService {
    * listener 仍然存活。若 pending-notifications 先于本扩展执行 session_shutdown（后注册
    * 先执行的语义下会如此），listener 已注销，unregister 事件被静默丢弃。这是可接受的
    * 退化——进程退出后两侧状态本就不保证一致，下次 session_start 的 crash recovery 会修正。 */
+  /** [U4 deviation #8 接线] collectSync 预算热读（flush 时读值，与 getCollectSyncDefault
+   *  同款访问链 modelService.getGlobalConfig().collectSync）。节缺失/读失败 → undefined
+   *  → notifyBatch 落 buildBatchLlmContent 设计默认值（4000/24000，E5 不炸启动）。
+   *  sanitizeCollectSync 保证节存在时两字段必有合法正整数。 */
+  private getCollectSyncBudget(): BatchBudgetParams | undefined {
+    const cs = this.collectSyncSection();
+    return cs !== undefined ? { perItemChars: cs.perItemChars, totalChars: cs.totalChars } : undefined;
+  }
+
+  /** [E9 专用] batchFinalized 落标 + manifest fire-and-forget 写（设计 §3.1.5 E9）。
+   *  批通知路径（flush/E1）已改走「manifest 屏障 → 写账 → 纯落标」序列（「通知可达
+   *  ⇒ 索引就位」的构造性保证，见 flushBatch 闭包 / runSyncCollectRecoveryScan），
+   *  不再经本 helper；仅 E9 转换的成员保持原形态——其走 async 单条通知（全文注入、
+   *  无指针行消费），manifest 无时序要求，落标后 fire-and-forget 补写（list 后手动
+   *  反查的顺带索引）。
+   *  路径 = getFullRecord 冷路径重建 → appendBatchFinalizedEntry 纯落标 → fire
+   *  manifest。getFullRecord 不可达（子 session 文件缺失/已 GC）→ 跳过该成员
+   *  （详见 flushBatch 闭包注释）。 */
+  private markMembersBatchFinalized(memberIds: readonly string[]): void {
+    for (const id of memberIds) {
+      const full = this.store.getFullRecord(id);
+      if (!full) continue;
+      this.appendBatchFinalizedEntry(full);
+      // 反查索引缺失只影响指针行反查（session-reader 错误文案已指引绝对路径兜底），
+      // 不构成落标失败（与屏障路径的 best-effort 语义同源，仅无时序保证）。
+      void this.writeBatchMemberManifest(full).catch((err: unknown) => {
+        logger.debug(
+          `[subagents] batch-finalized manifest write failed (record=${full.id})`,
+          { reason: err instanceof Error ? err.message : String(err) },
+        );
+      });
+    }
+  }
+
+  /** batchFinalized 落标唯一出口（appendEntry 公共末步，纯落标）：显式覆写
+   *  collectMode/batchFinalized → reportSubagentRecord。覆写动机：recordToSubagent
+   *  投影已含两字段（U5 修复），但 getFullRecord 冷路径含 sidecar/manifest 重建分支
+   *  （非 entry 源），显式赋值防非 entry 源重建时丢标记。
+   *
+   *  [v2 D1 断链 1] 落标即「离开批 = 通知已/即将送达 = 指针行即将被消费」——成功
+   *  成员走 SP-5 改道 doFinalizeRoundToIdle（不写 manifest），批路径不补写则
+   *  records/<sa-id>.json 永不产生、session-reader 反查 0 命中。manifest 写点已从
+   *  本出口的 fire-and-forget 前移至各调用方：批通知路径（flush/E1）在写账前屏障
+   *  await 全部落盘（「通知可达 ⇒ 索引就位」的构造性保证）；E9 保持落标后
+   *  fire-and-forget（async 单条通知无指针行消费，无时序要求）。
+   *  rec 两来源（flush 的 getFullRecord 内存全量 / E1 的 rebuildEntryRecord 重建
+   *  快照）必需字段恒齐备（id/agentName←agent/rootSessionId/createdAt←startedAt），
+   *  task/slug/parentRecordId 等可选 undefined 自然缺省。 */
+  private appendBatchFinalizedEntry(rec: SubagentRecord): void {
+    this.store.reportSubagentRecord({ ...rec, collectMode: "sync", batchFinalized: true });
+  }
+
+  /** 批成员 manifest（sa- id → sessionFile 反查索引）写的唯一投影点（D2 字段投影 +
+   *  status 如实投影：成功成员此刻 record 实态 running+resumable → "running"，后续
+   *  message upgrade 走完整 finalize 时 Step 4 原子覆盖为 "closed"）。
+   *  返回原始 promise 不吞错——失败语义由调用方定：批通知路径经
+   *  writeSyncBatchManifestBarrier 的 allSettled（debug 不阻断写账）；E9 经
+   *  fire-and-forget catch（debug 不阻断落标）。 */
+  private writeBatchMemberManifest(rec: SubagentRecord): Promise<void> {
+    return this.manifestStore.writeManifest({
+      id: rec.id,
+      rootSessionId: rec.rootSessionId ?? "",
+      parentRecordId: rec.parentRecordId,
+      agentName: rec.agent,
+      status: rec.status,
+      createdAt: rec.startedAt,
+      completedAt: rec.endedAt,
+      sessionFile: rec.sessionFile,
+      task: rec.task,
+      slug: rec.slug,
+      model: rec.model,
+    });
+  }
+
+  /** [时序屏障] 批通知路径（flush/E1）专用：成员 manifest 并行写 + await 全部完成
+   *  （allSettled）后才允许写账投递——「通知可达 ⇒ 索引就位」的构造性保证。写失败
+   *  不阻断（best-effort 语义与 doFinalizeRecord Step 4 一致：反查索引缺失只影响指针行
+   *  反查，session-reader 错误文案已指引绝对路径兜底，不构成写账失败）；warn 留痕
+   *  （D6 #7a / SC-1：屏障失败意味着该成员指针行反查索引缺失，debug 级在排障时不可见）。 */
+  private async writeSyncBatchManifestBarrier(recs: readonly SubagentRecord[]): Promise<void> {
+    const results = await Promise.allSettled(recs.map((rec) => this.writeBatchMemberManifest(rec)));
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i]!;
+      if (result.status === "rejected") {
+        logger.warn(
+          `[subagents] batch-finalized manifest write failed (record=${recs[i]!.id}, manifest=${this.recordsDir}/${recs[i]!.id}.json)`,
+          { reason: result.reason instanceof Error ? result.reason.message : String(result.reason) },
+        );
+      }
+    }
+  }
+
+  /** [E9] dispose 时批未闭合：缓冲中已终态未通知成员逐条转 async 语义写账（放弃攒批）
+   *  + 落 batchFinalized 标记（E1 重建扫描据此排除，防双重通知），交由既有 shutdown
+   *  flush / resume 重放兑底；仍在跑的成员走现有退出路径（disposeAllRecords 关闭，
+   *  与 async 一致）。写账用 notifier.notify 现有通路（ledger.record + attemptDeliver）。
+   *  源序：写账先于落标——写账后崩溃 → E1 重建收该成员，但 async notifyId 与批 hash
+   *  跨键不拦的重发属设计披露的 E9 残余窗（at-least-once 良性，PS-17 同族，v1 接受）。 */
+  private convertPendingSyncBufferToAsync(): void {
+    // [U8 拆批修复·E9 交互] 挂起的合批排程先取消——dispose 已选「放弃攒批转 async」
+    // 语义（最简语义 = 取消而非同步 flush）：放任排程触发会让 flushBatch（批 hash
+    // 通道）与下方逐条 notify（async id 通道）双通道并发写账 → 同成员双投递，且触发
+    // 点可能落在 notifier/store dispose 之后。取消后缓冲原样保留，本函数既有单通路
+    // 完整接管（协调器侧幂等：无排程时 no-op）。
+    this.collectCoordinator.cancelScheduledFlush();
+    const members = this.collectCoordinator.pendingMembers();
+    if (members.length === 0) return;
+    for (const member of members) {
+      this.e9ConvertedIds.add(member.id);
+      this.notifyHost.notify(member);
+    }
+    this.markMembersBatchFinalized(members.map((m) => m.id));
+    logger.warn(
+      `[subagents] E9 dispose: converted ${members.length} buffered sync member(s) to async notify`,
+      { ids: members.map((m) => m.id) },
+    );
+  }
+
+  /**
+   * [E1] sync 批崩溃恢复钩子（设计 §3.1.5 E1，index.ts session_start 恢复编排处调用，
+   * 须晚于 initSession——孤儿终态恢复先行收敛 running 成员，「全员终态」判定才可达）：
+   *
+   *  - 扫描主 session 文件每 id 末条 subagent-record entry（store.scanLastRecordEntries，
+   *    collectLastRecordEntries 同构 + 投影扩展含 collectMode/batchFinalized + 终态五
+   *    字段；禁走 collectRecords light 路径——主 session 落标 entry 对它不可见）；
+   *  - 只收 collectMode=sync 且无 batchFinalized 的成员（排除已通过批 flush 或 E9
+   *    转换离场的，防双重通知），按 rootSessionId 过滤当前根；
+   *  - 全员终态且账本无同成员集批记录 → manifest 屏障（await 落盘，「通知可达 ⇒
+   *    索引就位」构造性保证，与 flushBatch 同款）→ notifyBatch 补发（内容 = 末条
+   *    entry 终态快照；账本 record 同 hash 幂等拒绝 = 已投递/已在账，两种结局都算
+   *    「已处理」）；
+   *  - 仍有 running → 本次不动，注册 settled 有界重扫（D4，见 armSettledRescan）——
+   *    成员延迟终态（主 agent 冷路径 resume → 正常流落 entry）由 settled 边沿驱动
+   *    重扫收敛，不再依赖「下次 session_start」作唯一再驱动（v2 §2.4 断链 4）；
+   *    running 口径与协调器同构
+   *    （resumable 豁免，v2 D3——覆写不可达的防御分支残余不被误判「仍在跑」）；
+   *  - 补发尝试后统一补 batchFinalized 标记（账本拒绝也算已投递；直接用末条重建快照
+   *    落标不经 getFullRecord——子文件缺失/已 GC 时标记仍可落盘，窗口自愈不依赖二次
+   *    重启；补标自身崩溃重入幂等收敛，末条 entry last-writer-wins）。
+   *
+   *  async 化（时序屏障修复）：返回 Promise 但**内部自捕获不外抛**——宿主 index.ts
+   *  session_start 以同步 try/catch 调用（其 catch 兑现不到 promise 内的异常），
+   *  自捕获维持同款 warn 容错语义，浮动调用零适配、不产生 unhandled rejection。
+   *
+   *  [U8 拆批修复] 与协调器合批排程无交集：E1 只在 session_start 编排处运行（此前
+   *  dispose 已取消挂起排程），补发直走 notifier.notifyBatch 不经协调器；异常时序
+   *  相撞由账本 sync-batch:<hash> 幂等拒绝兜底。
+   */
+  async recoverSyncCollectBatch(): Promise<void> {
+    try {
+      const { outcome } = await this.runSyncCollectRecoveryScan();
+      // [v2 D4] 断链 4：等待分支不再死等——挂 settled 有界重扫（幂等单注册）。
+      if (outcome === "waiting") {
+        this.armSettledRescan();
+      }
+    } catch (err) {
+      // 与 index.ts 调用点原 try/catch 的 warn 容错同语义（该处 catch 对 async 化后
+      // 的 promise 异常兑现不到，容错收敛到本方法内部）。
+      logger.warn("[subagents] sync collect batch recovery failed", {
+        reason: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+
+  /** [E1/D4] 单次「扫描→判定→可达则补发+落标」，E1 首扫与 settled 重扫共用同一实现
+   *  （防两处复制粘贴分岔）。三态返回：idle（无 sync 候选——已全部落标/E9 转换/异根，
+   *  无事可等）/ waiting（仍有 running 成员，本次不动）/ dispatched（全员终态，已补发
+   *  +统一落标）。async：补发前有 manifest 屏障 await（见函数头 E1 注释）。 */
+  /** 返回 outcome + waitingIds（达限 warn 需滞留成员 id，D6 #7b——仅 waiting 态非空）。 */
+  private async runSyncCollectRecoveryScan(): Promise<{
+    outcome: "idle" | "waiting" | "dispatched";
+    waitingIds: string[];
+  }> {
+    const lastRecords = this.store.scanLastRecordEntries(this.mainSessionFile);
+    if (lastRecords.length === 0) return { outcome: "idle", waitingIds: [] };
+    const rootFilter = this.sessionRootId;
+    const candidates = lastRecords.filter(
+      (r) =>
+        r.collectMode === "sync" &&
+        r.batchFinalized !== true &&
+        (rootFilter === undefined || r.rootSessionId === rootFilter),
+    );
+    if (candidates.length === 0) return { outcome: "idle", waitingIds: [] };
+    // [v2 D3] 与协调器 hasRunningSync 同构口径（collect-coordinator.ts）：running+
+    // resumable 视为已完成、不阻止补发——成功成员崩溃时的末条 entry 恒为轮终
+    // running+resumable（SP-5 有意语义），旧口径只看 status !== "closed" 会把主场景
+    // （批内含成功成员）顶死在「等自然终态」永不补发（v2 §2.3 断链 3）。
+    const running = candidates.filter((r) => r.resumable !== true && r.status !== "closed");
+    if (running.length > 0) {
+      logger.debug(
+        `[subagents] E1 sync batch recovery: ${running.length} member(s) still running, wait for natural completion`,
+        { ids: running.map((r) => r.id) },
+      );
+      return { outcome: "waiting", waitingIds: running.map((r) => r.id) };
+    }
+    // [时序屏障] manifest 先于写账 await 全部落盘——E1 补发同样是批通知（指针行消费
+    // 依赖反查索引），「通知可达 ⇒ 索引就位」的构造性保证与 flushBatch 同款。
+    await this.writeSyncBatchManifestBarrier(candidates);
+    // 全员终态：单条批补发（budget 热读与 flushBatch 同源）；账本同 hash 幂等拒绝也算
+    // 已投递（批已在账/已销账，重放由账本承接）——两种结局统一补标。
+    const members = candidates.map((r) => syncRebuildToNotifyMember(r));
+    const accepted = this.notifyHost.notifyBatch(members, this.getCollectSyncBudget());
+    for (const rec of candidates) {
+      this.appendBatchFinalizedEntry(rec);
+    }
+    logger.warn(
+      `[subagents] E1 sync batch recovery: re-notified ${members.length} member(s) (ledger accepted=${accepted})`,
+      { ids: members.map((m) => m.id) },
+    );
+    return { outcome: "dispatched", waitingIds: [] };
+  }
+
+  /** [v2 D4] 注册 agent_settled 有界重扫（幂等：settledRescanState 非 null 不叠加注册
+   *  ——E1 现仅 session_start 单调用点，守卫是防第二入口引入时的注册叠加断言面）。
+   *  每次 settled 边沿重跑同一 E1 扫描（runSyncCollectRecoveryScan）：dispatched
+   *  （补发+落标完成，scan 的 warn 已留痕）或 idle（候选已被其他通路落标）→ disposed；
+   *  累计 SETTLED_RESCAN_LIMIT 次仍在等 → disposed + warn 留痕（D6 #7b / SC-2：达限
+   *  放弃重扫意味着滞留成员的批通知要等下次 session_start 才收敛，含滞留 id 的 warn
+   *  是唯一线索，debug 级排障不可见；后续事件零处理，下次 session_start 再收敛）。
+   *  pi.on 无 off（0.84.4 实装）——disposed 标志包装兑现退订（scheduler extension
+   *  index.ts subscribeSettled 同款先例）。P-settled 定谳（0.84.4 dist 实装证据）：
+   *  pi.on 为 per-extension 列表分发——loader.js `on()` 把 handler push 进
+   *  extension.handlers.get(event) 数组（非覆盖），runner.js `emit()` 对全部
+   *  extension 的全部 handler 逐一 await；故本注册与 ledger host 经
+   *  piAdapter.onAgentSettled 注册的 settled 分发互不干扰，无需降级并入 host 链。 */
+  private armSettledRescan(): void {
+    if (this.settledRescanState !== null) return;
+    const state = { disposed: false, scans: 0 };
+    this.settledRescanState = state;
+    this.pi?.on?.("agent_settled", async () => {
+      if (state.disposed) return;
+      state.scans += 1;
+      // await 完整补发序列（manifest 屏障 → 写账 → 落标）：pi emit 对 handler 逐一
+      // await（P-settled 定谳，0.84.4 dist runner.js），async 化不改变分发语义。
+      const { outcome, waitingIds } = await this.runSyncCollectRecoveryScan();
+      if (outcome === "waiting" && state.scans < SETTLED_RESCAN_LIMIT) return;
+      state.disposed = true;
+      if (outcome === "waiting") {
+        // D6 #7b / SC-2：warn + 滞留成员 id（debug 级排障不可见——达限即批通知挂起至下次 session_start）
+        logger.warn(
+          `[subagents] E1 settled rescan: reached limit (${SETTLED_RESCAN_LIMIT}) with member(s) still running, disposed until next session_start`,
+          { ids: waitingIds },
+        );
+      }
+    });
+  }
+
+  // [E1 语义对齐 toNotifyRecord] 补发成员映射 syncRebuildToNotifyMember 拆至
+  // sync-rebuild.ts（变化轴：恢复批通知语义）：one-shot 成功成员末条恒
+  // running+resumable（SP-5），直通 status 会让恢复批批头「0 finished」且丢
+  // patchFile 的 git-apply 指针——对齐后补发记录为 closed + outcome 物化 +
+  // patchFile 透传。调用点：runSyncCollectRecoveryScan。
+
   dispose(): void {
     if (this._disposed) return;
     this._disposed = true;
     this.stopGcTimer();
+    // [v2 D4] settled 重扫 handler 惰化：dispose 后 trailing settled 边沿若仍触发，
+    // 旧 handler 不得再跑扫描——notifier 随后将 dispose，notifyBatch 短路返回 false
+    // 且不写账，而 E1 dispatched 段不判 accepted 仍统一落标 → 批被标 batchFinalized
+    // 而通知从未写账（永久丢失，不可逆）。惰化后通知由下次重启的 E1 首扫兑现
+    // （成员无标记，候选可达）。与 initSession revive 重置不冲突：dispose 是终态置
+    // disposed，revive 置 null 是新 session 的重新注册，旧 state 对象随旧 handler
+    // 闭包保持 disposed 永久惰化。
+    if (this.settledRescanState !== null) this.settledRescanState.disposed = true;
     // [dispose stub] 第一时间换 stub，防 trailing ui_request 调到 stale handler 闭包
     // （仍持有 disposed session 的 ctx）产生误导性 console.error。stub 干净降级为 cancelled。
     // 必须在 emit/abort 之前——这些步骤可能同步触发 trailing pump。
-    this.setUiRequestHandler(disposedUiRequestStub);
+    // [D4-④] 原 setUiRequestHandler 方法已删（initSession 参数为唯一注入入口），
+    // 此处内联其方法体（赋值 + 缺失告警去重重置）。
+    this.uiRequestHandler = disposedUiRequestStub;
+    this.uiObservability.resetMissingHandlerWarnings();
     // [R0/C1 孤儿进程修复] 先 abort running controllers + kill spawned children，再 dispose 资源。
     // abortRunningControllers 需要在 disposeAllRecords archive 之前执行（archive 后 store 找不到 record）。
     this.store.abortRunningControllers();
     killAllSpawnedChildren();
+    // [E9] 批未闭合时缓冲终态成员逐条转 async 写账 + 落 batchFinalized（设计 §3.1.5 E9）。
+    // 必须在 disposeAllRecords 之前——它会把活跃 record（含 SP-5 成功回退的
+    // running+resumable 缓冲成员）全部 archive 清内存，之后再 getFullRecord 落标只剩
+    // 冷 idToFile（无目录扫描则 miss → 跳过落标 → E1 重建误收已转换成员）；先转换取
+    // 内存命中，与 flushBatch 出口①同款通路。同样在 flushPendingNotifications 之前
+    //（转换条目加入本次 flush）与 notifier/store dispose 之前（写账与 appendEntry
+    // 通道仍可用）。仍在跑成员不在此处理——后续 disposeAllRecords 按现有退出路径关闭。
+    this.convertPendingSyncBufferToAsync();
     // SP-4: 级联关闭所有活跃 record（parent-shutdown reason）
     // 在 abort/kill 之后执行：先终止子进程，再清理 record 状态。
     this.disposeAllRecords("parent-shutdown");
     // [v4 A-1] EPIPE 连续失败计数器清零（计数器已迁移到 stdin-writer，防跨 session 泄漏）
     resetAllEpipeFailures();
-    // [review MF1] 在途 resume 守卫清空（正常由 runAndFinalize finally 清除；此处兜底
+    // [review MF1] 在途 resume 守卫清空（正常由轮次收尾 finally 清除；此处兜底
     // abort/kill 后仍挂着的条目，防跨 session 复活时残留）
     this.resumesInFlight.clear();
+    // chat 轮次交接包清空（正常由 PiEngine.run 消费；此处兜底 kill 后仍挂着的条目）
+    this.chatRoundTickets.clear();
     // flush 待发通知（session_shutdown 尽力投递一次）。
-    this.notifier.flushPendingNotifications();
+    this.notifyHost.flushPendingNotifications();
     // [T4④ / PS-5] flush 被 isIdle 门拦时的丢失面闭合：attemptDeliver 的 isIdle 二次
     // 复查失败时 pending 挂在 ledger 内存态，随后 dispose 销毁——旧注释「flush 后 dispose
-    // （防丢失）」的承诺与行为不符。现把未投递 pending 经 ledger entry 通道复写落盘
+    //（防丢失）」的承诺与行为不符。现把未投递 pending 经 ledger entry 通道复写落盘
     // （notifyId 幂等，重复 entry 由恢复扫描后写覆盖吸收），重启 recoverFromSession 按
     // 账面差集重放补投——「不丢」由落盘账本承接而非本次 flush。
     this.persistUndeliveredNotificationsForReplay();
-    this.notifier.dispose();
+    this.notifyHost.dispose();
     this.store.dispose();
   }
 
@@ -701,108 +1119,9 @@ export class SubagentService {
 
   // ── 执行（subagent-tool 调）────────────────────────────
 
-  /** background 完成回注（record → BgNotifyRecord 映射 + notifier.notify）。
-   *  正在执行（running + 活进程 + 非 timer-armed）静默跳过——notify 只对 closed（终态）、
-   *  isIdle（chatMode 轮次完成）或 isResumable（SP-5 one-shot 成功完成 / MF-6 失败轮回退）有意义。
-   *  SP-1: closed 统一终态（done/failed/crashed 合并），closedReason 携带 L2 原因。 */
-  private notifyComplete(record: ExecutionRecord): void {
-    const notify = this.toNotifyRecord(record);
-    if (notify) this.notifier.notify(notify);
-  }
-
-  /** [C-1] chatMode close 终态通知（设计 D2：正文空/本轮增量 + sessionFile 指针行）。
-   *
-   *  与 notifyComplete 的差异只在 dedup 身份与轮次统计：终态通知必须与最后一轮的轮次通知
-   *  区分（轮次通知 key=`id:round`），否则同 key 被 60s dedup 吞——close 后父 agent 永远
-   *  收不到带指针行的终态通知（审查 C-1）。故 round 置 undefined（key 回退为裸 id），
-   *  轮数改经 totalRounds 进文案 "completed after N rounds."（C-2）。
-   *
-   *  仅 chatMode close 语义调用（closeChatIdle / closeAfterRoundSettled 终态化成功后）。
-   *  one-shot 显式拒绝（G4：one-shot close 路径现状无终态通知，字节不变）；cancel 走
-   *  cancelBackground 自己的 notifyComplete，不经本方法。幂等性：两条 close 路径均由
-   *  closeSubagent 的 status 分流守卫（closed 后幂等 no-op）/ CAS 抢锁保证只执行一次，
-   *  本方法自身不重复发送；迟到的 kickOffBackground.then 通知与轮次通知同 key=`id:round`，
-   *  60s 窗内仍被吞，不构成第三条。 */
-  /** @param emptyBody true = 终态通知正文置空串（D2 路径②）。W16 P-1 修复后
-   *  closeChatIdle 的 doneResult.text 改用 record.result 保真（close 终态
-   *  subagent-record entry 的 result 不抹空轮终真实值），「正文空」不再由合成空
-   *  text 的副作用承载，改为显式参数——持久化 result 与通知正文两个关注点解耦。 */
-  private notifyClosed(record: ExecutionRecord, emptyBody = false): void {
-    if (!record.chatMode) return;
-    const notify = this.toNotifyRecord(record);
-    if (!notify) return;
-    notify.round = undefined;
-    if (emptyBody) notify.result = "";
-    if (record.round != null) notify.totalRounds = record.round;
-    this.notifier.notify(notify);
-  }
-
-  /** notifier 的 NotifierHost 适配器（绑定到 pi.sendMessage + store 查询）。 */
-  private piAdapter(): NotifierHost {
-    return {
-      sendMessage: (message, options) => {
-        this.pi?.sendMessage(message, options);
-      },
-      hasRunningBackground: () => {
-        // [M3] 「在跑的 background 工作」= 有活进程且非等待续聊（idle timer armed）。
-        // v4 B-1 把旧 idle 折入 running 且 record 留 store：轮次完成的 chatMode record
-        // （timer armed、无在跑轮）与 one-shot 完成后等待 message 升级的 record 都不再计入。
-        // 旧判定 `mode === "background"` 对这两类恒 true → 轮次完成通知恒挂 60s 合并窗口
-        // （notifier MERGE_WINDOW_MS），主 agent 的续聊回复固定延迟 60s 送达，持续对话（G1）失效。
-        return this.store.listRunning().some(
-          (r) => r.mode === "background" && hasLiveProcessHandle(r.id) && !hasIdleTimer(r.id),
-        );
-      },
-      isIdle: () => this.isIdleFn?.() ?? true,
-      // [must-fix #4 / D8] settled 边沿订阅，与 isIdle 同源（session_start 注入的 pi）。
-      // 只注入原生订阅能力；disposed 标志包装（退订语义）在 notifier 的 port 装配完成。
-      onAgentSettled: (handler) => { this.pi?.on?.("agent_settled", handler); },
-    };
-  }
-
-  /** record → BgNotifyRecord（notifier.notify 入参映射，内部不外露）。
-   *  v4 B-1：守卫放行 closed（终态，含 cancelled）、isIdle（对话模式轮次完成，notify 主 agent G1）
-   *  或 isResumable（running + 无活进程——SP-5 one-shot 成功完成 / MF-6 失败轮回退）。
-   *  正在执行（running + 活进程 + 非 timer-armed）返回 undefined（调用方 notifyComplete 跳过）。
-   *  SP-1: closed 统一终态，closedReason 由 BgNotifyRecord 携带。 */
-  private toNotifyRecord(record: ExecutionRecord): BgNotifyRecord | undefined {
-    const snap = snapshot(record);
-    const s = snap.status;
-    // [N1] isResumable 放行：SP-5 one-shot 成功完成后 finalizeRoundToIdle 把 record 回退
-    // running-resumable——进程已死且永不 arm idle timer（armIdleTimer 只在 agent_settled 的
-    // chatMode 分支调用），旧守卫（closed / isIdle only）对其恒拒绝 → 完成通知静默丢失，
-    // 而 one-shot 失败走 finalizeRecord 保持 closed 反而通知——与 tool 契约「runs once,
-    // notifies on completion」完全倒置。isResumable = running + 无活进程，恰为该完成态；
-    // 在跑轮的 record 有活进程，不会被误放行。
-    if (s !== "closed" && !isIdle(record) && !isResumable(record)) return undefined;
-    // closed → BgNotifyRecord.closed（cancelled 区分靠 closedReason）；chatMode 的 isIdle/
-    // isResumable（轮次完成或 MF-6 失败轮回退，对话可续）→ running（轮次完成）。
-    // isResumable 且非 chatMode（SP-5 one-shot 成功完成）→ closed：对主 agent 的语义是
-    // completed（非对话轮次），且只有 closed 分支文案携带 worktree patchFile 的 git apply
-    // 提示——one-shot worktree 模式的改动回收依赖该提示（running 分支文案不含 patchFile）。
-    const notifyStatus: BgNotifyRecord["status"] =
-      s === "closed" || !record.chatMode ? "closed" : "running";
-    return {
-      id: snap.id,
-      status: notifyStatus,
-      agent: snap.agent,
-      model: snap.model,
-      result: snap.result,
-      error: snap.error,
-      startedAt: snap.startedAt,
-      endedAt: snap.endedAt,
-      patchFile: record.patchFile,
-      // round 透传给 notifier 的 dedup key（对话模式按轮次去重，G1 决策 9）。
-      round: record.round,
-      // SP-1: closedReason 透传给 notifier（L2 原因，供通知文案按需展示）。
-      closedReason: record.closedReason,
-      // [wave2] chatMode 条件透传 sessionFile：通知末尾追加 Full transcript 指针行
-      //（增量语义的全文恢复通道，见 notifier.buildLlmContent）。one-shot（chatMode
-      // falsy）不透传——通知输出逐字节不变（G4），该条件由 message-close 测试的
-      // 必选用例锁死（漏加条件时 notifier 单测不红——notifier 层只见最终字段）。
-      sessionFile: record.chatMode ? record.sessionFile : undefined,
-    };
-  }
+  // [D4-①] 通知簇四方法（notifyComplete / notifyClosed / piAdapter / toNotifyRecord）
+  // 与 emitPendingRegister / emitPendingUnregister 模块函数已整体搬移至 notify-host.ts
+  //（本类经 this.notifyHost 消费；行为逐字节等价，搬移 + 依赖注入）。
 
   /**
    * 预解析 model（renderCall 标题行用，同步）。代理 modelService.resolveModel。
@@ -828,13 +1147,14 @@ export class SubagentService {
     // [T4② / PS-4] idleTimeoutMs 配置错误在首个副作用前同步 fail-fast（错误含合法范围）。
     this.assertIdleTimeoutMsSafe(opts);
 
-    // 通用嵌套深度护栏（D-033）：execCtxAls 记录所有 subagent 嵌套层级（fork + 非 fork），
-    // 每层 +1。MAX_FORK_DEPTH 同时限 fork 链与通用嵌套——非 fork 递归虽不累积 session 体积，
-    // 但耗资源且 LLM 易陷入「委派→再委派」死循环。在所有副作用之前拦截，错误直达调用方。
+    // 通用嵌套深度护栏（D-033）：嵌套上下文（[D3-⑤] 公共层 ExecutionNestingContext）
+    // 记录所有 subagent 嵌套层级（fork + 非 fork），每层 +1。MAX_FORK_DEPTH 同时限
+    // fork 链与通用嵌套——非 fork 递归虽不累积 session 体积，但耗资源且 LLM 易陷入
+    // 「委派→再委派」死循环。在所有副作用之前拦截，错误直达调用方。
     // 计数基准：顶层 nestingDepth=0，nestingDepth>MAX 被拒。与 fork 体积护栏（parentForkDepth 检查）
     // 互补：本护栏更严（计所有嵌套），混合链下先生效；两者共享 MAX_FORK_DEPTH 上限不漂移。
-    // [ALS 断裂修复] getStore() 在 pi 事件回调模型下可能读空（enterWith 不贯穿），基线兜底。
-    const parentNesting = this.execCtxAls.getStore() ?? this.execCtxBaseline;
+    // [ALS 断裂修复] current() 内含基线兜底（pi 事件回调模型下 enterWith 不贯穿）。
+    const parentNesting = this.execNesting.current();
     const nestingDepth = parentNesting ? parentNesting.depth + 1 : 0;
     if (nestingDepth > MAX_FORK_DEPTH) {
       throw new ForkDepthExceededError(
@@ -844,92 +1164,41 @@ export class SubagentService {
 
     // mode 固定 background（sync 模式已删除）
     const mode: ExecutionMode = "background";
-    const ctx = this.buildSessionRunnerContext(opts.cwd);
 
-    // ── 1. IDENTITY 解析（确认 → agentConfig → resolveModel）──
-    const identity = await this.resolveIdentity(opts);
+    // ── 1. IDENTITY 前置解析：agentConfig（agent .md 加载）保持在最前 ──
+    // [u-h2 D2-1] 路由先行：model 解析从「路由之前」移到「路由之后、按目标引擎分支」
+    // （修 F2-A/B 时序根因——曾 :850 先解析 model 再 :867 路由）。agentConfig 是路由
+    // 第二层输入（frontmatter engine）必须先解析；显式 agent ref 校验语义不变。
+    const agent = opts.agent ?? DEFAULT_AGENT_NAME;
+    const agentConfig = opts.agent
+      ? this.modelService.getRequiredAgentConfig(opts.agent)
+      : undefined;
 
-    // ── 1.5 引擎路由（D4 chat 入口分叉；U2 升级为 routeEngine 编排）──
-    // 三层解析（调用参数 > agent frontmatter > config.json defaultEngine）仍是同步纯
-    // 函数；解析为非 pi 时升级走 routeEngine（probe 编排 + fallback 三守卫）。时机
-    // 选择：路由（含 probe）在 record 创建前完成——兜底时 record 直接按 pi 语义创建 +
-    // engineFallback 留痕（D5 字节级守护只约束「无 fallback 的纯缺省路径」，兜底路径
-    // 的 entry 允许含 engine/engineFallback 字段）；守卫命中/strict 时 routeEngine 在此
-    // throw，不产生孤儿 record。
+    // ── 1.5 引擎路由（D2 单轨 + D3-② 路由单点：统一经 routeEngineForHost）──
+    // 唯一实现在 engine/routing.ts（pi 同步短路 + registry 注入 + 兜底回本地 pi 实例
+    // 收敛于此）；本调用点只装配三层输入与注入件。时机：路由（含 probe）在 record
+    // 创建前完成——兜底时 record 按 pi 语义创建 + engineFallback 留痕（D5 字节级守护
+    // 只约束「无 fallback 的纯缺省路径」）；守卫命中/strict 时在此 throw，不产生孤儿
+    // record。pi 请求路径同步短路（routed 非 Promise，零微任务——缺省路径时序不变）。
+    // [u-h2 D2-1] 路由先行于 pi 链 model 解析：agentConfig 是路由第二层输入（frontmatter
+    // engine）已前置解析；pi 的 resolveModel 移到路由之后、按目标引擎分支执行——非 pi
+    // 请求不被 pi registry 解析错误拦截（F2-A/B 时序根因），model 校验归目标引擎（D2-2）。
     const routingInput = {
       callEngine: opts.engine,
-      agentEngine: identity.agentConfig?.engine,
+      agentEngine: agentConfig?.engine,
       globalDefaultEngine: this.modelService.getGlobalConfig().defaultEngine,
     };
-    const routing = resolveEngineRouting(routingInput);
-    let route: EngineRouteResult | undefined;
-    if (routing.engineId !== DEFAULT_ENGINE_ID) {
-      route = await routeEngine({
-        routing: routingInput,
-        // 守卫 c 判据只看调用方显式指定的 model（resolved model 含 ctxModel 兼底，
-        // 恒非空会把一切兜底误判为 model 绑定命中）
-        taskModel: opts.model,
-        strict: this.modelService.getGlobalConfig().engineRouting?.strict === true,
-        probe: (engineId) => getEngine(engineId).probe(),
-      });
-      if (route.engineId !== DEFAULT_ENGINE_ID) {
-        return this.executeViaEngine(opts, identity, route);
-      }
-      // 兜底成功（典型：默认路由 + probe 失败 + 无守卫命中）→ 落回下方 pi 主路径，
-      // record 创建时按 pi 语义 + engine/engineFallback 留痕（engine = 实际执行引擎）
-    }
-    // D5 字节级守护：无 fallback 的 pi 路由剥掉 opts.engine——createRecordForMode
-    // 不盖章（pi record entry 序列化产物不得新增 engine 键，undefined 经 JSON 省略）。
-    // 兜底路径显式盖 engine='pi' + engineFallback（见上方时机注释）。
-    const piOpts =
-      route?.engineFallback !== undefined
-        ? { ...opts, engine: DEFAULT_ENGINE_ID, engineFallback: route.engineFallback }
-        : opts.engine === undefined
-          ? opts
-          : { ...opts, engine: undefined };
-
-    // ── 2. RECORD 创建 + 注册 ──
-    const record = this.createRecordForMode(identity, piOpts, mode);
-    emitPendingRegister(this.pi, record.id, record.agent);
-
-    // ── 2.5 worktree 创建（仅 worktree===true 或已传入 handle 时）──
-    // record 先创建，worktree 失败时可 finalizeFailed（record 已在 store 中）。
-    // worktree 必须显式开启：worktree===true 创建新 worktree；worktree===undefined/false 不创建。
-    // fork 不隐含 worktree（UC-1 fork 可独立使用，fork 仅继承上下文，在 parent cwd 跑）。
-    let worktreeHandle: WorktreeHandle | undefined;
-    if (typeof opts.worktree === "object") {
-      // 传入的是已创建的 WorktreeHandle
-      worktreeHandle = opts.worktree;
-    } else if (opts.worktree === true) {
-      // worktree===true（显式要求）——创建新 worktree。与 fork 正交（worktree 文件隔离不依赖 fork 上下文继承）。
-      try {
-        worktreeHandle = await this.worktreeManager.create(this.cwd, record.id);
-        record.worktreeHandle = worktreeHandle;
-        // [create-await 竞态守卫] create 的 await 窗口内 cancel/dispose 可 CAS 把 record
-        // 转成 closed 终态——cancelBackground 当时读到的 worktreeHandle 可能仍是 undefined
-        // （cleanup 被跳过）。赋值后同同步段检查终态：closed 则主动 cleanup（幂等，抢先的
-        // fire-and-forget 清理无害）+ early-failed 返回，不进 kickOffBackground（避免子进程白跑）。
-        // 实现约束：赋值 → 终态检查 → kickOffBackground 必须在同一同步段，中间禁止插入 await。
-        if (record.status === "closed") {
-          await this.worktreeManager.cleanup(worktreeHandle);
-          return this.buildEarlyFailedHandle(record);
-        }
-      } catch (err) {
-        // create 失败→不进入 run，finalizeFailed 统一收尾（含 emitPendingUnregister failed）
-        const _result = await this.finalizeFailed(record, err);
-        return this.buildEarlyFailedHandle(record);
-      }
-    }
-
-    // ── 3. MODE 固定 background：signal/controller、priority 固定 ──
-    const signal = record.controller!.signal;
-    const priority = PRIORITY_BACKGROUND;
-
-    // ── 4-7. background 包 detached 立即返回 id ──
-    // background detached 运行对 tool 层不可见，完成由 notify 驱动新 turn。
-    const bgDetails = project(record);
-    this.kickOffBackground(record, { ...piOpts, worktree: worktreeHandle }, ctx, identity, signal, priority);
-    return { mode: "background", subagentId: record.id, sessionFile: record.sessionFile, details: bgDetails };
+    const routed = routeEngineForHost({
+      routing: routingInput,
+      // 守卫 c 判据只看调用方显式指定的 model（resolved model 含 ctxModel 兼底，
+      // 恒非空会把一切兜底误判为 model 绑定命中）
+      taskModel: opts.model,
+      strict: this.modelService.getGlobalConfig().engineRouting?.strict === true,
+      probe: (engineId) => getEngine(engineId).probe(),
+      piEngine: this.chatPiEngine,
+    });
+    const route: EngineRouteResult = routed instanceof Promise ? await routed : routed;
+    return this.executeViaEngine(opts, { agent, agentConfig }, route, mode);
   }
 
   /**
@@ -938,7 +1207,7 @@ export class SubagentService {
    * 供 tool 层 cancelHandler 翻译 throw 用（id 不存在 / mode / 终态三种错误）。
    * 不存在返回 undefined。
    */
-  findRecord(id: string): RecordSnapshot | undefined {
+  private findRecord(id: string): RecordSnapshot | undefined {
     this.assertReady();
     const record = this.store.getMutable(id);
     return record ? snapshot(record) : undefined;
@@ -963,7 +1232,7 @@ export class SubagentService {
    *
    * 返回 undefined：id 在内存与磁盘均不存在。
    */
-  lookupRecordAnyState(id: string): SubagentRecord | undefined {
+  private lookupRecordAnyState(id: string): SubagentRecord | undefined {
     try {
       this.assertReady();
     } catch {
@@ -977,33 +1246,81 @@ export class SubagentService {
   // ── 对话模式投递（M2-B3 message action 调用）──────────────
 
   // [review 修复] 已删除 deliverToRunning（busy follow_up/steer 投递 + pendingMessages
-  // 消费确认制）：SP-5 upgrade 后所有 running record 走 chatMode 分支 → deliverMessage
-  // 统一投递（热路径 prompt+streamingBehavior / 冷路径 resume），该方法无生产调用方，
+  // 消费确认制）：SP-5 upgrade 后所有 running record 走 chatMode 分支 → 统一投递
+  //（热路径 prompt+streamingBehavior / 冷路径 resume），该方法无生产调用方，
   // 其配套三段消费链（push / message_start shift / redeliverPending 补投）全部不可达，
   // 一并移除（详见各文件同步删除）。
+  // [D2 单轨] 投递的 pi RPC stdin 协议知识（stdin prompt 命令直调 + streamingBehavior
+  // 映射 + EPIPE 兜底 + 冷路径分流）已下沉 PiEngine.deliverPrompt——本层经
+  // deliverChatMessage → PiEngine.interactRecord 调用，见下方两方法。
+
+  /**
+   * [V2 决策 3] chatMode 统一投递入口（message action 的 Service 面）——经引擎交互面
+   * 执行（D2：PiEngine.interactRecord——port face interact 的 record 锚定形态，协议知识
+   * 在引擎边界，编排层不做 stdin 写入）。分流语义（按**进程死活**，
+   * 不按 record.status）与热/冷路径细节见 PiEngine.deliverPrompt：
+   *
+   *   热路径（进程活）：prompt + streamingBehavior——pi 权威裁决 busy/idle（F3/F4）。
+   *   冷路径（进程死）：冷路径续轮（resumeChatRound）重开 session + prompt（仅崩溃/
+   *     timeout kill/跨重启命中）。
+   *
+   * 失败语义与直调形态一致：业务拒绝（not ready / EPIPE 兜底耗尽等，文案自带行动语言）
+   * 经 interact 结构化结果回传后原样 throw（错误文本逐字节保持）。
+   *
+   * @param record 目标 record（chatMode，running 或 idle）
+   * @param text 消息正文
+   * @param interrupt true=steer（抢占）/ false=followUp（排队），仅热路径 streamingBehavior 用
+   */
+  private async deliverChatMessage(record: ExecutionRecord, text: string, interrupt: boolean): Promise<void> {
+    this.assertReady();
+    // interactRecord：interact 的 record 锚定形态（调用方已持归属校验过的同一 record
+    // 对象——port face interact 的 handle 解析在此冗余且会做二次 store 查找）
+    const result = await this.chatPiEngine.interactRecord(
+      record,
+      { kind: "message", payload: text, interrupt },
+    );
+    if (!result.ok) {
+      throw new Error(result.message);
+    }
+    // [T2③ / D9 两段式] 热路径轮 settled 等待守护（双挂载原语之热路径调用点，首轮
+    // 调用点在 session-runner runSpawn）。原挂载位在 deliverMessage prompt 写入成功后
+    // 的同步段——D2 协议知识下沉 PiEngine.deliverPrompt 后编排层在 interact 返回点
+    // arm（deliverPrompt 热路径段无 await，返回点距 prompt 发出仅差微任务链；窗口口径
+    // 「整轮含 turn 执行与收尾」不受影响）。冷路径（EPIPE 兜底/resume）下 runSpawn 的
+    // 首轮 arm 与此处重复挂载由原语幂等（先清旧 timer）吸收 = 窗口重置，无害。
+    // prompt 发出后挂**中段**无进展检测（有效协议事件行刷新，连续静默判 wedged）+
+    // agent_end 交棒收尾段固定上界；settled 到达（PiEngine.handleSdkEvent 的 disarm）/
+    // 进程 close / cancel/close 终态化处置后即清（disarm 站点散布上述路径，幂等）。
+    armMidRoundNoProgress(record.id, {
+      onMidTimeout: (fire) => this.onHotPathSettledWatchdogTimeout(record, fire),
+      onSettleTimeout: (fire) => this.onHotPathSettledWatchdogTimeout(record, fire),
+    });
+  }
 
   /**
-   * idle 投递：resume spawn 开启新一轮对话（设计决策 6 idle 分支）。
+   * 冷路径续轮（PiEngine.deliverPrompt 的编排回调，D2 下沉后的归属）：resume spawn
+   * 开启新一轮对话（设计决策 6 idle 分支）。仅进程死（idle timer reap / 崩溃 / 跨重启
+   * / EPIPE 兜底）时经引擎到达。
    *
-   * record 必须 idle（轮次完成、进程已回收、record 留内存）。手动把 status 设回 "running"
-   * （M2-A 边界：idle→running 是恢复非终态，绕过 tryTransition——tryTransition 要求当前态
-   * running 才 CAS，idle record 直接进 runAndFinalize 会被 tryTransition 拒绝转态）。
+   * record 必须 idle-resumable（轮次完成、进程已回收、record 留内存）。手动把 status
+   * 设回 "running"（M2-A 边界：idle→running 是恢复非终态，绕过 tryTransition——
+   * tryTransition 要求当前态 running 才 CAS）。
    *
    * resume 参数从 record identity 读（防多轮对话模型漂移，探针 P-10）：sessionFile、
    * model、thinkingLevel 均为 record 身份字段（创建时确定、不可变）。maxTurns/schema 等
    * 执行约束第一版不恢复（设计 §5 拆分 1 待验证检查点），agentConfig 用 undefined
-   * （pi --session 续写保留上下文，agent 行为由 session 内 messages 决定；M2-B3 messageHandler 可完善）。
+   *（pi --session 续写保留上下文，agent 行为由 session 内 messages 决定；M2-B3 messageHandler 可完善）。
    *
-   * detached 编排（参照 kickOffBackground）：不 await，runAndFinalize 在 background 跑。
-   * chatMode + done 时 runAndFinalize 的 M2-A 分流自动把 record 重新置 idle。并发槽在
-   * runAndFinalize 内重新 acquire（轮次间 idle 已 release）；pool.acquire 是排队模型，
+   * detached 编排（kickOffChatRound，经 EnginePort 交接）：不 await，轮次在 background 跑。
+   * chatMode + done 时轮次收尾的 M2-A 分流自动把 record 回退 idle-resumable。并发槽在
+   * 轮次执行内重新 acquire（轮次间 idle 已 release）；pool.acquire 是排队模型，
    * 池满时排队等待槽位而非 throw（与 execute 一致）。
    *
-   * @param record 目标 record（必须 idle）
+   * @param record 目标 record（必须 idle-resumable）
    * @param text 新一轮消息正文
-   * @throws Error record 非 idle / 无 sessionFile / 无 controller
+   * @throws Error record 非 running / 无 sessionFile / 无 controller / worktree 绑定丢失 / 续轮在途
    */
-  resumeRound(record: ExecutionRecord, text: string): void {
+  private resumeColdRound(record: ExecutionRecord, text: string): void {
     this.assertReady();
     // [CL-b1-cas-coupling / v4 B-1] v4 把旧 idle 折入 running 后此守卫对 idle-resumable
     // record 恒放行（idle 本来就是 running），`status = "running"`（下方）是幂等写——
@@ -1017,10 +1334,10 @@ export class SubagentService {
       );
     }
     // [review MF1] 在途 resume 守卫：上一条消息发起的 resume 仍在途（spawn 尚未注册 /
-    // 本轮 runAndFinalize 未收尾）时，再次到达（冷路径重入 / EPIPE 兜底）直接拒绝。
+    // 本轮轮次未收尾）时，再次到达（冷路径重入 / EPIPE 兜底）直接拒绝。
     // 触发链：pi 对同一 assistant message 的 tool calls 顺序执行（sequential），tool1 的
-    // deliverMessage 在冷路径 resumeRound 返回即 resolve（早于 spawn 注册完成），tool2
-    // 立即执行 → getChildByRecord 仍 undefined → 再次冷路径。无此守卫 → 两次 kickOff →
+    // 投递在冷路径续轮返回即 resolve（早于 spawn 注册完成），tool2 立即执行 →
+    // getChildByRecord 仍 undefined → 再次冷路径。无此守卫 → 两次 kickOff →
     // runSpawn 2 次 → 两 pi 子进程双写同一 session JSONL + 第一个脱离 kill 记账成孤儿。
     if (this.resumesInFlight.has(record.id)) {
       // MF-4：行动语言。
@@ -1033,7 +1350,7 @@ export class SubagentService {
     if (!record.sessionFile) {
       // MF-4：session 损坏 → canonical 文案（spec §3.1 失败表）。
       throw new Error(
-        `session unavailable for subagent ${record.id} (session file missing or unreadable). ` +
+        `subagent ${record.id} session unavailable (session file missing or unreadable). ` +
         `Recovery: use action:'close' to clean up, then action:'start' a new subagent.`,
       );
     }
@@ -1097,144 +1414,21 @@ export class SubagentService {
     };
     const ctx = this.buildSessionRunnerContext();
 
-    // detached 编排：runAndFinalize 在 background 跑，pool 重新 acquire（轮次间 idle 已 release）。
+    // detached 编排：轮次在 background 跑，pool 重新 acquire（轮次间 idle 已 release）。
     // chatMode + done 时 M2-A 分流自动 finalizeRoundToIdle（record 回 idle、round+1）。
-    // [review MF1] 在途标记在 kickOff 前同步设置：resumeRound 返回即生效，后续重入
-    // （冷路径 / EPIPE 兜底）在守卫处被拒；runAndFinalize finally 统一清除。
+    // [review MF1] 在途标记在 kickOff 前同步设置：本方法返回即生效，后续重入
+    // （冷路径 / EPIPE 兜底）在守卫处被拒；轮次收尾 finally 统一清除。
     this.resumesInFlight.add(record.id);
-    this.kickOffBackground(record, opts, ctx, identity, record.controller.signal, PRIORITY_BACKGROUND, resume);
-  }
-
-  /**
-   * [V2 决策 3] chatMode 统一投递：按**进程死活**分流，不按 record.status。
-   *
-   * V2 进程长驻——chatMode record 首轮 agent_settled 后进轻量 idle（Step 4a：进程保活、
-   * idle timer armed），续聊时进程仍在内存，不该重开 session。故续聊投递不按 status
-   *（running/idle 都可能是热路径），而是判进程死活：
-   *
-   *   热路径（进程活）：prompt + streamingBehavior——pi 权威裁决 busy/idle（F3/F4）。
-   *     busy（isStreaming）时 followUp 入队/steer 抢占；idle 时 streamingBehavior 被忽略、
-   *     直接开新 turn。不用 steer/followUp 命令、不依赖 clearQueue（F8），结构上消除残留。
-   *   冷路径（进程死）：复用 resumeRound 重开 session + prompt（仅崩溃/timeout kill/跨重启命中）。
-   *
-   * disarm idle timer：新 turn 开始必须 disarm（V2 决策 4），防 turn 期间 idle timer 误杀活进程。
-   *
-   * status 处理：判活分流后**各自**设 running——热路径手动设 running（新 turn 开始）；
-   * 冷路径由 resumeRound 校验 idle 并自行设 running + spawn（故不在此预设 running，否则
-   * resumeRound 的 idle 检查会 throw）。resume spawn 后 session-runner 回填 record.pid，
-   * 热路径拿到 child 时也顺便刷新 pid（resume 重开进程后 pid 已变）。
-   *
-   * [review 修复] 曾对比的 deliverToRunning（非 chatMode busy 投递 + pendingMessages
-   * 消费确认制）已删除——SP-5 upgrade 后无生产调用方（V2 决策 3 已删消费确认制）。
-   *
-   * @param record 目标 record（chatMode，running 或 idle）
-   * @param text 消息正文
-   * @param interrupt true=steer（抢占）/ false=followUp（排队），仅热路径 prompt streamingBehavior 用
-   */
-  async deliverMessage(record: ExecutionRecord, text: string, interrupt: boolean): Promise<void> {
-    this.assertReady();
-    // 新 turn，disarm idle timer（防 turn 期间误杀活进程，V2 决策 4）
-    disarmIdleTimer(record.id);
-    const child = getChildByRecord(record.id);
-    if (child && !child.killed) {
-      // 热路径：进程活，prompt + streamingBehavior（V2 决策 3，pi 权威裁决 busy/idle）
-      record.status = "running";
-      // 刷新 pid 内存记账（resume spawn 后 child.pid 已变，顺便更新）
-      if (child.pid !== undefined) record.pid = child.pid;
-      try {
-        sendPromptCommand(child, text, { streamingBehavior: interrupt ? "steer" : "followUp" });
-        // 热路径成功，清零 EPIPE 连续失败计数（[v4 A-1] 计数器已迁移到 stdin-writer）
-        clearEpipeFailure(record.id);
-        // [race-F5] 写后死进程检测：write 同步成功只代表数据进了内核 pipe 缓冲，子进程
-        // 可能在读取前死亡（gate/idle kill 竞速）。exitCode/signalCode 已非 null = 进程已死
-        //（close 事件可能尚未到达），缓冲中的消息将被静默丢弃。只 warn 留证（含 runId 与
-        // 消息类型），不抛错不重试：终态回收已由 kill 路径保证，对死进程重试反而可能二次写。
-        if (child.exitCode !== null || child.signalCode !== null) {
-          logger.warn(
-            `[subagents] deliverMessage: child ${record.id} died around stdin write, message may be lost`,
-            {
-              msgType: interrupt ? "steer" : "followUp",
-              exitCode: child.exitCode,
-              signalCode: child.signalCode,
-            },
-          );
-        }
-        // 轮始执行态信号清除 + 迁移上报（residual-fixes U3 补全，与冷路径 resumeRound
-        // 对称）：新一轮开跑 = 无轮终信号——清上一轮 result（§5.4 isStreaming 公式要求
-        // result undefined 才显示 streaming）与 resumable，appendEntry 让 runtime/W18
-        // 派生缓存失效、GUI 侧从 waiting 切回 spinner。仅在投递成功后清（失败保留
-        // 上一轮信号，EPIPE 兜底走 resumeRound 时由其再清）。
-        record.result = undefined;
-        record.resumable = undefined;
-        this.store.reportRecordTransition(record);
-        // [T2③ / LC-1] 热路径轮 settled 等待固定硬上限（双挂载原语之热路径调用点，
-        // 首轮调用点在 session-runner runSpawn）。prompt 发出即起算（整轮含 turn 执行与
-        // 收尾都在窗口内，impl-plan §5 窗口口径裁决），settled 到达（session-runner
-        // handleSdkEvent 的 disarm，幂等生效于热路径轮）/ 进程 close（waitForChildExit
-        // 的 disarm）/ 本方终态化处置后即清——settled 永不到达（事件行丢失 / 子进程
-        // wedged）时本 timer 是唯一独立回收通道：现状「settled 不 arm 则 idle timer 不挂、
-        // runSpawn 已在首轮返回、spawn watchdog 默认关」的三无窗口由此收敛。
-        armSettledWatchdog(record.id, () => this.onHotPathSettledWatchdogTimeout(record));
-      } catch (err) {
-        // EPIPE 兜底：stdin 管道已断，进程实际已死但 close 事件尚未到达。
-        // 检测 EPIPE 关键词 → 进程按 dead 处理 → 自动转冷路径 resume + 消息重放。
-        // [review MF1] 本兜底不持 activateLock，但与冷路径共用 resumeRound 的在途守卫
-        //（resumesInFlight）：resume 已在途时兜底的 resumeRound 调用被拒（throw 行动语言），
-        // 不会二次 spawn。
-        if (err instanceof Error && err.message.includes("EPIPE")) {
-          logger.warn(`[subagents] EPIPE on hot path for ${record.id}, falling back to cold path resume`, {
-            detail: err.message,
-          });
-          // 清理 spawnedChildren 中的死进程条目（让 resumeRound 能重新 spawn）。
-          // [M4] 按值守卫：仅当 Map 当前值仍是本次写 EPIPE 的 child 才删——若已被 resume
-          // spawn 覆盖为新 child（close 事件先于本 catch 到达的极端时序），不误删新注册
-          //（与 session-runner removeChildRegistration 同语义）。
-          if (spawnedChildren.get(record.id) === child) {
-            spawnedChildren.delete(record.id);
-          }
-          // 递增连续 EPIPE 计数（[v4 A-1] helper 合并同步/异步路径计数）
-          const count = recordEpipeFailure(record.id);
-          if (count >= EPIPE_FAILURE_THRESHOLD) {
-            // 连续达阈值 EPIPE → 不再尝试 resume，throw 含恢复指引
-            clearEpipeFailure(record.id);
-            throw new Error(
-              `[subagents] EPIPE fallback exhausted for ${record.id}: ${count} consecutive EPIPE failures. ` +
-                `Recovery: use action:'close' to clean up, then action:'start' a new subagent.`,
-            );
-          }
-          // 冷路径 resume + 原消息重放（v4 B-1: status 已 running，resumeRound CAS 直接放行）
-          this.resumeRound(record, text);
-          return;
-        }
-        // [T2⑧ / PS-3] 非 EPIPE 写失败（如 ERR_STREAM_DESTROYED——错误分类只认 "EPIPE"
-        // 子串，过窄）：deliverMessage 入口已无条件 disarmIdleTimer，旧实现直接 rethrow
-        // 不 re-arm——「timer armed」这个防泄漏前提在失败路径永久丢失：进程无人回收
-        //（无 timer、无轮、record=running）泄漏至宿主退出，hasRunningBackground 恒真
-        // 还会顺延其他完成通知。修复：rethrow 前再武装 idle timer（含防御性降级），恢复
-        // 进程回收通道 + 通知放行门；调用方错误语义不变（仍 rethrow）。
-        this.rearmIdleTimerAfterHotPathFailure(record, err);
-        // 非 EPIPE 错误——不应发生，重新抛出让调用方处理
-        throw err;
-      }
-    } else {
-      // 冷路径：进程死（idle timer reap / 崩溃 / 跨重启），record 应为 idle → resume spawn。
-      // D3：acquireActivateLock 双保险——注意锁只覆盖 resumeRound 同步段，释放在子进程注册
-      //（session-runner spawnedChildren.set）之前（中间隔 pool.acquire await + tempFile 等异步点）。
-      // 真正的单写者守卫是 resumeRound 的 resumesInFlight（[review MF1]）：锁释放后、child
-      // 注册前到达的第二次冷路径 message 在 resumeRound 处被拒，不会二次 spawn。
-      const releaseLock = await acquireActivateLock(record.id);
-      try {
-        this.resumeRound(record, text);
-      } finally {
-        releaseLock();
-      }
-    }
+    this.kickOffChatRound(record, opts, identity, ctx, record.controller.signal, PRIORITY_BACKGROUND, resume);
   }
 
   /**
    * [T2③] 热路径轮 settled watchdog 到期处置（对齐 u-t2a 首轮形态：kill + 该轮失败
    * 终态化 + 失败通知，error 含 'settled watchdog' 标记与恢复指引）。
    *
+   * [D9 两段式] 两段（mid-round 无进展 / settled 收尾段上界）共用本处置，fire 信息
+   *（段 + 窗长）由原语注入，失败文案按段分叉窗长语义。
+   *
    * 与首轮的差异：runSpawn 已返回（无收尾链路承接 settledWatchdogFired 标记），失败
    * 终态化在本回调内完成。chatMode 按 MF-6 语义回退 running-resumable（与首轮 watchdog
    * 经 runAndFinalize 失败分支的最终形态一致——对话可冷路径复活）；非 chatMode 终态
@@ -1243,10 +1437,14 @@ export class SubagentService {
    * 回调在 timer 触发的同步上下文执行：同步段只做 kill + CAS（不抛），异步收尾
    * fire-and-forget 且 catch 归 bestEffort——错误逃出回调 = uncaughtException 崩宿主。
    */
-  private onHotPathSettledWatchdogTimeout(record: ExecutionRecord): void {
+  private onHotPathSettledWatchdogTimeout(record: ExecutionRecord, fire: SettledWatchdogFireInfo): void {
+    const windowDesc =
+      fire.phase === "mid-round"
+        ? `no valid protocol event for ${fire.waitedMs / MS_PER_SECOND / SECONDS_PER_MINUTE} min after prompt (mid-round no-progress)`
+        : `no agent_settled within ${fire.waitedMs / MS_PER_SECOND}s after agent_end (settled phase)`;
     logger.warn(
-      `[subagents] settled watchdog fired for ${record.id}: no agent_settled within ` +
-        `${SETTLED_WATCHDOG_TIMEOUT_MS / MS_PER_SECOND / SECONDS_PER_MINUTE} min of hot-path prompt, terminating (LC-1 wedge recovery)`,
+      `[subagents] settled watchdog (${fire.phase}) fired for ${record.id}: ${windowDesc}, ` +
+        `terminating (LC-1 wedge recovery)`,
     );
     killRecordChildWithEscalation(record.id, "settled watchdog (hot path)");
     const failedResult: AgentResult = {
@@ -1255,7 +1453,7 @@ export class SubagentService {
       durationMs: Date.now() - record.startedAt,
       success: false,
       error:
-        `subagent did not reach agent_settled within ${SETTLED_WATCHDOG_TIMEOUT_MS / MS_PER_SECOND / SECONDS_PER_MINUTE} min (settled watchdog); ` +
+        `subagent did not reach agent_settled (${windowDesc}; settled watchdog); ` +
         `the process was terminated to bound the wait. ` +
         `Recovery: check state with subagents action:'list', then re-send your message to continue.`,
       sessionId: record.id,
@@ -1268,38 +1466,17 @@ export class SubagentService {
       ? this.finalizeRoundToIdle(record, failedResult)
       : this.finalizeRecord(record, failedResult, "closed", "gc");
     void finalize
-      .then(() => this.notifyComplete(record))
+      // [D4-①] 通知簇搬移 notify-host 后的遗留调用点修正：this.notifyComplete 方法已
+      // 不存在（其余三处调用点均 this.notifyHost.notifyComplete），旧引用 throw
+      // TypeError 被本 .catch 吞掉 → settled watchdog 失败通知静默丢失
+      .then(() => this.collectCoordinator.route(record))
       .catch((err: unknown) => bestEffort(err, "settled watchdog hot-path finalize", "error"));
   }
 
-  /**
-   * [T2⑧ / PS-3] 非 EPIPE 热路径失败后的 idle timer 再武装（防泄漏底线）。
-   *
-   * record.idleTimeoutMs 已在 spawn 入口经 assertIdleTimeoutMsSafe 校验（T4②），此处
-   * armIdleTimer 理论不 throw；降级链仍保底：非法 → 挂 DEFAULT_IDLE_TIMEOUT_MS + warn
-   * （兜底可见，对齐 session-runner agent_settled 侧的 T4② 降级形态），双重失败退回
-   * 「不挂」但留 error 痕。
-   */
-  private rearmIdleTimerAfterHotPathFailure(record: ExecutionRecord, cause: unknown): void {
-    const detail = cause instanceof Error ? cause.message : String(cause);
-    const onTimeout = (): void => {
-      killRecordChildWithEscalation(record.id, "idle timer (hot-path failure fallback)");
-    };
-    try {
-      armIdleTimer(record.id, onTimeout, record.idleTimeoutMs);
-    } catch {
-      try {
-        armIdleTimer(record.id, onTimeout, DEFAULT_IDLE_TIMEOUT_MS);
-      } catch (fallbackErr) {
-        bestEffort(fallbackErr, "rearmIdleTimer fallback (deliverMessage non-EPIPE failure)", "error");
-        return;
-      }
-    }
-    logger.warn(
-      `[subagents] deliverMessage hot path failed for ${record.id}; idle timer re-armed to keep process recovery bounded`,
-      { detail },
-    );
-  }
+  // [T2⑧ / PS-3] 非 EPIPE 热路径写失败后的 idle timer 再武装已随 D2 投递下沉迁移落位：
+  // 挂载点在 PiEngine.deliverPrompt 的非 EPIPE catch（engine/engines/pi/pi-engine.ts 的
+  // rearmIdleTimerAfterHotPathFailure，该文件归 engine 域）——编排层 interactRecord 的
+  // 结构化结果无法区分「stdin 写失败」与业务拒绝，盲目 re-arm 会误武装。
 
   // ── 对话模式 message/close action 支持（M2-B3）──────────────
 
@@ -1323,14 +1500,15 @@ export class SubagentService {
    * @throws Error record 不存在 / 非本 session 所有（含恢复指引）
    * @throws ResurrectDeniedError 命中可重连集但被 worktree/异进程活实例守卫拦截（自带完整行动语言）
    */
-  getRecordForAction(id: string, opts?: { allowReconnect?: boolean }): ExecutionRecord {
+  private getRecordForAction(id: string, opts?: { allowReconnect?: boolean }): ExecutionRecord {
     this.assertReady();
     let record = this.store.getMutable(id);
     // SP-2 跨重启恢复：内存未命中时，从磁盘 collectRecords 重建 idle record。
     // reconstructAll 已将跨重启 record（无 sidecar + pid 死）标记为 running（v4 B-1 可续聊语义，非 crashed），
     // 直接转为可变 ExecutionRecord register 进内存，供 message/close action 续操作。
     if (!record) {
-      record = this.coldLookupForAction(id, opts?.allowReconnect === true);
+      // [D4-③] 冷查/复活链整体搬移至 cold-resurrect.ts（行为逐字节等价）。
+      record = coldLookupForAction(this.coldResurrectDeps, id, opts?.allowReconnect === true);
     }
     if (!record || record.rootSessionId !== this.sessionRootId) {
       throw new Error(
@@ -1340,12 +1518,12 @@ export class SubagentService {
     }
     // [v4 A-5 / P7] 直接父校验：rootSessionId 已确认 record 属于本 session 树，但递归场景下
     // 孙级 record（parentRecordId = 某子进程的 self recordId）的子进程句柄只存在于其直接父
-    // 进程内存。主进程（execCtxBaseline=null）若仅凭 rootSessionId 通过就 message 孙级，会走
+    // 进程内存。主进程（基线 null）若仅凭 rootSessionId 通过就 message 孙级，会走
     // 冷路径重新 spawn → 双写同一 session 文件（P7 双写者窗口）。统一用 baseline recordId 校验：
     //   - 主进程 baseline=undefined → 只能操作 parentRecordId=undefined 的根层 record
     //   - 子进程 baseline="sa-X"    → 只能操作 parentRecordId="sa-X" 的直接孩子
     // record.parentRecordId===undefined 视作根层，仅主进程可操作（身份缺省的旧/异常 record 归此）。
-    const baselineRecordId = this.execCtxBaseline?.recordId ?? undefined;
+    const baselineRecordId = this.execNesting.baseline()?.recordId ?? undefined;
     if (record.parentRecordId !== baselineRecordId) {
       throw new Error(
         `subagent ${id} is owned by its direct parent; message it through that parent ` +
@@ -1357,156 +1535,13 @@ export class SubagentService {
     return record;
   }
 
-  /** SP-2 冷路径（getRecordForAction 内存未命中分支的提取）：从磁盘重建可变 ExecutionRecord
-   *  并 register 进内存。[perf] 先走 idToFile 索引直查（单文件 stat 校验），未命中（进程重启后
-   *  尚未扫描、索引未热）才全目录 collectRecords 兜底建索引——跨重启后每条 message 从
-   *  「readdir + N×4 stat 全扫」降为单文件校验。
-   *  @returns 重建的 record；磁盘也无则 undefined
-   *  @throws ResurrectDeniedError 可重连候选被 worktree/异进程活实例守卫拦截 */
-  /** 冷查候选定位（coldLookupForAction 步骤 1）：idToFile 索引直查 running 命中，
-   *  未命中再全目录 collectRecords 兜底（running，或 allowReconnect 且可重连 closed）。
-   *
-   *  [T5③ / PS-7b] running 候选异进程活实例守卫：冷查 running 候选（跨重启 / 内存重建）
-   *  此前不经任何探针直接 resurrect + resume spawn——若其 .alive marker 仍指向活着的
-   *  异进程实例（父进程重启后旧子进程尚存的窗口），resume 会 spawn 第二个 pi 子进程
-   *  写同一 session JSONL（本代码最忌惮的双写者形态，v4 A-5/P7 事故模式）。closed 候选
-   *  的同款守卫已在 assertReconnectAllowed（v8.5 D）；本守卫闭合 running 候选的防御
-   *  不对称。marker 的 pid 是子进程 pi 的 pid（非父进程），本进程持有的 running record
-   *  恒在内存（archive 才移出），可达本冷查分支的 running 候选必然来自磁盘重建——
-   *  探针命中即拒绝（ResurrectDeniedError，与 closed 候选守卫同异常类型，错误含 pid
-   *  与恢复指引）。 */
-  private findColdLookupCandidate(id: string, allowReconnect: boolean): SubagentRecord | undefined {
-    const direct = this.store.findLightById(id);
-    const found =
-      (direct?.status === "running" ? direct : undefined) ??
-      this.store
-        .collectRecords(COLD_LOOKUP_SCAN_LIMIT, "all", undefined)
-        .find((r) => r.id === id && (r.status === "running" || (allowReconnect && this.isReconnectableClosed(r))));
-    if (found?.status === "running" && found.sessionFile) {
-      const foreign = findForeignLiveInstance(found.sessionFile);
-      if (foreign) {
-        throw new ResurrectDeniedError(
-          `subagent ${id} is currently running in another process instance (pid ${foreign.pid}, ` +
-            `startedAt=${new Date(foreign.startedAt).toISOString()}); resuming here would double-write ${found.sessionFile}. ` +
-            `Recovery: retry once that process exits; if it never exits, action:'close' this subagent, then action:'start' a fresh one.`,
-        );
-      }
-    }
-    return found;
-  }
-
-  /** 可重连守卫（coldLookupForAction 步骤 2，[v8.5 D]）：先于任何状态突变与注册。
-   *  worktree 绑定丢失 / 异进程活实例以 ResurrectDeniedError 抛出（endedMessageGuard
-   *  必须原样透传，不得改写为 fork-from 指引误导 agent 走已被判死的通道）；拒绝时
-   *  内存不得残留该记录（findRecord 契约）。 */
-  private assertReconnectAllowed(found: SubagentRecord, id: string): void {
-    if (found.status !== "closed") return;
-    if (found.worktree === true) {
-      throw new ResurrectDeniedError(
-        `subagent ${id} cannot be transparently resumed: it was created with worktree isolation, ` +
-        `and its worktree checkout no longer exists after restart (resuming in place would make spawn cwd fall back to the main repo). ` +
-        `Recovery: action:'start' a fresh subagent (with a new worktree if isolation is still needed); ` +
-        `its conversation history remains intact at ${found.sessionFile}.`,
-      );
-    }
-    const foreign = found.sessionFile ? findForeignLiveInstance(found.sessionFile) : undefined;
-    if (foreign) {
-      throw new ResurrectDeniedError(
-        `subagent ${id} is not transparently resumable: its previous instance still finishing in another process ` +
-        `(pid ${foreign.pid}, startedAt=${new Date(foreign.startedAt).toISOString()}). ` +
-        `Resuming in place would double-write ${found.sessionFile}. ` +
-        `Recovery: retry once that process exits; if it never exits, action:'start' a fresh subagent and treat the history at ${found.sessionFile} as read-only reference.`,
-      );
-    }
-  }
-
-  /** 磁盘候选重建为可变 record 并 register + 上报（coldLookupForAction 步骤 4）。 */
-  private resurrectColdRecord(found: SubagentRecord, id: string): ExecutionRecord {
-    const record = createRecord(id, {
-      agent: found.agent,
-      model: found.model,
-      thinkingLevel: found.thinkingLevel,
-      mode: found.mode,
-      task: found.task,
-      slug: found.slug,
-      startedAt: found.startedAt,
-      rootSessionId: found.rootSessionId,
-      parentRecordId: found.parentRecordId,
-      depth: found.depth,
-      // [v4 A-3] 跨重启恢复入口——message 路径磁盘重建无条件置 chatMode=true（现状机制，
-      // V3 方案 A 方向兑现）。改动此处必须带 S3 回归场景（跨重启 message 续聊验证）。
-      // V3 SP-5 探针定案：机制已存在，本注释即定案，不再悬置。
-      chatMode: true,
-      controller: new AbortController(),
-    });
-    record.sessionFile = found.sessionFile;
-    record.round = found.round;
-    // [review round2] 跨重启 worktree 绑定丢失防护：原 record 创建时启用了 worktree 隔离
-    //（session entry 的 worktree 标志），但 WorktreeHandle 不可序列化、重建后恒缺失。
-    // 标记 hadWorktree，resumeRound 守卫据此拒绝续聊（防 spawn cwd 静默回落主 repo 破坏
-    // 隔离——正是 worktree 要防的并发写冲突场景）。close 不受影响（closeChatIdle 走
-    // doFinalizeRecord，泄漏的 worktree 由 reaper 兜底回收）。
-    record.hadWorktree = found.worktree === true;
-    // [v8.5 D] 透明重生回边：独立函数不走 tryTransition 单向语义（closed 单向性对正常
-    // 执行流完整保留）；准入唯一依据 = A 档 sidecar 真实死因 ∈ 可重连集。死亡语义位由
-    // resurrectClosed 清除；register 后立刻上报 transition entry，live/reload 视图同步
-    // 翻回 running（等价性由 applyEntry reducer 保证，对齐 SP-2 重建即报告先例）。
-    if (found.status !== "running") {
-      // [review MF-8] 磁盘终态位同步翻转：record-store buildRecord 分支 2（.finalized
-      // 存在 → closed）优先级高于 .alive 活态分支 3，重生若不删 sidecar，任何磁盘扫描
-      // （异进程 / reload / session-reader）都会把本进程内存里 running 的 record 报成
-      // closed/disconnected——破坏 live ≡ reload，且为跨进程二次 resurrect 开门。
-      // best-effort 对齐 BC-4 语义；.alive 刷新为当前进程（后续 resume spawn 会覆盖写）。
-      if (record.sessionFile) {
-        try {
-          fs.rmSync(`${record.sessionFile}.finalized`, { force: true });
-          writeAliveMarker(record.sessionFile, { pid: process.pid, id, startedAt: Date.now() });
-        } catch (_e) {
-          void _e; // best-effort：sidecar 翻转失败不阻断重生主流程
-        }
-      }
-      resurrectClosed(record);
-    }
-    this.store.register(record);
-    if (found.status !== "running") {
-      this.store.reportRecordTransition(record);
-    }
-    return record;
-  }
-
-  private coldLookupForAction(id: string, allowReconnect: boolean): ExecutionRecord | undefined {
-    const found = this.findColdLookupCandidate(id, allowReconnect);
-    if (!found) return undefined;
-    // [v8.5 D] 可重连候选的守卫先于任何状态突变与注册（细节见 assertReconnectAllowed）
-    this.assertReconnectAllowed(found, id);
-    // [review MF-9] 归属校验先于任何持久化副作用：coldLookup 是 getRecordForAction 的
-    // 内存未命中分支，若先 resurrect/register/report 再由调用方抛归属错误，会在磁盘/
-    // 内存留下幽灵 running record + running transition entry（跨进程双 resurrect 窗口）。
-    // rootSessionId 不匹配 → 返回 undefined，由 getRecordForAction 抛统一「not found or
-    // not owned」（不区分失败形态，防跨 session 探测）；parentRecordId 跨层不匹配 →
-    // 原样抛 direct parent 错误（与外层校验同文案，保留跨层导航指引）。
-    if (found.rootSessionId !== this.sessionRootId) {
-      return undefined;
-    }
-    const baselineRecordId = this.execCtxBaseline?.recordId ?? undefined;
-    if (found.parentRecordId !== baselineRecordId) {
-      throw new Error(
-        `subagent ${id} is owned by its direct parent; message it through that parent ` +
-        `(see /subagents list, parent=${found.parentRecordId ?? "(root layer)"}). [v4 A-5] cross-layer ` +
-        `ownership guard: this process's baseline=${baselineRecordId ?? "(root)"} is not the direct parent of ${id}; ` +
-        `operating here would race the owning child process's handle and double-write the session file.`,
-      );
-    }
-    return this.resurrectColdRecord(found, id);
-  }
-
-  /** [v8.5 D] 冷查候选过滤：closed 且死因落在可重连集。判定源 = closedReason（buildRecord
-   *  归一化后的对外字段：A 档真实死因直通、旧空 sidecar 兑底 disconnected——SubagentRecord
-   *  不暴露 raw finalizedReason）；cancelled/user-close/gc 等主动关闭与自然完成死因天然不在集合内。
-   *  防线在集合本身而非调用点。 */
-  private isReconnectableClosed(r: SubagentRecord): boolean {
-    return isReconnectableFinalReason(r.closedReason);
-  }
+  // [D4-③] 冷路径复活链（findColdLookupCandidate / assertReconnectAllowed /
+  // resurrectColdRecord / coldLookupForAction + isReconnectableClosed 判定）已整体
+  // 搬移至 cold-resurrect.ts（本类经 coldResurrectDeps 注入，行为逐字节等价）。
+  // SP-2 冷路径 [perf] 语义不变：idToFile 索引直查 → collectRecords 全扫兜底。
+  // [T5③ / PS-7b] running 候选异进程活实例守卫（findForeignLiveInstance 探针，
+  // ResurrectDeniedError）已随迁 cold-resurrect.ts 的 findColdLookupCandidate
+  //（与 closed 候选守卫 assertReconnectAllowed 对称）。
 
   /**
    * close action 的统一行为分流（running 子态 × force）。
@@ -1523,7 +1558,7 @@ export class SubagentService {
    * @param record 目标 record（getRecordForAction 已校验归属）
    * @param force true=立即终止（running 时 SIGTERM）/ false=优雅关闭（running 时等轮完）
    */
-  async closeSubagent(record: ExecutionRecord, force: boolean): Promise<void> {
+  private async closeSubagent(record: ExecutionRecord, force: boolean): Promise<void> {
     this.assertReady();
     if (record.status === "running") {
       if (force) {
@@ -1590,7 +1625,7 @@ export class SubagentService {
         store: this.store,
         modelService: this.modelService,
         pi: this.pi,
-        emitUnregister: (id, st) => emitPendingUnregister(this.pi, id, st),
+        emitUnregister: (id, st) => this.notifyHost.emitPendingUnregister(id, st),
         sessionDir: this.sessionsDir,
       },
       record,
@@ -1603,7 +1638,7 @@ export class SubagentService {
     // （P-1 修复），正文空由 notifyClosed 的 emptyBody 参数显式表达。
     // dedup 身份独立于轮次通知（notifyClosed 置 round=undefined），60s 窗内不被吞。
     // 防重入：closeSubagent 对 closed record 幂等 no-op，本路径不会被二次进入。
-    this.notifyClosed(record, true);
+    this.notifyHost.notifyClosed(record, true);
   }
 
   /**
@@ -1641,7 +1676,7 @@ export class SubagentService {
     await this.finalizeRecord(record, doneResult, "closed", "user-close");
     // [C-1] 终态通知（设计 D2 路径①）：与前置轮次通知（key=`id:round`）dedup 身份区分，
     // 「最后一轮轮次通知 + 终态通知」两条都送达父 agent。
-    this.notifyClosed(record);
+    this.notifyHost.notifyClosed(record);
   }
 
   // ── 编排层专用接口（workflow 消费）──────────────────────
@@ -1651,7 +1686,7 @@ export class SubagentService {
    *
    * 与 execute() 的区别（D-A1）：
    *   1. 返回 workflow AgentResult（content 字段），非 ExecutionHandle
-   *   2. 不调 kickOffBackground → 不注入 followUp 完成通知（BC-11，结果直接返回 workflow）
+   *   2. 不经 chat 轮次 kick-off（detached 回注）→ 不注入 followUp 完成通知（BC-11，结果直接返回 workflow）
    *   3. T2 删 sync 时 executeAndAwait 不受牵连（独立方法）
    *
    * 共享：runSpawn + ConcurrencyPool + record + pending emit（D-A4）。
@@ -1666,9 +1701,9 @@ export class SubagentService {
     // [T4② / PS-4] 与 execute() 同款入口校验（两入口共享 runAndFinalize → armIdleTimer 链）。
     this.assertIdleTimeoutMsSafe(opts);
 
-    // ── BC-12 嵌套护栏：复用 execute() 的 execCtxAls 深度检查 ──
-    // [ALS 断裂修复] getStore() 可能读空，基线兜底（与 execute 同）。
-    const parentNesting = this.execCtxAls.getStore() ?? this.execCtxBaseline;
+    // ── BC-12 嵌套护栏：复用 execute() 的嵌套上下文深度检查 ──
+    // [ALS 断裂修复] current() 内含基线兜底（与 execute 同）。
+    const parentNesting = this.execNesting.current();
     const nestingDepth = parentNesting ? parentNesting.depth + 1 : 0;
     if (nestingDepth > MAX_FORK_DEPTH) {
       throw new ForkDepthExceededError(
@@ -1681,7 +1716,7 @@ export class SubagentService {
 
     // ── 步骤 2: RECORD 创建（mode="background" 进池）──
     const record = this.createRecordForMode(identity, opts, "background");
-    emitPendingRegister(this.pi, record.id, record.agent);
+    this.notifyHost.emitPendingRegister(record.id, record.agent);
 
     // ── 步骤 2.5: worktree creation (only worktree===true; handle injection is execute()'s path) ──
     // Workflow path receives boolean only (AgentCallOpts.worktree: boolean) — WorktreeHandle is a
@@ -1764,59 +1799,138 @@ export class SubagentService {
   // ── 状态查询（TUI 调）──────────────────────────────────
 
   /** 订阅 store 变更（widget/list requestRender）。返回取消订阅。 */
-  onChange(listener: () => void): () => void {
+  private onChange(listener: () => void): () => void {
     return this.store.onChange(listener);
   }
 
-  /** 列出 running record 快照（widget 计数用）。 */
-  listRunning(): RecordSnapshot[] {
-    return this.store.listRunning();
-  }
+  // [D4] listRunning 已删除：零生产调用方（TUI 计数经 collectRecords / notify-host 的
+  // piAdapter 直调 store.listRunning 覆盖），唯一消费是初始空态单测——保留 store 层方法。
 
   /** 合并内存(running) + 磁盘(session.jsonl 重建) record（/subagents list + tool list 消费）。
    *  按 rootSessionId 过滤：根进程=本 session（sessionRootId===sessionId）；
    *  子进程=env 贯穿的真 ROOT（sessionRootId≠sessionId）→ 看到整棵 ROOT 树（决策 3）。
    *  [perf] 磁盘源为 light（头部 identity + 状态，无 eventLog/result/turns 等重数据）
    *  ——列表/补全/hasRunning 够用；详情场景调 getFullRecord(id) 懒加载补齐。 */
-  collectRecords(limit: number, statusFilter: StatusFilter = "all"): SubagentRecord[] {
+  private collectRecords(limit: number, statusFilter: StatusFilter = "all"): SubagentRecord[] {
     return this.store.collectRecords(limit, statusFilter, this.sessionRootId ?? this.sessionId ?? undefined);
   }
 
+  /**
+   * collectSync.default 当前生效值（subagent-sync-collect U2，偏差#3 接线：
+   * startHandler 缺省 collect 解析用）。
+   * config 未配/读失败 → DEFAULT_COLLECT_SYNC.default 兜底（E5 不炸启动）。
+   * 新 session 生效语义与 engine 配置一致（globalConfig 由 ModelConfigService
+   * reloadGlobalConfig 刷新）。
+   */
+  /** collectSync 节单读取点（S9，code-simplify）：「读节」一处，「投影成 default 或
+   *  budget」各自 accessor 负责（getCollectSyncDefault / getCollectSyncBudget）。 */
+  private collectSyncSection() {
+    return this.modelService.getGlobalConfig().collectSync;
+  }
+
+  getCollectSyncDefault(): "async" | "sync" {
+    return this.collectSyncSection()?.default ?? DEFAULT_COLLECT_SYNC.default;
+  }
+
   /** [perf] 单 record 详情懒加载（全量：eventLog/displayItems/result/turns/tokens）。
    *  内存 running record 直接投影；磁盘 record 全量重建（per-file 缓存，stat 戳校验）。
    *  返回 undefined：id 不存在于内存与磁盘。 */
-  getFullRecord(id: string): SubagentRecord | undefined {
+  private getFullRecord(id: string): SubagentRecord | undefined {
     return this.store.getFullRecord(id);
   }
 
   // ── 执行内部：身份解析 + record 创建 ──────────
 
-  /** 步骤 1：身份解析。agentConfig → resolveModel（三层：override → agentConfig → 主 agent model）。 */
-  private async resolveIdentity(opts: ExecuteOptions): Promise<ResolvedIdentity> {
+  /** 步骤 1：身份解析。agentConfig → resolveModel（三层：override → agentConfig → 主 agent model）。
+   *
+   * [u-h2] pi 未命中跨引擎候选（D2-4）：resolveModel 抛 notFoundError（pi registry
+   * 全等裁决未命中）时反查其他已注册引擎清单，唯一命中则追加「该 id 属于引擎 X」
+   * 候选段（场景 3）；其余裁决失败（孪生歧义/auth）与命中路径原样返回（零回归）。
+   * execute() 与 executeAndAwait() 两个派发路径共享本方法，故 chat 与 workflow 域的
+   * pi 校验同享场景 3 文案。
+   */
+  private async resolveIdentity(
+    opts: ExecuteOptions,
+    pre?: { agent: string; agentConfig: AgentConfig | undefined },
+  ): Promise<ResolvedIdentity> {
     // agentRef 语义（S2）：agent 参数 = .md 绝对路径；不传 = 不加载 agentConfig，
     // 直接用 override → 主 agent model。DEFAULT_AGENT_NAME 仅作 record 显示名
     // （TUI 层 extractAgentName 共用，保证显示一致）。
-    const agent = opts.agent ?? DEFAULT_AGENT_NAME;
+    const agent = pre?.agent ?? opts.agent ?? DEFAULT_AGENT_NAME;
     // 显式 agent ref（用户点名）失败必须报错，不静默降级：无 require 的 loadByPath
     // 对相对路径/裸名/文件缺失都返回 undefined → agentConfig undefined → resolveModel
     // 静默回落 override→主 agent model，用户拿到的 subagent 无 systemPrompt/工具白名单
     // 且零反馈。require:true 让失败抛出带 <available_subagents> 指引的错误（对齐
     // workflow name not found 反馈风格）；不传 agent = 默认 general-purpose 语义，
     // agentConfig 保持 undefined（合法缺省，走 override → ctxModel 兑底）。
-    const agentConfig = opts.agent
-      ? this.modelService.getRequiredAgentConfig(opts.agent)
-      : undefined;
-
-    const resolved = this.modelService.resolveModel(
-      opts.agent ?? "",
-      { model: opts.model, thinkingLevel: opts.thinkingLevel },
-      opts.ctxModel,
-      agentConfig,
-    );
+    // [u-h2 D2-1] execute() 已在路由前解析 agentConfig（pre 通道），此处复用不二次加载。
+    const agentConfig = pre
+      ? pre.agentConfig
+      : opts.agent
+        ? this.modelService.getRequiredAgentConfig(opts.agent)
+        : undefined;
+
+    let resolved: ResolvedModel;
+    try {
+      resolved = this.modelService.resolveModel(
+        opts.agent ?? "",
+        { model: opts.model, thinkingLevel: opts.thinkingLevel },
+        opts.ctxModel,
+        agentConfig,
+      );
+    } catch (err) {
+      throw withCrossEngineHint(err, listEngines(), (id) => {
+        try {
+          return getEngine(id);
+        } catch {
+          return undefined; // 清单快照与注册表并发变化的防御：取不到引擎按未注册处理
+        }
+      });
+    }
 
     return { agent, agentConfig, resolved };
   }
 
+  /**
+   * [u-h2 D2-1③] 非 pi 引擎的 identity 解析：跳过 pi registry 三层解析（ctxModel 主
+   * agent model 不透传——主 agent 的 pi id 对目标引擎大概率无效，缺省语义归引擎）。
+   *
+   * 逐层语义（设计 D2-1 归趋表）：
+   *   - model 源 = engineModel（调用参数 opts.model > agentConfig.model frontmatter，
+   *     agent 作者声明不忽略——配错在 validateModel 同步报错，不落引擎缺省静默续跑）；
+   *   - 无显式 model → 校验/留痕走引擎缺省（validateModel(undefined) 的 canonicalRef）；
+   *   - thinkingLevel 直接透传（引擎中立参数，不涉 registry）。
+   *
+   * 引擎未实现 validateModel 时 modelRef 原样透传（其 prepare 期校验兜底，现状语义）。
+   */
+  private resolveIdentityForEngine(
+    engine: EnginePort,
+    engineModel: string | undefined,
+    agent: string,
+    agentConfig: AgentConfig | undefined,
+    opts: ExecuteOptions,
+  ): ResolvedIdentity {
+    const canonical = validateModelForEngine(engine, engineModel);
+    // record.model 留痕：canonical（引擎裁决全名，含短名→缺省 provider 归一化）；
+    // 引擎未实现校验面且无显式 model 时为空串（记录形态退化，生产不可达——注册表
+    // 内非 pi 引擎均实现 validateModel；防御性拼接避免 throw 打断兜底语义）。
+    const modelStr = canonical ?? engineModel ?? "";
+    const slashIdx = modelStr.indexOf("/");
+    return {
+      agent,
+      agentConfig,
+      resolved: {
+        model: {
+          id: slashIdx > 0 ? modelStr.slice(slashIdx + 1) : "",
+          name: modelStr,
+          provider: slashIdx > 0 ? modelStr.slice(0, slashIdx) : modelStr,
+          reasoning: false,
+        },
+        thinkingLevel: opts.thinkingLevel ?? agentConfig?.thinkingLevel,
+      },
+    };
+  }
+
   /** 步骤 2：按 mode 生成 id + controller，创建 record 并注册。
    *  [L-1] ExecutionMode 类型固定 "background"（sync 已删除），id/controller 分支简化。 */
   private createRecordForMode(
@@ -1829,11 +1943,11 @@ export class SubagentService {
     const controller = new AbortController();
 
     // 从 async 调用链读父执行上下文：主 session 链上无 store → 顶层 record；
-    // B run() 期间包了 execCtxAls，B 内创建 C 时读到 B → C.parentRecordId=B.id, C.depth=B.depth+1。
+    // B run() 期间包了嵌套上下文，B 内创建 C 时读到 B → C.parentRecordId=B.id, C.depth=B.depth+1。
     // depth 语义：顶层（无父）=0；有父=父 depth+1。靠 recordId 是否存在区分，不用负数魔数。
-    // [ALS 断裂修复] getStore() 在 pi 事件回调模型下可能读空（enterWith 不贯穿），
-    // 基线兜底——本进程的身份在 initSession 已确定（env 注入），任何上下文下都能正确挂父链。
-    const parentCtx = this.execCtxAls.getStore() ?? this.execCtxBaseline;
+    // [ALS 断裂修复] current() 内含基线兜底——本进程的身份在 initSession 已确定（env 注入），
+    // 任何上下文下都能正确挂父链。
+    const parentCtx = this.execNesting.current();
     const parentRecordId = parentCtx?.recordId;
     const depth = parentCtx ? parentCtx.depth + 1 : 0;
 
@@ -1854,6 +1968,10 @@ export class SubagentService {
       // 从 RunContext 回填；缺省 = pi 投影，存量调用方零感知）
       engine: opts.engine,
       engineFallback: opts.engineFallback,
+      // subagent-sync-collect U2（偏差#4 接线）：sync record 落 collectMode——
+      // 协调器路由判据 + startHandler pendingSyncCount 枚举含本条的数据源。
+      // undefined = async（缺省语义，旧记录零迁移）。
+      collectMode: opts.collect === "sync" ? "sync" : undefined,
       controller,
     });
 
@@ -1871,70 +1989,113 @@ export class SubagentService {
   // ── 引擎分支（D4/D10：非 pi 引擎的 chat 域执行骨架，U0）──────────
 
   /**
-   * 路由到非 pi 引擎的执行入口：routeEngine（注册表校验 + probe/守卫）已由 execute
-   * 完成——这里只剩 unsupported 预检 → record 创建+盖章 → detached 引擎 run。
+   * chat 域统一执行入口（D2 单轨：全引擎——含 pi——经此进入 EnginePort）。路由
+   *（routeEngineForHost：三层 + pi 同步短路 + probe/守卫）已由 execute 完成——这里
+   * 只剩 unsupported 预检 → identity（pi 链解析 / 非 pi 按目标引擎校验，
+   * [u-h2 D2-1/D2-2]）→ record 创建+盖章 → worktree → detached 引擎 run。
    * 全部同步拒绝发生在 record 创建前（不产生孤儿 record）。
    */
-  private executeViaEngine(
+  private async executeViaEngine(
     opts: ExecuteOptions,
-    identity: ResolvedIdentity,
+    preIdentity: { agent: string; agentConfig: AgentConfig | undefined },
     route: EngineRouteResult,
-  ): ExecutionHandle {
+    mode: ExecutionMode,
+  ): Promise<ExecutionHandle> {
     const engine = route.engine;
-    this.assertEngineParamSupport(engine, opts);
-    // record 盖章路由结果（D5 仅 pi 缺省不盖章；非 pi 显式留痕，createRecordForMode
-    // 经 opts.engine/engineFallback 读入 record identity——engine 为实际执行引擎，
-    // fallback 路径 from=请求引擎留痕，probe 通过的常态路径恒缺省）
-    const record = this.createRecordForMode(
-      identity,
-      {
+    // [D3-④ 预检 capabilities 化] 唯一实现 = common/capability-gate（capabilities
+    // 驱动，含 maxTurns 扩位）。检查点钉死：execute/executeViaEngine 同步段、record
+    // 创建前（engine.capabilities() 同步可得）——承接「全部同步拒绝发生在 record
+    // 创建前、不产生孤儿 record」不变量（其后的 kickOffEngineRun 是 fire-and-forget，
+    // 检查若只落在 engine.run 内则拒绝异步化为「派发成功 + 静默失败 record」）。
+    assertTaskShapeSupported(engine.id, engine.capabilities(), opts);
+
+    // identity 按路由结果分支构造（[u-h2 D2-1] 路由先行）：
+    //   - pi：pi 链三层解析在路由后执行（现状三层解析链行为零变化；含 resolveModel
+    //     失败的跨引擎候选提示，D2-4）；
+    //   - 非 pi：跳过 pi registry，model 按目标引擎校验（同步期 throw，record 创建前
+    //     ——场景 2 错误；ctxModel 不透传，缺省语义归引擎，D2-1③）。
+    const isPiRoute = route.engineId === DEFAULT_ENGINE_ID;
+    // [u-h2 D2-1③] 非 pi 的 model 源 = 调用参数 > agent .md frontmatter（作者声明不
+    // 忽略）——frontmatter 声明须真正透传给引擎（taskSpec.model 消费 opts.model），
+    // 不能只进 record 留痕；无显式 model 时引擎落自身缺省（validateModel(undefined) 裁决）。
+    const engineModel = isPiRoute ? undefined : (opts.model ?? preIdentity.agentConfig?.model);
+    const identity = isPiRoute
+      ? await this.resolveIdentity(opts, preIdentity)
+      : this.resolveIdentityForEngine(engine, engineModel, preIdentity.agent, preIdentity.agentConfig, opts);
+
+    // record 盖章路由结果（D5 字节级守护的执行侧落点）：
+    //   - pi 纯缺省/显式 pi：不盖 engine 键（pi record entry 序列化产物不得新增 engine
+    //     键，undefined 经 JSON 省略）——与旧 pi 主路径 piOpts 剥离语义逐字节一致；
+    //   - pi 兜底：engine='pi' + engineFallback 留痕（engine = 实际执行引擎，from=请求
+    //     引擎留痕）；
+    //   - 非 pi：engine=route.engineId 显式留痕（+engineFallback 如有）+ model 覆写
+    //     （frontmatter 声明透传，u-h2 D2-1③）。
+    const recordOpts: ExecuteOptions = isPiRoute
+      ? route.engineFallback !== undefined
+        ? { ...opts, engine: DEFAULT_ENGINE_ID, engineFallback: route.engineFallback }
+        : opts.engine === undefined
+          ? opts
+          : { ...opts, engine: undefined }
+      : {
         ...opts,
+        ...(engineModel !== undefined ? { model: engineModel } : {}),
         engine: route.engineId,
         ...(route.engineFallback !== undefined ? { engineFallback: route.engineFallback } : {}),
-      },
-      "background",
-    );
-    emitPendingRegister(this.pi, record.id, record.agent);
-    this.kickOffEngineRun(record, opts, engine);
-    return { mode: "background", subagentId: record.id, sessionFile: record.sessionFile, details: project(record) };
-  }
+      };
+    const record = this.createRecordForMode(identity, recordOpts, mode);
+    this.notifyHost.emitPendingRegister(record.id, record.agent);
 
-  /**
-   * 非 pi 引擎的 unsupported 参数预检（D11 处置「调用前拒绝」的判据 = capabilities）。
-   * conversation / fork / worktree 三参数对首期接入的引擎（zcode）均不可用：
-   * conversation 依赖同进程 idle 复用、fork 依赖父 pi session 上下文继承、worktree 依赖
-   * 文件隔离（capabilities.sandbox='none'）。同步 throw，文案含 capabilities 依据与恢复指引。
-   */
-  private assertEngineParamSupport(engine: EnginePort, opts: ExecuteOptions): void {
-    const caps = engine.capabilities();
-    if (opts.conversation === true && caps.conversation === "unsupported") {
-      throw new EngineError(
-        "engine_capability_unsupported",
-        `engine '${engine.id}' 不支持 conversation（capabilities.conversation = 'unsupported'，` +
-          `spawn 单轮模式无同进程 idle 复用，message/close 交互控制面不可用）`,
-        `改用 engine: pi（支持 conversation 续聊），或不传该参数（一次性任务默认形态）`,
-      );
-    }
-    if (opts.fork === true || opts.forkFromSessionFile !== undefined) {
-      throw new EngineError(
-        "engine_capability_unsupported",
-        `engine '${engine.id}' 不支持 fork${opts.forkFromSessionFile !== undefined ? "（fork-from 同为父 pi session 上下文继承）" : ""}（fork 依赖父 pi session 上下文继承，` +
-          `capabilities.steer = '${caps.steer}'——非 pi 引擎无父 session 分叉通道）`,
-        `把所需父上下文写进 task 正文后不传 fork，或改用 engine: pi`,
-      );
+    // ── worktree 创建（仅 worktree===true 或已传入 handle 时）──
+    // record 先创建，worktree 失败时可 finalizeFailed（record 已在 store 中）。
+    // worktree 必须显式开启：worktree===true 创建新 worktree；worktree===undefined/false 不创建。
+    // fork 不隐含 worktree（UC-1 fork 可独立使用，fork 仅继承上下文，在 parent cwd 跑）。
+    // 非 pi 引擎带 worktree 已被上方预检同步拒绝（caps.sandbox='none'），此段实际仅
+    // sandbox 能力引擎（pi：caps.sandbox='emulated'）可达。
+    let worktreeHandle: WorktreeHandle | undefined;
+    if (typeof opts.worktree === "object") {
+      // 传入的是已创建的 WorktreeHandle
+      worktreeHandle = opts.worktree;
+    } else if (opts.worktree === true) {
+      // worktree===true（显式要求）——创建新 worktree。与 fork 正交（worktree 文件隔离不依赖 fork 上下文继承）。
+      try {
+        worktreeHandle = await this.worktreeManager.create(this.cwd, record.id);
+        record.worktreeHandle = worktreeHandle;
+        // [create-await 竞态守卫] create 的 await 窗口内 cancel/dispose 可 CAS 把 record
+        // 转成 closed 终态——cancelBackground 当时读到的 worktreeHandle 可能仍是 undefined
+        // （cleanup 被跳过）。赋值后同同步段检查终态：closed 则主动 cleanup（幂等，抢先的
+        // fire-and-forget 清理无害）+ early-failed 返回，不进轮次 kick-off（避免子进程白跑）。
+        // 实现约束：赋值 → 终态检查 → kick-off 必须在同一同步段，中间禁止插入 await。
+        if (record.status === "closed") {
+          await this.worktreeManager.cleanup(worktreeHandle);
+          return this.buildEarlyFailedHandle(record);
+        }
+      } catch (err) {
+        // create 失败→不进入 run，finalizeFailed 统一收尾（含 emitPendingUnregister failed）
+        const _result = await this.finalizeFailed(record, err);
+        return this.buildEarlyFailedHandle(record);
+      }
     }
-    if ((opts.worktree === true || typeof opts.worktree === "object") && caps.sandbox === "none") {
-      throw new EngineError(
-        "engine_capability_unsupported",
-        `engine '${engine.id}' 不支持 worktree 隔离（capabilities.sandbox = 'none'，` +
-          `引擎未接文件系统隔离层）`,
-        `改用 engine: pi（worktree 隔离可用），或不传该参数（在 parent cwd 执行）`,
+
+    if (isPiRoute) {
+      // pi：record 耦合执行（runSpawn 直驱 record 记账）——预备轮次经 EnginePort 交接
+      //（kickOffChatRound），编排收尾（notify/终态迁移）与旧 pi 主路径语义一致。
+      this.kickOffChatRound(
+        record,
+        { ...recordOpts, worktree: worktreeHandle },
+        identity,
+        this.buildSessionRunnerContext(opts.cwd),
+        record.controller!.signal,
+        PRIORITY_BACKGROUND,
       );
+    } else {
+      // 非 pi 引擎：engine.run 自足执行（handle+outcome），编排侧 journal 接线 + 终态迁移
+      this.kickOffEngineRun(record, recordOpts, engine);
     }
+    return { mode: "background", subagentId: record.id, sessionFile: record.sessionFile, details: project(record) };
   }
 
   /**
-   * 非 pi 引擎的 detached 执行编排（与 kickOffBackground 同构的 background 语义）：
+   * 非 pi 引擎的 detached 执行编排（与 pi 轮次 kick-off 同构的 background 语义）：
    * pool 并发槽（maxConcurrent 对非 pi 引擎同样生效）→ journal 接线（D6 第②级：
    * taskId=record.id，初始池 key 占位 'shared'，onPoolResolved retarget 到引擎实际
    * 池 key——路径与 paths.ts 同源推导）→ engine.run（signal 接 record controller，
@@ -1962,7 +2123,7 @@ export class SubagentService {
         await this.runEngineTask(record, opts, engine, signal);
         // cancel 抢先（closedReason='cancelled'）时 cancelBackground 自己 notify，跳过
         if (record.closedReason !== "cancelled") {
-          this.notifyComplete(record);
+          this.collectCoordinator.route(record);
         }
       } finally {
         this.pool.release();
@@ -1974,7 +2135,7 @@ export class SubagentService {
    * kickOffEngineRun 的 acquire 后主体：journal 接线（D6 第②级：taskId=record.id，
    * 初始池 key 占位 'shared'，onPoolResolved retarget 到引擎实际池 key）→ engine.run
    * （signal 接 record controller，kill-chain 两级生效）→ engineHandle 回填（终态迁移
-   * 落 entry 前）→ 终态迁移。bg notify 归编排侧（与 kickOffBackground 收尾通知归编排对称）。
+   * 落 entry 前）→ 终态迁移。bg notify 归编排侧（与 pi 轮次收尾通知归编排对称）。
    */
   private async runEngineTask(
     record: ExecutionRecord,
@@ -1982,20 +2143,16 @@ export class SubagentService {
     engine: EnginePort,
     signal: AbortSignal | undefined,
   ): Promise<void> {
-    const journal = new JournalWriter({
-      path: resolveJournalPath(getEngineDataDir(), engine.id, "shared", record.id),
-      taskId: record.id,
-      engineId: engine.id,
-    });
-    const retargetJournal = (poolKey: string): void => {
-      journal.retarget(resolveJournalPath(getEngineDataDir(), engine.id, poolKey, record.id));
-    };
+    // [D3-③ journal 接线合一] writer + retarget + 路径权威收敛 common/journal-wiring
+    //（与 SAR 同一实现）。chat 域无下游 onEvent 消费者——journal 是事件唯一出口，
+    // 不传 forwardEvents。
+    const journal = wireEventJournal({ engineId: engine.id, taskId: record.id });
     // [R4 §3.4 不变量 3] 运行中句柄回填：create 应答后（远早于 run resolve）回填
     // record.engineHandle 并经 reportRecordTransition 落 entry——运行中的 GUI 经 entry
     // 重建 record 即拿到 ①②级读取钥匙（sessionRef/dbPath/poolKey/journalPath），
     // 不再等终态回填（详情页中途打开可见当时进度快照）。journalPath 此时已是
-    // retarget 后的最终路径（onPoolResolved 在 prepare 期先行触发）。仅 chat 域接线
-    // ——workflow 域 SAR 无运行中 record 读取方，刻意不做同类回填（防误扩展）。
+    // retarget 后的最终路径（onPoolResolved 在 prepare 期先行触发，writer 是路径权威）。
+    // 仅 chat 域接线——workflow 域 SAR 无运行中 record 读取方，刻意不做同类回填（防误扩展）。
     const backfillEngineHandle = (partial: { sessionRef: Record<string, string>; poolKey: string }): void => {
       if (record.engineHandle !== undefined && record.engineHandle.sessionRef["sessionId"] !== undefined) {
         return; // 幂等守卫：终态回填已落（迟到重复回调不覆盖）
@@ -2008,14 +2165,15 @@ export class SubagentService {
       this.store.reportRecordTransition(record);
     };
     // 对齐点③：journal 路径权威 = 引擎声明的池 key（writer 初始用占位，retarget 后
-    // 与 handle.poolKey 同源）。模式对齐 SAR 的 journalingOnEvent：先落盘再转发。
+    // 与 handle.poolKey 同源）。
     const runCtx: RunContext = {
       taskId: record.id,
-      poolKey: "shared",
+      poolKey: JOURNAL_INITIAL_POOL_KEY,
       signal,
       ctxModel: opts.ctxModel,
-      onEvent: (event) => journal.append(event),
-      onPoolResolved: retargetJournal,
+      onEvent: journal.onEvent,
+      onPoolResolved: journal.onPoolResolved,
+      // [R4 §3.4 不变量 3] 运行中句柄回填通道（engine/port.ts RunContext.onHandleReady）
       onHandleReady: backfillEngineHandle,
       // D9①：路由层 fallback 留痕投影进 outcome（zcode 无独立 record 通路）
       ...(record.engineFallback !== undefined ? { engineFallback: record.engineFallback } : {}),
@@ -2090,17 +2248,14 @@ export class SubagentService {
     /** resume 选项（M2-B1）：透传 runSpawn，重开已 idle 的 session 续聊。undefined = 新 session。 */
     resume?: SpawnResumeOpts,
   ): Promise<AgentResult> {
+    // [U04 阶段化提取] 主函数只留编排，按「装配（池槽/worktree/深度）→ 执行（ALS 包装
+    // spawn）→ 回收（finally）→ 错误收口 → 终态收口」分段；行为逐字节不变。
     const pooled = record.mode === "background";
     let acquired = false;
     if (pooled) {
-      try {
-        await this.pool.acquire(priority, this.effectiveMaxConcurrentFor(record), signal);
-        acquired = true;
-      } catch {
-        // S1: 排队中被 abort（signal.aborted）走 cancelled，与已运行被 abort 一致。
-        if (signal?.aborted) return this.finalizeAborted(record);
-        return this.finalizeFailed(record, new Error("aborted"));
-      }
+      const acquireFailure = await this.acquirePoolOrFinalize(record, signal, priority);
+      if (acquireFailure !== undefined) return acquireFailure;
+      acquired = true;
     }
     // onEvent 直通（原此处曾有 onUpdate(project(record)) 节流回流包装——生产死路径，
     // 三调用点恒 onUpdate: undefined、仅测试触达，已按 swf-perf-impl ledger #22 删除
@@ -2108,78 +2263,24 @@ export class SubagentService {
     // ExecuteOptions.onUpdate 字段一并删除，未来误用将编译期失败而非静默无效。
     const onEvent = rawOnEvent;
 
-    // 解析 worktree 参数：boolean → WorktreeHandle | undefined（true/undefined 由 run 内部处理）
-    let worktreeHandle: WorktreeHandle | undefined;
-    if (typeof opts.worktree === "object") {
-      worktreeHandle = opts.worktree;
-    }
-    // [MF#4][MF#2] fork 深度护栏：ALS 传递深度（主 session 链无 store→0，fork 推进 +1）。
-    const parentDepth = this.forkDepthAls.getStore() ?? this.forkDepthBaseline;
-    const effectiveDepth = opts.fork ? parentDepth + 1 : parentDepth;
+    const worktreeHandle = this.resolveWorktreeHandle(opts);
+    const { parentDepth, effectiveDepth } = this.resolveForkDepths(opts);
 
     let result: AgentResult;
     try {
-      // execCtxAls 包在 forkDepthAls 内层：B run() 期间它的 store={recordId:B.id,depth:B.depth}，
-      // B 内创建 C 时 createRecordForMode 读到 B → C 挂到 B 名下。两层 ALS 独立但同生命周期。
-      result = await this.forkDepthAls.run(effectiveDepth, () =>
-        this.execCtxAls.run(
-          { recordId: record.id, depth: record.depth },
-          () => runSpawn(record, opts.task, {
-            resolved: identity.resolved,
-            agentConfig: identity.agentConfig,
-            appendSystemPrompt: opts.appendSystemPrompt,
-            skillPath: opts.skillPath,
-            schema: opts.schema,
-            schemaEnv: opts.schemaEnv, // D-A6 bridge: workflow 编排层透传 schema 到 childEnv
-            maxTurns: opts.maxTurns,
-            graceTurns: opts.graceTurns,
-            signal,
-            onEvent,
-            stream, // text_delta streaming（background 路径有值，workflow 路径 undefined）
-            fork: opts.fork,
-            // [v8.5 B] fork-from 显式源（ExecuteOptions.forkFromSessionFile）优先于
-            // opts.fork 推导的 mainSessionFile；undefined = 旧语义不变。
-            forkSource: opts.forkFromSessionFile,
-            worktree: worktreeHandle,
-            parentForkDepth: parentDepth, // [MF#4] 父链深度，不从 opts 读
-          }, ctx, resume),
-        ),
+      result = await this.runSpawnNested(
+        record, opts, ctx, identity, signal, onEvent, stream, resume,
+        worktreeHandle, parentDepth, effectiveDepth,
       );
     } catch (err) {
       // run() 正常路径不抛错，但创建期异常（createAndConfigureSession 失败）
       // 会逃逸出 run() —— 合成 failed result + 收尾。
       // swallow（不 re-throw）：sync 调用方拿到合成 failed result，background 的
       // .then 正常跑 notify。避免异常逃逸到 tool 层 + record 卡 running。
-      //
-      // MF-6（决策 6 spec §3.1）：chatMode（含 resume）spawn/创建失败不销毁对话——回退 idle
-      //（可恢复），让 agent 可重试 message 或 close。与一次性模式（finalizeFailed 终态销毁）区分。
-      if (record.chatMode) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        const failedResult: AgentResult = {
-          text: "",
-          turns: record.turnCount,
-          durationMs: Date.now() - record.startedAt,
-          success: false,
-          error: errMsg,
-          sessionId: record.id,
-          toolCalls: [],
-        };
-        if (tryTransition(record, "closed", "gc")) {
-          // 回退 idle（record.result 由 finalizeRoundToIdle 设为 error 兜底文本，notify 可读）。
-          await this.finalizeRoundToIdle(record, failedResult);
-        }
-        return failedResult;
-      }
-      result = await this.finalizeFailed(record, err);
-      return result;
+      if (record.chatMode) return this.finalizeChatSpawnFailure(record, err);
+      return this.finalizeFailed(record, err);
     } finally {
-      if (pooled && acquired) this.pool.release();
-      // 清除 streaming widget（subagent 终态，幂等）
-      stream?.dispose();
-      // [review MF1] 清除在途 resume 守卫（幂等）：本轮收尾——无论轮次完成（early return）、
-      // MF-6 失败回退 resumable、abort 还是终态化，record 都可再次接受冷路径 message。
-      // execute() 新建 record 不在集合，delete 是 no-op。
-      this.resumesInFlight.delete(record.id);
+      this.releaseRoundResources(record, pooled && acquired, stream);
     }
 
     // [V2 决策 2/3] chatMode 首轮闭环：runSpawn 因 agent_settled 提前 resolve（onRoundSettled
@@ -2187,97 +2288,320 @@ export class SubagentService {
     // 不进下方 chatMode 分流（那是 close 后 done/failed/cancelled 终态化的，走 finalizeRoundToIdle
     // / finalizeRecord）。tryTransition(idle→done) 天然失败（要求 status==="running"），此处显式
     // early return 让语义清晰 + 防状态机未来改动。防 double-notify 由 notifier dedup 兜底
-    //（同 id:round 60s 内吞，kickOffBackground.then 的 notify 是 no-op，见 notifier.ts L122）。
+    //（同 id:round 60s 内吞，chat 轮次收尾 .then 的 notify 是 no-op，见 notifier.ts L122）。
     if (record.chatMode && isIdle(record)) {
       return result;
     }
 
     // v4 B-1: status 恒为 closed。cancelled 折入 closed（closedReason='cancelled'）。
     const aborted = signal?.aborted === true;
-    // closedReason 派生：aborted → cancelled；否则 success → user-close，!success → gc。
-    const closedReason: ClosedReason = aborted ? "cancelled" : result.success ? "user-close" : "gc";
-
-    // CAS 抢锁：抢到则完整收尾；没抢到（cancel 已先设 closed+cancelled）则跳过
-    if (tryTransition(record, "closed", closedReason)) {
-      if (record.chatMode && !aborted && result.success) {
-        if (record.closeAfterRound) {
-          // close 优雅关闭（force:false）：当前轮完成后终态化为 closed。
-          record.closeAfterRound = undefined;
-          await this.finalizeRecord(record, result, "closed", "user-close");
-        } else {
-          // 对话模式轮次成功完成 → 保持 running（旧 idle 折入 running，finalizeRoundToIdle 设回 running）。
-          await this.finalizeRoundToIdle(record, result);
-        }
-      } else if (record.chatMode && (!result.success || aborted)) {
-        // MF-6：chatMode 轮次失败/取消不销毁对话——回退 running-resumable（旧 idle，可恢复）。
-        if (record.closeAfterRound) {
-          // [M5] 优雅关闭挂起的失败/取消轮：轮已完成即兑现 close 意图终态化（含本轮 result），
-          // 不再回退 resumable——否则标志残留到下一轮，record 已被 tool 谎报 closed。
-          record.closeAfterRound = undefined;
-          await this.finalizeRecord(record, result, "closed", closedReason);
-        } else {
-          await this.finalizeRoundToIdle(record, result);
-        }
-      } else if (!record.chatMode && !aborted && result.success) {
-        if (record.closeAfterRound) {
-          // [M5] 非 chatMode（one-shot）busy 时 close(force:false) 置的标志在本轮完成时消费
-          // 终态化（对齐 close schema 文案 "release its resources"）。旧代码走
-          // finalizeRoundToIdle 不消费——tool 返回 {closed:true} 谎报，record 永久
-          // running-resumable、5min idle timer 杀进程、期间还能继续收 message。
-          record.closeAfterRound = undefined;
-          await this.finalizeRecord(record, result, "closed", "user-close");
-        } else {
-          // [SP-5] one-shot 成功完成 → 保持 running（旧 idle），等待 message 触发 upgrade。
-          await this.finalizeRoundToIdle(record, result);
-        }
+    await this.settleFinalOutcome(record, result, aborted, this.deriveClosedReason(aborted, result.success));
+    return result;
+  }
+
+  /** [U04 提取·装配] 池槽获取：pooled（background）record 排队 acquire。成功返回 undefined
+   *  继续执行；失败返回终态 result 供调用方 early-return（该路径在 try/finally 之前，
+   *  不触发轮次资源回收——与原控制流逐字节一致）。 */
+  private async acquirePoolOrFinalize(
+    record: ExecutionRecord,
+    signal: AbortSignal | undefined,
+    priority: number,
+  ): Promise<AgentResult | undefined> {
+    try {
+      await this.pool.acquire(priority, this.effectiveMaxConcurrentFor(record), signal);
+    } catch {
+      // S1: 排队中被 abort（signal.aborted）走 cancelled，与已运行被 abort 一致。
+      if (signal?.aborted) return this.finalizeAborted(record);
+      return this.finalizeFailed(record, new Error("aborted"));
+    }
+    return undefined;
+  }
+
+  /** [U04 提取·装配] 解析 worktree 参数：boolean → WorktreeHandle | undefined（true/undefined 由 run 内部处理）。 */
+  private resolveWorktreeHandle(opts: ExecuteOptions): WorktreeHandle | undefined {
+    return typeof opts.worktree === "object" ? opts.worktree : undefined;
+  }
+
+  /** [U04 提取·装配] [MF#4][MF#2] fork 深度护栏：ALS 传递深度（主 session 链无 store→0，fork 推进 +1）。 */
+  private resolveForkDepths(opts: ExecuteOptions): { parentDepth: number; effectiveDepth: number } {
+    const parentDepth = this.forkDepthAls.getStore() ?? this.forkDepthBaseline;
+    const effectiveDepth = opts.fork ? parentDepth + 1 : parentDepth;
+    return { parentDepth, effectiveDepth };
+  }
+
+  /** [U04 提取·执行] runSpawn 的两层 ALS 包装（forkDepthAls 外层 + execNesting 内层）。 */
+  private runSpawnNested(
+    record: ExecutionRecord,
+    opts: ExecuteOptions,
+    ctx: SessionRunnerContext,
+    identity: ResolvedIdentity,
+    signal: AbortSignal | undefined,
+    onEvent: ((event: AgentEvent) => void) | undefined,
+    stream: SubagentStream | undefined,
+    resume: SpawnResumeOpts | undefined,
+    worktreeHandle: WorktreeHandle | undefined,
+    parentDepth: number,
+    effectiveDepth: number,
+  ): Promise<AgentResult> {
+    // 嵌套上下文包在 forkDepthAls 内层：B run() 期间挂 {recordId:B.id,depth:B.depth}，
+    // B 内创建 C 时 createRecordForMode 读到 B → C 挂到 B 名下。两层 ALS 独立但同生命周期。
+    return this.forkDepthAls.run(effectiveDepth, () =>
+      this.execNesting.run(
+        { recordId: record.id, depth: record.depth },
+        () => runSpawn(record, opts.task, {
+          resolved: identity.resolved,
+          agentConfig: identity.agentConfig,
+          appendSystemPrompt: opts.appendSystemPrompt,
+          skillPath: opts.skillPath,
+          schema: opts.schema,
+          schemaEnv: opts.schemaEnv, // D-A6 bridge: workflow 编排层透传 schema 到 childEnv
+          maxTurns: opts.maxTurns,
+          graceTurns: opts.graceTurns,
+          signal,
+          onEvent,
+          stream, // text_delta streaming（background 路径有值，workflow 路径 undefined）
+          fork: opts.fork,
+          // [v8.5 B] fork-from 显式源（ExecuteOptions.forkFromSessionFile）优先于
+          // opts.fork 推导的 mainSessionFile；undefined = 旧语义不变。
+          forkSource: opts.forkFromSessionFile,
+          worktree: worktreeHandle,
+          parentForkDepth: parentDepth, // [MF#4] 父链深度，不从 opts 读
+        }, ctx, resume),
+      ),
+    );
+  }
+
+  /** [U04 提取·回收] 轮次资源回收（finally 语义，幂等）：池槽归还（仅 pooled 且 acquire
+   *  成功）、streaming widget 清除、在途 resume 守卫清除。 */
+  private releaseRoundResources(
+    record: ExecutionRecord,
+    holdSlot: boolean,
+    stream: SubagentStream | undefined,
+  ): void {
+    if (holdSlot) this.pool.release();
+    // 清除 streaming widget（subagent 终态，幂等）
+    stream?.dispose();
+    // [review MF1] 清除在途 resume 守卫（幂等）：本轮收尾——无论轮次完成（early return）、
+    // MF-6 失败回退 resumable、abort 还是终态化，record 都可再次接受冷路径 message。
+    // execute() 新建 record 不在集合，delete 是 no-op。
+    this.resumesInFlight.delete(record.id);
+  }
+
+  /** [U04 提取·错误收口] MF-6（决策 6 spec §3.1）：chatMode（含 resume）spawn/创建失败
+   *  不销毁对话——回退 idle（可恢复），让 agent 可重试 message 或 close。与一次性模式
+   *  （finalizeFailed 终态销毁）区分。返回合成 failed result（swallow，不 re-throw）。 */
+  private async finalizeChatSpawnFailure(record: ExecutionRecord, err: unknown): Promise<AgentResult> {
+    const errMsg = toErrorMessage(err);
+    const failedResult: AgentResult = {
+      text: "",
+      turns: record.turnCount,
+      durationMs: Date.now() - record.startedAt,
+      success: false,
+      error: errMsg,
+      sessionId: record.id,
+      toolCalls: [],
+    };
+    if (tryTransition(record, "closed", "gc")) {
+      // 回退 idle（record.result 由 finalizeRoundToIdle 设为 error 兜底文本，notify 可读）。
+      await this.finalizeRoundToIdle(record, failedResult);
+    }
+    return failedResult;
+  }
+
+  /** [U04 提取·收口派生] closedReason 派生：aborted → cancelled；否则 success → user-close，!success → gc。 */
+  private deriveClosedReason(aborted: boolean, success: boolean): ClosedReason {
+    return aborted ? "cancelled" : success ? "user-close" : "gc";
+  }
+
+  /** [U04 提取·终态收口] CAS 抢锁：抢到则按 chatMode 分流完整收尾；没抢到（cancel 已先设
+   *  closed+cancelled）则跳过。 */
+  private async settleFinalOutcome(
+    record: ExecutionRecord,
+    result: AgentResult,
+    aborted: boolean,
+    closedReason: ClosedReason,
+  ): Promise<void> {
+    if (!tryTransition(record, "closed", closedReason)) return;
+    if (record.chatMode) {
+      await this.settleChatRoundOutcome(record, result, aborted, closedReason);
+    } else {
+      await this.settleOneShotOutcome(record, result, aborted, closedReason);
+    }
+  }
+
+  /** [U04 提取·终态收口] chatMode 轮次分流（原 A/B 分支，De Morgan 等价拆分）：
+   *  成功轮（!aborted && success）与失败/取消轮（其补集 !success || aborted）各自处理
+   *  closeAfterRound 挂起语义。 */
+  private async settleChatRoundOutcome(
+    record: ExecutionRecord,
+    result: AgentResult,
+    aborted: boolean,
+    closedReason: ClosedReason,
+  ): Promise<void> {
+    if (!aborted && result.success) {
+      if (record.closeAfterRound) {
+        // close 优雅关闭（force:false）：当前轮完成后终态化为 closed。
+        await this.consumeCloseAfterRound(record, result, "user-close");
       } else {
-        // 非 chatMode 失败/取消 或其他终态：一次性销毁（archive + worktree cleanup）。
-        await this.finalizeRecord(record, result, "closed", closedReason);
+        // 对话模式轮次成功完成 → 保持 running（旧 idle 折入 running，finalizeRoundToIdle 设回 running）。
+        await this.finalizeRoundToIdle(record, result);
+      }
+    } else {
+      // MF-6：chatMode 轮次失败/取消不销毁对话——回退 running-resumable（旧 idle，可恢复）。
+      if (record.closeAfterRound) {
+        // [M5] 优雅关闭挂起的失败/取消轮：轮已完成即兑现 close 意图终态化（含本轮 result），
+        // 不再回退 resumable——否则标志残留到下一轮，record 已被 tool 谎报 closed。
+        await this.consumeCloseAfterRound(record, result, closedReason);
+      } else {
+        await this.finalizeRoundToIdle(record, result);
       }
     }
-    return result;
   }
 
-  /** background 的步骤 4-6：包进 detached promise（不 await），execute 立即返回。 */
-  private kickOffBackground(
+  /** [U04 提取·终态收口] one-shot（非 chatMode）分流（原 C/D 分支）：成功轮消费
+   *  closeAfterRound 挂起标志；失败/取消一次性销毁。 */
+  private async settleOneShotOutcome(
+    record: ExecutionRecord,
+    result: AgentResult,
+    aborted: boolean,
+    closedReason: ClosedReason,
+  ): Promise<void> {
+    if (!aborted && result.success) {
+      if (record.closeAfterRound) {
+        // [M5] 非 chatMode（one-shot）busy 时 close(force:false) 置的标志在本轮完成时消费
+        // 终态化（对齐 close schema 文案 "release its resources"）。旧代码走
+        // finalizeRoundToIdle 不消费——tool 返回 {closed:true} 谎报，record 永久
+        // running-resumable、5min idle timer 杀进程、期间还能继续收 message。
+        await this.consumeCloseAfterRound(record, result, "user-close");
+      } else {
+        // [SP-5] one-shot 成功完成 → 保持 running（旧 idle），等待 message 触发 upgrade。
+        await this.finalizeRoundToIdle(record, result);
+      }
+    } else {
+      // 非 chatMode 失败/取消 或其他终态：一次性销毁（archive + worktree cleanup）。
+      await this.finalizeRecord(record, result, "closed", closedReason);
+    }
+  }
+
+  /** [U04 提取·终态收口] closeAfterRound 挂起标志消费（原三处分支的公共收尾序列）：
+   *  清标志 + 终态化 closed。reason：成功轮恒 user-close；失败/取消轮用派生值。 */
+  private async consumeCloseAfterRound(
+    record: ExecutionRecord,
+    result: AgentResult,
+    reason: ClosedReason,
+  ): Promise<void> {
+    record.closeAfterRound = undefined;
+    await this.finalizeRecord(record, result, "closed", reason);
+  }
+
+  /**
+   * pi chat 域轮次的 detached 编排（D2 单轨——旧 pi 主路径绕过 EnginePort 的 detached
+   *  编排删除后的 EnginePort 化形态）：
+   * 预备轮次（record/opts/identity/host ctx/stream/resume）挂载交接 Map → engine.run 经
+   * ctx.taskId 消费（PiEngine chat 分支回调 runChatRound——即 runAndFinalize 链，含 pool
+   * 并发槽 acquire/release 与杀链，行为零变化）→ 完成回注 notify（cancel 抢先时跳过，
+   * 与旧 .then 语义一致）。
+   * stream 在挂载前同步创建（spawn 前置不变量，stream-sink 退役步骤 2 守护）。
+   * chat 域不接 event journal（pi 子代理 session JSONL 即原生数据源；与迁移前产物
+   * 形态一致——journal 接线仅 workflow 域 SAR 与非 pi 引擎 chat 路径）。
+   */
+  private kickOffChatRound(
     record: ExecutionRecord,
     opts: ExecuteOptions,
-    ctx: SessionRunnerContext,
     identity: ResolvedIdentity,
+    ctx: SessionRunnerContext,
     signal: AbortSignal | undefined,
     priority: number,
-    /** resume 选项（M2-B1）：透传 runAndFinalize→runSpawn。undefined = 新 session。 */
+    /** resume 选项（M2-B1）：透传轮次执行→runSpawn。undefined = 新 session。 */
     resume?: SpawnResumeOpts,
   ): void {
     // 创建 streaming 生命周期对象。策略（含 widget 退役步骤 2：GUI + relay 激活时停发
     // 私货、TUI/未激活原样创建、sink 未注入降级 undefined）集中在 createBackgroundStream。
     const stream = createBackgroundStream(record.id, this.streamSink, ctx.mode, process.env);
 
-    void this.runAndFinalize(
-      record, opts, ctx, identity, signal, priority,
-      undefined, stream, resume,
-    )
+    this.chatRoundTickets.set(record.id, { record, opts, identity, ctx, signal, priority, stream, resume });
+    void this.chatPiEngine
+      .run(
+        // task 形参仅满足 port 签名——chat 轮次由 ticket lossless 携带
+        //（identity/forkFromSessionFile/host ctx 是 host 编排件，不入任务声明
+        // AgentCallOpts——[u-3b D6] 双形态保留的结构性裁决见 ChatRoundTicket 注释）
+        executeOptionsToEngineTaskSpec(opts),
+        { taskId: record.id, poolKey: PI_POOL_KEY, signal, stream },
+      )
       .then(() => {
         // background 回注：仅当本路径抢到 CAS 才 notify。cancel 抢先时 closedReason=
         // 'cancelled'（cancelBackground 自己 notify）；[T4①/PS-2] parent-new/parent-fork
         // 是 disposeAllRecords 的编排性关闭（record 已关、告知由 list 的 closedReason
         // 表达）——迟到的完成回注不注入（可能已切换的）新 session。
         if (notifyGateAllowsDelivery(record.closedReason)) {
-          this.notifyComplete(record);
+          this.collectCoordinator.route(record);
         }
       })
       .catch((err: unknown) => {
-        // detached 吞错：runAndFinalize 内部已 finalize record（含 emitPendingUnregister），
+        // detached 吞错：轮次执行内部已 finalize record（含 emitPendingUnregister），
         // 且 finalizeRecord 的 manifest 写入已降级为 best-effort（失败仅 logger.error + appendEntry，
         // 不外抛）。因此此处不应走到——但作为最后一道兼底，记录调试日志后吞下，不外抛。
         // 完成通知由 finalizeRecord 内的 emitPendingUnregister 承担（pending-notifications 消费）。
         // cancel 抢先时 status=cancelled，cancelBackground 自己 emit，此处无需重复。
+        // 交接包未被消费（engine.run 前置 throw 的极端形态）时的泄漏兜底。
+        this.chatRoundTickets.delete(record.id);
         if (err instanceof Error) {
           logger.debug(`[subagent] background finalize error (record=${record.id}): ${err.message}`);
         }
       });
   }
 
+  /** PiEngine 的编排服务适配器（chat 绑定）：闭包持有本实例的编排面——chat 轮次交接
+   *  由此成为 PiEngineService 的可选面（SAR 直绑 Service 的 workflow 实例不提供，
+   *  Service 公共接口不为引擎内部交接扩面）。 */
+  private piEngineServiceAdapter(): PiEngineService {
+    return {
+      executeAndAwait: (opts, signal, onEvent, stream) => this.executeAndAwait(opts, signal, onEvent, stream),
+      getRecordForAction: (id) => this.getRecordForAction(id),
+      closeSubagent: (record, force) => this.closeSubagent(record, force),
+      cancel: (id) => this.cancel(id),
+      collectRecords: (limit, statusFilter) => this.collectRecords(limit, statusFilter),
+      takeChatRound: (taskId) => this.takeChatTicket(taskId),
+      runChatRound: (ticket) => this.runTicketRound(ticket),
+      resumeChatRound: (record, text) => this.resumeColdRound(record, text),
+      reportRecordTransition: (record) => this.store.reportRecordTransition(record),
+    };
+  }
+
+  /** [D4 聚合连带] PiEngineService 的显式结构视图（registration / SAR 直绑消费）。
+   *  原两绑定点把 SubagentService 整体结构化兼容为 PiEngineService——依赖查询/交互
+   *  方法 public；聚合收窄后改经本视图显式适配（成员集合与原直绑等价，行为零差异）。
+   *  getter 形态：face 视图（惰性构造的适配对象）而非动作方法。 */
+  get asEngineService(): PiEngineService {
+    return this.piEngineServiceAdapter();
+  }
+
+  /** chat 域轮次交接的消费侧（PiEngine.run 回调）：一次性取走，防重复消费。私有名与
+   *  PiEngineService 可选面成员不同名（历史约束：D4 聚合前的结构化直绑时代，私有同名
+   *  成员会阻断 SubagentService 直绑；聚合后经 asEngineService 显式视图，约束已消失，
+   *  不同名保留为与 adapter 显式映射一致的命名纪律）。 */
+  private takeChatTicket(taskId: string): ChatRoundTicket | undefined {
+    const ticket = this.chatRoundTickets.get(taskId);
+    if (ticket !== undefined) this.chatRoundTickets.delete(taskId);
+    return ticket;
+  }
+
+  /** PiEngine chat 分支的执行回调：原 runAndFinalize 直调链的 EnginePort 化落点
+   *  （编排归 Service——pool 槽 + runSpawn + 终态迁移，行为零变化）。 */
+  private async runTicketRound(ticket: ChatRoundTicket): Promise<AgentResult> {
+    return this.runAndFinalize(
+      ticket.record,
+      ticket.opts,
+      ticket.ctx,
+      ticket.identity,
+      ticket.signal,
+      ticket.priority,
+      undefined,
+      ticket.stream,
+      ticket.resume,
+    );
+  }
+
   /**
    * 取消 background record。CAS 抢锁（tryTransition）——抢到则 notify + 写 tombstone；
    * 没抢到（detached 已 finalize，record 已终态）返回 false，不触碰任何收尾副作用。
@@ -2291,7 +2615,7 @@ export class SubagentService {
     record.controller?.abort();
     // [M6] 显式 kill + disarm：chatMode 首轮 agent_settled 后 runSpawn 提前 resolveRun(0)
     // 返回，`opts.signal.removeEventListener("abort", onAbort)`（session-runner runSpawn 尾部）
-    // 已移除 abort→kill listener；热路径续聊轮（deliverMessage 直接 sendPromptCommand）不再
+    // 已移除 abort→kill listener；热路径续聊轮（PiEngine 直接 stdin 写入）不再
     // 进 runSpawn。此后 cancel 只有 controller.abort() 无人响应——record 已终态化 cancelled
     // 但子进程继续跑完当前 turn（工具副作用继续发生），之后 agent_settled 还对已 archived
     // record 触发脏通知（round+1 → 新 dedup key → "finished a round"），最终靠 5min idle
@@ -2341,9 +2665,9 @@ export class SubagentService {
       }
     }
     // pending-notifications：cancel 注销（只记 registry 状态）
-    emitPendingUnregister(this.pi, record.id, "closed");
-    // cancel 完成通知（与 kickOffBackground.then 对称——cancel 抢先时 .then 跳过 notify）
-    this.notifyComplete(record);
+    this.notifyHost.emitPendingUnregister(record.id, "closed");
+    // cancel 完成通知（与轮次收尾 .then 对称——cancel 抢先时 .then 跳过 notify）
+    this.collectCoordinator.route(record);
     return true;
   }
 
@@ -2363,7 +2687,7 @@ export class SubagentService {
         store: this.store,
         modelService: this.modelService,
         pi: this.pi,
-        emitUnregister: (id, st) => emitPendingUnregister(this.pi, id, st),
+        emitUnregister: (id, st) => this.notifyHost.emitPendingUnregister(id, st),
         sessionDir: this.sessionsDir,
       },
       record,
@@ -2388,7 +2712,7 @@ export class SubagentService {
         store: this.store,
         modelService: this.modelService,
         pi: this.pi,
-        emitUnregister: (id, st) => emitPendingUnregister(this.pi, id, st),
+        emitUnregister: (id, st) => this.notifyHost.emitPendingUnregister(id, st),
       },
       record,
       result,
@@ -2399,7 +2723,7 @@ export class SubagentService {
    *  AgentResult → CAS 抢锁 → finalizeRecord（与正常路径同形）。返回合成 result 供 runAndFinalize
    *  继续返回（不 re-throw，swallow 策略）。 */
   private async finalizeFailed(record: ExecutionRecord, err: unknown): Promise<AgentResult> {
-    const errMsg = err instanceof Error ? err.message : String(err);
+    const errMsg = toErrorMessage(err);
     // durationMs 用真实耗时（startedAt → now），避免失败统计恒为 0 失真。
     const failedResult: AgentResult = { text: "", turns: record.turnCount, durationMs: Date.now() - record.startedAt, success: false, error: errMsg, sessionId: record.id, toolCalls: [] };
     // CAS 抢锁：抢到（status 仍 running）则完整收尾；没抢到（cancel 已先设 cancelled）跳过。
@@ -2502,74 +2826,11 @@ export class SubagentService {
       // 落盘统一用 rootCwd 编码，ROOT 磁盘重建才扫得到深层 record（与 sessionRootId 同构）。
       rootCwd: this.rootCwd,
       // [V2 决策 2] chatMode 首轮闭环：agent_settled 时 session-runner 调本回调。
-      // 轻量 idle 化（选项 1）：设 record.status=idle + round+=1 让 notify 守卫放行 + notify
-      // 主 agent，但**不调 doFinalizeRoundToIdle**（不 emitUnregister /
-      // 不 redeliver——V2 要删的副作用都不做）。runAndFinalize 检测到 status=idle 后 early return，
-      // 不进现有 chatMode 分流。Step 5 删 idle 状态机时统一清理这个过渡 idle。
-      // 防箭头函数 this 丢失：用箭头函数捕获 SubagentService 实例 this。
-      onRoundSettled: (record) => {
-        // v4 B-1：status 保持 running（旧 idle 折入 running）；session-runner 已 arm idle timer，
-        // isIdle=true 让 notify 守卫放行（时序：armIdleTimer → onRoundSettled，见 session-runner.ts:670）。
-        // round 可能初始 undefined（与 notifier.ts `record.round ?? 0` 兜底一致），
-        // 首轮 0+1=1。round 是 notifier dedup key 的组成部分，递增后同 id 下一轮不被 60s dedup 吞。
-        record.round = (record.round ?? 0) + 1;
-        // [N2][增量] 轮次回复写点（增量语义）：roundText 自 roundBaseTurnIndex 起派生本轮增量
-        //（undefined 视为 0——首轮增量 = 全量，与改造前首轮逐字节一致）。成功轮次的 MF-2 原写点
-        //（doFinalizeRoundToIdle）不可达——agent_settled 恒 arm idle timer → runAndFinalize 恒
-        // early return。写入 record.result 后再 notify；本轮无非空增量且无 lastError（纯工具轮 /
-        // interrupt 抢占轮 / 模型空回复）时固定占位 "(no output this round)"（D5：增量语义下沿用
-        // 旧 record.result = 上一轮增量 → 本轮通知正文 = 上一轮内容，父 agent 误读为原样重复回复；
-        // lastError 兜底保留让失败轮通知可读）。后续 closeAfterRoundSettled 的合成 result 读
-        // record.result，同样携带本轮增量。
-        const roundText = getFullTextFrom(record, record.roundBaseTurnIndex ?? 0);
-        record.result = roundText ||
-          (record.lastError ? `round did not complete: ${record.lastError}` : "(no output this round)");
-        // 先送达本轮增量（notify），再推进 base / 消费 closeAfterRound——终态通知由
-        // closeAfterRoundSettled / closeChatIdle 的 notifyClosed 显式发出（dedup 身份为裸 id，
-        // 与本次 round notify 的 id:round key 区分），保证「本轮增量 + 终态通知」都送达；
-        // kickOffBackground.then 的冷路径 notifyComplete 仍与本次 round notify 同 key 被 60s
-        // dedup 吞（不构成第三条）。
-        //
-        // 幂等性（覆盖面如实限定）：同步路径 at-least-once——notifyComplete（同步 void）抛错时
-        // 推进/消费被跳过 → base 不推进 → 增量未消费，下轮 roundText 必含本轮文本（重发载体为
-        // 后续轮次增量拼接）。kickOffBackground.then 的冷路径 notifyComplete 不构成重发通道
-        // （notifier dedup.set 与 pending.splice 均先于 sendMessage，同 key `${id}:${round}`——
-        // round 已递增——60s 窗内重入被吞）。异步 flush 窗口不保证：合并 timer armed（其他 busy
-        // background 在场）或 isIdle 退避期间 notify 的『成功』只是入队，实际 sendMessage 发生在
-        // base 推进之后的异步时机；该窗口进程崩溃或 sendMessage 失败 → 丢失不可重发（现状全量
-        // 重发的次轮自愈在增量语义下消失），wave1 期恢复通道仅父 agent 经 /subagents 详情读取
-        // record.result，wave2 指针行落地后补全。反序（先推进后 notify）在同步路径 notify 失败时
-        // 静默丢增量且无任何重算机会，故 notify 后推进是定案。重复发送由 notifier dedup key
-        // 60s 窗界定。
-        this.notifyComplete(record);
-        // R1 观测哨（不变式违反形态）：推进前检查末 turn 未闭合且 text 非空——pi 现序下不可达
-        //（带 usage 的 message_end 恒先于 turn_end，settle 时 turn 全闭合，见 types.ts
-        // roundBaseTurnIndex 注释的行号锚定），ES1 单测自造事件序列锁不住 pi 层变化；pi 升级若
-        // 改变 turn_end/agent_end 时序，此哨兵留痕（该形态下公式仍把文本计入本轮，不丢数据）。
-        const lastTurn = record.turns[record.turns.length - 1];
-        if (lastTurn !== undefined && !lastTurn.closed && lastTurn.text.length > 0) {
-          logger.warn(
-            `[subagents] round settle with unclosed non-empty turn (record=${record.id}, turnIndex=${record.turns.length - 1}) — pi turn_end/agent_end ordering may have changed`,
-          );
-        }
-        // [增量] base 推进（notify 之后）：下一轮增量从本轮边界起。滞后空 turn 不计入边界
-        //（防御分支，留在下一轮增量内防丢文本——nextRoundBaseTurnIndex 注释）。
-        record.roundBaseTurnIndex = nextRoundBaseTurnIndex(record);
-        // 轮终迁移持久化（residual-fixes U3 补全）：热路径轮终不经 doFinalizeRoundToIdle
-        //（agent_settled 恒 arm idle timer → runAndFinalize 恒 early return，MF-2 原写点
-        // 不可达）——不 appendEntry 则 runtime/W18 派生缓存不失效，renderer 停留在
-        // register 快照（无 result），chat 等续聊的 waiting 形态显示不出来、spinner
-        // 卡死。显式上报：entry 携带本轮 result/round/chatMode（§5.4：result 有值 +
-        // chatMode=true → waiting）。closeAfterRound 的终态 entry 在此后追加，序不变。
-        this.store.reportRecordTransition(record);
-        // [M5] closeAfterRound 消费点：chatMode 每轮完成的统一汇聚点（热路径轮不经
-        // runAndFinalize CAS 分支——agent_settled 恒 arm idle timer → runAndFinalize 恒
-        // early return，旧消费点对 chatMode 不可达，标志置了无人消费、tool 谎报 closed:true）。
-        if (record.closeAfterRound) {
-          record.closeAfterRound = undefined;
-          void this.closeAfterRoundSettled(record);
-        }
-      },
+      // [D4-②] 业务闭包已拆至 round-settlement.ts（this.settleRound 字段工厂构造，
+      // deps 回调注入 notifyComplete / reportRecordTransition / closeAfterRoundSettled，
+      // 行为逐字节等价）——轻量 idle 化语义（round+=1 + notify 主 agent，不调
+      // doFinalizeRoundToIdle）与增量派生/base 推进/哨兵的机制注释见该文件。
+      onRoundSettled: this.settleRound,
     };
   }
 }