@zhushanwen/subagent-core 0.8.0 → 0.9.0

package/dist/index.d.cts

@@ -1,14 +1,803 @@
-import { E as EnginePort, D as DiscoverEnginesOptions, a as ExecutionRecord, C as ClosedReason, b as ExecutionOutcome, A as AgentEventLogEntry, c as ExecutionStatus, P as ProjectedOutcome, R as RecordSnapshot, S as SubagentRecord, d as ExecuteOptions, e as SubagentStream, f as AgentResult, g as AgentResult$1, h as SubagentsGlobalConfig, M as ModelRegistryLike, i as ModelInfo, j as AgentConfig, k as ResolvedModel, l as StreamSink, m as ExecutionHandle, n as ExecutionMode, o as PatchResult, p as AgentCallOpts, q as ExecutionTraceNode, T as TracePatch, r as RunStatus, s as DoneReason, W as WorkerLogEntry, t as DisplayItem, u as CancelResponse, v as CloseResponse, F as ForkFromResponse, L as ListResponse, w as MessageResponse, B as BgResponse, x as ExternalState, y as SubagentListItem, z as DiscoveryRoot } from './engine-discovery-scan-BXLA8y-z.cjs';
-export { G as CLOSED_REASONS, H as CoreLogger, I as DEFAULT_AGENT_NAME, J as DEFAULT_DATA_ROOT, K as DEFAULT_ENGINE_ID, N as DirtyWorktreeError, O as EngineHandle, Q as EngineRunResult, U as ForkDepthExceededError, V as HostServices, X as LogLevel, Y as ResurrectDeniedError, Z as RunContext, _ as SLUG_MAX_LENGTH, $ as SubagentToolResult, a0 as configureCore, a1 as getHostServices, a2 as getLogger, a3 as normalizeEngineId } from './engine-discovery-scan-BXLA8y-z.cjs';
-import { ProbeReport, SessionView, ToolCall, UiRequest, UiRequestHandler, UiResponse, AgentEvent, UiChannelRegistry, WorktreeHandle, AgentOutcomeUsage } from '@zhushanwen/subagent-engine-sdk';
-export { AgentEvent, AgentOutcome, ChannelHandler, EngineCapabilities, EngineHandleData, InteractAction, InteractResult, ProbeReport, ReplayedTurn, SessionView, ToolCallEntry, UiChannelRegistry } from '@zhushanwen/subagent-engine-sdk';
+import { M as ModelInfo, E as EnginePort, D as DiscoverEnginesOptions, a as ModelRegistryLike, A as AgentConfig, R as ResolvedModel, S as SubagentStream, b as AgentResult$1, c as StreamSink, d as AgentCallOpts, e as ExecutionTraceNode, T as TracePatch, f as RunStatus, g as DoneReason, W as WorkerLogEntry, h as DiscoveryRoot } from './engine-discovery-scan-Da4Dkzsi.cjs';
+export { C as CoreLogger, i as DEFAULT_DATA_ROOT, j as DEFAULT_ENGINE_ID, k as EngineHandle, l as EngineRunResult, H as HostServices, L as LogLevel, m as RunContext, n as SLUG_MAX_LENGTH, o as configureCore, p as getHostServices, q as getLogger, r as normalizeEngineId } from './engine-discovery-scan-Da4Dkzsi.cjs';
+import { Turn, AgentFailureKind, ToolCall, AgentUsageTotal, WorktreeHandle, ProbeReport, SessionView, AgentEvent, UiRequest, UiRequestHandler, UiResponse, UiChannelRegistry, AgentOutcomeUsage } from '@zhushanwen/subagent-engine-sdk';
+export { AgentEvent, AgentOutcome, ChannelHandler, EngineCapabilities, EngineHandleData, ProbeReport, ReplayedTurn, SessionView, ToolCallEntry, UiChannelRegistry } from '@zhushanwen/subagent-engine-sdk';
+import { GuiRenderResult } from '@xyz-agent/extension-protocol';
 import { Worker } from 'node:worker_threads';
 import 'node:child_process';
-import '@xyz-agent/extension-protocol';
 
 /** thinking level 支持顺序（低→高）。spawn 侧 `:level` 后缀仅接受本白名单值。 */
 declare const THINKING_ORDER: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 
+/**
+ * 未显式指定 agent 时的兜底名。
+ *
+ * 必须是真实存在、可被 agentRegistry 发现的 agent（用户 agentDir 内置的通用 agent）。
+ * Service 层（resolveIdentity）与 TUI 层（extractAgentName）共用此常量，保证
+ * 「调用时显示的名」与「实际加载的 agent.md」一致。
+ *
+ * [HISTORICAL] 旧实现两处各硬编码：service 用 "default"（虚构名），format 用
+ * "worker"（真实但不是兜底语义，worker agent 已在 2026-08 agent 重构中删除）。
+ * 导致不传 agent 时，block 标题显示 worker，但实际执行兜底逻辑不一致。统一为
+ * general-purpose 后名实相符。
+ */
+declare const DEFAULT_AGENT_NAME = "general-purpose";
+/**
+ * 唯一执行状态。所有路径共用。v4 B-1 两态收敛：旧 idle 折入 running、
+ * 旧 cancelled 折入 closed（closedReason='cancelled' 区分）。
+ *
+ * running = 活跃态。含两种子态（由派生谓词区分，见 lifecycle-predicates.ts）：
+ *   - 对话模式等待续聊（旧 idle）：进程已回收，待冷路径 resume
+ *     （isResumable=running && 无活进程句柄）。旧「进程保活待热路径」形态随
+ *     H1 U6 长驻退役消亡，isIdle（hasIdleTimer）生产恒 false。
+ *   - 正在执行（有活进程句柄）。
+ *
+ * closed = 统一终态（done/failed/crashed/cancelled 合并）。具体关闭原因由
+ * {@link ClosedReason} 子枚举表达（如 user-close / gc / cancelled / parent-shutdown）。
+ * ExecutionRecord.closedReason 携带 L2 原因，投影层按需派生对外语义（error / ended）。
+ */
+type ExecutionStatus = "running" | "closed";
+/**
+ * record 来源身份（H2 W1，设计 subagent-workflow-record-unification §3.3 D1 建议新增）：
+ *   "tool"     — 主 agent 经 subagent 工具手动派发（现状全部 record）；
+ *   "workflow" — workflow 脚本内 agent() 调用派发（生产写入方 W2 executeWorkflowAgent 接线）。
+ * 缺省语义 = "tool"：存量 record / 未传字段的 entry 反序列化产物一律视为手动派发，
+ * 四个投影消费面（subagents tool list / renderer 侧栏计数 / renderer 后台工作指示 /
+ * TUI /subagents）对缺省 record 的可见性与历史行为完全一致（零迁移）。
+ */
+type RecordOrigin = "tool" | "workflow";
+/**
+ * closed 终态的 L2 关闭原因子枚举。
+ *
+ * 与 ExecutionStatus="closed" 配合使用，表达「为什么关闭」：
+ *   parent-shutdown  — 父进程 session_shutdown 时回收子进程
+ *   parent-fork     — 父进程 fork 新 session 时清理旧子进程
+ *   parent-new      — 父进程创建新 subagent 时清理旧子进程
+ *   user-close      — 用户手动 close action（含对话模式 close）
+ *   cancelled       — 用户取消（close(force:true) / cancelBackground）
+ *   gc              — 通用完成/失败（一次执行自然结束、超时、错误等无专属 reason 的终态）
+ *   disconnected    — .finalized sidecar 存在但无 reason 内容（磁盘重建兜底）：
+ *                     正常结束但死因不可考——旧格式 sidecar（v8.5 前写入的是空文件）、
+ *                     或外部工具手工创建。替代旧的误导性 "gc" 兜底（自然完成 vs 断联
+ *                     不分），message/fork-from 据此给出可行动指引。
+ */
+type ClosedReason = 'parent-shutdown' | 'parent-fork' | 'parent-new' | 'user-close' | 'cancelled' | 'gc' | 'disconnected';
+/**
+ * [v8.5 D] 透明重生守卫拒绝专用错误：messageHandler 的 endedMessageGuard 必须原样
+ * 透传本类错误（自带完整行动语言），不得按 A1 分流规则改写——否则 worktree/异进程
+ * 占用文案会被「fork-from 指引」覆盖，误导 agent 走已被判死的通道。
+ */
+declare class ResurrectDeniedError extends Error {
+}
+/** ClosedReason 全枚举值（运行时守卫用——防御性解析外部输入时校验成员资格）。 */
+declare const CLOSED_REASONS: readonly ClosedReason[];
+/**
+ * 终态三态对外语义（U3 C-outcome 一等披露）。
+ *
+ * 由 completeRecord 唯一写入点按 deriveOutcome 一次计算（判定顺序：cancelled 优先
+ * → error 非空 → completed），消费方（project/list/notify 文案/渲染器）只读本字段，
+ * 不再各自手写成败推导 switch（三处同构 switch 已随 U3 收敛删除）。
+ *
+ * [D6 显式取舍] parent-shutdown/parent-fork/parent-new 合成关闭（subagent-service
+ * disposeAllRecords 合成 result 恒写 error:"closed due to ..."）落 "failed"——语义为
+ * 「父进程关闭时子 agent 未完成即失败」，选定行为而非疏漏，勿当 bug 改回 cancelled。
+ */
+type ExecutionOutcome = "completed" | "failed" | "cancelled";
+/**
+ * 对外投影的 outcome 联合：含历史 record（outcome 字段诞生前的存量数据）兼容态。
+ * 投影层（projectOutcome 唯一出口）对无 outcome 字段的 closed record 按
+ * deriveOutcome(closedReason, error) 兜底派生；"closed-legacy" 预留给连派生输入都
+ * 不足以判读的存量形态，消费方必须处理该成员（不得因未知值崩溃）。
+ */
+type ProjectedOutcome = ExecutionOutcome | "closed-legacy";
+/**
+ * 对外两态（设计决策 10 细则 3）：内部 ExecutionStatus（v4 B-1 两态）收敛为 agent
+ * 可理解的状态语义。真实映射只有两条：
+ *   running → active / closed → ended（closed 统一终态，含 cancelled）。
+ * mapExternalState 不消费 ClosedReason——closed 恒映射 ended。
+ *
+ * 原始 ExecutionStatus 进 list item 的 status 字段供调试；state 是对外主字段。
+ * 映射实现见 subagent-actions-core.ts mapExternalState——未来内部加态必须扩展该处，
+ * 漏加会在 default 分支编译报错，不影响对外契约。
+ */
+type ExternalState = "active" | "ended";
+/** 执行模式。background = 调用方立即拿 handle 返回，子 agent 在 detached promise 里跑。 */
+type ExecutionMode = "background";
+
+/**
+ * eventLog 条目（getEventLog 派生产出的元素）。所有字段 readonly。
+ *
+ * text_output / thinking 类型已移除——它们是 100 字切片的碎片副产物，
+ * 现在完整内容收口在 record.turns[] 里，eventLog 只承载离散语义事件
+ * （tool 调用 / turn 边界 / error）。
+ */
+interface AgentEventLogEntry {
+    readonly type: "tool_start" | "tool_end" | "turn_end" | "error";
+    readonly label: string;
+    /** 事件发生的墙钟时间戳（Date.now()，ms）。由 getEventLog 从 turns[] 派生时记录。 */
+    readonly ts: number;
+    readonly status?: "running" | "done" | "failed";
+}
+/**
+ * [STEP3] displayItem：从 turns[] 派生的展示项（对齐 nicobailon getDisplayItems）。
+ *
+ * 与 eventLog 的区别：eventLog 承载离散语义事件（tool_start/tool_end/turn_end），
+ * displayItem 承载「可渲染单元」（toolCall 含完整 name+args 供 formatToolCall 格式化；
+ * text 含 assistant 正文）。renderResult compact 分支改用 displayItems 后，
+ * 行格式与 nicobailon 完全一致（→ formatToolCall）。
+ */
+interface DisplayItem {
+    readonly type: "toolCall" | "text";
+    /** toolCall：tool 名称（bash/read/edit...）；text：无。 */
+    readonly name?: string;
+    /** toolCall：tool 原始 args（供 formatToolCall 提取路径/命令）；text：无。 */
+    readonly args?: Record<string, unknown>;
+    /** toolCall：执行状态（running 时无✓/✗标记）；text：正文文本。 */
+    readonly status?: "running" | "done" | "failed";
+    /** text：assistant 正文（compact 时取首行/截断）。 */
+    readonly text?: string;
+}
+/** 一次 session 执行的完整结果。collectResult 产出，写入 Record.outcome。 */
+interface AgentResult {
+    text: string;
+    turns: number;
+    durationMs: number;
+    success: boolean;
+    error?: string;
+    /**
+     * [D5-③] 失败分诊结构化标签（类型 SSOT 在 orchestration/models/types.ts 的
+     * AgentFailureKind——消费语义「unknown=可重试」与其文档同源）。collectResult 对
+     * 最终 error 分类后写入；缺省 = unknown（可重试）。type-only 引用零运行时依赖。
+     */
+    failureKind?: AgentFailureKind;
+    sessionId: string;
+    toolCalls: ToolCall[];
+    usage?: AgentUsageTotal;
+    /** /resume /fork 可恢复的 session 文件名（不含目录）。 */
+    sessionFile?: string;
+    /** schema 模式下，structured-output tool 的 result.details（已通过 schema 校验）。 */
+    parsedOutput?: unknown;
+}
+
+/** git diff patch 结果。 */
+interface PatchResult {
+    readonly patchFile: string;
+    readonly failed: boolean;
+    /** patch 是否实际写入 patchFile。true=diff 非空且写盘成功；false=空 diff 或写失败。
+     *  调用方据此回填 record.patchFile，避免悬空路径（`git apply` 不存在的文件）。 */
+    readonly written: boolean;
+}
+/** fork depth 超限错误。 */
+declare class ForkDepthExceededError extends Error {
+    constructor(message: string);
+}
+/** worktree 有未提交变更错误。 */
+declare class DirtyWorktreeError extends Error {
+    constructor(message: string);
+}
+/**
+ * 所有执行路径的唯一状态源。
+ *
+ * 收口设计：一次执行的完整内容（text/thinking/toolCalls/usage）按 turn 收口在
+ * `turns: Turn[]` 里。eventLog / currentActivity / result 文本均从 turns[] 派生
+ * （getEventLog / getCurrentActivity / getFullText），不再独立存储切片或缓冲。
+ *
+ * 生命周期：createRecord() 创建 → updateFromEvent() 实时更新（累积进 turns）→
+ *           completeRecord() 冻结 → archive 立即移出内存（读时从 session.jsonl 重建）。
+ *
+ * TUI 永远拿 RecordSnapshot（.slice() 快照），不直接持此可变对象。
+ */
+interface ExecutionRecord {
+    /** 唯一 ID（sync: "run-N"，bg: "bg-N-xxx"）。 */
+    readonly id: string;
+    readonly agent: string;
+    readonly model: string;
+    readonly thinkingLevel: string | undefined;
+    readonly mode: ExecutionMode;
+    readonly task: string;
+    /**
+     * 人类可读的短标签（≤35 字符），简述本次 subagent「在做什么」。
+     * 区别于 agent（类型名）/ task（完整 prompt）。旧持久化 record 反序列化时缺失兜底空串。
+     */
+    readonly slug: string;
+    readonly startedAt: number;
+    /** 根 Pi session ID（session 隔离过滤用）。递归链上所有层 record 同值。 */
+    readonly rootSessionId: string | undefined;
+    /** 直接父 subagent record ID（层级树构建用）。顶层 record 为 undefined。 */
+    readonly parentRecordId: string | undefined;
+    /** subagent 递归深度。顶层（主 session 直接创建）=0，每层嵌套 +1。 */
+    readonly depth: number;
+    /**
+     * 来源身份（H2 W1，D1）。缺省（undefined）语义 = "tool"（存量 record 零迁移）；
+     * "workflow" = workflow 脚本 agent() 派发（生产写入方 W2 接线）。过滤在投影/查询
+     * 消费面（list 默认滤 workflow origin），store 治理面（孤儿恢复/revive）全量可见。
+     * 持久化经 subagent-record entry。
+     */
+    readonly origin?: RecordOrigin;
+    /**
+     * origin="workflow" 时所属 workflow run 的 id（W2 写入）；tool 来源恒 undefined。
+     * W2 run 视图进度 / W3 下钻按本 id 查询本 run 的 record 集（内存 ∪ 磁盘重建口径，
+     * collectRecordsByParentRunId）。持久化经 subagent-record entry。
+     */
+    readonly parentRunId?: string;
+    /**
+     * 对话模式标志（可持续对话 subagent）。true = 轮次完成进 idle 态（保留 record +
+     * worktree）等待续聊，而非一次性终态化。
+     * undefined/false = 一次性模式（默认，行为完全不变）。
+     * 向后兼容：旧 record / 旧 session 文件无此字段，按一次性模式处理。
+     */
+    readonly chatMode?: boolean;
+    /**
+     * 执行态信号（residual-fixes 设计）：true = 该 record 无活进程驱动（轮终 idle /
+     * 重建孤儿兜底），处于「可续聊/等续聊」态——不是后台真在跑。轮终迁移
+     * （doFinalizeRoundToIdle）置 true，冷路径续轮（进程启动）清除；GUI 侧
+     * streaming/waiting 细分与 hasRunning 判据消费。缺省 falsy = 有进程或旧数据。
+     */
+    resumable?: boolean;
+    /**
+     * 空闲超时毫秒数（仅 chatMode 有意义）。覆盖默认 5min idle timeout。
+     * 优先级：参数 > env XYZ_SUBAGENT_IDLE_TIMEOUT_MS > 默认 300000ms。
+     * 向后兼容：旧 record 无此字段，按默认值处理。
+     */
+    readonly idleTimeoutMs?: number;
+    /**
+     * 实际执行引擎 id（P4 路由留痕，D9①）。创建时确定不可变；缺省（存量 record）
+     * = pi 投影（消费方零迁移）。持久化经 subagent-record entry。
+     */
+    readonly engine?: string;
+    /**
+     * 引擎 fallback 留痕（D9①：probe 失败路由回默认引擎）。GUI 警告条数据源；
+     * 缺省 = 无 fallback。持久化经 subagent-record entry。
+     */
+    readonly engineFallback?: {
+        from: string;
+        reason: string;
+    };
+    /**
+     * 引擎自描述定位符（U2：非 pi run resolve 后回填、终态迁移落 entry 前——run 前
+     * 缺省不可用）。sessionRef 整体透传（失败终态 sessionId 缺失时仍回填已有部分，
+     * 读侧①级降②级的防御形态）；journalPath 为 retarget 后实际落盘路径。pi 分支不
+     * 回填（sessionFile 即定位符）。持久化经 subagent-record entry。
+     */
+    engineHandle?: {
+        sessionRef: Record<string, string>;
+        journalPath?: string;
+        poolKey: string;
+    };
+    /**
+     * 同步收集模式标记（subagent-sync-collect 设计 §3.1.3，U1 foundation 契约）。
+     * 创建时确定不可变；undefined = async（缺省语义，旧记录零迁移）。持久化经
+     * subagent-record entry（record-entry.ts 序列化白名单，entry 唯一写点）。
+     * 消费方：U2 collectCoordinator 路由（sync→批缓冲）、U5 E1 重建投影。
+     * U2 接线点：service.createRecordForMode 从 ExecuteOptions.collect 读入 identity。
+     */
+    readonly collectMode?: "sync";
+    status: ExecutionStatus;
+    /** L2 关闭原因子枚举（仅 status="closed" 时有意义）。表达「为什么关闭」。
+     *  由 tryTransition(record, "closed", reason) 写入；投影层按需派生对外语义。
+     *  向后兼容：旧 record 无此字段，按 gc 处理（通用完成/失败）。 */
+    closedReason?: ClosedReason;
+    /**
+     * 终态三态对外语义（U3 C-outcome）。completeRecord 唯一写入点按 deriveOutcome
+     * 一次计算，消费方只读本字段不再自行推导。向后兼容：旧 record / 磁盘重建
+     * record 无此字段，投影层按 projectOutcome 兜底（closed-legacy 语义）。
+     */
+    outcome?: ExecutionOutcome;
+    /**
+     * 离开批的终局标记（subagent-sync-collect 设计 §3.1.3，U1 foundation 契约）。
+     * 两出口统一落标：① 批闭合 flush 写账成功后；② E9 dispose 逐条转 async 写账后
+     * （均 appendEntry 持久化，U3/U5 写点）。undefined = 未离开批 / 旧记录零迁移。
+     * 消费方：U5 E1 重建扫描只收「collectMode=sync 且无本标记」的成员（防双重通知）。
+     */
+    batchFinalized?: boolean;
+    /** 完整执行内容，按 turn 组织。createRecord 初始化为 [空 turn]。 */
+    turns: Turn[];
+    /** turn 计数（= turns.filter(closed).length，冗余存储供投影直接读）。 */
+    turnCount: number;
+    totalTokens: number;
+    /** 运行期最近一次 error 事件的消息（getEventLog 派生 error 条目用）。 */
+    lastError: string | undefined;
+    /**
+     * 对话轮次计数（仅 chatMode 有意义）。首轮运行时 = 0；每完成一轮（finalizeRoundToIdle
+     * 进 idle）+1。undefined 时视为 0。非 chatMode 不自增。
+     */
+    round?: number;
+    /**
+     * record 进入 idle 态的时间戳（ms）。finalizeRoundToIdle 设值；GC 定时器据此计算
+     * 剩余 TTL。undefined = 非 idle 态（running/closed/cancelled）或旧 record 缺失字段。
+     */
+    idleSince?: number;
+    /**
+     * close 优雅关闭标志（M2-B3）。chatMode record 运行中调 `close {force:false}` 时置 true；
+     * runAndFinalize 的 done 分流检查此标志——true 则终态化为 done（而非进 idle），并清标志。
+     * undefined/false = 正常 idle 分流（对话模式轮次完成进 idle 等续聊）。
+     * 仅 chatMode + running 时有意义；force:true（立即终止）不走此标志。
+     */
+    closeAfterRound?: boolean;
+    endedAt: number | undefined;
+    result: string | undefined;
+    error: string | undefined;
+    /** 完整 AgentResult（含 usage/toolCalls，完成时填）。 */
+    agentResult: AgentResult | undefined;
+    /** session jsonl 文件名。session 创建成功后由 session-runner.run() 回填（窗口期内 undefined）。 */
+    sessionFile?: string;
+    /**
+     * [V2 决策 3] 子进程 pid（spawn 后回填到内存 record，并随 record 持久化落盘）。
+     *
+     * 诊断字段：排障时对照 record 文件与进程表核实 spawn 事实。原职责 4 孤儿扫描
+     * （按持久化 pid 扫收上次崩溃遗留孤儿）自落地起未接线，已随 L2 死代码清扫删除。
+     * undefined = 尚未 spawn / 已退出。向后兼容：旧 record 无此字段，按无 pid 处理。
+     */
+    pid?: number;
+    /** [MF#3] worktree 模式下子 agent 改动的 patch 文件路径（worktree 外，供调用方应用）。 */
+    patchFile?: string;
+    /** worktree 隔离时的 handle（仅 worktree:true 时存在；fork alone 无此字段）。 */
+    worktreeHandle?: WorktreeHandle;
+    /**
+     * [review round2] 该 record 创建时启用了 worktree 隔离（跨重启磁盘重建时从 session
+     * entry 的 worktree 标志恢复）。handle 本体不可序列化——跨重启后 worktreeHandle 恒
+     * undefined，续聊（冷路径 resume）须拒绝（防 cwd 静默回落主 repo 破坏隔离）。仅内存
+     * record 使用，与持久化无关；execute() 新建 record 不设（有真 handle 时无意义）。
+     */
+    hadWorktree?: boolean;
+    controller: AbortController | undefined;
+}
+/**
+ * Tool 返回的 details（内层扁平结构）。
+ * 由 project(record) 唯一产出——sync/bg 两路径字段一致。
+ * 含 mode + sessionFile（供外层 SubagentToolResult 分组 + spinner 判断）。
+ *
+ * 分层（spec FR-3）：此为**内层**，不感知 action/外层分组。
+ * 外层 SubagentToolResult 由 adapter 包裹产出（加 action/subagentId/sessionFile + 分组）。
+ */
+interface SubagentToolDetails {
+    status: ExecutionStatus;
+    /**
+     * 终态三态对外语义（U3 C-outcome，projectOutcome 唯一出口）。running → undefined；
+     * 历史数据无 outcome 字段时兜底派生（见 ProjectedOutcome）。
+     */
+    outcome?: ProjectedOutcome;
+    mode: ExecutionMode;
+    agent: string;
+    model: string;
+    thinkingLevel: string | undefined;
+    /** 短标签（≤35 字符），来自 record.slug。旧 record 反序列化时为空串。 */
+    slug: string;
+    turns: number;
+    totalTokens: number;
+    elapsedSeconds: number;
+    eventLog: AgentEventLogEntry[];
+    /** [STEP3] 从 turns[] 派生的展示项（对齐 nicobailon getDisplayItems）。 */
+    displayItems: DisplayItem[];
+    result?: string;
+    error?: string;
+    /** running 时的当前活动行（tool/thinking/text 优先级）。 */
+    currentActivity?: {
+        type: "tool" | "text" | "thinking";
+        label: string;
+    };
+    /** schema 模式下，structured-output tool 的 result.details（对齐 workflow agent-pool）。 */
+    parsedOutput?: unknown;
+    /** session jsonl 文件名（不含目录）。窗口期内可能 undefined（session 尚未创建成功）。 */
+    sessionFile?: string;
+    /** [MF#3] worktree 模式下子 agent 改动的 patch 文件路径（worktree 外，供调用方应用）。 */
+    patchFile?: string;
+}
+/** Hub.execute 的入参（sync/bg 共用）。mode 由 Hub 内部判定，不暴露给调用方。 */
+interface ExecuteOptions {
+    task: string;
+    /**
+     * 短标签（≤35 字符），简述本次执行用途，展示在 TUI。必填。
+     * workflow 内 agent() 调用时从 AgentCallOpts.description 透传而来。
+     */
+    slug: string;
+    agent?: string;
+    model?: string;
+    thinkingLevel?: string;
+    skillPath?: string;
+    appendSystemPrompt?: string[];
+    schema?: Record<string, unknown>;
+    /** D-A6 bridge: workflow schemaEnv 经 ExecuteOptions 透传到 runSpawn childEnv。 */
+    schemaEnv?: string;
+    /**
+     * Turn 上限 limiter。显式 0/负 = 显式不限：压过 SPAWN_WATCHDOG_ENV 兑底不挂
+     * watchdog（SP-6 参数 > env，U5）；undefined 未传才由 env 兑底。
+     */
+    maxTurns?: number;
+    graceTurns?: number;
+    /** sync 模式来自 Pi tool 框架；background 模式 hub 忽略，自建 controller。 */
+    signal?: AbortSignal;
+    /** 主 agent 当前模型（模型解析第三层兼底）。execute 调用方从 ctx.model 传入。 */
+    ctxModel?: ModelInfo;
+    /** background 完成回调（sync 不调）。 */
+    onComplete?: (record: RecordSnapshot) => void;
+    /** 是否继承父会话上下文（fork 模式，只继承上下文）。 */
+    fork?: boolean;
+    /**
+     * [v8.5 B] fork-from 显式指定继承源 session 文件（非主 session）。
+     * 与 fork:true 的区别：fork:true 用主 session 作 --fork 源；本字段用任意已有
+     * session 文件（断联 subagent 接续场景）作源。优先级高于 fork；传了本字段时
+     * fork 取值不影响 spawn 参数。仅 pi 引擎支持（同 fork）。仅 background tool
+     * 层 fork-from action 使用；workflow / executeAndAwait 不消费。
+     */
+    forkFromSessionFile?: string;
+    /** 文件系统隔离：true=创建新 git worktree，WorktreeHandle=复用外部已创建的；undefined=不隔离（parent cwd）。 */
+    worktree?: boolean | WorktreeHandle;
+    /** 覆盖执行 cwd（默认 mainCwd）。 */
+    cwd?: string;
+    /**
+     * 可持续对话模式（决策 8：独立 chatMode 标志，不扩展 ExecutionMode）。
+     * true = record 标记 chatMode，轮次完成进 idle 态（保留 record + worktree，等待 message 续聊）；
+     * undefined/false = 一次性模式（默认，行为完全不变）。service.execute 透传到 createRecordForMode。
+     */
+    conversation?: boolean;
+    /**
+     * 同步收集模式（subagent-sync-collect 设计 §3.1.3，U1 foundation 契约）。
+     * undefined = config collectSync.default（缺省 "async"，新 session 生效）。
+     * schema 层枚举限 "async"|"sync"；运行时宽收 string 与 engine 字段同风格
+     * （非法值 ≠ "sync" 按 async 处理）。
+     * "sync" + conversation:true 组合在 startHandler E4 校验即拒
+     * （immediate throw，不产生半启动 record）。
+     * U2 接线点：service.createRecordForMode 读入 createRecord identity.collectMode
+     * （U1 打通类型与 startHandler 透传，record 落点归 U2）。
+     */
+    collect?: string;
+    /**
+     * 空闲超时毫秒数（仅 conversation 模式有意义）。覆盖默认 5min idle timeout。
+     * 优先级：参数 > env XYZ_SUBAGENT_IDLE_TIMEOUT_MS > 默认 300000ms。
+     * 显式传 0/负数 = 禁用 idle GC（不挂 timer；旧实现 0 会落成 setTimeout(0) 立即 kill）。
+     */
+    idleTimeoutMs?: number;
+    /**
+     * 实际执行引擎 id（P4 路由留痕）：pi 引擎由 PiEngine.run 在还原 opts 时写入；
+     * 缺省（历史调用方不设）= pi 投影。createRecordForMode 读入 record identity。
+     */
+    engine?: string;
+    /**
+     * 引擎 fallback 留痕（D9①：probe 失败路由回默认引擎时由路由层写入）。
+     * from = 请求引擎 id，reason 恒 'engine_probe_failed'（GUI 警告条数据源）。
+     */
+    engineFallback?: {
+        from: string;
+        reason: string;
+    };
+}
+/**
+ * execute 返回值。
+ *   background: { mode:"background", subagentId, sessionFile, details } —— 立即返回。
+ *            subagentId 供后续 cancel/list 用；sessionFile 窗口期可能 undefined。
+ */
+type ExecutionHandle = {
+    mode: "background";
+    subagentId: string;
+    sessionFile: string | undefined;
+    details: SubagentToolDetails;
+};
+/** list 的 item 结构。 */
+interface SubagentListItem {
+    subagentId: string;
+    agent: string;
+    /** 短标签（≤35 字符），来自 record.slug。旧 record 反序列化时为空串。 */
+    slug: string;
+    /** 对外四态（决策 10 细则 3，主字段）。由 mapExternalState(status) 派生。 */
+    state: ExternalState;
+    /** 原始内部状态（调试用，供 details 展示）。 */
+    status: ExecutionStatus;
+    mode: ExecutionMode;
+    /** 运行秒数（running 态实时计算，终态 endedAt-startedAt）。 */
+    duration: number;
+    model: string;
+    totalTokens: number;
+    /** session jsonl 文件名（窗口期内可能 undefined）。 */
+    sessionFile?: string;
+    /** 直接父 subagent record ID（顶层 record 为 undefined）。[v4 A-6] 从
+     *  record.parentRecordId 派生，配合 A-5 直接父守卫（message/close 仅作用于直接子）。 */
+    parent?: string;
+    /** 可冷路径 resume（running 且无活进程句柄）。[v4 A-6] B-1「可续聊」对外表达，
+     *  agent 据 list 判断哪些 running subagent 实际可续聊（vs 正在忙）。 */
+    resumable?: boolean;
+    /**
+     * 终态三态对外语义（U3 C-outcome 一等披露，projectOutcome 唯一出口）：
+     * completed / failed / cancelled，历史 record 无 outcome 字段时兜底派生，
+     * 不可判读的存量形态为 "closed-legacy"。GUI pane / agent 据此判读成败，
+     * 无需翻 error 字段原文（S5）。
+     */
+    outcome?: ProjectedOutcome;
+    /**
+     * 来源身份（H2 W1）：undefined（存量 list 形态 / record 无 origin）= "tool" 语义。
+     * includeWorkflow 打开后 list 条目与手动派发 record 靠本字段区分（排查 workflow
+     * run's subagents 场景的辨识数据）。
+     */
+    origin?: RecordOrigin;
+    /** origin="workflow" 时所属 workflow run id；tool 来源恒缺省（同 record 侧）。 */
+    parentRunId?: string;
+}
+/** background 启动的内层响应（挂在 SubagentToolResult.bgResponse）。 */
+interface BgResponse {
+    status: "running";
+    mode: "background";
+    /** 启动提示文案（"detached, will notify on completion"）。 */
+    message: string;
+    /**
+     * 终态三态语义（U3 C-outcome 对外 JSON 契约完备位）。start 时点 record 尚未终态，
+     * 恒 undefined（JSON.stringify 落键省略）；终态成败语义经 list items[].outcome
+     * 披露。旧字段 status/mode/message 原样保留（向后兼容）。
+     */
+    outcome?: ProjectedOutcome;
+    /**
+     * 通知投递契约回显位（U1 预置，U2 通知账本的契约声明）。恒值
+     * "ledger+at-least-once"：主 agent 在当前 run 结束或有限延迟内收到完成通知，
+     * 送达保证为 at-least-once + notifyId 幂等可识别。字段与填充由 U1 负责，
+     * 值语义由 U2（execution/notify-ledger.ts）兑现。
+     */
+    notifyContract: "ledger+at-least-once";
+    /**
+     * 同步收集登记回显段（subagent-sync-collect 设计 §3.1.1 交互样例，U1 foundation）。
+     * 仅 resolved 模式为 sync 时附带（async 响应字节零变化，G3）：mode = 生效模式；
+     * pendingSyncCount = 当前未闭合批的 sync 成员总数（含本条；跨轮派发续累不重置，
+     * 与 D2 隐式批一致）。
+     */
+    collect?: {
+        mode: "sync";
+        pendingSyncCount: number;
+    };
+}
+/** list 的内层响应（挂在 SubagentToolResult.listResponse）。 */
+interface ListResponse {
+    /** items 中 status==="running" 的计数（受 limit 截断如实反映，非全局总数）。 */
+    running: number;
+    items: SubagentListItem[];
+}
+/** cancel 的内层响应（挂在 SubagentToolResult.cancelResponse）。 */
+interface CancelResponse {
+    cancelled: true;
+}
+/**
+ * message 的内层响应（挂在 SubagentToolResult.messageResponse，决策 10 瘦身）。
+ *
+ * [R1 删除记录] 旧 PendingMessage（在途消息缓存条目，消费确认制，设计决策 6 状态×
+ * interrupt 映射）已随 deliverToRunning 一并删除——SP-5 upgrade 后无生产调用方，
+ * 配套三段消费链（push / message_start shift / redeliverPending 补投）全部不可达。
+ * 详见 subagent-service.ts 的删除记录注释。
+ */
+interface MessageResponse {
+    delivered: true;
+}
+/** close 的内层响应（挂在 SubagentToolResult.closeResponse，决策 10 瘦身）。 */
+interface CloseResponse {
+    closed: true;
+}
+/**
+ * Tool 外层出参（renderResult + LLM content JSON 同源）。
+ * adapter 唯一产出：领域对象（bg/list/cancel/message/close 五选一）+ action/subagentId/sessionFile。
+ *
+ *   - background 启动 → bgResponse（subagentId 有值；sessionFile 窗口期可能 undefined）
+ *   - list → listResponse（最外层 subagentId/sessionFile 为 null，sessionFile 在各 item 内）
+ *   - cancel → cancelResponse（subagentId 有值；sessionFile 无意义，可为 null）
+ *   - message → messageResponse（subagentId 有值；sessionFile 无意义，可为 null）
+ *   - close → closeResponse（subagentId 有值；sessionFile 无意义，可为 null）
+ */
+type SubagentToolResult = {
+    action: "start";
+    subagentId: string;
+    sessionFile: string | null;
+    slug: string; /** registry 全等回显（U1）：放行即与 registry 条目全等，"provider/id" 形态。 */
+    model: string;
+    bgResponse: BgResponse;
+    __gui__?: GuiRenderResult;
+} | {
+    action: "list";
+    subagentId: null;
+    sessionFile: null;
+    listResponse: ListResponse;
+    __gui__?: GuiRenderResult;
+} | {
+    action: "cancel";
+    subagentId: string;
+    sessionFile: null;
+    cancelResponse: CancelResponse;
+    __gui__?: GuiRenderResult;
+} | {
+    action: "message";
+    subagentId: string;
+    sessionFile: null;
+    messageResponse: MessageResponse;
+    __gui__?: GuiRenderResult;
+} | {
+    action: "close";
+    subagentId: string;
+    sessionFile: null;
+    closeResponse: CloseResponse;
+    __gui__?: GuiRenderResult;
+} | {
+    action: "fork-from";
+    subagentId: string;
+    sessionFile: string | null;
+    forkFromResponse: ForkFromResponse;
+    __gui__?: GuiRenderResult;
+};
+/** fork-from 的内层响应：新 subagent id + 作为继承源的旧记录 session 文件。
+ *  [v8.5 B] 断联恢复通道——新 subagent 以 --fork 方式继承旧会话历史，源文件只读
+ *  不续写（pi fork 建 branched session，copy-on-write）。 */
+interface ForkFromResponse {
+    /** 新 subagent record id（接续对话用 action:'message'）。 */
+    newSubagentId: string;
+    /** 作为继承源的旧 subagent session jsonl 绝对路径。 */
+    sourceSessionFile: string;
+}
+/** /subagents list 左列展示单元。来自内存(running) 或 session.jsonl 重建(终态)。 */
+interface SubagentRecord {
+    id: string;
+    agent: string;
+    /** 任务提示词（详情面板置顶展示）。磁盘/内存源均有。 */
+    task: string;
+    /** 短标签（≤35 字符）。磁盘重建源旧文件可能缺失→兜底空串。 */
+    slug: string;
+    status: ExecutionStatus;
+    /** L2 关闭原因子枚举（仅 status="closed" 时有意义）。SP-1 新增。 */
+    closedReason?: ClosedReason;
+    /** 终态三态对外语义（U3 C-outcome）。磁盘重建源一等直读；无字段的存量兜底走 projectOutcome。 */
+    outcome?: ExecutionOutcome;
+    mode: ExecutionMode;
+    startedAt: number;
+    /** 根 Pi session ID（session 隔离过滤用）。递归链上所有层 record 同值。 */
+    rootSessionId: string | undefined;
+    /** 直接父 subagent record ID（层级树构建用）。顶层 record 为 undefined。 */
+    parentRecordId: string | undefined;
+    /** subagent 递归深度。顶层 =0，每层嵌套 +1。 */
+    depth: number;
+    /**
+     * 来源身份（H2 W1，D1，与 ExecutionRecord.origin 同源投影/entry 重建）。
+     * 缺省（undefined / 存量磁盘重建源）语义 = "tool"；消费面按 `=== "workflow"`
+     * 负向判定，list 查询缺省过滤（includeWorkflow 缺省 false）。
+     */
+    origin?: RecordOrigin;
+    /**
+     * origin="workflow" 时所属 workflow run id（与 ExecutionRecord.parentRunId 同源）。
+     * W2/W3 run 视图下钻按 collectRecordsByParentRunId 查询；tool 来源恒 undefined。
+     */
+    parentRunId?: string;
+    endedAt: number | undefined;
+    turns: number;
+    totalTokens: number;
+    model: string;
+    thinkingLevel: string | undefined;
+    eventLog: AgentEventLogEntry[];
+    /** [STEP3] 从 turns[] 派生的展示项（对齐 nicobailon getDisplayItems）。 */
+    displayItems: DisplayItem[];
+    /** running 时的当前活动行（仅内存源；磁盘重建无此数据）。streaming 可观测性用。 */
+    currentActivity?: {
+        type: "tool" | "text" | "thinking";
+        label: string;
+    };
+    result?: string;
+    error?: string;
+    sessionFile?: string;
+    /** [MF#3] worktree 模式下子 agent 改动的 patch 文件路径（worktree 外，供调用方应用）。 */
+    patchFile?: string;
+    /**
+     * [review round2] 创建时启用 worktree 隔离（磁盘重建源从 session entry 恢复；内存源由
+     * recordToSubagent 从 worktreeHandle 投影）。getRecordForAction 跨重启重建时据此拒绝续聊。
+     */
+    worktree?: boolean;
+    /**
+     * 对话轮次计数（仅 chatMode idle record 有意义）。round 仅在内存维护（doFinalizeRoundToIdle
+     * 递增），跨重启不恢复（round 无磁盘持久化）；非对话模式 / 非 idle record 为 undefined。内存源由 recordToSubagent 从
+     * ExecutionRecord.round 投影。
+     */
+    round?: number;
+    /**
+     * 对话模式标志（与 ExecutionRecord.chatMode 同义；投影给 GUI 侧 streaming/waiting/done
+     * 细分判据——one-shot 轮终（chatMode 非 true + result 有值）显示完成态，chat 轮终显示
+     * 等续聊。内存源由 recordToSubagent 投影，磁盘源经 subagent-record entry 重建）。
+     */
+    chatMode?: boolean;
+    /**
+     * 执行态信号（与 ExecutionRecord.resumable 同义）：true = 无活进程驱动的 running
+     * （轮终 idle / 重建孤儿兜底），GUI 侧据此排除「真在跑」判定。
+     */
+    resumable?: boolean;
+    /** fork 模式下的 worktree handle。 */
+    worktreeHandle?: WorktreeHandle;
+    /**
+     * 实际执行引擎 id（P4 路由留痕）。缺省 = pi 投影（存量 record 零迁移）；
+     * GUI 警告条/引擎标记的数据源之一。
+     */
+    engine?: string;
+    /** 引擎 fallback 留痕（D9①：probe 失败路由回默认引擎）。GUI 警告条数据源。 */
+    engineFallback?: {
+        from: string;
+        reason: string;
+    };
+    /**
+     * 引擎自描述定位符（U1：EngineHandleData 的持久化消费面子集，引擎无关——
+     * sessionRef 整体透传不枚举内部键）。read 降级链①②级的数据源（runtime
+     * subagent-engine-history）；缺省 = pi（走 JSONL 直读链）。
+     */
+    engineHandle?: {
+        sessionRef: Record<string, string>;
+        journalPath?: string;
+        poolKey: string;
+    };
+    /**
+     * 同步收集模式标记（与 ExecutionRecord.collectMode 同源投影/重建，U1 foundation）。
+     * 缺省（存量 record）= async 投影，消费方零迁移。
+     */
+    collectMode?: "sync";
+    /**
+     * 离开批终局标记（与 ExecutionRecord.batchFinalized 同源投影/重建，U1 foundation）。
+     * 缺省 = 未离开批；U5 E1 重建扫描据此排除已离场成员。
+     */
+    batchFinalized?: boolean;
+}
+/**
+ * 同步收集（sync collect）配置节类型（subagent-sync-collect 设计 §3.1.3，U1 foundation）。
+ * 权威默认值在 config.ts DEFAULT_COLLECT_SYNC；坏值 sanitize 回默认不炸启动（E5，
+ * 与 maxConcurrent 同判）。类型定义于 types.ts（避免 config → types 反向依赖成环），
+ * config.ts re-export。
+ */
+interface CollectSyncConfig {
+    /** start 未显式传 collect 时的缺省模式。新 session 生效（与 engine 配置时机一致）。 */
+    default: "async" | "sync";
+    /** 批通知单条目结果正文预算（字符）：超出截断并接 session_read 指针行。flush 时热读。 */
+    perItemChars: number;
+    /** 批通知结果正文总量预算（字符）：Σ 超限时统一收紧 effectivePerItem（U4 算法）。flush 时热读。 */
+    totalChars: number;
+}
+/**
+ * 全局配置（~/.pi/agent/subagents/config.json）。
+ *
+ * 模型解析已退化为「主 agent model 优先，仅 override 时查 registry」——
+ * 不再有 category/fallback/yolo 字段。config.json 只保留 maxConcurrent
+ * （pool 大小）。旧 config.json 中的 categories/fallback 等字段读取时忽略。
+ */
+interface SubagentsGlobalConfig {
+    version: number;
+    maxConcurrent: number;
+    /**
+     * 全局默认执行引擎（D9 三层优先级的最底层：调用参数 > agent frontmatter > 本值）。
+     * 缺省 'pi'（P4 路由层 DEFAULT_ENGINE_ID）。加载期只做类型校验，注册表校验归路由层。
+     */
+    defaultEngine?: string;
+    /** 引擎路由策略（D9①）：strict=true 时一切 probe 失败直接报错（不 fallback）。 */
+    engineRouting?: {
+        strict: boolean;
+    };
+    /**
+     * 同步收集配置节（subagent-sync-collect 设计 §3.1.3，U1 foundation）。
+     * 整节缺省 = DEFAULT_COLLECT_SYNC（config.ts）；逐字段 sanitize 回默认（E5）。
+     */
+    collectSync?: CollectSyncConfig;
+}
+/**
+ * Record 的只读视图。store.snapshot() 返回。
+ * TUI 拿到此类型，保证不会回写 Core 状态。
+ *
+ * 不含 eventLog——snapshot 的消费点（cancel 判 mode/status、hasRunning 判 mode、
+ * toNotifyRecord 取 result/error）均不读 eventLog。需要 eventLog 的场景用 project()
+ * 投影的 SubagentToolDetails。需要完整内容用 record.turns[]（Core 内部）。
+ */
+interface RecordSnapshot {
+    readonly id: string;
+    readonly agent: string;
+    readonly model: string;
+    readonly thinkingLevel: string | undefined;
+    readonly mode: ExecutionMode;
+    readonly task: string;
+    /** 短标签（≤35 字符）。来自 record.slug。 */
+    readonly slug: string;
+    readonly status: ExecutionStatus;
+    /** 对话模式标志（与 ExecutionRecord.chatMode 同源）。cancel 别名判定用。 */
+    readonly chatMode?: boolean;
+    readonly turns: number;
+    readonly totalTokens: number;
+    readonly startedAt: number;
+    readonly endedAt: number | undefined;
+    readonly result: string | undefined;
+    readonly error: string | undefined;
+    readonly sessionFile: string | undefined;
+}
+
 type ExtensionMode = "tui" | "rpc" | "json" | "print";
 
 /** 投递意图（与 session-delivery 的 DeliveryIntent 字面量一致）。 */
@@ -497,215 +1286,396 @@ declare function projectLiveProgress(record: ExecutionRecord): {
     lastError: string | undefined;
 };
 
-/** 入队项的 child 引用形状（只取 pid 用于 rejectChildDialogs 匹配）。 */
-interface DialogChildRef {
-    pid: number;
+interface ManifestRecord {
+    id: string;
+    rootSessionId: string;
+    /** 直接父 subagent record ID（层级树构建用）。顶层 record 缺失（undefined）。M3a 补字段。 */
+    parentRecordId?: string;
+    agentName: string;
+    /**
+     * 终态枚举：finalizeRecord 写 running/closed/cancelled 三态。
+     * SP-1 重构：旧 completed/failed 合并为 closed（L1 统一终态）。
+     * cancelled 保持独立（用户取消语义）。crashed 不进 manifest——
+     * crashed 是重启重建时靠 sidecar 四分支推断的派生态（见 record-store.ts reconstructAll）。
+     * 历史 "error"/"completed"/"failed" 值由读侧 mapManifestStatus 向后兼容映射。
+     */
+    status: "running" | "closed" | "cancelled";
+    /**
+     * [U4c / D5 词汇双写过渡] 内部权威状态词汇（ExecutionStatus 二态）。
+     * 与上方旧 status 三态投影**永久双写**——无版本磁盘 schema 不做破坏性变更；
+     * session-reader（独立 npm 包独立进程）直读旧 status 做 identity 富字段投影
+     * 与孤儿判定，删字段 = 外部消费方富字段降级。旧 status 只降权威地位不删字段。
+     * 宿主内消费方不读本字段（终态判定走 `.state` 权威，D1）；本字段是词汇收口
+     * （全景① ExecutionStatus+ClosedReason）在 manifest 写面的过渡锚。
+     */
+    executionStatus?: ExecutionStatus;
+    /**
+     * [M2 Gate B] closed 终态的 L2 关闭原因（status="closed" 时有意义）。旧 manifest 无
+     * 此字段（undefined = 死因不可考，读侧守卫归一 undefined）。缺失时 manifest 源重建
+     * 的快照丢 closedReason，endedMessageGuard 把 user-close/cancelled 误分流进
+     * 「reconnectable/fork-from」分支——本字段是 manifest 源快照三分流的唯一依据
+     * （磁盘 sidecar 源由 .state reason 承载，不经本字段）。
+     */
+    closedReason?: ClosedReason;
+    createdAt: number;
+    completedAt?: number;
+    sessionFile?: string;
+    /** FR-7 补字段：manifest 写入时从 ExecutionRecord 抓取，供 manifestToSubagent 投影真实值。 */
+    task?: string;
+    slug?: string;
+    model?: string;
 }
-/** enqueue 的可选项。child 用于 rejectChildDialogs 关联（child close 时批量 reject）。 */
-interface EnqueueOptions {
-    child?: DialogChildRef;
+declare class ManifestStore {
+    private readonly dir;
+    /** [perf] per-file 缓存：file → { stamp, record }。record=null 表示「已解析但非法」（缓存
+     *  负结果避免反复 parse 损坏文件）。stat 戳变化（writeManifest tmp→rename 后 mtime/size 变）
+     *  自动失效；删除的文件在下次扫描时修剪。 */
+    private readonly cache;
+    constructor(dir: string);
+    /**
+     * 原子写：tmp → fsync → rename → fsync dir（shared/atomic-write 统一原语，
+     * U6b 迁移——原逐行实现与 writeAtomicFile 逐环等值）。真异步（fs.promises，
+     * 不阻塞 event loop）。
+     *
+     * 失败时原语尽力清理残留 tmp（debug 记录，不掩盖原错误）并原样上抛——
+     * 调用方（RecordStore 写面：writeManifestPersisted 缺省异步分支 / 批写 barrier /
+     * rebuildIndexes 重建降级（debug 留痕）/ rematerializeManifest（warn 语义））
+     * 决定降级策略——各面降级策略分化见各调用点。
+     */
+    writeManifest(record: ManifestRecord): Promise<void>;
+    /**
+     * 按 id 读 manifest。文件不存在/JSON 损坏/schema 不合法均返回 null。
+     * 调用方需处理 null。
+     */
+    readManifest(id: string): Promise<ManifestRecord | null>;
+    /**
+     * 同步读取所有 manifest 记录（best-effort，损坏/非法文件跳过）。
+     * 供 RecordStore.collectRecords 投影 orphan 记录使用——替代对私有 dir 的反射访问。
+     * 仅返回通过 isValidManifest 校验的记录。
+     *
+     * [perf] per-file 缓存 + stat 戳校验：collectRecords 每次渲染都调本方法，旧实现每次
+     * 全量 readFileSync + JSON.parse 千级 manifest（实测 ~300ms/次）。命中缓存的文件零读取。
+     */
+    listAllSync(): readonly ManifestRecord[];
+    /**
+     * 启动时清扫 tmp 残留（[U4c / D6] tmp 恢复退役后的语义——[H4/U5 收口] 更名
+     * recoverTmpFiles → sweepTmpFiles，名实对齐「静默删除」）。
+     *
+     * 旧语义（ADR-035 三分支：manifest 已存在删 tmp / tmp 合法且 manifest 缺失
+     * promote / tmp 非法删）已随缓存降级退役——manifest 现为可丢可重建缓存
+     * （权威 = `.state`，重建 = RecordStore.rebuildIndexes，D5），promote 半写 tmp
+     * 只会把陈旧快照复活成「看似权威」的索引，语义失效；统一**静默删除**全部
+     * tmp（含 0 字节/半写形态——D8 停机窗残留由本清扫顺带清理）。
+     *
+     * [T5④ / PS-13] per-file 容错保留：单个 tmp 删除失败（ENOENT——并发回收/外部
+     * 清理抢先、EACCES 等）只 warn + 跳过该文件，不再中断整轮。promote 退役后
+     * 无恢复形态，返回值简化为删除计数。
+     *
+     * @returns 删除的 tmp 文件数。
+     */
+    sweepTmpFiles(): Promise<number>;
+}
+
+/** 三态读取结果（判别联合，调用方按 status 分派）。 */
+type GlobalConfigReadResult = 
+/** 读到明确值：JSON 可解析，字段已经 sanitize。 */
+{
+    status: "ok";
+    config: SubagentsGlobalConfig;
+}
+/** 明确缺省：文件不存在（ENOENT）。这是用户意图（删配置切回缺省 pi），不是故障。 */
+ | {
+    status: "absent";
+    config: SubagentsGlobalConfig;
 }
+/** 读失败：坏 JSON / 权限等。携带原始错误消息供诊断；调用方保持 lastEngine 不动。 */
+ | {
+    status: "failed";
+    reason: string;
+};
 /**
- * L2 跨子进程全局 dialog 串行队列（进程单例）。
- *
- * 用法（createUiRequestHandlerForMode 返回的总 handler 内）：
- * ```ts
- * const dialogQueue = new DialogGlobalQueue();
- * return async (req: UiRequest) => {
- *   // 调用方负责判断：dialog 入队，fire-and-forget 直接调 realHandler
- *   if (isDialogMethod(req.method)) return dialogQueue.enqueue(req, realHandler);
- *   return realHandler(req);
- * };
- * ```
- *
- * 语义保证：
- *   - FIFO 串行：前一个 handler settle 后才处理下一个
- *   - SR-4：rejectChildDialogs(child) 把该 child 的 pending 全部 resolve 为 {cancelled:true}
- *   - handler 抛错兜底：catch → {cancelled:true} → 继续下一个（队列不卡死）
- *   - 超时上界（LC-3/T2⑦）：每个 dialog 项必有上界——req.timeout 显式传值优先，
- *     未传挂 DEFAULT_DIALOG_TIMEOUT_MS（30min，裁决值）；到点 settle {cancelled:true}
- *     并 warn（恢复指引见 dialogTimeoutLogMessage），L2 processing 释放、队列继续推进。
- *     「等用户无限久」改为默认有界是有意的行为变更。
- *   - 调用方约定只对 dialog 类调 enqueue；fire-and-forget 由调用方直接调 handler 不入队
- *（enqueue 内仍防御性兼容 fire-and-forget，但不保证行为）
+ * 三态读取全局配置（设计 D5）。
  *
- * 线程模型：纯 Promise + 微任务驱动，无锁。Node 单线程 event loop 保证队列状态一致。
+ * 为什么不用 loadGlobalConfig：后者 ENOENT 与坏 JSON 同归 DEFAULT_CONFIG（静默
+ * 回落），检测器若消费该形态会把「用户删配置切回缺省」（合法变更，须生效）误判成
+ * 「读失败」（须保持 lastEngine），也会把坏 JSON（torn write）误判成合法缺省——
+ * 两个方向都会产生错误的引擎切换信号。
+ */
+declare function readGlobalConfig(agentDir: string): GlobalConfigReadResult;
+
+/** Service 构造参数（进程级，跨 session 不变）。 */
+interface ModelConfigServiceInit {
+    agentDir: string;
+    /** 项目根目录（ctx.cwd，用于推导 workspaceRoot 扫描 project 级资源）。 */
+    cwd: string;
+}
+/** session_start 注入参数（session 级，每次重建）。 */
+interface ModelServiceSessionInit {
+    /** 模型注册表（鉴权 + 发现）。null 立即抛错（fail-fast）。 */
+    modelRegistry: ModelRegistryLike | null;
+    /** 当前 session ID。 */
+    sessionId: string;
+    /**
+     * 主 agent 当前 model（session_start 时注入，model_select 时刷新）。
+     *
+     * renderCall 阶段的 ToolRenderContext 不含 model 字段（SDK 限制），无法直接拿到
+     * 主 agent model。缓存后 renderCall 的 resolveModel 能命中第三层（ctxModel），
+     * 让标题行恢复显示 model——即使未显式传 model 也能展示默认 model。
+     *
+     * [HISTORICAL] 99f20da1e 引入三层 fallback 后，renderCall 因拿不到 ctxModel
+     * 而 resolveModel 拗错→降级不显示 model。此缓存修复该降级。
+     */
+    ctxModel?: ModelInfo;
+}
+/**
+ * 配置 + 模型解析 Service。进程级单例。
  *
- * 单 session 假设（M-2，与 index.ts lastSessionId 同源）：本队列是进程级单例（实例挂在
- * globalThis[Symbol.for("@zhushanwen/pi-subagents.dialogQueue")]，见 getOrCreateDialogQueue）。
- * rejectAll() 清空所有 pending dialog——无 per-session 隔离。Pi 当前架构保证单进程
- * 单 session 串行（同进程不会并发多个 session），故 session_shutdown 调 rejectAll() 只会清掉
- * 当前 session 的 pending。若未来 Pi 支持同进程多 session 并发，session A 退出会误清 session B
- * 的 pending dialog——届时需改为 per-session 隔离（入队项 QueueItem 带 sessionId，rejectAll
- * 改 rejectAllForSession(sessionId)，session_shutdown 只清当前 session）。
+ *   ┌──────────────────────────────────────────────────────┐
+ *   │  globalConfig（~/.pi/.../config.json，仅 maxConcurrent）│
+ *   │  agentRegistry（agent .md 发现 + frontmatter）         │
+ *   │  modelRegistry（SDK 注入的可用模型）                    │
+ *   │                                                      │
+ *   │  resolveModel: override → agentConfig → 主 agent model │
+ *   └──────────────────────────────────────────────────────┘
  */
-declare class DialogGlobalQueue {
-    /** 等待处理的队列（FIFO）。正在处理的项从 queue shift 出后由 current 持有。 */
-    private queue;
-    /** 正在处理的项（handler 已调、未 settle）。用于 rejectChildDialogs 取消占位中的 dialog。 */
-    private current;
-    private processing;
+declare class ModelConfigService {
+    private globalConfig;
+    private readonly agentRegistry;
+    private readonly agentRegistryDir;
+    private modelRegistry;
+    private _sessionId;
+    /** 主 agent 当前 model 缓存（session_start 注入，model_select 刷新）。 */
+    private _ctxModel;
+    constructor(init: ModelConfigServiceInit);
+    /**
+     * session_start 注入。封装 3 步固定时序：
+     *   1. reloadGlobalConfig（复用时拿最新 config）
+     *   2. injectModelRegistry（fail-fast：null 抛错）
+     *   3. setSessionId
+     */
+    initModel(init: ModelServiceSessionInit): void;
     /**
-     * 入队一个 UI 请求，返回 Promise<UiResponse>。
+     * 将一次三态读取结果提交到路由缓存（纯赋值幂等）。
      *
-     * 调用方约定：只对 dialog 类（isDialogMethod===true）调 enqueue。fire-and-forget 由
-     * 调用方（ui-request-handler-factory.ts）在 enqueue 前判 isDialogMethod 后直接调 handler，
-     * 不经过本队列。enqueue 内仍防御性兼容 fire-and-forget（万一调用方未判）：直接调 handler 返回，
-     * 不入队串行，但调用方不应依赖此防御行为。
+     * ok/absent 覆盖缓存、failed 保持缓存不动（坏 JSON 不能把好缓存打回缺省）；
+     * 返回入参便于链式消费。用途 = 构造性同源：session_start 初始化与 per-turn 引擎
+     * 检测各只读一次文件，同一读取结果既刷新路由缓存又充当检测基准，消灭两次独立
+     * 读取之间的分叉窗口（两次读值不一致时检测走 unchanged，状态段/路由永停旧值）。
+     */
+    applyGlobalConfig(read: GlobalConfigReadResult): GlobalConfigReadResult;
+    /**
+     * 三态重读全局配置并提交缓存（幂等可重入），返回本次读取结果供调用方感知。
      *
-     * dialog 项处理（TC-E4 case 1）：进队列 FIFO 串行，等前一个 settle 后才调 handler
-     *（争输入焦点，防并发弹窗）。
+     * 从 initModel 提取（设计 D2）：引擎感知检测器 per-turn poll 发现 config 变更时
+     * 调用本方法，使「system prompt 现值、路由缓存、变更通知」同 turn 对齐——只改注入
+     * 不刷新路由缓存，会出现 prompt 说引擎 B、实际派发跑引擎 A（权威信息源说谎）。
+     * 幂等性：只做「读文件 → 按三态提交缓存」单向赋值，无时序状态，重复调用收敛到
+     * 同一结果。三态语义（failed 保持缓存、静默回落 DEFAULT 是旧缺陷——读失败曾把
+     * 好缓存打回缺省且调用方无法感知）：ok/absent 覆盖、failed 保持并携带原因。
+     */
+    reloadGlobalConfig(): GlobalConfigReadResult;
+    /**
+     * 刷新主 agent model 缓存。model_select 事件时调用。
+     * renderCall 的 resolveModel 读此缓存以显示标题行 model。
+     */
+    setCtxModel(model: ModelInfo | undefined): void;
+    /**
+     * 解析 agent 的模型（三层：override → agentConfig → 主 agent model）。
      *
-     * handler 抛错兜底：catch → 回 {cancelled:true}（dialog 路径，队列不卡死）。
-     * SR-4：opts.child 用于 rejectChildDialogs 关联（dialog 项会被批量 reject，含 current）。
+     * @param agentRef   agent 引用（.md 绝对路径；查 agentConfig 的 model override）
+     * @param override   调用方显式 override（最高优先级）
+     * @param ctxModel   主 agent 当前模型（兜底，直接透传）
+     */
+    resolveModel(agentRef: string, override?: {
+        model?: string;
+        thinkingLevel?: string;
+    }, ctxModel?: ModelInfo, 
+    /** 已解析的 agent 配置（调用方已加载时复用，避免同一 agentRef 二次 loadByPath）。 */
+    agentConfig?: AgentConfig): ResolvedModel;
+    /** 查询 agent 配置（SubagentService 内部判定 defaultBackground 用）。
+     *  undefined = 合法缺省语义（未点名 / 默认 general-purpose 形态）。 */
+    getAgentConfig(agentRef?: string): AgentConfig | undefined;
+    /**
+     * 查询 agent 配置——显式 ref 失败即 throw（SubagentService.resolveIdentity 用）。
      *
-     * @param req UI 请求（约定只传 dialog 类；fire-and-forget 防御性兼容）
-     * @param handler 真正执行请求的 handler（TUI/GUI 模式分流后的 realHandler）
-     * @param opts 可选 child 引用（用于 rejectChildDialogs 关联）
-     * @returns handler 的响应；dialog 抛错时回 {cancelled:true}；child close 时回 {cancelled:true}
+     * 与 getAgentConfig 的语义分界（「用户显式点名」vs「默认 general-purpose」）：
+     * 用户显式点名的 agentRef（工具 agent 参数 / workflow agent({agent}) opts）解析
+     * 失败 = 配置错误，必须显式报错——错误文案含 <available_subagents> 恢复指引
+     * （对齐 workflow name not found 反馈风格），不允许静默降级为无配置
+     * general-purpose 形态（systemPrompt/工具白名单全丢且零反馈）。默认形态
+     * （不传 agent）走 getAgentConfig：undefined = 合法缺省，走 override → ctxModel 兑底。
      */
-    enqueue(req: UiRequest, handler: UiRequestHandler, opts?: EnqueueOptions): Promise<UiResponse>;
+    getRequiredAgentConfig(agentRef: string): AgentConfig;
+    /** 全局配置深拷贝（调用方拿到副本，改不影响 Service 内部）。 */
+    getGlobalConfig(): SubagentsGlobalConfig;
+    /** 内部：session id 缓存（initModel 注入；当前无消费者，保留供未来 session 作用域需求）。 */
+    get sessionId(): string | undefined;
+    /** agent 配置目录（SubagentService 构造 store/SessionRunnerContext 时读）。 */
+    getAgentDir(): string;
+    /** modelRegistry（SubagentService 构造 factoryCtx 时读）。已注入保证非 null。 */
+    getModelRegistry(): ModelRegistryLike;
+    /** 校验 modelRegistry 已注入。 */
+    private assertReady;
+}
+/** 获取进程单例。session_start 前为 null。 */
+declare function getModelConfigService(): ModelConfigService | null;
+/** 设置进程单例（session_start 首次创建时）。 */
+declare function setModelConfigService(service: ModelConfigService): void;
+
+declare class WorktreeManager {
+    private readonly registry;
+    private readonly agentDir;
+    private readonly writeQueues;
+    private readonly ambiguousSkipCycles;
+    constructor(agentDir: string);
     /**
-     * settle 一个 item（幂等）。handler 完成 / rejectChildDialogs / rejectAll / 超时 timer
-     * 都通过本方法，settled 标志保证只 settle 一次（防竞争）。
+     * 为子 agent 创建隔离 worktree。
      *
-     * #19 单一推进点：本方法 settle Promise + 清状态后，**唯一**调 processNext 推进队列。
-     * processNext 尾部不再调 processNext（旧代码双重推进，虽靠 processing 标志幂等，但语义混乱）。
-     * 为什么推进必须在 settleItem 而非 processNext 尾部：rejectChildDialogs 取消一个永不 settle
-     * 的 current（handler 等用户输入卡死）时，processNext 的 `await item.handler` 永不 resume，
-     * 尾部不会执行；只有 settleItem 里的 processNext 才能打破死锁，推进下一个。
+     * @param mainCwd 主仓库根目录
+     * @param recordId 执行记录 ID（必须匹配 `^[\w-]+$`）
+     * @returns 冻结的 WorktreeHandle
+     */
+    create(mainCwd: string, recordId: string): Promise<WorktreeHandle>;
+    /**
+     * 注册子进程 pid（runSpawn spawn() 返回后调）。
+     * create 时 pid 未知写 0 占位，子进程 spawn 返回后（child.pid 同步可得）由此补全。
+     * reaper 据 pid 死活判孤儿，pid=0 条目用 SPAWN_GRACE 宽限。
+     * sessionFile 可选补全：传入时填入 registry entry（reaper 据 pid 死活判孤儿，不读本字段；保留供诊断）。
      *
-     * [A2-2] 超时 timer 清理也统一收口在这里：任何路径抢先 settle（reject/rejectAll/超时
-     * 自身）都必须撤下 armed timer——handler 永挂时 processNext 内联的 clearTimeout 不可达，
-     * 不在这里清则 timer 到期触发虚假「dialog timed out」warn 且句柄滞留至超时点。
+     * [D5a] async 化：pid 补全走跨进程锁内 RMW（互斥窗口消除 updatePid 与并发 add/remove
+     * 的交错）。永不 reject（锁降级 + best-effort save 均内部兜底），调用方可安全
+     * fire-and-forget（session-runner 的 stdout data 回调上下文）。
      */
-    private settleItem;
+    registerPid(branch: string, pid: number, sessionFile?: string): Promise<void>;
     /**
-     * SR-4：把指定 child 的所有 pending dialog resolve 为 {cancelled:true}。
+     * 清理 worktree：git worktree remove --force + git branch -D + 注册表移除。
+     * 三步各自独立 try/catch——任一步失败不阻断其余（如 remove 失败仍尝试 branch -D + 注册表移除），
+     * 避免单步失败导致后续资源泄漏。
      *
-     * 触发场景：子进程 close（用户取消 / crash / 超时 kill）时，其 pending dialog 的 handler
-     * 可能永不 settle（等用户输入），导致 Promise 永挂 + 内存泄漏。本方法批量清理。
+     * @param handle 要清理的 worktree handle（含 mainCwd，不靠路径反推）
+     */
+    cleanup(handle: WorktreeHandle): Promise<void>;
+    /**
+     * 收集 worktree 的改动为 patch。
      *
-     * 处理范围（TC-E4 case 2）：
-     *   - 正在处理中（current）的该 child 项：settle {cancelled:true}，解阻塞队列推进下一个
-     *     （关键：handler 可能永不 settle，必须由这里打破死锁）
-     *   - 队列中等待处理的该 child 项：settle {cancelled:true} 并移除
+     * [MF#3] patchFile 由调用方指定（写在 worktree 之外，避免被 cleanup 删除）。
+     * [MF#2] 先 git add -A 暂存全部改动（含未跟踪新文件），再 git diff --cached baseCommit
+     * 对比暂存区与 base commit。旧实现 `git diff HEAD baseCommit` 是树 vs 树对比：
+     * worktree HEAD 初始即 baseCommit，子 agent 不提交时 HEAD 仍 == baseCommit → diff 恒空 → 改动丢失。
      *
-     * 不影响其他 child 的 pending dialog（TC-E4 case 2 子测试 2）。
+     * @param handle worktree handle
+     * @param patchFile patch 输出路径（须在 worktree 之外）
+     * @returns patch 结果（patchFile 路径 + failed/written 标记）。
+     *   written=true 仅当 diff 非空且写盘成功；空 diff 或写失败均 written=false，
+     *   调用方据此回填 record.patchFile，避免悬空路径（`git apply` 不存在的文件）。
      */
-    rejectChildDialogs(child: DialogChildRef): void;
+    collectPatch(handle: WorktreeHandle, patchFile: string): Promise<PatchResult>;
     /**
-     * 处理队列下一项（FIFO）。
+     * 扫描并清理 pi-sub-* 孤儿 worktree + 物理面对账（D5b）。
      *
-     * processing 标志保证串行：handler 运行期间 processing=true，新的 processNext 调用直接返回；
-     * handler settle 后由 settleItem 清 processing=false 并推进下一项（#19 单一推进点）。
+     * 阶段一（既有）：遍历全局注册表（<agentDir>/subagents/worktrees.json），
+     * 按 pid 死活判孤儿。不依赖当前 cwd 是否 git repo——注册表里记了 repo 路径，
+     * 直接 git -C <repo> 跨 repo 清理。
      *
-     * handler 抛错兜底（TC-E4 case 3）：catch → settle {cancelled:true} → 继续。
-     * 不能让一个失败卡死队列（processing 永远 true）。
+     * 判据（唯一不删条件 = 进程还活着）：
+     *   pid > 0 且 isProcessAlive(pid)   → 跳过（活进程，绝不删）
+     *   pid > 0 且进程已死                → 孤儿（正常退出未 cleanup / 崩溃残留）
+     *   pid == 0 且超 SPAWN_GRACE_MS      → 孤儿（create 后崩溃，pid 永未补全）
+     *   pid == 0 且未超宽限               → 跳过（可能正在 spawn）
      *
-     * LC-3/T2⑦ 超时上界：`await item.handler` 原本无上界——host UI promise 挂死或用户
-     * 永不回答时 processing 恒 true（全局 dialog 死锁）。现在每项挂队列级 timer：
-     * req.timeout（请求方显式传值）优先，未传/非法挂 DEFAULT_DIALOG_TIMEOUT_MS。
-     * 到点 settle {cancelled:true}（完整错误消息落父进程日志，含恢复指引与等待时长），
-     * settleItem 的 settled 标志保证与 handler 完成 / rejectChildDialogs 三方竞态下
-     * 恰 settle 一次。timer 回调闭包捕获 item（非读 this.current）：迟到触发时
-     * settled 标志已置位，直接 noop，不误伤后继项。
+     * 阶段二（D5b）：物理面（tmpdir checkout + 分支）与注册表双向 diff 收敛——
+     * 兑现 worktree-registry.ts 头注释声称的「tmpdir + 分支对账兜底」。全流程
+     * 幂等、失败仅日志（对账失败不阻断 session_start）。
      */
-    private processNext;
+    scan(): Promise<void>;
     /**
-     * #10：把所有 pending dialog（queue + current）全部 settle 为 {cancelled:true}，
-     * 并清空 queue/current/processing 状态。session_shutdown 调用，保证不留永挂 Promise。
-     *
-     * 约定签名：rejectAll(): void（无参，返 void）。Group C 的 index.ts session_shutdown 依赖此契约。
-     *
-     * 幂等：依赖 settleItem 的 settled 标志——重复调用只会对已 settled 项 noop。
-     * 顺序敏感（#19 推进点在 settleItem）：必须先清空 queue 数组再 settle current，
-     * 否则 settleItem(current) 同步触发的 processNext 会从旧 queue 抢占下一项作为新 current，
-     * 避开本方法的 cancel 语义。清空后 processNext 看到空队列直接返回，新 current 不会被抢占。
+     * D5b 双向 diff 对账：物理面（tmpdir checkout 目录 + git branch --list）与
+     * 注册表互查，收敛三类漂移（锁消灭交错主因后，本对账兜底条目丢失/文件损坏的长尾）。
+     * 方向一/方向二的完整判据见 {@link removePhantomRegistryEntries} /
+     * {@link reconcileUnregisteredWorktrees}。
+     */
+    private reconcileWithPhysical;
+    /** 对账方向一（注册有 → 物理无）：条目的分支与 checkout 目录都已不存在 → 条目指向
+     *  幻影资源 → 移除条目（纯清账，不删任何仍存在的资源，幂等安全）。 */
+    private removePhantomRegistryEntries;
+    /** 对账方向二（物理有 → 注册无）：按 enc 段（encodeCwd(mainCwd)）聚合，活信号 =
+     *  <agentDir>/subagents/<enc>/sessions/*.alive 中存活的 pid（session-runner
+     *  first header 时写入，崩溃残留不删）：
+     *    - 无活 pid：残留判死，checkout mtime 超 SPAWN_GRACE_MS 才清（防误清另一
+     *      进程 worktree add 完成到 registry.add 落盘之间的 create 窗口）；
+     *    - 恰好 1 个活 pid 且恰好 1 个残留：补写回注册表（自愈——最常见的双 session
+     *      并发覆盖丢条目场景，补写后回归标准 pid 判据路径）；
+     *    - 多活 pid 或多残留无法建立 branch↔pid 对应：跳过 + warn——宁延迟勿误删；
+     *      活体自身 cleanup 路径正常（registry.remove 幂等），死体等活 pid 全灭后
+     *      下一周期收敛。
      *
-     * 单 session 假设（M-2）：见类注释。本方法清空所有 pending 不分 session——依赖 Pi 单进程
-     * 单 session 串行保证。session_shutdown handler（index.ts）调用本方法时，进程内只会有当前
-     * session 的 pending dialog。多 session 并发场景的迁移策略（rejectAllForSession）见类注释。
+     *  返回本轮实际进入「歧义跳过」的 checkout 路径集（PS-12 老化计数收敛依据，
+     *  见 reconcileWithPhysical 尾部）。 */
+    private reconcileUnregisteredWorktrees;
+    /** 单 enc 段的残留处置三分支：无活 pid 判死清理 / 唯一对应自愈补写 / 多对应保守跳过。 */
+    private reconcileEncSegment;
+    /** 无活 pid 段：残留判死清理——checkout mtime 超 SPAWN_GRACE_MS 才清（防误清另一
+     *  进程 worktree add 完成到 registry.add 落盘之间的 create 窗口）。 */
+    private cleanupDeadSegment;
+    /**
+     * 物理面发现：扫描 <tmpdir>/pi-subagents/<enc>/<pi-sub-*> checkout 目录。
+   * repo 从 checkout/.git 指针文件推导（`gitdir: <repo>/.git/worktrees/<branch>`，
+     * 普通 repo 与 bare+worktree（.bare/worktrees/...）统一取 worktrees 段上两级）；
+     * 推导失败（残缺 checkout）repo=undefined，由调用方按无主残留处置。
      */
-    rejectAll(): void;
-    /** 清空队列状态（仅在 rejectAll 之后调用）。pending Promise 必须先由 rejectAll settle。
-     *  不 settle Promise 的纯状态重置——单独调用会导致 Promise 永挂（footgun），故设为 private。
-     *  外部调用方应使用 rejectAll()（它 settle 所有 pending + 重置状态，是原子操作）。 */
-    private resetState;
-    /** 当前队列长度（测试/诊断用）。含等待处理项（不含 current）。 */
-    get size(): number;
-}
-
-interface ManifestRecord {
-    id: string;
-    rootSessionId: string;
-    /** 直接父 subagent record ID（层级树构建用）。顶层 record 缺失（undefined）。M3a 补字段。 */
-    parentRecordId?: string;
-    agentName: string;
+    private discoverPhysicalWorktrees;
     /**
-     * 终态枚举：finalizeRecord 写 running/closed/cancelled 三态。
-     * SP-1 重构：旧 completed/failed 合并为 closed（L1 统一终态）。
-     * cancelled 保持独立（用户取消语义）。crashed 不进 manifest——
-     * crashed 是重启重建时靠 sidecar 四分支推断的派生态（见 record-store.ts reconstructAll）。
-     * 历史 "error"/"completed"/"failed" 值由读侧 mapManifestStatus 向后兼容映射。
+     * per repo 查物理分支全集：`git -C <repo> branch --list 'pi-sub-*' --format=%(refname:short)`。
+     * 读类命令不加写锁；单 repo 失败 → map 不含该 repo（get 返回 undefined），
+     * 调用方据此保守跳过该 repo 的条目判定（防把「查询失败」误判成「分支不存在」）。
      */
-    status: "running" | "closed" | "cancelled";
-    createdAt: number;
-    completedAt?: number;
-    sessionFile?: string;
-    /** FR-7 补字段：manifest 写入时从 ExecutionRecord 抓取，供 manifestToSubagent 投影真实值。 */
-    task?: string;
-    slug?: string;
-    model?: string;
-}
-declare class ManifestStore {
-    private readonly dir;
-    /** [perf] per-file 缓存：file → { stamp, record }。record=null 表示「已解析但非法」（缓存
-     *  负结果避免反复 parse 损坏文件）。stat 戳变化（writeManifest tmp→rename 后 mtime/size 变）
-     *  自动失效；删除的文件在下次扫描时修剪。 */
-    private readonly cache;
-    constructor(dir: string);
+    private listPhysicalBranches;
     /**
-     * 原子写：tmp → fsync → rename → fsync dir（shared/atomic-write 统一原语，
-     * U6b 迁移——原逐行实现与 writeAtomicFile 逐环等值）。真异步（fs.promises，
-     * 不阻塞 event loop）。
-     *
-     * 失败时原语尽力清理残留 tmp（debug 记录，不掩盖原错误）并原样上抛——
-     * 调用方（finalizeRecord）决定降级策略。
+     * 收集 enc 段的活 pid：<agentDir>/subagents/<enc>/sessions/*.alive 中
+     * readAliveMarker 解析成功且 isProcessAlive 的 pid（去重）。
+     * 崩溃残留的 .alive（pid 已死）天然过滤掉——这正是「死活判据」的物理面来源。
      */
-    writeManifest(record: ManifestRecord): Promise<void>;
+    private collectAlivePids;
     /**
-     * 按 id 读 manifest。文件不存在/JSON 损坏/schema 不合法均返回 null。
-     * 调用方需处理 null。
+     * 清理物理残留（D5b 方向二的死体处置）：worktree remove → prune → branch -D
+     * → 目录 rm 兜底，四步各自 best-effort（幂等，失败仅日志）。
+     * prune 必要性：checkout 目录已不存在的 worktree，remove 会失败且 branch -D
+     * 被「used by worktree」拒绝——prune 清掉缺失目录的元数据后分支才可删。
      */
-    readManifest(id: string): Promise<ManifestRecord | null>;
+    private cleanupPhysical;
     /**
-     * 同步读取所有 manifest 记录（best-effort，损坏/非法文件跳过）。
-     * 供 RecordStore.collectRecords 投影 orphan 记录使用——替代对私有 dir 的反射访问。
-     * 仅返回通过 isValidManifest 校验的记录。
-     *
-     * [perf] per-file 缓存 + stat 戳校验：collectRecords 每次渲染都调本方法，旧实现每次
-     * 全量 readFileSync + JSON.parse 千级 manifest（实测 ~300ms/次）。命中缓存的文件零读取。
+     * 判孤儿：pid 死活为主判据。pid=0 走 SPAWN_GRACE 宽限（create→spawn 窗口）。
      */
-    listAllSync(): readonly ManifestRecord[];
+    private isOrphan;
+    /** 清理单个孤儿条目：worktree remove + branch -D + 注册表移除，三步各自 best-effort。 */
+    private cleanupOrphan;
     /**
-     * 启动时恢复 tmp 文件。
-     * 3 分支逻辑：
-     * 1. manifest 已存在 → 删 tmp（陈旧）
-     * 2. tmp 合法 + manifest 缺失 → rename tmp 为 manifest
-     * 3. tmp 非法 + manifest 缺失 → 删 tmp
+     * git 命令异步执行器。与 gitRun 同一超时/错误包装约定（message 格式逐字一致），
+     * 差异仅在错误属性形态（GitRunError 挂 exitCode/stderr/timedOut）。
+     * 写类命令经 per-repo mutex 串行（不依赖 git 锁实现细节 + 并发限流 + 行为确定性）。
      *
-     * [T5④ / PS-13] per-file 容错：单个 tmp 文件操作失败（ENOENT——并发回收/外部清理
-     * 抢先、EACCES 等）只 warn + 跳过该文件，不再中断整轮——旧实现单文件 ENOENT 即抛，
-     * 剩余 tmp 本轮不再处理，自愈但不可见（残留顺延下次启动）。跳过数经 warn 汇总留痕，
-     * 调用方返回值形态不变（跳过者不计数）。
+     * stdout 保真返回（不 trim）：collectPatch 把 diff 输出原样落盘为 patch 文件，
+     * 裁掉尾换行会产出 `git apply` 拒绝的 corrupt patch（2026-08-16 门 4 实测）。
+     * 需要干净文本的消费点（baseCommit / 脏树 status 拼接）自行 trim。
      */
-    recoverTmpFiles(): Promise<{
-        deleted: number;
-        recovered: number;
-    }>;
+    private gitRunAsync;
 }
 
+/**
+ * [H1 U2 / D7] 轮终处置的 outcome 入参（判别联合）。
+ *
+ * 命名与协议 AgentOutcome 同名不同物（设计 D7 v6：kind 判别联合消歧）——
+ * kind 判别轮终分流：成功轮正文来源 = Continuation 成功分支的 content（协议
+ * AgentOutcome.content 映射产物）；失败轮 reason = 失败原因原文。
+ */
+type RoundSettlementOutcome = {
+    kind: "success";
+    content: string;
+} | {
+    kind: "failed";
+    reason: string;
+};
+
 /** store 变更监听器（返回取消订阅函数）。 */
 type ChangeListener = () => void;
 /** status 过滤模式（collectRecords 的核心能力参数）。 */
@@ -760,11 +1730,31 @@ declare class RecordStore {
     /** [perf L-1] loadIndex 高版本标志的进程级持久态：true 时本进程所有后续扫描均不
      *  落盘（防 v1/v2 last-writer-wins 覆盖振荡），直至下次 loadIndex 重新评估。 */
     private indexHigherVersion;
+    /** [U4c / G1] manifest 惰性重建的每 id 尝试守卫（mergedRecords 高频路径防磁盘写
+     *  放大：每 id 每进程至多一次；dispose/revive 随其余缓存态一并重置）。 */
+    private manifestRebuildTried;
+    /**
+     * [D8 v7] manifest 同步写目录（与 manifestStore 同一 records 目录，由构造方提供——
+     * manifestStore.dir 私有，本类不经反射访问）。提供时终态原语（markFinalized /
+     * markCancelled / markBatchFinalized）走 writeAtomicFileSync 同步落盘——停机窗
+     * fire-and-forget 竞态构造性消灭（disposeAllRecords 同步链全链同步段内完成）；
+     * 已接线（subagent-service.ts 构造点 recordsDir）；缺省分支仅纯内存测试形态。
+     */
+    private readonly manifestDir;
+    /**
+     * [§3.1 markRoundIdle 簿记⑧] pending-notifications 轮终注销（发射点②）的注入面。
+     * store 不直接依赖 pending 注册表（「零副作用编排」边界——文件布局收口 ≠ 通知
+     * 注册表依赖）；由 SubagentService 构造点注入 emitPendingUnregister 闭包（U5 收口
+     * 接线），缺省 no-op（纯内存测试形态不发射）。
+     */
+    private pendingUnregister;
     constructor(sessionsDir: string, manifestStore?: ManifestStore | undefined, 
     /** Pi 入口（注入 appendEntry 用于上报损坏 manifest）。
      *  SubagentService 构造时 this.pi 尚未注入（session_start 之前），传 undefined 兜底；
      *  后续通过 setPi() 注入（见下）。允许 null = 兼容 PiLike 字段类型。 */
-    pi?: RecordStorePi);
+    pi?: RecordStorePi, 
+    /** [D8 v7] manifest 同步写目录（见 manifestDir 字段注释）。 */
+    manifestDir?: string);
     /** session_start 后由 SubagentService.initSession 调，注入真实 Pi handle。
      *  设计为独立方法而非要求构造时必传——RecordStore 在 SubagentService 构造时即建
      *  （与 sessionsDir/manifestStore 一同初始化），但 this.pi 此时尚未注入。
@@ -777,7 +1767,7 @@ declare class RecordStore {
     /**
      * 归档：record 已被 completeRecord 设置了终态 status。
      * 立即从内存移除（终态 record 下次读时从 session.jsonl 重建）。
-     * cancelled record 由调用方先写 tombstone（cancel 路径），此处只负责移除。
+     * cancelled record 由调用方先写终态 sidecar（cancel 路径），此处只负责移除。
      *
      * W16 [D4]：终态冻结字段（result/endedAt/closedReason）在 completeRecord 已就绪，
      * 此处 append 的快照即完整终态记录（所有终态路径的必经锚点）。
@@ -792,12 +1782,210 @@ declare class RecordStore {
      * pi 未注入（session_start 前）时可选链静默降级，不阻断主流程。
      */
     reportRecordTransition(record: ExecutionRecord): void;
+    /**
+     * 注入 pending-notifications 轮终注销闭包（markRoundIdle 簿记⑧发射点②，见字段
+     * pendingUnregister 注释）。装配点 = SubagentService 构造器（U5 收口接线）。
+     */
+    setPendingUnregister(fn: ((id: string, status: string) => void) | undefined): void;
+    /**
+     * 意图原语：事件追加（过程记录）。turns/eventLog/totalTokens 经 execution-record
+     * 事件归约累积（字段⑧），随后 entry 变迁上报（best-effort——过程面可丢，重建由
+     * 子 session 文件承接）。调用方按事件粒度决定调用频率（高频 delta 逐事件上报会
+     * 放大 entry 写面，编排粒度属调用方职责）。
+     *
+     * @returns false = id 不在内存（未注册/已归档）——事件丢弃并 debug 留痕。
+     */
+    appendEvent(id: string, event: AgentEvent): boolean;
+    /**
+     * 意图原语：轮始重置（字段①②⑤）。status=running + result/resumable 清除——
+     * §5.4 isStreaming 公式要求 result undefined 才显示 streaming，不清则续轮流仍显示
+     * waiting。归口写点：热路径轮始与冷启动 resume 续轮（subagent-service，U3 迁移）。
+     *
+     * @returns false = id 不在内存（debug 留痕，无副作用）。
+     */
+    markRoundStarted(id: string): boolean;
+    /**
+     * 意图原语：轮末收口——**保持 running-resumable**（名称沿用，非置 idle：status 写
+     * idle 会断 SP-5 升级链与 hasRunning 判据）。簿记全集（①-⑨，= doFinalizeRoundToIdle
+     * 现状簿记 + D3a 修订）：
+     *   ① status 保持 running；② result 按 outcome 写入（成功=content / 失败=前值??
+     *      失败摘要 + lastError）；③ round+1；④ closedReason 清除（[S10]）；⑤ resumable=true
+     *      （GUI waiting 判据）；⑥ idleSince 刷新（idle-GC 判据）；⑦ **`.alive` 保留**
+     *      （D3a 跨轮延续——写权声明至 release 两出口[终态原语/idle-GC 归档]，轮终
+     *      record 仍 resumable 随时续聊 spawn 写同一 sessionFile，删则轮后跨进程防御
+     *      空窗）；⑧ pending 注销发射点②（进程已死，从活跃后代差集移除——经
+     *      setPendingUnregister 注入，未注入时跳过）；⑨ reportRecordTransition（entry
+     *      携带新 round 与本轮 result）。
+     * worktree/通知等副作用编排留调用方。
+     *
+     * @param outcome 轮终结果（kind 判别：success=content / failed=reason）
+     * @returns false = id 不在内存（debug 留痕，无副作用）。
+     * @throws Error record 终态簿记已冻结（endedAt 已设——复活终态的调用即 bug，
+     *         fail-fast，对齐 doFinalizeRoundToIdle A3 断言）。
+     */
+    markRoundIdle(id: string, outcome: RoundSettlementOutcome): boolean;
+    /**
+     * 意图原语：正常终态（含 disposeAllRecords 编排性关闭，reason=parent-*，D8 矩阵）。
+     * 只吸收**持久化面**——collectPatch / worktree cleanup / pending 注销① / onFinalized
+     * 钩子留调用方编排（§3.1 副作用边界）。内存终态冻结（completeRecord/tryTransition）
+     * 亦留调用方——状态机操作非文件布局。
+     *
+     * 内部写序（D8 v7）：`.state` writeSync **先**（终态权威优先落）→ entry/archive →
+     * manifest writeSync 后 → `.alive` 删除（release 出口①）。
+     *
+     * 失败语义（§3.4）：`.state` 重试耗尽仍未落 → 返回 false，**零持久化副作用**（不
+     * archive / 不写 manifest / 不 release 写权声明）——record 留 running 形态（磁盘无
+     * 终态位，下次 boot 孤儿恢复终态化承接）；错误已在 state-marker 层 error 级响亮暴露。
+     *
+     * @returns true = 持久化面完成；false = `.state` 未落（record 不应被视作已终态化）。
+     */
+    markFinalized(record: ExecutionRecord, closedReason?: ClosedReason): boolean;
+    /**
+     * 意图原语：取消终态（tombstone）。写序与失败语义同 markFinalized（D8 v7）；区别
+     * 仅 `.state` 载荷 = {status:"cancelled", endedAt}（重建判定分支消费精确结束时间）。
+     * 归口写点：cancelBackground 终态写面（record-lifecycle，U2a 迁移）。
+     */
+    markCancelled(record: ExecutionRecord): boolean;
+    /**
+     * 意图原语：sync 批终态（统一写点）。内部写序显式复刻 barrier：manifest 落盘
+     * **完成**先于批通知写账（batchFinalized 落标 entry）——「通知可达 ⇒ 索引就位」
+     * 构造性保证（session-reader 指针行反查依赖；缓存降级下 barrier 不可删，D4②/D5）。
+     * manifestDir 提供时为同步写（写完即返回）；缺省降级 allSettled 异步屏障（原
+     * writeSyncBatchManifestBarrier，已随 U3 归口删除）。
+     */
+    markBatchFinalized(records: readonly SubagentRecord[]): Promise<void>;
+    /**
+     * 意图原语：引擎死亡收养（字段⑤⑩——error/result/resumable 三写，record 保持
+     * resumable 交监督器接管，禁 completed 谎报 / closed 直接终局）。归口写点：
+     * adoptResumableAfterEngineDeath（run-orchestration——已随 U2b 修复轮迁移）；
+     * 监督器 adoptOnProcessDeath 编排留调用方。
+     *
+     * @returns false = id 不在内存（debug 留痕，无副作用）。
+     */
+    adoptEngineDeath(id: string, opts: {
+        error: string;
+    }): boolean;
+    /**
+     * 意图原语：磁盘终态位翻回活态（透明重生回边整体收编，D3c 规格）。
+     *
+     * acquire-first 顺序（单 try 域原子收敛）：写 `.alive` 写权声明（acquire）→ 删
+     * `.state` → 删 `.finalized`/`.cancelled` legacy（读侧兼容回退认领旧名，残留未删
+     * 则重建仍读出终态），随后 resurrectClosed 内存翻回 + register——
+     * 任一步失败**响亮抛错**（禁止 best-effort 吞错续跑：acquire 失败 = 双写风险敞口；
+     * acquire-first 顺序保证失败时磁盘保持 closed 可读形态——极端形态下经 legacy
+     * 文件名回退仍读出终态，见 catch 文案）。reportTransition（entry 上报）留编排层
+     * （纯投递副作用，失败不破坏状态一致性）。
+     *
+     * 两种接管形态统一（wasClosed 判别）：closed 候选 = 三件套全量；running 候选接管
+     * （跨重启磁盘重建）= 跳过删终态位（无 `.state` 可删）**仍 acquire marker**
+     * （「接管即声明」——现状此路径不写 marker 的双写窗随归口消灭）。
+     * 中间形态推演（G3 单点论证）见设计 D3c (i)(ii)(iii)：三形态无卡死态、无双写窗。
+     *
+     * @param record 调用方重建的可变 record（createRecord 产物）
+     * @param wasClosed 磁盘候选是否为 closed 形态（cold-lookup 的 found.status 判定）
+     * @throws Error acquire 或终态位删除失败（含 sessionFile 缺失——无锚点无法声明写权）
+     */
+    markResurrected(record: ExecutionRecord, wasClosed: boolean): void;
+    /**
+     * 意图原语：idle-GC 归档（30 天 TTL 内存回收，**非终态化**——record 磁盘仍 running
+     * 可接管；归档 ≠ 放弃可重连性，故不写 `.state`「gc」——那会把「可接管」变「不可
+     * 重连硬拒」，D3a 被否分支）。
+     *
+     * 写序（D3a/轮 5）：store.archive **先**、`.alive` release **后**——archive 抛错则
+     * 原语整体失败、marker 必未删（持有与声明一致）；release 失败 best-effort 留痕
+     * （removeAliveMarker 内部 warn——GC 为旁路维护路径不阻断 interval，泄漏窗 = 至
+     * 宿主退出，已接受）。归档 record 后续被接管时统一 acquireWriteLease 重新声明。
+     *
+     * [U4c / G2] 归档点补写 manifest（投影 running——磁盘确仍 running）：record 离开
+     * 内存后，外部 session-reader 的 identity 富字段主路径只剩 manifest（子文件
+     * identity entry 随 30 天 GC 衰减），归档时不落盘则该 record 在 manifest 面长期
+     * 缺席。写失败走 writeTerminalManifest 同款响亮上报（终态写面共用通道）。
+     */
+    markIdleArchived(record: ExecutionRecord): void;
+    /**
+     * [A6 / D3a 时机①] store 内部 acquire 动作——writeAliveMarker 的唯一包装（G1 口径
+     * = store 内部写面；非新意图原语）。spawn 侧 sessionFile 锚点确立（run 应答回填 /
+     * 冷启动 resume 续轮）时由调用方挂钩（U2b），宿主开始往 session 文件写即声明写权。
+     *
+     * @throws Error 写失败原样上抛（acquire 失败 = 双写风险敞口，调用方响亮处理——
+     *         禁止 best-effort 吞错续跑，D3c 失败语义）。
+     */
+    acquireWriteLease(sessionFile: string, recordId: string): void;
+    /** 终态 manifest 投影（markFinalized/markCancelled 共用；对齐 writeManifestBestEffort
+     *  现状投影——status 统一 closed，closedReason 随投影携带）。
+     *  [U4c / G2 词汇双写] executionStatus（ExecutionStatus 二态）随终态写面双写——
+     *  旧 status 三态是 session-reader 直读的投影字段（永久保留），新字段是内部权威
+     *  词汇的写面过渡锚（D5 词汇全景①③并存）。 */
+    private static terminalManifestRecord;
+    /** 批成员 manifest 投影（markBatchFinalized 用；原 writeBatchMemberManifest，
+     *  已随 U3 归口删除——status 如实投影[成功成员此刻 running+resumable]，后续
+     *  upgrade 终态时原子覆盖）。[U4c / G2] executionStatus/closedReason 双写同 terminal 投影。 */
+    private static batchManifestRecord;
+    /**
+     * [U4c / G1+G2] 状态派生 manifest 投影（rebuildIndexes / 反查 miss 惰性通道 /
+     * markIdleArchived 归档点共用）。数据源 = SubagentRecord 投影（identity entry/
+     * binding + `.state` sidecar 矩阵，D1「.state 权威 + entry 尽力」）——词汇双写
+     * 同终态写面。旧 status 三态从 closedReason 派生 cancelled（对齐 markCancelled
+     * 的 `.state` cancelled 分支重建语义：buildRecord 分支 1 closedReason="cancelled"）。
+     */
+    private static derivedManifestRecord;
+    /**
+     * [D8 v7] manifest 落盘统一通道：manifestDir 提供时 writeAtomicFileSync 同步写
+     * （停机竞态构造性消灭；与 ManifestStore.writeManifest 字节形态一致——2 空格缩进
+     * JSON，读侧/外部 session-reader 不感知差异）；缺省 fire-and-forget 异步写（仅纯
+     * 内存测试形态）。写失败响亮（error 日志 + 用户可见 entry，对齐 writeManifestBestEffort）。
+     */
+    private writeManifestPersisted;
+    /**
+     * [D8 v7] 终态 manifest 落盘（markFinalized/markCancelled 共用，投影 status 恒
+     * closed）。同步性与失败语义见 writeManifestPersisted。
+     */
+    private writeTerminalManifest;
+    /**
+     * [U4c / G1] 全量重建可丢缓存（boot 通道：boot revive 完成后由宿主调用）。
+     *
+     * manifest 与 sessions-index 均为可丢缓存（D5）：权威 = `.state`，重建源 =
+     * `.state` + entry 尽力。本方法：
+     *   1. 触发全量扫描（reconstructAll）——sessions-index 的重建隐式完成于既有机制
+     *      （loadIndex 空/损坏 → 探测 → dirty → saveIndex，「损坏静默回退全扫」同款
+     *      先例），不另设第二条索引写路径；
+     *   2. 对扫描重建出的每个 record，manifest 缺失时补写（幂等补缺，不覆写幸存
+     *      manifest——幸存者可能比重建源新鲜，覆写 = 用尽力数据降级权威快照）。
+     *
+     * 失败降级（D5 三要素）：单 record 重建源不可用（子 session 已 GC/损坏 → 不在
+     * 扫描集）或 manifest 写失败 → debug 留痕跳过该条，整轮不抛（S5「重建照常无错
+     * 误静默吞」）——缓存补缺失败不构成宿主错误。
+     *
+     * @returns 补写的 manifest 数（诊断/日志用）。
+     */
+    rebuildIndexes(): number;
+    /**
+     * [U4c / G1] 单 record 的 manifest 惰性补建（rebuildIndexes 全量轮 + mergedRecords
+     * 惰性通道共用）。manifest 已存在 → 跳过；无 manifest 落点（manifestDir/manifestStore
+     * 均缺省，纯内存测试形态）→ 跳过；每 id 每进程至多尝试一次（manifestRebuildTried
+     * 守卫——boot 全量轮与惰性通道共享，防重复磁盘写）。写失败 debug 留痕不抛
+     * （缓存面，§3.4「缓存损坏」行——无需动作）。
+     *
+     * @returns true = 本次实际补写。
+     */
+    private rebuildManifestIfMissing;
+    /** manifest 写失败的双通道上报（error 日志给开发者 + entry 给用户，对齐
+     *  writeManifestBestEffort 现状）。 */
+    private static reportManifestWriteFailure;
+    /**
+     * [H4 收口 / G1] entry 重物化腿的 manifest 投影补写（record-access 可重连终态
+     * 重物化通道的唯一入口——store 外零 manifest 直写）。manifest 是可丢缓存（D5），
+     * 本方法只做缺员补写：失败 warn 留痕不响亮（缓存补缺失败不构成宿主错误，对齐
+     * U4c rebuildIndexes 的降级语义——区别于终态面 writeManifestPersisted 的响亮）；
+     * manifestDir 接线时为同步写（停机窗防护与终态面同源）。
+     */
+    rematerializeManifest(manifest: ManifestRecord): void;
     /** 按 id 查找。返回可变 record（仅 runtime 内部用）。 */
     getMutable(id: string): ExecutionRecord | undefined;
     /**
      * abort 所有 running record 的 controller（background 子进程 SIGTERM）。
      *
-     * 仅在 SubagentService.dispose（进程退出路径）调用。不做 CAS/tombstone——dispose
+     * 仅在 SubagentService.dispose（进程退出路径）调用。不做 CAS/终态标记——dispose
      * 是终局，状态机收尾无意义；目的是让 background 子进程的 AbortSignal 触发 →
      * runSpawn 的 signal listener → child.kill("SIGTERM")，防止主进程退出后子进程成孤儿。
      *
@@ -818,7 +2006,7 @@ declare class RecordStore {
      *   ╔══════════════════════════════════════════════════════════════════╗
      *   ║  1. 磁盘源：扫 sessionsDir 的 .jsonl，逐个 scanFile（[perf] 头部    ║
      *   ║     identity 轻量重建 + stat 戳缓存命中零读取）。cancelled          ║
-     *   ║     tombstone override status。详情字段（eventLog/result/turns）    ║
+     *   ║     终态 sidecar override status。详情字段（eventLog/result/turns）    ║
      *   ║     缺省，由 getFullRecord(id) 懒加载                              ║
      *   ║  2. 内存源覆盖（同 id 内存优先——running record 更新鲜）          ║
      *   ║  3. session 过滤：只留 rootSessionId === rootSessionFilter 的       ║
@@ -836,8 +2024,30 @@ declare class RecordStore {
      *
      * session 隔离：同一 cwd 下多个 Pi session 共享 sessionsDir，靠 rootSessionId
      * 区分。内存与磁盘源都按 rootSessionFilter 过滤后再 merge/sort/slice。
+     *
+     * [H2 W1] includeWorkflow（设计 subagent-workflow-record-unification §3.3 D1）：
+     * 缺省 false = 过滤 origin==="workflow" 的 record（subagents tool list / TUI
+     * /subagents 等消费面默认不展示 workflow 派发的 record）；true = 全量（排查通道）。
+     * 过滤只在查询消费面——治理路径（recoverOrphanRecords / recoverEntryOnlyOrphans /
+     * revive）与本参数无关，永远全量可见（D1 ⑥ 负向规格）。
+     */
+    collectRecords(limit: number, statusFilter?: StatusFilter, rootSessionFilter?: string, includeWorkflow?: boolean): SubagentRecord[];
+    /**
+     * [H2 W1] 按 workflow run id 列 record（parentRunId 查询入口，W2 run 视图进度 /
+     * W3 下钻消费）。查询域 = collectRecords 现状口径（内存 ∪ 磁盘重建 ∪ manifest 补充，
+     * 设计 D2「查询域显式」）。不过滤 origin——按 parentRunId 显式查询即下钻/治理语义
+     * （tool 来源 record parentRunId 恒 undefined，不会被误中）。
+     *
+     * 返回排序与 slice 口径同 collectRecords（STATUS_PRIORITY + startedAt desc + limit）。
      */
-    collectRecords(limit: number, statusFilter?: StatusFilter, rootSessionFilter?: string): SubagentRecord[];
+    collectRecordsByParentRunId(parentRunId: string, limit: number, rootSessionFilter?: string): SubagentRecord[];
+    /**
+     * collectRecords / collectRecordsByParentRunId 共用的三源合并（磁盘重建 ∪ manifest
+     * 补充 ∪ 内存覆盖）。返回 byId Map（内存优先——running record 是活态比磁盘重建新）。
+     * [D1 ⑤] 磁盘重建投影本身不做任何 origin 过滤——record 全量重建，过滤只在上层
+     * 查询消费面按参数生效。
+     */
+    private mergedRecords;
     /**
      * 重建 SubagentRecord 的自描述 entry 落盘入口（签名适配：reportRecordTransition 收
      * ExecutionRecord，重建孤儿的数据源是 SubagentRecord——直接经 toSubagentRecordEntry
@@ -845,14 +2055,15 @@ declare class RecordStore {
      */
     reportSubagentRecord(record: SubagentRecord): void;
     /**
-     * 孤儿终态恢复：对重建矩阵分支 4 兜底（running 且无 externalInstance）的 record
+     * 孤儿终态恢复：对重建矩阵兜底分支（running 且无异宿主在持声明；编号沿用设计
+     * D3b 文档的「分支 4」表述，分支 3 已随 externalInstance 投影移除）的 record
      * 判定真实终态并落 entry，消除「父扩展死后再无人写终态 → 侧栏永久 running」。
      *
      * 判定（residual-fixes §5.2 三判据 + chat 分流）：
      * - chatMode = true → 不终态化（跨重启可续聊是产品语义，v4 B-1），落 resumable
      *   entry 供侧栏 waiting 细分；
      * - 子 JSONL 末行完整 JSON.parse → closed（closedReason=gc，与分支 2 重建映射一致；
-     *   done/failed 细分由 error 字段经 deriveClosedDisplay 派生）+ 写 .finalized sidecar
+     *   done/failed 细分由 error 字段经 deriveClosedDisplay 派生）+ 写 .state sidecar
      *   （防重锚——下次重建走分支 2 不再进判定）；
      * - 末行截断 → closed + error（保守，错误方向安全）+ sidecar；
      * - 文件不可读（IO 错误，可能暂时）→ 不判终态，落 resumable entry（防御性路径，
@@ -902,7 +2113,9 @@ declare class RecordStore {
      */
     private isEntryOrphanCandidate;
     /** entry-born 孤儿按无文件判据收敛落 entry：chatMode → resumable（分流语义一致）；
-     *  否则 closed+gc+error（子文件由子进程创建，无文件 = 子进程从未开跑，error 方向安全）。 */
+     *  否则 closed+gc+error（entry-born 是 zcode 引擎 record 的常态形态——无子 session 文件
+     *  非异常，D8 第五行 entry-born 作用域注记；one-shot 直断 closed/gc，续聊对无 transcript
+     *  形态结构性不成立，承接通道仅 start fresh）。 */
     private finalizeEntryOnlyOrphan;
     /**
      * [E1/U5] sync 批崩溃恢复扫描：主 session 文件「每 id 末条 subagent-record entry」
@@ -927,7 +2140,7 @@ declare class RecordStore {
      * /resume /fork /new 后复活（dispose 的逆操作）。
      *
      * [PS-10/T6④] 同步复位 orphanJudged 防重缓存：resumable 形态（IO-error 保守分支 /
-     * chatMode 分流）没有 .finalized sidecar 锚，重判资格完全由本缓存承载——dispose 时
+     * chatMode 分流）没有 .state sidecar 锚，重判资格完全由本缓存承载——dispose 时
      * 有 clear（session 结束），但 revive 此前不复位，导致「同进程内曾经的 IO 失败记录
      * 永久停留 resumable」，与本文件 recoverOrphanRecords 注释承诺的「IO 恢复后重开可重判」
      * 不符。/new 复活正是「重开」语义：IO 已恢复的记录下次 recoverOrphanRecords 重新判定
@@ -935,13 +2148,17 @@ declare class RecordStore {
      */
     revive(): void;
     /**
-     * 四分支 sidecar 矩阵重建（[perf] light 版）。
+     * 三分支状态矩阵重建（终态 marker / 兜底；[perf] light 版）。
      *
      * 优先级：
-     *   1. .cancelled → closed（closedReason=cancelled）
-     *   2. .finalized → closed（closedReason=sidecar 内容 reason；空/旧格式 → disconnected）
-     *   3. .alive + pid 存活 + 未超软超时 → running, externalInstance=true
-     *   4. 兜底（无 marker、pid 死、超时）→ running（v4 B-1 可续聊语义）
+     *   1. 终态 sidecar status=cancelled → closed（closedReason=cancelled）
+     *   2. 终态 sidecar status=finalized → closed（closedReason=内容 reason；空/旧格式 → disconnected）
+     *   （旧名 .finalized/.cancelled 由 readStateMarker 归一，判定分支不区分来源）
+     *   3. 兜底（其余一切，含 .alive 在持形态）→ running（v4 B-1 可续聊语义）
+     *
+     * [U4a / D3b (a)] 原分支 3（.alive + pid 活 → running + externalInstance 投影）已
+     * 移除：探活缓存的读面角色由 (a′)(a″) 的 findForeignLiveInstance 现查探针替代，
+     * status 判定与 .alive 解耦（终态判定由 `.state` 权威分支承接）。
      *
      * [perf]：逐文件 scanFile（stat 戳校验 + 头部 identity 轻量重建）。命中缓存的
      * 文件零文件读取；变化的文件只重建自身，其余 N-1 个复用缓存。
@@ -951,18 +2168,31 @@ declare class RecordStore {
      */
     private reconstructAll;
     /**
-     * 扫描单文件：stat 戳（jsonl + 3 sidecar）校验，全同 → 复用缓存（零文件读取，
-     * 含负缓存直接返回 null）；否则重建 light。
+     * 扫描单文件：stat 戳（jsonl + 终态 sidecar + record 绑定）校验，全同 →
+     * 复用缓存（零文件读取，含负缓存直接返回 null）；否则重建 light。
      * identity 定位两级：头部 64KB（首轮会话）→ 全文 fallback（续聊场景 identity
-     * append 在尾部）；两级都找不到 → 写负缓存（防每轮全文重读）。
-     * 返回 null：文件消失/读失败/无 identity → 跳过。
+     * append 在尾部）；两级都找不到 → [UF-1] record 绑定 sidecar 回退（宿主侧身份
+     * 载荷重建 light）→ 仍无 → 写负缓存（防每轮全文重读）。
+     * 返回 null：文件消失/读失败/无 identity 且无绑定 → 跳过。
      */
     private scanFile;
+    /**
+     * [UF-1 / H2 A3] 绑定承载域补投影（仅 header === undefined 的绑定重建路径；
+     * identity entry 命中时绑定不参与）。自 scanFile 原样搬移：赋值条件与顺序等价。
+     */
+    private static projectBindingDerivedFields;
+    /**
+     * [UF-1] record 绑定载荷 → light 身份基底（IdentityHeaderRecon 同形投影）。
+     * 绑定缺失/损坏返回 undefined（调用方落负缓存，不把损坏残留误判成身份）。
+     * forkDepth/model_change/thinking_level_change 等头部途经信息绑定期不存在：
+     * forkDepth 恒 undefined、model/thinkingLevel 取绑定快照值。
+     */
+    private static identityFromBinding;
     /**
      * [perf L-1] 磁盘索引查询（首扫惰性装载，miss/空索引时 get 恒 undefined = 无索引）。
-     * 条目戳匹配 jsonl 当前 stat → 零内容读取构造缓存条目。sidecar payload（tombstone/
-     * alive）是活态数据，沿用探测分支的每轮重读语义；finalized reason 静态数据仅在
-     * sidecar 存在时读一次（文件小，成本可忽略）。
+     * 条目戳匹配 jsonl 当前 stat → 零内容读取构造缓存条目。sidecar payload（终态 marker）
+     * 是活态数据，沿用探测分支的每轮重读语义；终态 reason 静态数据仅在 sidecar 存在
+     * 时读一次（文件小，成本可忽略）。
      *
      * 返回 undefined = 索引未命中/戳不匹配（调用方落到原三级探测）；null = 负条目命中
      * （「确认无 identity」跨实例持久，零探测跳过，与内存负缓存同款形态）。
@@ -991,7 +2221,8 @@ declare class RecordStore {
      * [perf] byId 索引直查 light record（单文件 stat 校验，不触发 getFullRecord 的
      * 全量重建）。idToFile 未热（进程重启后尚未扫描过）时返回 undefined，调用方
      * 自行兜底全目录扫描——用于把「跨重启后每条 message 一次 collectRecords 全扫」
-     * 降为 O(1) 索引命中。
+     * 降为 O(1) 索引命中。（反查 miss 的索引自愈不在此层——miss 契约被 cold-lookup
+     * 链与 record-binding 测试钉死；manifest 惰性重建挂 mergedRecords，见其注释。）
      */
     findLightById(id: string): SubagentRecord | undefined;
     /**
@@ -1004,13 +2235,9 @@ declare class RecordStore {
      * assistant message 等）→ 返回 light（无详情可补，缓存哨兵防重复全文重读）。
      */
     getFullRecord(id: string): SubagentRecord | undefined;
-    /** alive 探活刷新（scanFile 缓存命中与 reconstructAll 快路径共用）：
-     *  分支 3 的 running + alive 条目每扫重查 pid（结果不落盘，进程死亡无 IO），
-     *  保留旧实现「每次 collectRecords 重新 isProcessAlive」的语义。 */
-    private static refreshAlive;
     /** identity 基底 + sidecar 状态矩阵 → 缓存条目（索引命中与探测重建两分支的公共装配点）。 */
     private static buildFileCacheEntry;
-    /** identity 基底（头部 light 或全量 recon）+ 四分支 sidecar 状态矩阵 → SubagentRecord。 */
+    /** identity 基底（头部 light 或全量 recon）+ sidecar 状态矩阵（终态 marker / 兜底两态）→ SubagentRecord。 */
     private static buildRecord;
     /** 排序比较器：status priority（running<failed<cancelled<done）+ startedAt desc。 */
     private static compareRecords;
@@ -1018,216 +2245,182 @@ declare class RecordStore {
     private readManifestsSync;
     /** FR-8: ManifestRecord → SubagentRecord（manifest 源投影）。
      *  task/slug/model 从 manifest 真实值投影（配合 writeManifest 补字段），缺失兜底空串。
-     *  status 越界（mapManifestStatus 返回 null）时返回 null，由 collectRecords 跳过。 */
+     *  status 越界（mapManifestStatus 返回 null）时返回 null，由 collectRecords 跳过。
+     *  [M2 Gate B] closedReason 投影（枚举守卫，同 mapManifestStatus 的越界容错口径）：
+     *  旧 manifest 无此字段 / 损坏值 → undefined。缺失曾让 manifest 源快照在
+     *  endedMessageGuard 丢失三分流依据（user-close/cancelled 误入 reconnectable 分支）。 */
     private static manifestToSubagent;
     /** ExecutionRecord → SubagentRecord（内存源投影）。 */
     private static recordToSubagent;
 }
 
-/**
- * chat 域轮次交接包的 core 契约基座（设计 §3.8 D2「ChatRoundTicket → HostBridge」）。
- * pi 专有扩展（identity / SessionRunnerContext / SpawnResumeOpts resume）在
- * pi-engine.ChatRoundTicket extends 本接口（W7 随包迁移；过渡期 record/opts/signal/
- * priority/stream 五字段的宿主编排语义在此单一权威）。
- */
-interface HostChatRoundTicket {
-    record: ExecutionRecord;
-    opts: ExecuteOptions;
-    signal: AbortSignal | undefined;
-    priority: number;
-    stream?: SubagentStream;
-}
 /**
  * HostBridge 的服务实现面（SubagentService 的结构子集，鸭子类型——与原 pi-engine 的
- * PiEngineService 同一形态的协议化泛化：chat 域轮次面泛型参数化，pi 绑定 =
- * HostBridgeServiceFace<ChatRoundTicket>，见 pi-host-binding.ts 的 re-export）。
- * 为什么用结构接口而非 import SubagentService 类型：防 Service 内部演进连锁影响
- * 契约面 + 测试可注入 fake（PiEngineService 的既有先例，语义照搬）。
- */
-interface HostBridgeServiceFace<TTicket extends HostChatRoundTicket = HostChatRoundTicket> {
-    executeAndAwait(opts: ExecuteOptions, signal?: AbortSignal, onEvent?: (event: AgentEvent) => void, stream?: SubagentStream): Promise<AgentResult>;
+ * PiEngineService 同一形态的协议化泛化）。为什么用结构接口而非 import SubagentService
+ * 类型：防 Service 内部演进连锁影响契约面 + 测试可注入 fake（PiEngineService 的既有
+ * 先例，语义照搬）。
+ * [H1 U6] chat 域轮次交接可选面（HostChatRoundTicket / takeChatRound / runChatRound /
+ * resumeChatRound）已随 chat 域退役删除——续聊 = Continuation → 新 run + resume，
+ * 引擎经协议 converse，不再回调宿主编排面。
+ */
+interface HostBridgeServiceFace {
+    executeAndAwait(opts: ExecuteOptions, signal?: AbortSignal, onEvent?: (event: AgentEvent) => void, stream?: SubagentStream): Promise<AgentResult$1>;
     getRecordForAction(id: string): ExecutionRecord;
     closeSubagent(record: ExecutionRecord, force: boolean): Promise<void>;
     cancel(id: string): boolean;
     collectRecords(limit: number, statusFilter?: StatusFilter): SubagentRecord[];
-    /** chat 域轮次交接（run 的 chat 分支入口）：按 taskId 取走预备包（一次性消费）。 */
-    takeChatRound?(taskId: string): TTicket | undefined;
-    /** 执行预备的 chat 轮次（编排归 Service：pool 槽 + runSpawn + 终态迁移）。 */
-    runChatRound?(ticket: TTicket): Promise<AgentResult$1>;
-    /** 冷路径续轮（interact message 分支的编排回调：守卫 + record 迁移 + kick-off）。 */
-    resumeChatRound?(record: ExecutionRecord, text: string): void;
     /** record 状态迁移上报（热路径投递后让 runtime 派生缓存失效 / GUI 回流）。 */
     reportRecordTransition?(record: ExecutionRecord): void;
 }
 
-/** 三态读取结果（判别联合，调用方按 status 分派）。 */
-type GlobalConfigReadResult = 
-/** 读到明确值：JSON 可解析，字段已经 sanitize。 */
-{
-    status: "ok";
-    config: SubagentsGlobalConfig;
-}
-/** 明确缺省：文件不存在（ENOENT）。这是用户意图（删配置切回缺省 pi），不是故障。 */
- | {
-    status: "absent";
-    config: SubagentsGlobalConfig;
-}
-/** 读失败：坏 JSON / 权限等。携带原始错误消息供诊断；调用方保持 lastEngine 不动。 */
- | {
-    status: "failed";
-    reason: string;
-};
 /**
- * 三态读取全局配置（设计 D5）。
+ * [T4① / PS-2] 轮次完成回注的 notify 门（按 closedReason 白名单放行）。
  *
- * 为什么不用 loadGlobalConfig：后者 ENOENT 与坏 JSON 同归 DEFAULT_CONFIG（静默
- * 回落），检测器若消费该形态会把「用户删配置切回缺省」（合法变更，须生效）误判成
- * 「读失败」（须保持 lastEngine），也会把坏 JSON（torn write）误判成合法缺省——
- * 两个方向都会产生错误的引擎切换信号。
+ * cancelled（cancelBackground 自己 notify）与 parent-new/parent-fork（编排性关闭，
+ * 告知由 list 的 closedReason 表达）不放行；其余（undefined = 本路径抢到 CAS 尚未
+ * 终态化的迟到回调、user-close/gc 等真实终态）照旧回注。导出供测试与调用点复用。
+ * [H1 U2] 消费面扩为三处：Continuation 成功分支（route 前）、失败分支（独立载荷
+ * 发出前，B#19 投递门照迁移）、泛化派发主干尾部（one-shot 回注，现状不变）。
  */
-declare function readGlobalConfig(agentDir: string): GlobalConfigReadResult;
+declare function notifyGateAllowsDelivery(closedReason: ClosedReason | undefined): boolean;
 
-/** Service 构造参数（进程级，跨 session 不变）。 */
-interface ModelConfigServiceInit {
-    agentDir: string;
-    /** 项目根目录（ctx.cwd，用于推导 workspaceRoot 扫描 project 级资源）。 */
-    cwd: string;
+/** 入队项的 child 引用形状（只取 pid 用于 rejectChildDialogs 匹配）。 */
+interface DialogChildRef {
+    pid: number;
 }
-/** session_start 注入参数（session 级，每次重建）。 */
-interface ModelServiceSessionInit {
-    /** 模型注册表（鉴权 + 发现）。null 立即抛错（fail-fast）。 */
-    modelRegistry: ModelRegistryLike | null;
-    /** 当前 session ID。 */
-    sessionId: string;
-    /**
-     * 主 agent 当前 model（session_start 时注入，model_select 时刷新）。
-     *
-     * renderCall 阶段的 ToolRenderContext 不含 model 字段（SDK 限制），无法直接拿到
-     * 主 agent model。缓存后 renderCall 的 resolveModel 能命中第三层（ctxModel），
-     * 让标题行恢复显示 model——即使未显式传 model 也能展示默认 model。
-     *
-     * [HISTORICAL] 99f20da1e 引入三层 fallback 后，renderCall 因拿不到 ctxModel
-     * 而 resolveModel 拗错→降级不显示 model。此缓存修复该降级。
-     */
-    ctxModel?: ModelInfo;
+/** enqueue 的可选项。child 用于 rejectChildDialogs 关联（child close 时批量 reject）。 */
+interface EnqueueOptions {
+    child?: DialogChildRef;
 }
 /**
- * 配置 + 模型解析 Service。进程级单例。
+ * L2 跨子进程全局 dialog 串行队列（进程单例）。
  *
- *   ┌──────────────────────────────────────────────────────┐
- *   │  globalConfig（~/.pi/.../config.json，仅 maxConcurrent）│
- *   │  agentRegistry（agent .md 发现 + frontmatter）         │
- *   │  modelRegistry（SDK 注入的可用模型）                    │
- *   │                                                      │
- *   │  resolveModel: override → agentConfig → 主 agent model │
- *   └──────────────────────────────────────────────────────┘
+ * 用法（createUiRequestHandlerForMode 返回的总 handler 内）：
+ * ```ts
+ * const dialogQueue = new DialogGlobalQueue();
+ * return async (req: UiRequest) => {
+ *   // 调用方负责判断：dialog 入队，fire-and-forget 直接调 realHandler
+ *   if (isDialogMethod(req.method)) return dialogQueue.enqueue(req, realHandler);
+ *   return realHandler(req);
+ * };
+ * ```
+ *
+ * 语义保证：
+ *   - FIFO 串行：前一个 handler settle 后才处理下一个
+ *   - SR-4：rejectChildDialogs(child) 把该 child 的 pending 全部 resolve 为 {cancelled:true}
+ *   - handler 抛错兜底：catch → {cancelled:true} → 继续下一个（队列不卡死）
+ *   - 超时上界（LC-3/T2⑦）：每个 dialog 项必有上界——req.timeout 显式传值优先，
+ *     未传挂 DEFAULT_DIALOG_TIMEOUT_MS（30min，裁决值）；到点 settle {cancelled:true}
+ *     并 warn（恢复指引见 dialogTimeoutLogMessage），L2 processing 释放、队列继续推进。
+ *     「等用户无限久」改为默认有界是有意的行为变更。
+ *   - 调用方约定只对 dialog 类调 enqueue；fire-and-forget 由调用方直接调 handler 不入队
+ *（enqueue 内仍防御性兼容 fire-and-forget，但不保证行为）
+ *
+ * 线程模型：纯 Promise + 微任务驱动，无锁。Node 单线程 event loop 保证队列状态一致。
+ *
+ * 单 session 假设（M-2，与 index.ts lastSessionId 同源）：本队列是进程级单例（实例挂在
+ * globalThis[Symbol.for("@zhushanwen/pi-subagents.dialogQueue")]，见 getOrCreateDialogQueue）。
+ * rejectAll() 清空所有 pending dialog——无 per-session 隔离。Pi 当前架构保证单进程
+ * 单 session 串行（同进程不会并发多个 session），故 session_shutdown 调 rejectAll() 只会清掉
+ * 当前 session 的 pending。若未来 Pi 支持同进程多 session 并发，session A 退出会误清 session B
+ * 的 pending dialog——届时需改为 per-session 隔离（入队项 QueueItem 带 sessionId，rejectAll
+ * 改 rejectAllForSession(sessionId)，session_shutdown 只清当前 session）。
  */
-declare class ModelConfigService {
-    private globalConfig;
-    private readonly agentRegistry;
-    private readonly agentRegistryDir;
-    private modelRegistry;
-    private _sessionId;
-    /** 主 agent 当前 model 缓存（session_start 注入，model_select 刷新）。 */
-    private _ctxModel;
-    constructor(init: ModelConfigServiceInit);
-    /**
-     * session_start 注入。封装 3 步固定时序：
-     *   1. reloadGlobalConfig（复用时拿最新 config）
-     *   2. injectModelRegistry（fail-fast：null 抛错）
-     *   3. setSessionId
-     */
-    initModel(init: ModelServiceSessionInit): void;
+declare class DialogGlobalQueue {
+    /** 等待处理的队列（FIFO）。正在处理的项从 queue shift 出后由 current 持有。 */
+    private queue;
+    /** 正在处理的项（handler 已调、未 settle）。用于 rejectChildDialogs 取消占位中的 dialog。 */
+    private current;
+    private processing;
     /**
-     * 将一次三态读取结果提交到路由缓存（纯赋值幂等）。
+     * 入队一个 UI 请求，返回 Promise<UiResponse>。
      *
-     * ok/absent 覆盖缓存、failed 保持缓存不动（坏 JSON 不能把好缓存打回缺省）；
-     * 返回入参便于链式消费。用途 = 构造性同源：session_start 初始化与 per-turn 引擎
-     * 检测各只读一次文件，同一读取结果既刷新路由缓存又充当检测基准，消灭两次独立
-     * 读取之间的分叉窗口（两次读值不一致时检测走 unchanged，状态段/路由永停旧值）。
+     * 调用方约定：只对 dialog 类（isDialogMethod===true）调 enqueue。fire-and-forget 由
+     * 调用方（ui-request-handler-factory.ts）在 enqueue 前判 isDialogMethod 后直接调 handler，
+     * 不经过本队列。enqueue 内仍防御性兼容 fire-and-forget（万一调用方未判）：直接调 handler 返回，
+     * 不入队串行，但调用方不应依赖此防御行为。
+     *
+     * dialog 项处理（TC-E4 case 1）：进队列 FIFO 串行，等前一个 settle 后才调 handler
+     *（争输入焦点，防并发弹窗）。
+     *
+     * handler 抛错兜底：catch → 回 {cancelled:true}（dialog 路径，队列不卡死）。
+     * SR-4：opts.child 用于 rejectChildDialogs 关联（dialog 项会被批量 reject，含 current）。
+     *
+     * @param req UI 请求（约定只传 dialog 类；fire-and-forget 防御性兼容）
+     * @param handler 真正执行请求的 handler（TUI/GUI 模式分流后的 realHandler）
+     * @param opts 可选 child 引用（用于 rejectChildDialogs 关联）
+     * @returns handler 的响应；dialog 抛错时回 {cancelled:true}；child close 时回 {cancelled:true}
      */
-    applyGlobalConfig(read: GlobalConfigReadResult): GlobalConfigReadResult;
+    enqueue(req: UiRequest, handler: UiRequestHandler, opts?: EnqueueOptions): Promise<UiResponse>;
     /**
-     * 三态重读全局配置并提交缓存（幂等可重入），返回本次读取结果供调用方感知。
+     * settle 一个 item（幂等）。handler 完成 / rejectChildDialogs / rejectAll / 超时 timer
+     * 都通过本方法，settled 标志保证只 settle 一次（防竞争）。
      *
-     * 从 initModel 提取（设计 D2）：引擎感知检测器 per-turn poll 发现 config 变更时
-     * 调用本方法，使「system prompt 现值、路由缓存、变更通知」同 turn 对齐——只改注入
-     * 不刷新路由缓存，会出现 prompt 说引擎 B、实际派发跑引擎 A（权威信息源说谎）。
-     * 幂等性：只做「读文件 → 按三态提交缓存」单向赋值，无时序状态，重复调用收敛到
-     * 同一结果。三态语义（failed 保持缓存、静默回落 DEFAULT 是旧缺陷——读失败曾把
-     * 好缓存打回缺省且调用方无法感知）：ok/absent 覆盖、failed 保持并携带原因。
+     * #19 单一推进点：本方法 settle Promise + 清状态后，**唯一**调 processNext 推进队列。
+     * processNext 尾部不再调 processNext（旧代码双重推进，虽靠 processing 标志幂等，但语义混乱）。
+     * 为什么推进必须在 settleItem 而非 processNext 尾部：rejectChildDialogs 取消一个永不 settle
+     * 的 current（handler 等用户输入卡死）时，processNext 的 `await item.handler` 永不 resume，
+     * 尾部不会执行；只有 settleItem 里的 processNext 才能打破死锁，推进下一个。
+     *
+     * [A2-2] 超时 timer 清理也统一收口在这里：任何路径抢先 settle（reject/rejectAll/超时
+     * 自身）都必须撤下 armed timer——handler 永挂时 processNext 内联的 clearTimeout 不可达，
+     * 不在这里清则 timer 到期触发虚假「dialog timed out」warn 且句柄滞留至超时点。
      */
-    reloadGlobalConfig(): GlobalConfigReadResult;
+    private settleItem;
     /**
-     * 刷新主 agent model 缓存。model_select 事件时调用。
-     * renderCall 的 resolveModel 读此缓存以显示标题行 model。
+     * SR-4：把指定 child 的所有 pending dialog resolve 为 {cancelled:true}。
+     *
+     * 触发场景：子进程 close（用户取消 / crash / 超时 kill）时，其 pending dialog 的 handler
+     * 可能永不 settle（等用户输入），导致 Promise 永挂 + 内存泄漏。本方法批量清理。
+     *
+     * 处理范围（TC-E4 case 2）：
+     *   - 正在处理中（current）的该 child 项：settle {cancelled:true}，解阻塞队列推进下一个
+     *     （关键：handler 可能永不 settle，必须由这里打破死锁）
+     *   - 队列中等待处理的该 child 项：settle {cancelled:true} 并移除
+     *
+     * 不影响其他 child 的 pending dialog（TC-E4 case 2 子测试 2）。
      */
-    setCtxModel(model: ModelInfo | undefined): void;
+    rejectChildDialogs(child: DialogChildRef): void;
     /**
-     * 解析 agent 的模型（三层：override → agentConfig → 主 agent model）。
+     * 处理队列下一项（FIFO）。
      *
-     * @param agentRef   agent 引用（.md 绝对路径；查 agentConfig 的 model override）
-     * @param override   调用方显式 override（最高优先级）
-     * @param ctxModel   主 agent 当前模型（兜底，直接透传）
+     * processing 标志保证串行：handler 运行期间 processing=true，新的 processNext 调用直接返回；
+     * handler settle 后由 settleItem 清 processing=false 并推进下一项（#19 单一推进点）。
+     *
+     * handler 抛错兜底（TC-E4 case 3）：catch → settle {cancelled:true} → 继续。
+     * 不能让一个失败卡死队列（processing 永远 true）。
+     *
+     * LC-3/T2⑦ 超时上界：`await item.handler` 原本无上界——host UI promise 挂死或用户
+     * 永不回答时 processing 恒 true（全局 dialog 死锁）。现在每项挂队列级 timer：
+     * req.timeout（请求方显式传值）优先，未传/非法挂 DEFAULT_DIALOG_TIMEOUT_MS。
+     * 到点 settle {cancelled:true}（完整错误消息落父进程日志，含恢复指引与等待时长），
+     * settleItem 的 settled 标志保证与 handler 完成 / rejectChildDialogs 三方竞态下
+     * 恰 settle 一次。timer 回调闭包捕获 item（非读 this.current）：迟到触发时
+     * settled 标志已置位，直接 noop，不误伤后继项。
      */
-    resolveModel(agentRef: string, override?: {
-        model?: string;
-        thinkingLevel?: string;
-    }, ctxModel?: ModelInfo, 
-    /** 已解析的 agent 配置（调用方已加载时复用，避免同一 agentRef 二次 loadByPath）。 */
-    agentConfig?: AgentConfig): ResolvedModel;
-    /** 查询 agent 配置（SubagentService 内部判定 defaultBackground 用）。
-     *  undefined = 合法缺省语义（未点名 / 默认 general-purpose 形态）。 */
-    getAgentConfig(agentRef?: string): AgentConfig | undefined;
+    private processNext;
     /**
-     * 查询 agent 配置——显式 ref 失败即 throw（SubagentService.resolveIdentity 用）。
+     * #10：把所有 pending dialog（queue + current）全部 settle 为 {cancelled:true}，
+     * 并清空 queue/current/processing 状态。session_shutdown 调用，保证不留永挂 Promise。
      *
-     * 与 getAgentConfig 的语义分界（「用户显式点名」vs「默认 general-purpose」）：
-     * 用户显式点名的 agentRef（工具 agent 参数 / workflow agent({agent}) opts）解析
-     * 失败 = 配置错误，必须显式报错——错误文案含 <available_subagents> 恢复指引
-     * （对齐 workflow name not found 反馈风格），不允许静默降级为无配置
-     * general-purpose 形态（systemPrompt/工具白名单全丢且零反馈）。默认形态
-     * （不传 agent）走 getAgentConfig：undefined = 合法缺省，走 override → ctxModel 兑底。
+     * 约定签名：rejectAll(): void（无参，返 void）。Group C 的 index.ts session_shutdown 依赖此契约。
+     *
+     * 幂等：依赖 settleItem 的 settled 标志——重复调用只会对已 settled 项 noop。
+     * 顺序敏感（#19 推进点在 settleItem）：必须先清空 queue 数组再 settle current，
+     * 否则 settleItem(current) 同步触发的 processNext 会从旧 queue 抢占下一项作为新 current，
+     * 避开本方法的 cancel 语义。清空后 processNext 看到空队列直接返回，新 current 不会被抢占。
+     *
+     * 单 session 假设（M-2）：见类注释。本方法清空所有 pending 不分 session——依赖 Pi 单进程
+     * 单 session 串行保证。session_shutdown handler（index.ts）调用本方法时，进程内只会有当前
+     * session 的 pending dialog。多 session 并发场景的迁移策略（rejectAllForSession）见类注释。
      */
-    getRequiredAgentConfig(agentRef: string): AgentConfig;
-    /** 全局配置深拷贝（调用方拿到副本，改不影响 Service 内部）。 */
-    getGlobalConfig(): SubagentsGlobalConfig;
-    /** 内部：session id 缓存（initModel 注入；当前无消费者，保留供未来 session 作用域需求）。 */
-    get sessionId(): string | undefined;
-    /** agent 配置目录（SubagentService 构造 store/SessionRunnerContext 时读）。 */
-    getAgentDir(): string;
-    /** modelRegistry（SubagentService 构造 factoryCtx 时读）。已注入保证非 null。 */
-    getModelRegistry(): ModelRegistryLike;
-    /** 校验 modelRegistry 已注入。 */
-    private assertReady;
-}
-/** 获取进程单例。session_start 前为 null。 */
-declare function getModelConfigService(): ModelConfigService | null;
-/** 设置进程单例（session_start 首次创建时）。 */
-declare function setModelConfigService(service: ModelConfigService): void;
-
-/** Pi ExtensionAPI 的最小接口（duck-typed）——原定义于 subagent-service.ts，随通知簇
- *  （piAdapter / emitPending* 的依赖）搬移至此并导出（Service 的 session 注入参数仍引用）。
- *  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";
-    }): void;
-    /** 订阅 pi 事件（D8：notifier 的 settled 边沿订阅用 'agent_settled'）。
-     *  pi 0.84.1 的 on 返回 void 且无 off——退订语义由调用侧 disposed 标志包装兑现。
-     *  可选：旧测试 mock pi 可能未实现 on，缺省时 notifier 退化为内核退避路径。 */
-    on?(event: "agent_settled", handler: () => void): void;
+    rejectAll(): void;
+    /** 清空队列状态（仅在 rejectAll 之后调用）。pending Promise 必须先由 rejectAll settle。
+     *  不 settle Promise 的纯状态重置——单独调用会导致 Promise 永挂（footgun），故设为 private。
+     *  外部调用方应使用 rejectAll()（它 settle 所有 pending + 重置状态，是原子操作）。 */
+    private resetState;
+    /** 当前队列长度（测试/诊断用）。含等待处理项（不含 current）。 */
+    get size(): number;
 }
 
 /** [D4 查询面聚合] 读模型轴（record 快照读取 + store 订阅）——Service 上的
@@ -1239,8 +2432,13 @@ interface SubagentQueries {
     /** [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[];
+    /** 合并内存 + 磁盘 record（/subagents list + tool list 消费，按 rootSessionId 过滤）。
+     *  [H2 W1] includeWorkflow 缺省 false = 过滤 origin==="workflow"（D1 投影过滤①③④）；
+     *  true = 排查通道全量。 */
+    collectRecords(limit: number, statusFilter?: StatusFilter, includeWorkflow?: boolean): SubagentRecord[];
+    /** [H2 W1] 按 workflow run id 列 record（内存 ∪ 磁盘重建 ∪ manifest 口径，不过滤
+     *  origin——W2 run 视图进度 / W3 下钻消费）。 */
+    collectRecordsByParentRunId(parentRunId: string, limit: number): SubagentRecord[];
     /** [perf] 单 record 详情懒加载（全量：eventLog/displayItems/result/turns/tokens）。 */
     getFullRecord(id: string): SubagentRecord | undefined;
     /** 订阅 store 变更（widget/list requestRender）。返回取消订阅。 */
@@ -1256,10 +2454,10 @@ interface SubagentChatActions {
     }): ExecutionRecord;
     /** close action 的统一行为分流（running 子态 × force）。 */
     closeSubagent(record: ExecutionRecord, force: boolean): Promise<void>;
-    /** chatMode 统一投递入口（message action，经引擎交互面执行）。 */
-    deliverChatMessage(record: ExecutionRecord, text: string, interrupt: boolean): Promise<void>;
+    /** chatMode 统一投递入口（message action → ConversationContinuation.onMessage，
+     *  [H1 U6] interrupt 参数随 D2 打断统一语义退役）。 */
+    deliverChatMessage(record: ExecutionRecord, text: string): Promise<void>;
 }
-
 /**
  * Service 构造参数（进程级）。
  *
@@ -1276,7 +2474,51 @@ interface SubagentServiceInit {
      *  签名见 dialog-queue.ts UiRequestHandler：接收 UiRequest，返回 UiResponse。 */
     uiRequestHandler?: UiRequestHandler;
 }
-/** session_start 注入参数（session 级）。 */
+/** 获取进程单例。session_start 前为 null。 */
+declare function getSubagentService(): SubagentService | null;
+/** 设置进程单例（session_start 首次创建时）。 */
+declare function setSubagentService(service: SubagentService): void;
+/**
+ * [U10① D6] 第三宿主最小构造入口：仅凭参数注入构造 SubagentService（无全局查找）。
+ *
+ * 构造依赖（modelService / getMainSessionFile / uiRequestHandler）全部经 init
+ * 参数注入；本工厂是 `new SubagentService(init)` 的薄包装，不读也不写
+ * getSubagentService/setSubagentService 的全局槽位——session_start 单例流程
+ * 行为零改动，宿主自持实例时用本工厂。构造内部行为与直接 new 逐字等价。
+ *
+ * @experimental execution 运行时面（设计 docs/design/subagent-core-sink-design.md §3.3 D6）：
+ * 一个 minor 周期内允许签名微调，稳定后转常规 semver 承诺。
+ */
+declare function createSubagentService(init: SubagentServiceInit): SubagentService;
+
+/** Pi ExtensionAPI 的最小接口（duck-typed）——原定义于 subagent-service.ts，随通知簇
+ *  （piAdapter / emitPending* 的依赖）搬移至此并导出（Service 的 session 注入参数仍引用）。
+ *  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";
+    }): 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;
+}
+
+/** session_start 注入参数（session 级）。
+ *  [R1] 接口本体自壳文件迁入（唯一消费者 = SessionBaselines.initSession）；壳经类型
+ *  别名 re-export 保持对外符号面（SubagentServiceSessionInit 仍从 subagent-service.ts
+ *  导出，消费方零改动）。 */
 interface SubagentServiceSessionInit {
     pi: PiLike;
     sessionId: string;
@@ -1297,22 +2539,15 @@ interface SubagentServiceSessionInit {
      *  createUiRequestHandlerForMode 返回 undefined 时壳侧传 null）；值 = 注入并重置
      *  缺失告警去重。 */
     uiRequestHandler?: UiRequestHandler | null;
-    /** L2 跨子进程全局 dialog 串行队列（进程单例）。透传给 session-runner，
-     *  child close 时调 rejectChildDialogs 清理 pending（SR-4 防全局死锁）。 */
+    /** L2 跨子进程全局 dialog 串行队列（进程单例）。子进程退出时经引擎镜像层
+     *  （SpawnedChildrenMirror → notifyChildProcessExited）取消该 pid 的挂起请求（SR-4）。 */
     dialogQueue?: DialogGlobalQueue;
     /** [竞态修复] 主 agent 是否空闲查询（ctx.isIdle），透传给 notifier 的 flush isIdle gate。
      *  避免 background 完成通知在 agent_end→finishRun 窗口里走错 sendMessage 分支丢失。
      *  可选：未注入时 notifier flush 不 gate（原行为）。 */
     isIdle?: () => boolean;
 }
-/**
- * [T4① / PS-2] 轮次完成回注的 notify 门（按 closedReason 白名单放行）。
- *
- * cancelled（cancelBackground 自己 notify）与 parent-new/parent-fork（编排性关闭，
- * 告知由 list 的 closedReason 表达）不放行；其余（undefined = 本路径抢到 CAS 尚未
- * 终态化的迟到回调、user-close/gc 等真实终态）照旧回注。导出供测试与未来调用点复用。
- */
-declare function notifyGateAllowsDelivery(closedReason: ClosedReason | undefined): boolean;
+
 /**
  * 执行编排 Service。进程级单例。
  *
@@ -1337,44 +2572,6 @@ declare class SubagentService {
     private readonly cwd;
     private readonly worktreeManager;
     private readonly getMainSessionFile;
-    /** UI 请求 handler（进程级，可被 setUiRequestHandler / initSession 覆盖）。 */
-    private uiRequestHandler;
-    /** L2 dialog 串行队列（进程级）。SR-4：child close 时 session-runner 调 rejectChildDialogs 清理。 */
-    private dialogQueue;
-    /** UI 请求可观测性（sessionMode + handler 缺失告警去重，提取自本类降低行数）。 */
-    private readonly uiObservability;
-    private pi;
-    /** 当前 Pi session ID（本进程 pi session，事件路由等用；record 过滤不用它）。initSession 时注入。 */
-    private sessionId;
-    /** 主 session 文件（initSession 按值直传——jiti 多实例下闭包缓存不可靠，见 SessionInit 注释）。 */
-    private mainSessionFile;
-    /** 所属根 session ID（record 归属过滤用）。根进程 = sessionId（自己是 root）；
-     *  子进程 = env PI_SUBAGENT_ROOT_SESSION_ID 贯穿的真 ROOT（initSession 读取）。
-     *  与 sessionId 正交：sessionId 是本进程 pi session（事件路由等），sessionRootId 是所属根
-     *  （collectRecords filter 用，与 createRecordForMode 的 rootSessionId 盖章同源——子进程
-     *  因此看到整棵 ROOT 树）。设计见 recursive-subagent-visibility.md 决策 3。 */
-    private sessionRootId;
-    /**
-     * [D3-⑤ 嵌套防护合一] 进程内执行嵌套上下文（原 execCtxAls 私有字段下沉公共层
-     * common/nesting-guard.ts ExecutionNestingContext——机制注释含 ALS 断裂基线兜底）。
-     * 实例 per-Service：基线随宿主进程身份而异（initSession 从 env 建立）。
-     */
-    private readonly execNesting;
-    /** fork 深度基线（同 ALS 断裂问题：forkDepthAls.getStore() 兜底用）。根进程=0。 */
-    private forkDepthBaseline;
-    /** [MF-3] 所属根进程 cwd（sessions/records 落盘目录编码键）。
-     *  根进程=自身 cwd（构造时 init.cwd）；子进程=env PI_SUBAGENT_ROOT_CWD 贯穿的真 ROOT cwd。
-     *  worktree 模式下子进程 this.cwd 是 checkout 路径，若按它编码目录，深层 record 落到
-     *  enc(worktree) 段、ROOT 扫描不到 → 全树可见性深度 ≥ 2 断裂（与 sessionRootId 同构）。 */
-    private rootCwd;
-    /** UI streaming sink（ctx.ui.setWidget）。workflow 域经 getStreamSink() 取用。 */
-    private streamSink;
-    /** [竞态修复] 主 agent isIdle 查询（ctx.isIdle）。notifier flush gate 用。
-     *  initSession 注入，piAdapter 透传给 NotifierHost。 */
-    private isIdleFn;
-    getStreamSink(): StreamSink | null;
-    private _disposed;
-    private _seq;
     /** [D4-①] 通知簇 host 面（notifyComplete/notifyClosed/pending 注册注销 + notifier
      *  实例封装，原私有通知簇四方法与模块函数的搬移落点——notify-host.ts）。
      *  deps 惰性求值（pi/session 级状态运行时可变），行为与原 constructor 内
@@ -1382,61 +2579,6 @@ declare class SubagentService {
      *  [sync-collect 合并] toNotifyRecord/notify/notifyBatch 随批路由需要由 host 导出
      *  （collectCoordinator 闭包与 E9/E1 直发路径消费，见 notify-host.ts 接口注释）。 */
     private readonly notifyHost;
-    /** collectCoordinator（subagent-sync-collect U2）：sync 批缓冲 + 闭合检测 + flush 分流。 */
-    private readonly 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;
-    /** [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;
-    /** [MF#4][MF#2] fork 深度按 async 调用链传递（AsyncLocalStorage），替代共享可变计数器。
-     *  主 session=0；fork 进入子 session 期间推进为子深度，供嵌套 fork 经 ALS 读到自身深度作为
-     *  parentForkDepth。并发 background fork 各自独立调用链，不再互相压低深度值。
-     *  [MF#2] 旧实现用单实例字段跨执行链共享 → 并发下 A 还原深度后 B 读到被压低值 → 护栏失效。 */
-    private readonly forkDepthAls;
-    /** [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;
-    /**
-     * [W3 chat 域收口] chat 轮次反向通道路由表（recordId 键）：首轮 run chat 注册、
-     * interact 续聊轮复用——host/streamDelta（recordId 分支）与 host/roundLifecycle
-     * （recordId 键）的分发目标（EngineClient.recordRoutes 经
-     * EnginePort.registerChatRoundRoute 注册）。record 终态化路径注销（[F-5 修复]
-     * 汇聚点 = doFinalizeRecord 的 onFinalized 钩子 + cancelBackground /
-     * disposeAllRecords 两处直连终态化路径显式注销）。
-     */
-    private readonly chatRoundRoutes;
-    /** [D4-③] 冷路径复活依赖（原四件 private 方法的搬移落点——cold-resurrect.ts；
-     *  deps 闭包惰性求值：sessionRootId / execNesting 基线运行时可变）。 */
-    private readonly coldResurrectDeps;
-    /**
-     * [W4] 轮次活性监督器（D2「等待有主」权威层）：死亡事件纳管（run failed / 引擎
-     * exited → adoptOnProcessDeath）+ boot 分区重认领（initSession）+ 三态判定
-     * （record 级视图）+ 该放弃（终态化 failed + 注销 + 终止通知）。装配绑定面
-     * （deps/giveUp 编排/sweep 挂点）在 round-supervisor/service-binding.ts——变化轴
-     * 独立（通知文案 / 终态化编排 / store 读侧判据只动该文件），本字段只持实例。
-     */
-    private readonly roundSupervisor;
-    /** [D4 查询面聚合] 读模型消费面（壳 interface/ 视图与 tool 查询经此访问；
-     *  纯委托——方法本体保留 private 实现不重写，行为逐字节等价）。 */
-    readonly queries: SubagentQueries;
-    /** [D4 对话 action 面聚合] chat 域 message/close 消费面（壳 subagent-actions 经此访问；
-     *  纯委托同上。PiEngineService 适配器不经此——引擎边界走 piEngineServiceAdapter）。 */
-    readonly chatActions: SubagentChatActions;
     private readonly manifestStore;
     /**
      * [D6 #7a] records 目录（与 manifestStore 同源同一推导）——屏障失败 warn 带 manifest
@@ -1450,587 +2592,174 @@ declare class SubagentService {
      */
     private readonly sessionsDir;
     constructor(init: SubagentServiceInit);
-    /** session_start 注入 pi + revive（modelRegistry/entries 归 ModelConfigService.initModel）。 */
+    /** [D4 查询面聚合] 读模型消费面（壳 interface/ 视图与 tool 查询经此访问；
+     *  纯委托——方法本体保留 private 实现不重写，行为逐字节等价）。 */
+    readonly queries: SubagentQueries;
+    /** [D4 对话 action 面聚合] chat 域 message/close 消费面（壳 subagent-actions 经此访问；
+     *  纯委托同上。PiEngineService 适配器不经此——引擎边界走 piEngineServiceAdapter）。 */
+    readonly chatActions: SubagentChatActions;
+    /** [R1] 域 #2 聚合实例：session 级基线状态（pi / session 身份 / fork ALS / 嵌套 ALS /
+     *  UI handler 面）的唯一宿主与唯一写者（r0-inventory 清单① #13-#25 共 13 字段）。
+     *  deps 全晚绑定闭包（装配见构造器），壳经下方 getter/方法透传，对外签名零变化。 */
+    private readonly baselines;
+    private get pi();
+    private get sessionId();
+    private get mainSessionFile();
+    private get sessionRootId();
+    private get streamSink();
+    private get isIdleFn();
+    private get execNesting();
+    private get rootCwd();
+    private get uiObservability();
+    /** session_start 注入 pi + revive（modelRegistry/entries 归 ModelConfigService.initModel）。
+     *  本体已迁 SessionBaselines.initSession（fork/exec 嵌套基线建立、复活与跨域编排时序
+     *  逐行等价随迁）；壳纯转发，对外签名不变。 */
     initSession(init: SubagentServiceSessionInit): void;
     /**
-     * [SPAWN fork depth 跨进程传递] fork 链深度基线：子进程被父 spawn 时，父通过 env
-     * PI_SUBAGENT_FORK_DEPTH 传入当前 fork 链深度。子进程 session_start 时读取作为
-     * forkDepthAls 基线，使后续嵌套 spawn fork 能从正确深度递增。未设置（顶层主
-     * session）→ 基线 0。enterWith 贯穿整个 session 生命周期。
-     */
-    private initForkDepthBaseline;
-    /**
-     * [递归可见性] exec 上下文基线：子进程读 env PI_SUBAGENT_SELF_RECORD_ID / DEPTH
-     * 建立身份基线后，createRecordForMode 读嵌套上下文自动正确（孙挂到子名下）。
-     * enterWith 贯穿整个 session 生命周期（与 forkDepthAls 同构，决策 4）。
-     */
-    private initExecContextBaseline;
-    /**
-     * 孤儿终态恢复（residual-fixes）：session_start 主动触发一次——父扩展死后再无人写
-     * 终态 entry 的 record 在此判定落盘（否则侧栏永久 running）。幂等不 throw，失败不
-     * 阻断 session_start。
-     *
-     * [T5① / PS-8] 只有根进程做扫描者：恢复机制假设「单扫描者」，但子进程 sessionRootId
-     * 经 env 与父同值（过滤域 = 整树共享的 sessions/records 目录），env 贯穿让每个子进程
-     * 都成了扫描者——递归编排中任一子进程启动时，恰有兄弟记录 marker 缺失或超软超时
-     *（hours-long wave 必然命中）→ 活记录被无关进程盖 .finalized sidecar，closed entry
-     * 写进别的进程的 session 文件（跨进程互写，无任何锁）。子进程身份判据 = env
-     * PI_SUBAGENT_SELF_RECORD_ID（父 spawn 时注入的「子进程自己的 record id」，仅子进程
-     * 非空）——与 execNesting 基线同源。根进程恢复语义不变。
+     * [F6] 当前根 session id 的只读访问——引擎接线方（SAR 等）构造 RunContext 注入
+     * `ctx.sessionRootId`（pi 引擎 relay 归属键 SESSION_ID 权威源）。initSession 后有值
+     * （根进程 = 本 session id；嵌套 = env 贯穿的真 ROOT）。[D3+] 壳终态保留面。
      */
+    getSessionRootId(): string | null;
+    /** UI streaming sink 只读访问（workflow 域消费）。[D3+] 壳终态保留面。 */
+    getStreamSink(): StreamSink | null;
+    /** [D4 下沉] 就绪断言本体已迁聚合（late-bound getter 现读 pi/disposed，错误文案不变）；
+     *  壳 9 个调用点经此转发。 */
+    private assertReady;
+    /** [R2] 域 #5 聚合实例：sync 批自闭合语义（collectCoordinator 装配 + E9 dispose 转账 +
+     *  E1 崩溃恢复 + settled 有界重扫 + collectSync 配置读取）的唯一宿主与唯一写者
+     *  （r0-inventory 清单① #26-#28）。deps 全晚绑定闭包（装配见构造器；检查点①
+     *  flushBatch 显式依赖注入随聚合落地），壳经下方 getter/方法透传，对外签名零变化。 */
+    private readonly syncCollect;
+    private get collectCoordinator();
+    /** [E1] sync 批崩溃恢复（index.ts session_start 恢复编排处调用）。本体已迁
+     *  SyncCollectDomain（扫描/补发/落标/settled 重扫时序逐行等价随迁）；壳纯转发，
+     *  对外签名不变。 */
+    recoverSyncCollectBatch(): Promise<void>;
+    /** collectSync.default 当前生效值（startHandler 缺省 collect 解析用；本体与配置读取
+     *  链已迁聚合）。[D3+] 壳终态保留面（subagent-actions-core 消费）。 */
+    getCollectSyncDefault(): "async" | "sync";
+    /** [R3] 读建面聚合实例（域 #3 孤儿恢复 / #8 查询面 / #10 action 网关 / #13 身份解析与
+     *  record 创建的唯一宿主）。deps 全晚绑定闭包（装配见构造器），壳经下方同名方法
+     *  透传，对外签名零变化。[D-R3-1] 与 RecordLifecycle 拆分的计划变更见聚合文件头。 */
+    private readonly recordAccess;
+    /** [R3] 终态迁移写面聚合实例（域 #4 回收面 / #11 close 三路 / #17 cancel / #18
+     *  finalize 簇的唯一宿主——D5「store 与终态迁移入口的唯一宿主」，H4 落点）。
+     *  deps 全晚绑定闭包（装配见构造器；C-5 跨域汇聚经回调、collectCoordinator 经 #5
+     *  显式投影现读），壳经下方同名方法透传，对外签名零变化。 */
+    private readonly recordLifecycle;
+    /** [R3] 孤儿终态恢复编排入口（baselines deps.recoverOrphans 回调消费点——initSession
+     *  复活后编排，时序逐行等价随迁读建面）；壳纯转发，签名不变。 */
     private recoverOrphansIfRootProcess;
-    /** 孤儿终态恢复委托（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 注入（构造期可空）。 */
-    private recoverOrphanRecords;
-    /** 启动恢复：扫描 manifest tmp 残留（崩溃打断的 writeManifest 留下的 *.json.tmp.<pid>），
-     *  3 分支判定（manifest已存在删tmp / tmp合法promote / tmp非法删）。幂等，不 throw。
-     *  ADR-035 启动恢复接线——session_start 每次都调（与 maybeCleanupExpiredSessionFiles 一致）。
-     *  manifestStore 保持 private 封装，本方法是唯一公开入口。 */
+    /** 启动恢复：manifest tmp 残留清扫（ADR-035；index.ts session_start 每次都调）。
+     *  [U4c / D6] tmp 恢复已退役为**静默删除**——manifest 现为可丢可重建缓存（权威
+     *  = `.state`，重建 = rebuildIndexes），promote 半写 tmp 的恢复语义失效；本入口
+     *  只清残留（含 0 字节/半写形态）。本体已迁 RecordAccess（行为随 ManifestStore
+     * 退役语义）；壳纯转发，对外签名不变。 */
     recoverManifestTmpFiles(): Promise<{
         deleted: number;
         recovered: number;
     }>;
-    /** SP-4: 关闭所有活跃 record。
-     *
-     *  遍历 store 中所有 running record，逐个 CAS 转终态 + completeRecord + archive。
-     *  对有 worktreeHandle 的 record 触发 worktreeManager.cleanup（T3: worktree 绑定清理）。
-     *
-     *  [T2⑥ / PS-1] 补齐三回收面（对照 dispose() 的既有形态，消除同文件双标）：
-     *  controller.abort + kill（收敛到 killChildWithEscalation）+ disarmIdleTimer +
-     *  disarmSettledWatchdog。旧实现只关 record 不中止执行——「record 已关」≠「执行已
-     *  处置」：在途子进程继续跑且无任何用户可及的取消通道（cancel 只查内存 running，
-     *  archive 后恒 false），若挂死唯一上界是默认关闭的 spawn watchdog → 泄漏至宿主退出。
-     *  abort/kill/timer 三面对已终态/已死 record 均幂等 no-op，dispose() 先行的
-     *  abortRunningControllers + killAllSpawnedChildren 不受影响（parent-shutdown 路径
-     *  双保险）。
-     *
-     *  [v4 A-6] 旧实现的 recentlyCascaded 收集（供已删除的 before_agent_start 注入告知）
-     *  与 drainCascaded 已一并移除——被关 record 的告知改由 list 的 closedReason 表达。
-     *
-     *  @param reason 关闭原因（parent-fork / parent-new / parent-shutdown）
-     *  @returns 被关闭的 record 数量
+    /**
+     * [U4c / G1] 缓存降级重建通道（boot 全量腿）：manifest 与 sessions-index 均为
+     * 可丢缓存，本入口在 boot revive 完成后（initSession 的孤儿恢复/重物化已收敛
+     * 磁盘态）全量重建——幂等补缺（幸存 manifest 不覆写），失败静默降级不抛。
+     * 语义细节见 RecordStore.rebuildIndexes（D5 三要素）。壳纯转发。
      */
+    rebuildIndexes(): number;
+    /** SP-4: 关闭所有活跃 record（dispose 编排 parent-shutdown 路径 + D3 对外面）。
+     *  本体已迁 RecordLifecycle（三回收面 + manifest 补写 + 锚点提升时序逐行等价随迁）；
+     *  壳纯转发，对外签名不变。 */
     disposeAllRecords(reason: ClosedReason): number;
-    /** SP-4: /fork 新 session 时清理旧 record。
-     *  调用 disposeAllRecords("parent-fork")。由 index.ts 的 session_before_fork handler 触发。 */
+    /** SP-4: /fork 新 session 时清理旧 record（index.ts session_before_fork handler 触发）。
+     *  本体已迁 RecordLifecycle；壳纯转发，对外签名不变。 */
     onParentFork(): number;
-    /** SP-4: /new 创建全新 session 时清理旧 record。
-     *  调用 disposeAllRecords("parent-new")。由 index.ts 的 session_before_switch
-     *  （reason==="new"）handler 触发。 */
+    /** SP-4: /new 创建全新 session 时清理旧 record（index.ts session_before_switch 触发）。
+     *  本体已迁 RecordLifecycle；壳纯转发，对外签名不变。 */
     onParentNew(): number;
-    /** SP-4: idle record GC（30 天 TTL，实现抽至 idle-gc.ts）。stop 函数（dispose 调）。 */
-    private stopIdleGc;
-    /** 启动 idle record GC 定时器（session_start 调用，幂等）。
-     *  [W4] WorkflowRun store（FileRunStore）同批纳入：running 且 startedAt 超 30 天
-     *  锚窗的 run 终态化归档（只终态化不补注销，见 idle-gc.ts 头注）。宿主未
-     *  configureCore 时 loadAll 抛错由 idle-gc 内部吞掉（单轮跳过）。
-     *  [F-1 修复] stateDir 与 pi 壳 JsonlRunStore 落盘布局同源
-     *  （resolvePiWorkflowStateDir → <sessionDir>/workflow-state/）——缺省 dataRoot 根
-     *  与 pi 生产落盘不相交，WorkflowRun GC 曾恒空转（W4 引入的装配错位）。 */
-    startGcTimer(): void;
-    /** 停止 idle record GC 定时器（dispose 调用）。 */
-    private stopGcTimer;
-    /** session 结束清理（清定时器，丢弃 pending 通知）。幂等。
-     *
-     * [M-7] dispose 顺序假设：pending:unregister emit 依赖 pending-notifications 扩展的
-     * 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;
-    /** [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;
-    /** 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;
-    /** 批成员 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;
-    /** [时序屏障] 批通知路径（flush/E1）专用：成员 manifest 并行写 + await 全部完成
-     *  （allSettled）后才允许写账投递——「通知可达 ⇒ 索引就位」的构造性保证。写失败
-     *  不阻断（best-effort 语义与 doFinalizeRecord Step 4 一致：反查索引缺失只影响指针行
-     *  反查，session-reader 错误文案已指引绝对路径兜底，不构成写账失败）；warn 留痕
-     *  （D6 #7a / SC-1：屏障失败意味着该成员指针行反查索引缺失，debug 级在排障时不可见）。 */
-    private writeSyncBatchManifestBarrier;
-    /** [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;
-    /**
-     * [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> 幂等拒绝兜底。
-     */
-    recoverSyncCollectBatch(): Promise<void>;
-    /** [E1/D4] 单次「扫描→判定→可达则补发+落标」，E1 首扫与 settled 重扫共用同一实现
-     *  （防两处复制粘贴分岔）。三态返回：idle（无 sync 候选——已全部落标/E9 转换/异根，
-     *  无事可等）/ waiting（仍有 running 成员，本次不动）/ dispatched（全员终态，已补发
-     *  +统一落标）。async：补发前有 manifest 屏障 await（见函数头 E1 注释）。 */
-    /** 返回 outcome + waitingIds（达限 warn 需滞留成员 id，D6 #7b——仅 waiting 态非空）。 */
-    private runSyncCollectRecoveryScan;
-    /** [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;
-    dispose(): void;
-    /**
-     * [T4④ / PS-5] shutdown flush 被门拦时把未投递 pending 复写落盘（供重启 replay）。
-     *
-     * 触发条件：flushPendingNotifications 后 ledger 仍有 pending（isIdle 门拦 / sendDelivery
-     * 受理失败的残留）且主 agent 非 idle——即本次 shutdown 注定投不出去。落盘动作 =
-     * pi.appendEntry 重写 NOTIFY_LEDGER_CUSTOM_TYPE entry（与 ledger.record 同通道同 schema，
-     * notifyId 幂等：恢复扫描按后写覆盖 + ack/abandoned 差集去重，重复账面不产生重复投递）。
-     * 主 agent idle 时 flush 已投出，无需复写（零开销）。
-     */
-    private persistUndeliveredNotificationsForReplay;
-    /**
-     * 预解析 model（renderCall 标题行用，同步）。代理 modelService.resolveModel。
-     * 仅解析 override/agentConfig 路径；ctxModel 缺失时拋错，调用方 catch 降级。
-     */
-    resolveModel(agent: string, override?: {
-        model?: string;
-        thinkingLevel?: string;
-    }, ctxModel?: ModelInfo, agentConfig?: AgentConfig): ResolvedModel;
-    /**
-     * 统一执行入口。mode 固定 background（sync 已删除）。
-     * 内部完成：模型解析 → 执行 → 收尾。
-     *
-     * @param opts.ctxModel  主 agent 当前模型（模型解析第三层兼底）。undefined 时仅依赖 override/agentConfig。
-     */
-    execute(opts: ExecuteOptions): Promise<ExecutionHandle>;
-    /**
-     * 按 id 查内存 running record 的只读快照（G3-002 修复）。
-     * 不从 session.jsonl 重建（cancel/list 单点查询只关心内存 running record）。
-     * 供 tool 层 cancelHandler 翻译 throw 用（id 不存在 / mode / 终态三种错误）。
-     * 不存在返回 undefined。
-     */
-    private findRecord;
-    /** 取消 background record（tryTransition CAS 抢锁防重复副作用）。 */
-    cancel(id: string): boolean;
-    /**
-     * [v8.5 A1/B] 全态查找：任意状态（running/closed）× 任意归属（含异 root session）的
-     * record 快照。供 message 拒绝文案分流（A1）与 fork-from 源解析（B）共用。
-     *
-     * 与 getRecordForAction 的差异：不做归属/直接父校验、不重建可变 record 入内存，
-     * 只读快照（light 形态可能缺详情重数据，身份/sidecar 状态字段齐全）。查询顺序与
-     * getRecordForAction 冷路径同款（idToFile 索引直查 → collectRecords 全扫兑底），
-     * 不限 status——终态（sidecar closed）记录也能查到。
-     *
-     * 返回 undefined：id 在内存与磁盘均不存在。
-     */
-    private lookupRecordAnyState;
-    /**
-     * [V2 决策 3 → W3 协议形态] chatMode 统一投递入口（message action 的 Service 面）
-     * ——经协议 interact（message action）发往 pi-subagent-cli 引擎进程。协议知识
-     * （stdin prompt 命令 + streamingBehavior 映射 + EPIPE 兜底）在引擎进程内
-     * （chat-session.deliverMessage）；编排层按结构化结果分流：
-     *
-     *   受理（引擎侧进程活）：prompt + streamingBehavior——pi 权威裁决 busy/idle。
-     *   冷路径（engine_session_not_resumable = 进程死/无活进程）：冷路径续轮
-     *     （resumeColdRound → run chat + resume 锚点接续，仅崩溃/timeout kill/跨重启命中）。
-     *   其他拒绝（EPIPE 兜底耗尽 / engine_interact_failed）：业务拒绝原样 throw
-     *     （文案自带行动语言——与 inproc 形态逐字节一致）。
-     *
-     * @param record 目标 record（chatMode，running 或 idle）
-     * @param text 消息正文
-     * @param interrupt true=steer（抢占）/ false=followUp（排队）
-     */
-    private deliverChatMessage;
-    /**
-     * 冷路径续轮（PiEngine.deliverPrompt 的编排回调，D2 下沉后的归属）：resume spawn
-     * 开启新一轮对话（设计决策 6 idle 分支）。仅进程死（idle timer reap / 崩溃 / 跨重启
-     * / EPIPE 兜底）时经引擎到达。
-     *
-     * 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 可完善）。
-     *
-     * detached 编排（kickOffChatRound，经 EnginePort 交接）：不 await，轮次在 background 跑。
-     * chatMode + done 时轮次收尾的 M2-A 分流自动把 record 回退 idle-resumable。并发槽在
-     * 轮次执行内重新 acquire（轮次间 idle 已 release）；pool.acquire 是排队模型，
-     * 池满时排队等待槽位而非 throw（与 execute 一致）。
-     *
-     * @param record 目标 record（必须 idle-resumable）
-     * @param text 新一轮消息正文
-     * @throws Error record 非 running / 无 sessionFile / 无 controller / worktree 绑定丢失 / 续轮在途
-     */
-    private resumeColdRound;
-    /**
-     * [T2③] 热路径轮 settled watchdog 到期处置（对齐 u-t2a 首轮形态：kill + 该轮失败
-     * 终态化 + 失败通知，error 含 'settled watchdog' 标记与恢复指引）。
-     *
-     * [D9 两段式] 两段（mid-round 无进展 / settled 收尾段上界）共用本处置，fire 信息
-     *（段 + 窗长）由原语注入，失败文案按段分叉窗长语义。
-     *
-     * 与首轮的差异：runSpawn 已返回（无收尾链路承接 settledWatchdogFired 标记），失败
-     * 终态化在本回调内完成。chatMode 按 MF-6 语义回退 running-resumable（与首轮 watchdog
-     * 经 runAndFinalize 失败分支的最终形态一致——对话可冷路径复活）；非 chatMode 终态
-     * 销毁。CAS（tryTransition closed+gc）防与 cancel/dispose 双收尾，抢锁失败即跳过。
-     *
-     * 回调在 timer 触发的同步上下文执行：同步段只做 kill + CAS（不抛），异步收尾
-     * fire-and-forget 且 catch 归 bestEffort——错误逃出回调 = uncaughtException 崩宿主。
-     */
-    private onHotPathSettledWatchdogTimeout;
+    /** 启动 idle record GC 定时器（session_start 调用，幂等）。本体已迁 RecordLifecycle
+     *  （stopIdleGc 句柄为聚合唯一写者字段）；壳纯转发，对外签名不变。 */
+    startGcTimer(): void;
+    /** 停止 idle record GC 定时器（dispose 编排消费点）。壳纯转发。 */
+    private stopGcTimer;
+    /** 按 id 查内存 running record 的只读快照（G3-002 修复）。本体已迁 RecordAccess
+     *  （assertReady 就绪门经 deps 现读）；壳纯转发，签名不变。 */
+    private findRecord;
+    /** [v8.5 A1/B] 全态查找（message 拒绝文案分流 + fork-from 源解析共用）。本体已迁
+     *  RecordAccess；壳纯转发。 */
+    private lookupRecordAnyState;
+    /** 订阅 store 变更（widget/list requestRender）。本体已迁 RecordAccess；壳纯转发。 */
+    private onChange;
+    /** 合并内存 + 磁盘 record（/subagents list + tool list 消费，按 rootSessionId 过滤）。
+     *  本体已迁 RecordAccess；壳纯转发（默认参数在聚合侧保持同值）。 */
+    private collectRecords;
+    /** [perf] 单 record 详情懒加载。本体已迁 RecordAccess；壳纯转发。 */
+    private getFullRecord;
     /**
-     * 按 id 查 record 并做归属校验（message/close action 的统一入口）。
-     *
-     * 设计决策 3（归属守卫）：校验 record.rootSessionId 必须等于当前 session 的根 id
-     *（this.sessionRootId）。不匹配 / 不存在统一抛「not found or not owned」——不区分
-     * 两种失败，防信息泄露（无法通过错误消息探测其他 session 的 subagent id）。
-     *
-     * 同进程内 running + idle record 都在内存（getMutable）；终态 record 已 archive。
-     * 跨重启（SP-2）内存空时，从磁盘 collectRecords 重建 idle record 并 register 进内存。
-     * reconstructAll 已将跨重启 record（无 sidecar marker + pid 死）标记为 running（v4 B-1 跨重启可续聊语义，record-store buildRecord 分支 4），
-     * collectRecords 返回的 SubagentRecord 可直接转为可变 ExecutionRecord 供续操作。
-     *
-     * @param id subagent record id
-     * @param opts.allowReconnect [v8.5 D] message 专属：冷查额外接受「可重连」的 closed 记录
-     *   （死因∈ RECONNECTABLE_FINAL_REASONS，A 档真实死因 sidecar 是唯一准入门），经四重守卫后
-     *   resurrectClosed 回边为 running 并续写原 session 文件。仅 message 开启；close/cancel 维持单向终态语义。
-     * @returns 可变 ExecutionRecord（message/close handler 直接操作）
-     * @throws Error record 不存在 / 非本 session 所有（含恢复指引）
-     * @throws ResurrectDeniedError 命中可重连集但被 worktree/异进程活实例守卫拦截（自带完整行动语言）
+     * 按 id 查 record 并做归属校验（message/close action 的统一入口；含 SP-2 冷查复活
+     * 与 v4 A-5 直接父校验）。本体已迁 RecordAccess；壳纯转发，签名不变。
      */
     private getRecordForAction;
     /**
-     * close action 的统一行为分流（running 子态 × force）。
-     *
-     *   running + force:true                → cancelBackground（显式 SIGTERM + closed+cancelled 终态）
-     *   running + force:false + 无在跑轮    → closeChatIdle（立即终态化 done + 回收保活进程 + disarm timer）
-     *     （isIdle timer armed 或 isResumable 无活进程）
-     *   running + force:false + 有活进程在跑轮 → 置 closeAfterRound=true（轮完成时终态化：
-     *     chatMode 消费点在 onRoundSettled，非 chatMode 在 runAndFinalize CAS 分支）
-     *   其他终态                            → 幂等 no-op（已结束）
-     *
-     * 与设计决策 5 一致：close = 正式终态（走 finalize），force 只影响 running 时机。
-     *
-     * @param record 目标 record（getRecordForAction 已校验归属）
-     * @param force true=立即终止（running 时 SIGTERM）/ false=优雅关闭（running 时等轮完）
+     * close action 的统一行为分流（running 子态 × force：chatMode abort+清队+立即终态 /
+     * one-shot closeAfterRound 挂起 / force 走 cancelBackground）。本体已迁 RecordLifecycle；
+     * 壳纯转发，签名不变。
      */
     private closeSubagent;
-    /**
-     * 无在跑轮 record 的手动终态化为 done（close action 的 isIdle/isResumable 分支）。
-     *
-     * 无在途 AgentResult（轮次完成时 record 未冻结，turns[] 保留运行时状态），
-     * 构造合成 done result（对齐 cancelBackground 的 cancelledResult 模式）。
-     * 走 doFinalizeRecord 的完整终态化路径（completeRecord + archive + finalized + worktree
-     * cleanup + alive marker + manifest）。
-     *
-     * [M5] 覆盖两路：Path B（无活进程，同旧行为）与 Path A（idle timer armed、进程保活等待
-     * 续聊）。Path A 必须先显式回收进程 + disarm timer——否则 record 已终态化但保活进程
-     * 继续驻留（终态后无人再杀它：closeSubagent 不再来、idle timer 已 disarm、runSpawn
-     * promise 早已 resolve），直到宿主进程退出。
-     *
-     * 不走 tryTransition（v4 B-1 此态 status=running，但由 doFinalizeRecord 内部的
-     * completeRecord 直接覆盖 status，与 cancelBackground 对 record 的处理同构）。
+    /** 取消 background record（tryTransition CAS 抢锁防重复副作用）。本体已迁
+     *  RecordLifecycle；壳纯转发，对外签名不变（D3 壳终态保留面）。 */
+    cancel(id: string): boolean;
+    /** [R4] 域 #6-#15 核心编排聚合实例：run 域执行编排（execute/executeAndAwait 入口、
+     *  引擎编排 + adopt 分诊、settleOneShotOutcome 终态收口、Continuation 协作面 +
+     *  continuations 队列（C-4/C-5 宿主）、pool/worktree 资源）。deps 全晚绑定闭包
+     *  （装配见构造器），壳经下方同名方法透传，对外签名零变化。 */
+    private readonly runOrchestration;
+    /** [R4 / D-R4-1] workflow 族聚合实例（executeWorkflowAgent 派发链 + 类外 helper）。
+     *  与 runOrchestration 组间零互调零 import（跨文件协作经壳 deps 闭包）。 */
+    private readonly workflowDispatch;
+    /**
+     * 预解析 model（renderCall 标题行用，同步）。本体已迁 RunOrchestration；壳纯转发，
+     * 对外签名不变（subagent-actions-core 消费）。
      */
-    private closeChatIdle;
+    resolveModel(agent: string, override?: {
+        model?: string;
+        thinkingLevel?: string;
+    }, ctxModel?: ModelInfo, agentConfig?: AgentConfig): ResolvedModel;
     /**
-     * [M5] closeAfterRound 消费：chatMode 轮次完成时终态化 record（closed + user-close）。
-     *
-     * 由 onRoundSettled（agent_settled 回调）调用——chatMode 轮次完成的统一汇聚点（热路径轮
-     * 不经 runAndFinalize CAS 分支，旧消费点对 chatMode 不可达）。合成 result 沿用 record.result
-     *（= 本轮增量，设计 D2 路径①）：本轮增量已由调用方前置的轮次通知送达，终态通知正文因此
-     * 是同一段增量 + 轮次统计 + sessionFile 指针行（notifyClosed），不重发全历史。
-     *
-     * 时序：同步前缀（disarm + kill + CAS）在 session-runner 的 resolveRun(0) 之前执行完——
-     * 冷路径轮的 runAndFinalize 续体因 timer 已 disarm 跳过 early return，但其 tryTransition
-     * CAS 对已 closed 的 record 失败 → 跳过二次 finalize（无双收尾）；热路径轮无 runAndFinalize
-     * 续体，本方法是唯一收尾。冷路径续体 .then 的 notifyComplete 与轮次通知同 key=`id:round`，
-     * 60s dedup 吞（不与下方终态通知叠加成第三条——后者 key 是裸 id）。
-     */
-    private closeAfterRoundSettled;
+     * 统一执行入口。mode 固定 background（sync 已删除）。本体已迁 RunOrchestration
+     *  （路由 → identity → record 创建 → worktree → 引擎 run 编排逐行等价随迁）；
+     *  壳纯转发，对外签名不变（subagent-tool / subagent-actions 消费）。 */
+    execute(opts: ExecuteOptions): Promise<ExecutionHandle>;
     /**
-     * workflow 编排层专用：sync-await 接口，内部走 background 管道但返回 Promise<AgentResult>。
-     *
-     * 与 execute() 的区别（D-A1）：
-     *   1. 返回 workflow AgentResult（content 字段），非 ExecutionHandle
-     *   2. 不经 chat 轮次 kick-off（detached 回注）→ 不注入 followUp 完成通知（BC-11，结果直接返回 workflow）
-     *   3. T2 删 sync 时 executeAndAwait 不受牵连（独立方法）
-     *
-     * 共享：runSpawn + ConcurrencyPool + record + pending emit（D-A4）。
-     */
-    executeAndAwait(opts: ExecuteOptions, signal?: AbortSignal, onEvent?: (event: AgentEvent) => void, stream?: SubagentStream): Promise<AgentResult>;
-    /** 订阅 store 变更（widget/list requestRender）。返回取消订阅。 */
-    private onChange;
-    /** 合并内存(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) 懒加载补齐。 */
-    private collectRecords;
+     * workflow 编排层专用 sync-await 接口（D-A1）。本体已迁 RunOrchestration；壳纯转发
+     *  （SAR / piEngineServiceAdapter 消费）。 */
+    executeAndAwait(opts: ExecuteOptions, signal?: AbortSignal, onEvent?: (event: AgentEvent) => void, stream?: SubagentStream): Promise<AgentResult$1>;
     /**
-     * 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;
-    getCollectSyncDefault(): "async" | "sync";
-    /** [perf] 单 record 详情懒加载（全量：eventLog/displayItems/result/turns/tokens）。
-     *  内存 running record 直接投影；磁盘 record 全量重建（per-file 缓存，stat 戳校验）。
-     *  返回 undefined：id 不存在于内存与磁盘。 */
-    private getFullRecord;
-    /** 步骤 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 resolveIdentity;
+     * [H2 W2] workflow 域统一派发入口。本体已迁 WorkflowDispatch（[D-R4-1] workflow 族
+     * 独立聚合）；壳纯转发，对外签名不变（SAR / pump 消费）。 */
+    executeWorkflowAgent(opts: AgentCallOpts, parentRunId: string, signal?: AbortSignal, onEvent?: (event: AgentEvent) => void, stream?: SubagentStream): Promise<AgentResult$1>;
     /**
-     * [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;
-    /** 步骤 2：按 mode 生成 id + controller，创建 record 并注册。
-     *  [L-1] ExecutionMode 类型固定 "background"（sync 已删除），id/controller 分支简化。 */
-    private createRecordForMode;
-    /** [MF#R4] worktree 前置失败的 early-return handle。
-     *  record 已被 finalizeFailed 收尾为 failed、detached promise 从未启动。 */
-    private buildEarlyFailedHandle;
-    /**
-     * 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;
-    /**
-     * 非 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，
-     * kill-chain 两级生效）→ engineHandle 回填（终态迁移落 entry 前）→ 终态迁移 →
-     * bg notify（chat 域宿主职责，与 pi 完成通知同语义）。
-     */
-    private kickOffEngineRun;
-    /**
-     * kickOffEngineRun 的 acquire 后主体：journal 接线（D6 第②级：taskId=record.id，
-     * 初始池 key 占位 'shared'，onPoolResolved retarget 到引擎实际池 key）→ engine.run
-     * （signal 接 record controller，kill-chain 两级生效）→ engineHandle 回填（终态迁移
-     * 落 entry 前）→ 终态迁移。bg notify 归编排侧（与 pi 轮次收尾通知归编排对称）。
-     */
-    private runEngineTask;
-    /**
-     * [W4 表 3 行 1] 引擎/子进程死亡、宿主存活的 record 处置：run 终态如实记 failed
-     * 证据（record.error），record **保持 resumable**（session 文件在盘，逻辑任务可续
-     * ——冷路径 resume 可直接续写），交监督器接管（合并单条通知 + 三态判定）。禁止
-     * 两个事故方向：completed 谎报（G3）与 closed 直接终局（resume 可能性丢失，等待
-     * 无主——2026-09-08 事故环 2/3 的 core 侧形态）。
-     *
-     * 判据状态源钉死 record 级：写点只动 record 字段（resumable/result/error），
-     * 不清镜像不查引擎——引擎进程被动重建（ensureConnected 退避重填镜像）不翻转
-     * 本处置（纳管模型：死亡事件纳管、重建不解管）。
-     */
-    private adoptResumableAfterEngineDeath;
+     * [D5 双写点 gate 判据] SP-5 升级（one-shot → chatMode）的 conversation 位检查。
+     *  本体已迁 RunOrchestration；壳纯转发（subagent-actions-core 消费）。 */
+    canUpgradeToConversation(record: Pick<ExecutionRecord, "engine">): boolean;
+    /**
+     * [V2 决策 3 → H1 U2 改写 / U6 定形] chatMode 统一投递入口。本体已迁
+     *  RunOrchestration；壳纯转发（chatActions 聚合面消费）。 */
+    private deliverChatMessage;
     /**
-     * 分层并发配额：depth 越深可用配额越少（下限 1）。fork 深度护栏在池维度的投影，
-     * 公式约定以 concurrency-pool.ts 注释为登记处、此处为唯一代码锚点。
+     * D-017 时序收尾：委托 doFinalizeRecord（finalize-record.ts 独立模块）。本体已迁
+     * RecordLifecycle（FinalizeDeps 装配经 deps 现读 + onFinalized 钩子经 C-5 回调）；
+     * 壳纯转发，签名不变。
      */
-    private effectiveMaxConcurrentFor;
+    private finalizeRecord;
     /**
-     * engine.run resolve 的终态迁移：outcome.error → failed（success=false + error 文案）；
-     * 否则 done（result=content）。CAS 抢锁（tryTransition）防与 cancelBackground 双收尾。
-     *
-     * [W4 表 3 行 1] 进程死亡分诊：outcome.error 存在且 **exitCode === null**（引擎侧
-     * 进程被信号终止/崩溃的合成 outcome 形态——RemoteEngine 运行中失败合成分支恒
-     * exitCode:null，引擎如实上报的 turn 失败带数值 exitCode；engine-client 注释同源
-     * 「exitCode null = 被信号杀死，杀链判据」）且宿主存活且非 conversation 形态 →
-     * record 保持 resumable 交监督器接管（如实 failed 证据 + 合并通知 + 三态判定），
-     * 不再 closed 终局。返回 true = 走了接管分支（调用方跳过 bg 完成回注）。
-     */
-    private finalizeEngineOutcome;
-    /**
-     * workflow 域"干活 + 收尾"（sync await；[W3] 执行叶 = 协议 engine.run——原 inproc
-     * runSpawn 链随 inproc pi 引擎目录 删除消亡，journal 接线 / record 终态迁移语义保持）。
-     * 编排分段保持「装配（池槽/worktree）→ 执行 → 回收（finally）→ 错误收口 → 终态收口」。
-     */
-    private runAndFinalize;
-    /** engine.run taskSpec 装配单一来源（runAndFinalize 与 kickOffChatRound 共用）：
-     *  executeOptions 协议映射 + model = record 留痕词形（resolved 解析产物，
-     *  joinEngineModelRef 规范形）覆盖——原 identity.resolved 经 runSpawn --model
-     *  兜底的协议等价承载。 */
-    private taskSpecWithModel;
-    /**
-     * one-shot（非 chatMode）终态收口（原 settleOneShotOutcome 分支）：成功轮消费
-     * closeAfterRound 挂起标志；失败/取消一次性销毁。CAS 抢锁失败（cancel/dispose 抢先
-     * 终态化）静默跳过。runAndFinalize（workflow 域）与 kickOffChatRound 非 chatMode
-     * 分支共用。
-     */
-    private settleOneShotOutcome;
-    /** AgentOutcome → execution AgentResult 单一映射源（workflow run 域映射；
-     *  finalizeEngineOutcome 终态 result 复用此处构造——exitCode null = 被信号杀死的
-     *  合成终态，error 如实透传）。 */
-    private outcomeToAgentResult;
-    /** [U04 提取·装配] 池槽获取：pooled（background）record 排队 acquire。成功返回 undefined
-     *  继续执行；失败返回终态 result 供调用方 early-return（该路径在 try/finally 之前，
-     *  不触发轮次资源回收——与原控制流逐字节一致）。 */
-    private acquirePoolOrFinalize;
-    /** [U04 提取·装配] 解析 worktree 参数：boolean → WorktreeHandle | undefined（true/undefined 由 run 内部处理）。 */
-    private resolveWorktreeHandle;
-    /** [U04 提取·回收] 轮次资源回收（finally 语义，幂等）：池槽归还（仅 pooled 且 acquire
-     *  成功）、streaming widget 清除。 */
-    private releaseRoundResources;
-    /** [U04 提取·错误收口] MF-6（决策 6 spec §3.1）：chatMode（含 resume）spawn/创建失败
-     *  不销毁对话——回退 idle（可恢复），让 agent 可重试 message 或 close。与一次性模式
-     *  （finalizeFailed 终态销毁）区分。返回合成 failed result（swallow，不 re-throw）。 */
-    private finalizeChatSpawnFailure;
-    /** [U04 提取·终态收口] closeAfterRound 挂起标志消费（原三处分支的公共收尾序列）：
-     *  清标志 + 终态化 closed。reason：成功轮恒 user-close；失败/取消轮用派生值。 */
-    private consumeCloseAfterRound;
-    /**
-     * pi chat 域轮次的 detached 编排（[W3 协议形态]）：轮次经协议 run（会话形态
-     * chat{recordId, resume?}）发往 pi-subagent-cli 引擎进程——
-     *   - 应答时点 = 首轮 agent_settled（W2 契约：idle 帧先于应答帧；outcome = 本轮
-     *     内容非会话终态）→ 应答到达即本轮 settle（round+1 / 增量通知 / closeAfterRound
-     *     消费，见 settleChatRoundFromResponse）；
-     *   - 流式 delta / 轮次生命周期经 host/streamDelta + host/roundLifecycle 反向通道
-     *     回流：首轮 runId 键（RunContext.stream / onRoundLifecycle）、续聊轮 recordId
-     *     键（chatRoundRoutes 注册的 recordId 路由）；
-     *   - recordId 路由在本方法注册（首轮 + 冷续轮替换式重注册），record 终态化路径注销。
-     * chat 域不接 event journal（pi 子代理 session JSONL 即原生数据源；与迁移前产物
-     * 形态一致——journal 接线仅 workflow 域 SAR 与非 pi 引擎 chat 路径）。
-     */
-    private kickOffChatRound;
-    /**
-     * [W3] chat 轮次生命周期帧消费（host/roundLifecycle，runId 键首轮 / recordId 键续聊轮
-     * 经本方法收敛）。相位 → 宿主编排语义（W4 协议事件面三入口）：
-     *   - settled：轮收敛——settled-watchdog 中段让位收尾段（noteRoundSettledFromProtocol）；
-     *   - idle：轮收口进 idle 稳态——两段守护一并清（disarmRoundFromProtocol）+ 冷续锚点
-     *     回填（sessionFile/engineHandle，idle 帧先于 run 应答帧）+ **idle 定时器挂载**
-       *     （引擎不实现 idle 定时器——core arm，W2 交接契约）；
-     *   - failed：轮异常终止（engine_round_aborted / engine_round_crashed /
-     *     engine_round_epipe_exhausted）——record 如实标 failed（禁 completed 谎报），
-     *     chatMode 按 MF-6 回退可恢复（onChatRoundFailed）。
-     */
-    private handleChatRoundPhase;
-    /**
-     * [W3] idle 相位 = idle 定时器锚点（原 session-runner handleAgentSettledForChatMode
-     * 的 armIdleTimer 段）：挂载降级链（配置值 → DEFAULT 兜底 + warn）语义保持；超时
-     * 处置 = 引擎侧进程回收（协议 interact close force）——idle timer SIGTERM 的协议形态。
-     */
-    private armChatIdleTimer;
-    /** [W3] idle 帧锚点回填（冷续锚点 = 引擎侧会话滚动/compaction 后的最新定位）。 */
-    private backfillChatAnchor;
-    /**
-     * [W3] chat 轮 failed 相位分诊：错误如实落 record（失败相位错误码——engine_round_
-     * aborted（宿主 cancel/close）/ engine_round_crashed（子进程外部死亡）/
-     * engine_round_epipe_exhausted（EPIPE 兜底耗尽）），禁 completed 谎报。chatMode 按
-     * MF-6 不销毁对话——回退可恢复（finalizeRoundToIdle + 通知），冷续 run 接续；
-     * record 已终态（cancel/close 抢先）= 迟到帧，幂等跳过。
-     */
-    private onChatRoundFailed;
-    /**
-     * [W3] 首轮 run 应答到达（= 首轮 agent_settled，W2 契约）的本轮 settle：round+1 /
-     * 轮次增量通知 / base 推进 / reportRecordTransition / closeAfterRound 消费——语义
-     * 权威自持于此（原 round-settlement.ts createRoundSettler 已删，本闭包为其唯一后继），
-     * 唯一偏差 = 轮次文本源：协议形态下 live turns 留在引擎进程内，core 以应答
-     * outcome.content（W2「outcome = 本轮内容」）为增量权威，record.turns 派生不可用。
-     * idle 定时器挂载不在此处——idle 相位帧先于应答帧到达，armChatIdleTimer 已锚定。
-     */
-    private settleChatRoundFromResponse;
-    /** [W3] chat 域引擎终止意图（协议面）：cancel = interact cancel（引擎侧 SIGTERM →
-     *  settle 等待 → 杀链升级）；close = interact close force（立即杀链收割）。fire-and-forget
-     *  ——失败 best-effort 留证（宿主组级收割兜底 = EngineClient killAll，dispose 路径）。 */
-    private terminateChatSession;
-    /** chat record 的协议 interact handle（engineHandle 缺省时按 recordId 合成——
-     *  引擎侧 interact 定位键 = sessionRef.recordId；sessionFile 有值时一并携带）。 */
-    private chatHandleFor;
-    /** [W3] pi 引擎 port 解析（chat 域路由与终止面共用）：registry cli 形态 port，
-     *  未注册 = 不可用 stub（engine_not_found，见 pi-host-binding）。 */
-    private resolveChatEnginePort;
-    /** [W3] record 终态化路径的 chat 反向通道路由注销（幂等）。 */
-    private unregisterChatRoundRoute;
+     * [W4] 轮次活性监督器（D2「等待有主」权威层）：死亡事件纳管（run failed / 引擎
+     * exited → adoptOnProcessDeath）+ boot 分区重认领（initSession）+ 三态判定
+     * （record 级视图）+ 该放弃（终态化 failed + 注销 + 终止通知）。装配绑定面
+     * （deps/giveUp 编排/sweep 挂点）在 round-supervisor/service-binding.ts——变化轴
+     * 独立（通知文案 / 终态化编排 / store 读侧判据只动该文件），本字段只持实例。
+     */
+    private readonly roundSupervisor;
     /** 引擎服务面适配器（HostBridgeServiceFace 结构视图）：闭包持有本实例的编排面。
      *  [W3] chat 域轮次交接可选面（takeChatRound/runChatRound/resumeChatRound）随
      *  inproc PiEngine 删除移除——引擎经协议 converse，不再回调宿主编排面。 */
@@ -2039,76 +2768,25 @@ declare class SubagentService {
      *  传入的 getService 兼容位消费——W3 后该面无引擎侧消费方，保留使 SAR 调用点
      *  零改动，W8 收口时随签名一并清理）。getter 形态：face 视图（惰性构造）。 */
     get asEngineService(): HostBridgeServiceFace;
-    /**
-     * 取消 background record。CAS 抢锁（tryTransition）——抢到则 notify + 写 tombstone；
-     * 没抢到（detached 已 finalize，record 已终态）返回 false，不触碰任何收尾副作用。
-     *
-     * stop 手段（abort/kill/disarm）无条件先执行：对已终态 record 幂等无害，且保证
-     * cancel 语义 = 进程必死；收尾副作用（completeRecord/tombstone/archive/notify）只归
-     * CAS 赢家。[A2-1] 此前 CAS 被误删，cancel 可在 doFinalizeRecord Step 0 await 窗口
-     * 命中已终态 record——覆写终态 + tombstone/finalized 双标 + notify 双发 + 谎报 true。
-     */
-    private cancelBackground;
-    /**
-     * D-017 时序收尾：委托 doFinalizeRecord（提取到 finalize-record.ts，降低本文件行数）。
-     * [Critical #1] cleanup 全部在 manifest 写之前，manifest best-effort 不阻断（详见 finalize-record.ts）。 */
-    private finalizeRecord;
-    /**
-     * 对话模式轮次完成收尾：委托 doFinalizeRoundToIdle（record 进 idle，保留内存 + worktree）。
-     * 与 finalizeRecord 对称的委托方法，deps 同源注入。chatMode + done/failed/cancelled 时由 runAndFinalize 调用
-     *（MF-6：chatMode 失败/取消也回退 idle 而非终态销毁）。 */
-    private finalizeRoundToIdle;
-    /** run() 创建期异常的收尾（H1 修复）：createAndConfigureSession 失败会抛，本方法合成 failed
-     *  AgentResult → CAS 抢锁 → finalizeRecord（与正常路径同形）。返回合成 result 供 runAndFinalize
-     *  继续返回（不 re-throw，swallow 策略）。
-     *  [W3 契约变更⑤（run 期失败清理前置副作用）] kickOffEngineRun 前已建的 worktree
-     *  （executeViaEngine 创建点，record.worktreeHandle 已绑定）经本方法 → finalizeRecord
-     *  → doFinalizeRecord Step 3b cleanupWorktreeIfBound 清理（manifest 多声明 run 期
-     *  失败 / engine.run prepare 期 reject 共用本收尾链）；CAS 没抢锁（cancel 抢先终态）
-     *  时由 cancelBackground 的 worktree cleanup 覆盖。唯一前置副作用 = worktree（并发
-     *  池槽 acquire/release 在 kickOffEngineRun finally 内自回收，journal 是宿主数据不清理）。 */
-    private finalizeFailed;
-    /** S1: 排队中被 abort 走 cancelled 终态（对齐已运行被 abort 的 cancelBackground）。 */
-    private finalizeAborted;
-    /**
-     * 校验 Service 就绪（pi 已注入 + 未 dispose）。
-     *
-     * dispose 后调用是异常路径：session_shutdown 已清资源，正常情况下紧接着
-     * session_start 会 initSession 复活。若走到这里说明 session_start 没跟上
-     * （RPC 边界 / reload 异常等），service 卡在 disposed 状态。
+    private _disposed;
+    /** session 结束清理（清定时器，丢弃 pending 通知）。幂等。
      *
-     * 旧实现只抛 "hub disposed"——无信息，调用方和 AI 都看不懂，导致反复盲试。
-     * 现在给出原因 + 恢复指引（重启会话或 /new）。真实错误文本会经 renderResult
-     * 兜底透传到 AI（见 tool-render.ts extractResultError）。
-     */
-    private assertReady;
+     * [M-7] dispose 顺序假设：pending:unregister emit 依赖 pending-notifications 扩展的
+     * listener 仍然存活。若 pending-notifications 先于本扩展执行 session_shutdown（后注册
+     * 先执行的语义下会如此），listener 已注销，unregister 事件被静默丢弃。这是可接受的
+     * 退化——进程退出后两侧状态本就不保证一致，下次 session_start 的 crash recovery 会修正。 */
+    dispose(): void;
     /**
-     * [T4② / PS-4] idleTimeoutMs 合法域入口校验（>2^31-1 / 非有限值 fail-fast）。
+     * [T4④ / PS-5] shutdown flush 被门拦时把未投递 pending 复写落盘（供重启 replay）。
      *
-     * 旧链路：非法值穿透到 agent_settled 回调里的 armIdleTimer → assertSafeTimerDelay
-     * throw 被异步 catch 降级——配置错误被吞成静默语义变更（每轮完成通知被 isIdle 放行门
-     * 吞 + 进程无回收 timer）。对齐 shared/timer-delay「不静默 clamp」既有裁决：配置错误
-     * 显式暴露，错误消息含合法范围（0/负数 = 显式禁用是合法语义，不在本校验域；env 非法值
-     * 由 lifecycle-manager 的 warn 回落承接）。execute/executeAndAwait 两入口共用。
+     * 触发条件：flushPendingNotifications 后 ledger 仍有 pending（isIdle 门拦 / sendDelivery
+     * 受理失败的残留）且主 agent 非 idle——即本次 shutdown 注定投不出去。落盘动作 =
+     * pi.appendEntry 重写 NOTIFY_LEDGER_CUSTOM_TYPE entry（与 ledger.record 同通道同 schema，
+     * notifyId 幂等：恢复扫描按后写覆盖 + ack/abandoned 差集去重，重复账面不产生重复投递）。
+     * 主 agent idle 时 flush 已投出，无需复写（零开销）。
      */
-    private assertIdleTimeoutMsSafe;
+    private persistUndeliveredNotificationsForReplay;
 }
-/** 获取进程单例。session_start 前为 null。 */
-declare function getSubagentService(): SubagentService | null;
-/** 设置进程单例（session_start 首次创建时）。 */
-declare function setSubagentService(service: SubagentService): void;
-/**
- * [U10① D6] 第三宿主最小构造入口：仅凭参数注入构造 SubagentService（无全局查找）。
- *
- * 构造依赖（modelService / getMainSessionFile / uiRequestHandler）全部经 init
- * 参数注入；本工厂是 `new SubagentService(init)` 的薄包装，不读也不写
- * getSubagentService/setSubagentService 的全局槽位——session_start 单例流程
- * 行为零改动，宿主自持实例时用本工厂。构造内部行为与直接 new 逐字等价。
- *
- * @experimental execution 运行时面（设计 docs/design/subagent-core-sink-design.md §3.3 D6）：
- * 一个 minor 周期内允许签名微调，稳定后转常规 semver 承诺。
- */
-declare function createSubagentService(init: SubagentServiceInit): SubagentService;
 
 /**
  * U4 投递计数分桶（设计 §5 U4：分桶口径与 §2.2 三条丢失路径一一对应，回归时定位到
@@ -2239,6 +2917,14 @@ interface SubagentIdentityData {
     worktree?: boolean;
     /** @deprecated 兼容旧文件：旧 identity entry 写的是 parentSessionId，读取时 fallback 到 rootSessionId。 */
     parentSessionId?: string;
+    /**
+     * 来源身份（H2 S3 修复）。旧文件缺失 → undefined（= "tool" 语义，缺省零迁移）。
+     * standalone 形态（identity entry 链）的 workflow record 经本字段在重建面保留
+     * origin 过滤语义；读取侧经 normalizeReconOrigin 守卫归一（非法值 → undefined）。
+     */
+    origin?: RecordOrigin;
+    /** origin="workflow" 时所属 workflow run id。旧文件缺失 → undefined。 */
+    parentRunId?: string;
 }
 /** custom entry 的 customType 标识（session-runner 写 / reconstructor 读，约定常量）。 */
 declare const IDENTITY_CUSTOM_TYPE = "subagent-identity";
@@ -2275,11 +2961,12 @@ declare function getOrCreateChannelRegistry(): UiChannelRegistry;
 /**
  * 可冷路径 resume（running 且无活进程句柄）。
  *
- * 旧 idle 中进程已回收的子态（Path B / 跨重启重建）。deliverMessage 冷路径、GC、
- * close action 的「无活进程立即终态化」分支据此判定。
+ * 等待续聊态的现行判据（[H1 U6] 每轮 = 新进程、轮末即回收，完成的轮次天然无活
+ * 进程句柄；跨重启重建同理）。deliverMessage 冷路径、GC、close action 的
+ * 「无活进程立即终态化」分支据此判定。
  *
- * 与 {@link isIdle} 的关系：isResumable=true 蕴含 isIdle 可能为 false（Path B 进程
- * 已退出，timer 未 armed）；isIdle=true（Path A）则 isResumable=false（进程保活）。
+ * 与 {@link isIdle} 的关系：isIdle 生产恒 false（见其 JSDoc），本谓词是
+ * 「等待续聊」唯一运行时生效的派生判据。
  *
  * [v4 A-6] 签名泛化为 Pick<"id"|"status">：ExecutionRecord（活态）与 SubagentRecord
  * （list 快照）均结构兼容——recordToListItem 据此为 list 输出派生 resumable 字段。
@@ -2336,145 +3023,6 @@ interface HostUIContext {
  *  @returns UiRequestHandler（tui/gui）；headless 返回 undefined */
 declare function createUiRequestHandlerForMode(ctx: HostUIContext, registry: UiChannelRegistry, dialogQueue: DialogGlobalQueue): UiRequestHandler | undefined;
 
-declare class WorktreeManager {
-    private readonly registry;
-    private readonly agentDir;
-    private readonly writeQueues;
-    private readonly ambiguousSkipCycles;
-    constructor(agentDir: string);
-    /**
-     * 为子 agent 创建隔离 worktree。
-     *
-     * @param mainCwd 主仓库根目录
-     * @param recordId 执行记录 ID（必须匹配 `^[\w-]+$`）
-     * @returns 冻结的 WorktreeHandle
-     */
-    create(mainCwd: string, recordId: string): Promise<WorktreeHandle>;
-    /**
-     * 注册子进程 pid（runSpawn spawn() 返回后调）。
-     * create 时 pid 未知写 0 占位，子进程 spawn 返回后（child.pid 同步可得）由此补全。
-     * reaper 据 pid 死活判孤儿，pid=0 条目用 SPAWN_GRACE 宽限。
-     * sessionFile 可选补全：传入时填入 registry entry（reaper 据 pid 死活判孤儿，不读本字段；保留供诊断）。
-     *
-     * [D5a] async 化：pid 补全走跨进程锁内 RMW（互斥窗口消除 updatePid 与并发 add/remove
-     * 的交错）。永不 reject（锁降级 + best-effort save 均内部兜底），调用方可安全
-     * fire-and-forget（session-runner 的 stdout data 回调上下文）。
-     */
-    registerPid(branch: string, pid: number, sessionFile?: string): Promise<void>;
-    /**
-     * 清理 worktree：git worktree remove --force + git branch -D + 注册表移除。
-     * 三步各自独立 try/catch——任一步失败不阻断其余（如 remove 失败仍尝试 branch -D + 注册表移除），
-     * 避免单步失败导致后续资源泄漏。
-     *
-     * @param handle 要清理的 worktree handle（含 mainCwd，不靠路径反推）
-     */
-    cleanup(handle: WorktreeHandle): Promise<void>;
-    /**
-     * 收集 worktree 的改动为 patch。
-     *
-     * [MF#3] patchFile 由调用方指定（写在 worktree 之外，避免被 cleanup 删除）。
-     * [MF#2] 先 git add -A 暂存全部改动（含未跟踪新文件），再 git diff --cached baseCommit
-     * 对比暂存区与 base commit。旧实现 `git diff HEAD baseCommit` 是树 vs 树对比：
-     * worktree HEAD 初始即 baseCommit，子 agent 不提交时 HEAD 仍 == baseCommit → diff 恒空 → 改动丢失。
-     *
-     * @param handle worktree handle
-     * @param patchFile patch 输出路径（须在 worktree 之外）
-     * @returns patch 结果（patchFile 路径 + failed/written 标记）。
-     *   written=true 仅当 diff 非空且写盘成功；空 diff 或写失败均 written=false，
-     *   调用方据此回填 record.patchFile，避免悬空路径（`git apply` 不存在的文件）。
-     */
-    collectPatch(handle: WorktreeHandle, patchFile: string): Promise<PatchResult>;
-    /**
-     * 扫描并清理 pi-sub-* 孤儿 worktree + 物理面对账（D5b）。
-     *
-     * 阶段一（既有）：遍历全局注册表（<agentDir>/subagents/worktrees.json），
-     * 按 pid 死活判孤儿。不依赖当前 cwd 是否 git repo——注册表里记了 repo 路径，
-     * 直接 git -C <repo> 跨 repo 清理。
-     *
-     * 判据（唯一不删条件 = 进程还活着）：
-     *   pid > 0 且 isProcessAlive(pid)   → 跳过（活进程，绝不删）
-     *   pid > 0 且进程已死                → 孤儿（正常退出未 cleanup / 崩溃残留）
-     *   pid == 0 且超 SPAWN_GRACE_MS      → 孤儿（create 后崩溃，pid 永未补全）
-     *   pid == 0 且未超宽限               → 跳过（可能正在 spawn）
-     *
-     * 阶段二（D5b）：物理面（tmpdir checkout + 分支）与注册表双向 diff 收敛——
-     * 兑现 worktree-registry.ts 头注释声称的「tmpdir + 分支对账兜底」。全流程
-     * 幂等、失败仅日志（对账失败不阻断 session_start）。
-     */
-    scan(): Promise<void>;
-    /**
-     * D5b 双向 diff 对账：物理面（tmpdir checkout 目录 + git branch --list）与
-     * 注册表互查，收敛三类漂移（锁消灭交错主因后，本对账兜底条目丢失/文件损坏的长尾）。
-     * 方向一/方向二的完整判据见 {@link removePhantomRegistryEntries} /
-     * {@link reconcileUnregisteredWorktrees}。
-     */
-    private reconcileWithPhysical;
-    /** 对账方向一（注册有 → 物理无）：条目的分支与 checkout 目录都已不存在 → 条目指向
-     *  幻影资源 → 移除条目（纯清账，不删任何仍存在的资源，幂等安全）。 */
-    private removePhantomRegistryEntries;
-    /** 对账方向二（物理有 → 注册无）：按 enc 段（encodeCwd(mainCwd)）聚合，活信号 =
-     *  <agentDir>/subagents/<enc>/sessions/*.alive 中存活的 pid（session-runner
-     *  first header 时写入，崩溃残留不删）：
-     *    - 无活 pid：残留判死，checkout mtime 超 SPAWN_GRACE_MS 才清（防误清另一
-     *      进程 worktree add 完成到 registry.add 落盘之间的 create 窗口）；
-     *    - 恰好 1 个活 pid 且恰好 1 个残留：补写回注册表（自愈——最常见的双 session
-     *      并发覆盖丢条目场景，补写后回归标准 pid 判据路径）；
-     *    - 多活 pid 或多残留无法建立 branch↔pid 对应：跳过 + warn——宁延迟勿误删；
-     *      活体自身 cleanup 路径正常（registry.remove 幂等），死体等活 pid 全灭后
-     *      下一周期收敛。
-     *
-     *  返回本轮实际进入「歧义跳过」的 checkout 路径集（PS-12 老化计数收敛依据，
-     *  见 reconcileWithPhysical 尾部）。 */
-    private reconcileUnregisteredWorktrees;
-    /** 单 enc 段的残留处置三分支：无活 pid 判死清理 / 唯一对应自愈补写 / 多对应保守跳过。 */
-    private reconcileEncSegment;
-    /** 无活 pid 段：残留判死清理——checkout mtime 超 SPAWN_GRACE_MS 才清（防误清另一
-     *  进程 worktree add 完成到 registry.add 落盘之间的 create 窗口）。 */
-    private cleanupDeadSegment;
-    /**
-     * 物理面发现：扫描 <tmpdir>/pi-subagents/<enc>/<pi-sub-*> checkout 目录。
-   * repo 从 checkout/.git 指针文件推导（`gitdir: <repo>/.git/worktrees/<branch>`，
-     * 普通 repo 与 bare+worktree（.bare/worktrees/...）统一取 worktrees 段上两级）；
-     * 推导失败（残缺 checkout）repo=undefined，由调用方按无主残留处置。
-     */
-    private discoverPhysicalWorktrees;
-    /**
-     * per repo 查物理分支全集：`git -C <repo> branch --list 'pi-sub-*' --format=%(refname:short)`。
-     * 读类命令不加写锁；单 repo 失败 → map 不含该 repo（get 返回 undefined），
-     * 调用方据此保守跳过该 repo 的条目判定（防把「查询失败」误判成「分支不存在」）。
-     */
-    private listPhysicalBranches;
-    /**
-     * 收集 enc 段的活 pid：<agentDir>/subagents/<enc>/sessions/*.alive 中
-     * readAliveMarker 解析成功且 isProcessAlive 的 pid（去重）。
-     * 崩溃残留的 .alive（pid 已死）天然过滤掉——这正是「死活判据」的物理面来源。
-     */
-    private collectAlivePids;
-    /**
-     * 清理物理残留（D5b 方向二的死体处置）：worktree remove → prune → branch -D
-     * → 目录 rm 兜底，四步各自 best-effort（幂等，失败仅日志）。
-     * prune 必要性：checkout 目录已不存在的 worktree，remove 会失败且 branch -D
-     * 被「used by worktree」拒绝——prune 清掉缺失目录的元数据后分支才可删。
-     */
-    private cleanupPhysical;
-    /**
-     * 判孤儿：pid 死活为主判据。pid=0 走 SPAWN_GRACE 宽限（create→spawn 窗口）。
-     */
-    private isOrphan;
-    /** 清理单个孤儿条目：worktree remove + branch -D + 注册表移除，三步各自 best-effort。 */
-    private cleanupOrphan;
-    /**
-     * git 命令异步执行器。与 gitRun 同一超时/错误包装约定（message 格式逐字一致），
-     * 差异仅在错误属性形态（GitRunError 挂 exitCode/stderr/timedOut）。
-     * 写类命令经 per-repo mutex 串行（不依赖 git 锁实现细节 + 并发限流 + 行为确定性）。
-     *
-     * stdout 保真返回（不 trim）：collectPatch 把 diff 输出原样落盘为 patch 文件，
-     * 裁掉尾换行会产出 `git apply` 拒绝的 corrupt patch（2026-08-16 门 4 实测）。
-     * 需要干净文本的消费点（baseCommit / 脏树 status 拼接）自行 trim。
-     */
-    private gitRunAsync;
-}
-
 /**
  * Workflow Extension — Worker Handle
  *
@@ -2797,7 +3345,7 @@ declare class AgentCall {
     readonly opts: AgentCallOpts;
     status: AgentCallStatus;
     attempts: number;
-    result?: AgentResult;
+    result?: AgentResult$1;
     /** Pi subprocess session ID（uuidv7，G-017 归此）。 */
     sessionId?: string;
     /** Session JSONL 绝对路径（finalizeCall 后从 result.sessionFile 填入，对齐 sessionId 模式）。 */
@@ -2814,7 +3362,7 @@ declare class AgentCall {
    * 标记完成（成功或失败均调用——result.error 区分）。
    * @throws 若当前非 running（pending 不能直接跳 done，必须先 markRunning）
    */
-    markDone(result: AgentResult): void;
+    markDone(result: AgentResult$1): void;
     /** 记录 pi subprocess session ID（dispatch 成功后）。 */
     setSessionId(sessionId: string): void;
     /** 记录 session JSONL 绝对路径（finalizeCall 后，对齐 setSessionId 模式）。 */
@@ -3099,17 +3647,17 @@ declare class WorkflowRun {
 /**
  * Agent 子进程执行 port。Infra 实现：SubprocessAgentRunner。
  *
- * run 执行单次 agent 调用（委托 SubagentService.executeAndAwait），返回结构化结果。
- * signal 用于 abort 传播。
+ * run 执行单次 agent 调用（委托 SubagentService.executeWorkflowAgent，[H2 W4] 纯转调），
+ * 返回结构化结果。signal 用于 abort 传播。
  *
- * onEvent（可选）：强类型 AgentEvent 回调，供调用方实时更新 live record 供 TUI 展示进度。
- * 不传则不回调（向后兼容；现有调用点不传不受影响）。
+ * onEvent（可选）：强类型 AgentEvent 回调，透传 service 派发路径（journal 转发/守护
+ * 刷新源），生产 pump 侧恒 undefined。
  *
  * D-005: onEvent 签名从 raw Record<string,unknown> 升级为 AgentEvent——委托后不再有
  * raw JSONL 中间层（executeAndAwait 直接出 AgentEvent，session-runner handleSdkEvent 出口）。
  */
 interface AgentRunner {
-    run(opts: AgentCallOpts, signal: AbortSignal, onEvent?: (event: AgentEvent) => void, stream?: SubagentStream): Promise<AgentResult>;
+    run(opts: AgentCallOpts, signal: AbortSignal, onEvent?: (event: AgentEvent) => void, stream?: SubagentStream): Promise<AgentResult$1>;
 }
 /**
  * WorkflowRun 持久化 port。Infra 实现：JsonlRunStore。
@@ -3209,103 +3757,52 @@ interface LifecycleDeps {
     */
     onWorkflowCall?: (name: string, args: Record<string, unknown>, parentRun: WorkflowRun) => Promise<unknown>;
     /**
-    * UI streaming sink（ctx.ui.setWidget），workflow agent call 创建 SubagentStream 用。
-    *
-    * 由 Interface 层 makeDeps 注入（从 SubagentService.getStreamSink() 取）。
-    * dispatchAgentCall 用它创建 SubagentStream（widgetKey=subagent-stream-<runId>-<stepIndex>），
-    * 使 workflow agent call 的 text_delta 走与 background subagent 相同的 streaming 链路。
-    * 可选——无 UI 模式（TUI/RPC 无 setWidget）时为 undefined，dispatchAgentCall 不创建 stream。
-    */
-    streamSink?: StreamSink;
+     * [H2 W3] workflow 域 agent() 统一派发入口（SubagentService.executeWorkflowAgent 的
+     * deps 注入形态，设计 §3.5 终态数据流）。窄函数类型——不引 execution 层具体类，
+     * 保持本 ports 文件零 infra/execution 依赖。由组合根（extension index.ts makeDeps）
+     * 注入：闭包捕获 getSubagentService() 单例，parentRunId 由 pump 侧补 run.runId。
+     *
+     * 可选——未注入时（旧测试 deps）dispatchAgentCall 回退 deps.runner（[H2 W4] 后
+     * SAR 已掏空为纯转调 executeWorkflowAgent，两分支执行体归一非双轨，差异仅 parentRunId
+     * 来源：注入 = 真实 run.runId，回退 = SAR_UNATTACHED_PARENT_RUN_ID 占位；生产装配
+     * 两字段同时注入，dispatch 恒优先）。
+     */
+    workflowAgentDispatch?: (opts: AgentCallOpts, parentRunId: string, signal?: AbortSignal) => Promise<AgentResult$1>;
 }
 
-/**
- * SAR 构造参数。
- *
- * per-session（makeDeps 时创建，随 session 销毁）：
- *   - subagentService: 进程单例（getSubagentService()），委托目标
- *   - ctxModel: 当前 session 主 agent 模型（D-008 model 填底，opts.model 空时用此）
- *
- * resolveAgentOpts 在 orchestration 层完成（M2 修正后单参数，只处理 schema SO 指令 + skill），
- * 结果填进 AgentCallOpts.skillPath/schemaEnv/appendSystemPrompt，SAR 收已解析的 opts。
- * 不含 agent/session 目录/临时文件集合依赖（agent ref 交 resolveIdentity，无临时文件）。
- */
+/** SAR 构造参数（签名冻结——session-lifecycle.ts 装配点零改动）。 */
 interface SubprocessAgentRunnerDeps {
     subagentService: SubagentService;
+    /** 兼容保留：run() 不消费（model 解析归 service resolveIdentity）。 */
     ctxModel?: ModelInfo;
 }
 /**
- * AgentRunner port 实现——委托 SubagentService.executeAndAwait。
+ * AgentRunner port 实现——纯转调 SubagentService.executeWorkflowAgent。
  *
- * 层归属：execution（MF-3 从 orchestration 迁入）。implements orchestration 层 port。
+ * 层归属：execution。implements orchestration 层 port。
  *
- * 行为契约（BC-1/BC-2/BC-9/BC-10）：
+ * 契约：
  *   - opts 形状不变（AgentCallOpts，含 resolveAgentOpts 填的 skillPath/schemaEnv）
- *   - result 形状不变（workflow AgentResult: content/parsedOutput/usage/error/toolCalls）
- *   - 不 reject——失败信息入 result.error（与 executeAgentCall 契约一致）
- *   - timeoutMs 合并 signal（D-A9）；onEvent 桥接 AgentEvent→workflow liveRecord（D-A8）
- *
- * [P1 引擎接线] 执行经 EnginePort。pi 引擎绑定本 SAR 的服务引用（per-session DI——
- * 单测注入 mock 时全局单例不可见；生产环境两者是同一进程单例对象），行为零变化；
- * 非 pi 引擎（P4 路由可达：frontmatter/调用参数/全局默认指定）经 registry.getEngine
- * 动态获取——「引擎身份」的归属边界在注册表，SAR 不感知具体引擎实现。
- *
- * [P4 配置路由] 每次运行经 engine/routing.ts 的 routeEngineForHost（D3-② 路由单点：
- * 唯一实现承载三层优先级（调用参数 opts.engine > agent frontmatter engine > 全局默认
- * 'pi'）+ pi 同步短路 + registry 注入 + probe/fallback 三守卫，D9；本类与
- * SubagentService.execute 是其仅有的两调用点）。路由失败（engine_not_found /
- * engine_probe_failed / model_not_available）与预检命中（engine_capability_unsupported，
- * D3-④）不 reject，入 result.error——与 executeAgentCall 契约一致。
+ *   - result 形状不变（AgentResult——executeWorkflowAgent 返回类型即 orchestration
+ *     AgentResult，零映射）
+ *   - 路由失败/预检命中/嵌套超限经 service 同步抛错（§3.4 同步抛错回脚本 + D3
+ *     路由先于 record 创建的构造性推论：不产生孤儿 record）——传播形态与
+ *     workflowAgentDispatch 注入路径一致（dispatch 闭包同样不吞错），pump 侧
+ *     dispatchCall catch 兜底回发。
  */
 declare class SubprocessAgentRunner implements AgentRunner {
     private readonly subagentService;
     private ctxModel;
-    /** pi 引擎（per-session DI 绑定，缺省执行路径——见类注释）。 */
-    private readonly piEngine;
     constructor(deps: SubprocessAgentRunnerDeps);
     /**
-     * 刷新主 agent model 缓存。model_select 事件时由 index.ts 调用。
-     * H1 修复：旧实现 ctxModel 是 readonly，session_start 后固化，
-     * model_select 只刷新 ModelConfigService._ctxModel 不更新 SAR →
-     * workflow 路径用过期模型。
-     */
-    updateCtxModel(model: ModelInfo | undefined): void;
-    /**
-     * 执行单次 agent 调用：路由（P4）→ 预检（D3-④）→ EnginePort.run → PiEngine 委托
-     * SubagentService.executeAndAwait。
+     * 刷新主 agent model 缓存（model_select 事件时由 extension index.ts 调用）。
      *
-     * 接线链路：
-     *   routeEngineForHost（D3-② 路由单点：三层 + pi 同步短路 + probe + 守卫）→
-     *   assertTaskShapeSupported（D3-④ 预检 capabilities 化）→ mergeTimeoutSignal →
-     *   engine.run(opts 直传——D6 合流：AgentCallOpts 即 EnginePort 任务形状，零映射；
-     *   PiEngine 内一次直出 ExecuteOptions + engine 留痕) → executeAndAwait →
-     *   AgentOutcome → AgentResult
-     *
-     * 错误处理：不 reject。
-     *   - 路由失败（未注册 id / probe 失败 + 守卫或 strict）→ AgentResult.error（错误码前缀）
-     *   - 预检命中（capabilities 不支持的任务形状参数）→ AgentResult.error
-     *     （engine_capability_unsupported——[D3-④] workflow 域 zcode+worktree 由漏拦变
-     *     拦截，本单元唯一有意行为变化；拒绝在 journal/run 之前，无进程无 journal 产物）
-     *   - executeAndAwait 内部失败 → 返回 AgentResult(success:false) → 已映射 error 字段
-     *   - executeAndAwait throw（嵌套超限 BC-12）→ catch → AgentResult.error
-     *   - spawn 级失败已由 runSpawn 内部收口为 failed AgentResult（不逃逸）
-     */
-    run(opts: AgentCallOpts, signal: AbortSignal, onEvent?: (event: AgentEvent) => void, stream?: SubagentStream): Promise<AgentResult>;
-    /**
-     * 引擎获取（routeEngineForHost 的 probe 注入体）：pi 走 per-session DI 绑定（mock
-     * 语义 + 生产同单例，P1 行为零变化）；非 pi 经 registry.getEngine 动态获取（P4：
-     * 引擎身份归属注册表，未注册 id 抛 EngineNotFoundError——路由期已前置校验，这里
-     * 是防御性兜底）。[D3-②] get/has/list 的路由期注入已由 routeEngineForHost 内部
-     * 承载（本地 pi 恒可用口径），本方法只剩 probe 一个消费点（pi 请求同步短路恒免探）。
-     */
-    private engineFor;
-    /**
-     * 三层路由输入装配（D9）：调用参数（opts.engine，workflow step 级透传）> agent
-     * frontmatter（ModelConfigService.getAgentConfig——loadByPath mtime 缓存，幂等）>
-     * 全局默认（config.json defaultEngine）。单例未就绪（session_start 前/测试 mock）
-     * 时各层缺省——落内置 'pi'。
+     * [H2 W4] run() 不再消费 ctxModel（model 解析归 service resolveIdentity），
+     * 本方法保留仅为装配链兼容（index.ts 调用不炸）；字段更新不再影响执行路径。
      */
-    private buildRoutingInput;
+    updateCtxModel(model: ModelInfo | undefined): void;
+    /** 纯转调 service 统一编排入口（形参原样透传；parentRunId 用直调占位）。 */
+    run(opts: AgentCallOpts, signal: AbortSignal, onEvent?: (event: AgentEvent) => void, stream?: SubagentStream): Promise<AgentResult$1>;
 }
 
 /** 索引文件名（落 sessionsDir 兄弟位置——写索引不改 sessionsDir 目录 mtime，不击穿 L0 快路径）。 */
@@ -3320,10 +3817,11 @@ declare const SUBAGENT_RECORD_CUSTOM_TYPE = "subagent-record";
  * `subagent-record` entry 的 data schema（v1）。
  *
  * = 完整 SubagentRecord 快照（GUI 侧列表/详情需要的全部持久化字段）+ 版本号。
- * 显式排除三个非持久化字段（与 SubagentRecord 的差集）：
+ * 显式排除两个非持久化字段（与 SubagentRecord 的差集）：
  *   - currentActivity：running 时的瞬时流态，重开 session 无重建价值；
- *   - externalInstance：跨重启探活态（pid/startedAt），由 .alive sidecar 重建；
  *   - worktreeHandle：不可 JSON 序列化的运行时句柄（布尔投影 worktree 保留）。
+ *（[U4a / D3b (a)] externalInstance 投影已随字段链删除——探活态由 .alive sidecar
+ * 现查探针承担，不再进 record 快照。）
  *
  * undefined 字段经 JSON.stringify 自然缺省（与 SubagentRecord 重建侧语义一致）。
  *
@@ -3406,6 +3904,18 @@ interface SubagentRecordEntryData {
      * 未离开批 / 旧 entry 零迁移。消费方：U5 E1 重建扫描只收无标记成员（防双重通知）。
      */
     batchFinalized?: boolean;
+    /**
+     * 来源身份（H2 W1，设计 subagent-workflow-record-unification §3.3 D1）。
+     * undefined（存量 entry）= "tool" 语义，消费方零迁移。重启后 origin 过滤面
+     * （subagents list / renderer / TUI）生效的唯一持久化载体——漏本字段则重启后
+     * workflow record 逃过全部投影过滤。
+     */
+    origin?: RecordOrigin;
+    /**
+     * origin="workflow" 时所属 workflow run id（W2 写入）；tool 来源恒缺省。
+     * W2/W3 run 视图按 collectRecordsByParentRunId 从本字段回查本 run 的 record 集。
+     */
+    parentRunId?: string;
 }
 /** SubagentRecord → 自描述 entry data（快照投影，不 mutate 源）。
  *
@@ -3640,6 +4150,12 @@ type StartHandlerResult = {
 };
 interface ListHandlerInput {
     includeFinished?: boolean;
+    /**
+     * [H2 W1，设计 subagent-workflow-record-unification §3.3 D1①] 同时列出 workflow
+     * 脚本 agent() 派发的 record（origin="workflow"）。缺省 false——list 默认只展示
+     * 手动 tool 派发的 subagent；排查 workflow 子代理时显式传 true。
+     */
+    includeWorkflow?: boolean;
     limit?: number;
 }
 /** list 领域对象（宿主 adapter 包成 list 工具结果，最外层 subagentId/sessionFile 为 null）。 */
@@ -3710,13 +4226,12 @@ declare function endedMessageGuard(service: SubagentService, id: string, origina
  * 内部 ExecutionStatus → 对外 state 映射（设计决策 10 细则 3）。
  * 两态收敛后的真实映射只有两条：
  *   running → active / closed → ended（closed 统一终态，含 cancelled）
- * ExternalState 仍声明 waiting/error 四态联合（对外契约不变），但当前状态机不产生
- * 这两个值——它们是历史多态映射（idle→waiting / failed+crashed→error）的遗留声明。
+ * ExternalState 即两态联合（历史 waiting/error 死值成员已随 L2 清扫删除）。
  * 未来内部加态必须扩展此处，漏加会在 default 分支编译报错（而非静默返回 undefined
  * 让 state 字段以无主值进入 listResponse JSON）。
  */
 declare function mapExternalState(status: ExecutionStatus): ExternalState;
-/** SubagentRecord → SubagentListItem（state 四态主字段 + status 调试字段，duration 实时计算）。
+/** SubagentRecord → SubagentListItem（state 两态主字段 + status 调试字段，duration 实时计算）。
  *  parent 从 record.parentRecordId 派生（配合直接父守卫），resumable 从 isResumable 派生
  *  （「可续聊」对外表达）；outcome 一等终态语义（projectOutcome 唯一出口），closedReason
  *  退出对外 JSON（保留为 record 内部诊断字段），对外成败判读收口到 outcome。
@@ -3726,21 +4241,21 @@ declare function recordToListItem(r: SubagentRecord): SubagentListItem;
 declare function startHandler(service: SubagentService, input: StartHandlerInput | undefined, signal: AbortSignal | undefined, ctxModel?: ModelInfo): Promise<StartHandlerResult>;
 /**
  * list 数据源（诚实声明）：
- * collectRecords(limit, statusFilter) 合并内存(running) + 磁盘(重建)。磁盘源天然
- * 跨 session 可见——/new /resume /fork 后前 session 的终态 record 仍在 sessions
- * 目录里（直到 GC）。内存源仅当前 session 的 running record。
+ * collectRecords(limit, statusFilter, includeWorkflow) 合并内存(running) + 磁盘(重建)。
+ * 磁盘源天然跨 session 可见——/new /resume /fork 后前 session 的终态 record 仍在
+ * sessions 目录里（直到 GC）。内存源仅当前 session 的 running record。
+ * [H2 W1] origin==="workflow" 的 record 默认过滤（D1①），includeWorkflow:true 放行。
  */
 declare function listHandler(service: SubagentService, input: ListHandlerInput | undefined): ListHandlerResult;
 declare function cancelHandler(service: SubagentService, input: CancelHandlerInput | undefined): Promise<CancelHandlerResult>;
 /**
  * message action handler：向对话模式 subagent 续聊/插入消息。
  *
- * 状态 × interrupt 自动映射（agent 只表达意图）：
- *   running → deliverChatMessage 热路径（进程活：prompt + streamingBehavior，interrupt=true
- *             抢占 / false 排队）
- *   进程死  → deliverChatMessage 冷路径（resumeRound 重开 session + prompt，interrupt 自动
- *             退化，agent 无感）
- *   终态    → throw ended（正常路径不命中——终态 record 已 archive，getRecordForAction 先 throw not found）
+ * [H1 U6] 状态分流面收敛：running → Continuation 派发新轮（新 run + resume 锚点）；
+ * 在途轮存在 → D2 打断（abort + 入队）；终态 → throw ended（正常路径不命中——终态
+ * record 已 archive，getRecordForAction 先 throw not found）。interrupt 输入字段保留
+ *（[A4] 工具 schema 兼容面——extensions subagent-tool-schema 仍声明该字段）但不参与
+ * 分派（D2 统一打断语义）。
  *
  * 归属守卫：getRecordForAction 内部校验 rootSessionId。
  *
@@ -4592,7 +5107,7 @@ declare function executeNestedWorkflow(name: string, args: Record<string, unknow
  *    pending:unregister → onRunDone」终态序列的唯一定义点（D5-② 单点化，收敛原
  *    8 处逐字复制；OR-8 收口步骤与 OR-4/B-4 双围栏内化于本函数）
  *
- * 4 个导出函数（domain-models.md §失败处理矩阵）：
+ * 4 个 handle* 路由函数（domain-models.md §失败处理矩阵）+ 终态化/重建/防御 helper 若干：
  * - handleWorkerMessage(run, raw, deps, handlers) — 路由 agent_call/return/error/log
  * - handleWorkerError(run, err, deps, handlers) — worker uncaught error
  * - handleWorkerExit(run, code, handle, deps, handlers) — worker exit
@@ -4679,7 +5194,7 @@ declare function resetRebuildFailureInjectionForTest(): void;
  *   result 以 IN_FLIGHT_CALL_CANCELLED_MSG 承载取消原因；
  * - trace 节点置 failed + 固定取消文案 + completedAt（「failed + Cancelled 文案」
  *   即取消的既有表达形态，不新增状态枚举）；
- * - node.live 清除（终态 run 无 TUI 轮询，防 ExecutionRecord 滞留）。
+ * - node 无运行期附属对象（[H2 W3] trace.live 退役后节点只剩终态摘要字段）。
  *
  * 调用点约定：每个 transition("done") 成功后、store.save 之前——先收口再落盘，
  * 内存态与持久化快照在同一时点收敛（「run-snapshot 落盘前」的实现形态）。
@@ -5218,7 +5733,7 @@ interface CallSnapshot {
     opts: AgentCallOpts;
     status: "pending" | "running" | "done";
     attempts: number;
-    result?: AgentResult;
+    result?: AgentResult$1;
     sessionId?: string;
     sessionFile?: string;
     traceNode: ExecutionTraceNode;
@@ -5249,10 +5764,9 @@ interface RunSnapshot {
  * WorkflowRun → 单行快照。
  *
  * - 补 v 字段（D4 裁决②：写入恒带当前版本）。
- * - strip live（防御内聚）：calls[].traceNode 与 trace 数组节点的 `live` 运行期
- *   对象剥除——ExecutionRecord 含可变 turns[]/controller，不可序列化且跨进程
- *   必死（重跑时由 dispatchAgentCall 重建）；strip 产出新对象，不 mutate 内存
- *   中的 run（save 后 run 可继续跑）。
+ * - trace 节点全量序列化（[H2 W3] live strip 分支随 ExecutionTraceNode.live 字段
+ *   删除而退役——节点不再携带运行期对象，无需防御性剥离；旧快照经 fromRunSnapshot
+ *   重水合时多余键自然丢弃，存量行零迁移）。
  * - spec.budgetRef 剔除：父 Budget 共享引用是进程内优化（嵌套 workflow 预算
  *   共享），非持久化数据；Budget 实例若混入 spec 落盘将退化为普通对象投影
  *   （重水合后类型不符的脏字段）——重水合后 budget 从 state.budget 独立重建，
@@ -5637,9 +6151,10 @@ declare function renderXmlSection(section: {
  * worktree-registry / engine-discovery / zcode preparer / zcode appserver-home），
  * tmp 命名各异（`.tmp.<pid>` / `.tmp_<pid>_<rand>` / `.tmp-<pid>-<ts>`）、失败路径
  * 清理纪律不齐（worktree-registry 失败时漏清残留 tmp）。本模块给出统一原语供全
- * 部写点收敛（调用点迁移归 u-wire 单元，本单元只建原语）。现存消费方 4 处：
- * manifest-store / sessions-index / worktree-registry / engine-discovery——zcode
- * preparer 与 zcode appserver-home 两处写点已随 2026-09 共享宿主 HOME 重构删除。
+ * 部写点收敛（调用点迁移归 u-wire 单元，本单元只建原语）。现存消费方 5 处：
+ * manifest-store / sessions-index / worktree-registry / engine-discovery / record-store
+ * （manifest writeSync 面）——zcode preparer 与 zcode appserver-home 两处写点已随
+ * 2026-09 共享宿主 HOME 重构删除。
  *
  * **统一 tmp 命名约定**：`<最终路径>.tmp.<pid>.<seq>-<rand>`。
  * - `.tmp.` 标记向后兼容 manifest-store 既有扫描（`x.json` 的 tmp 名为
@@ -5655,8 +6170,8 @@ declare function renderXmlSection(section: {
  *
  * **两种耐久档位**（对齐现存两族写点的生产模式）：
  * - sync（writeAtomicFileSync）：writeFileSync + renameSync，无 fsync——对齐
- *   worktree-registry / engine-discovery 两处同步写点现状（注册表/发现缓存类，
- *   进程崩溃窗口可容忍）；
+ *   worktree-registry / engine-discovery / record-store（manifest writeSync 面）
+ *   同步写点现状（注册表/发现缓存/索引类，进程崩溃窗口可容忍）；
  * - async（writeAtomicFile）：fsync 文件 → rename → 尽力 fsync 目录——对齐
  *   manifest-store / sessions-index 的生产耐久模式（掉电也不丢已确认写入）。
  */
@@ -5717,8 +6232,9 @@ declare function writeAtomicFile(filePath: string, content: string | Uint8Array,
  *
  * 供两类消费方：
  * - cleanupStaleTmpFiles 的内部步骤；
- * - 需要按域校验内容再决定「删 or 提升为正式文件」的宿主恢复逻辑
- *   （manifest-store.recoverTmpFiles 模式：tmp 合法且目标缺失 → rename 提升）。
+ * - 需要按域校验内容再决定「删 or 提升为正式文件」的宿主恢复逻辑（基于
+ *   listStaleTmpFiles + parseAtomicTmpPath().targetPath 组合实现；曾有的
+ *   manifest promote 消费方已随 U4c 缓存降级退役为 sweepTmpFiles 纯删除）。
  *
  * 目录不存在 → 返回空数组（恢复扫描对未初始化布局宽容）。非约定形态文件
  * 一律不认（用户数据零误伤边界见 parseAtomicTmpPath 注释）。
@@ -5745,7 +6261,7 @@ interface CleanupStaleTmpResult {
 /**
  * 清理目录内约定形态的 tmp 残留（单条失败不阻断其余条目，逐条结果回传）。
  *
- * 恢复语义（对齐 manifest-store.recoverTmpFiles 的删除分支泛化）：本函数只做
+ * 恢复语义（删除级恢复；曾对齐的 manifest-store promote 分支已随 U4c 退役）：本函数只做
  * 「删除」级恢复；「校验后提升为正式文件」需域知识（manifest 记录合法性），
  * 由调用方基于 listStaleTmpFiles + parseAtomicTmpPath().targetPath 自行实现。
  */
@@ -5811,6 +6327,6 @@ declare function boundedPrettySerialize(value: unknown, budget: number): string;
  * docs/design/subagent-core-sink-design.md（sink 下沉收口扩面，2026-08-31）；
  * 宿主接入示例见包 README（§3.4 core_host_not_configured 恢复指引的落点）。
  */
-declare const CORE_PACKAGE_VERSION = "0.8.0";
+declare const CORE_PACKAGE_VERSION = "0.9.0";
 
-export { AGENT_REF_EXT, AgentCall, AgentCallOpts, type AgentEntry, AgentEventLogEntry, type AgentProfile, AgentRegistry, AgentResult, type AgentRunner, type ArgKeySet, type ArgMetaOptions, type ArgMetaWarning, type AtomicTmpRef, type AtomicWriteFileOptions, type AtomicWriteOptions, BG_MESSAGE, BgResponse, Budget, CORE_PACKAGE_VERSION, type CachedWorkflowMeta, type CancelHandlerInput, type CancelHandlerResult, CancelResponse, type ChangeListener, type CleanupStaleTmpOptions, type CleanupStaleTmpResult, type CleanupWorktreeOptions, type CloseHandlerInput, type CloseHandlerResult, CloseResponse, ClosedReason, type CollectWorktreePatchOptions, type ConcurrencyPool, type CreateConcurrencyPoolOptions, type D8CompatZcodeEngineDeps, DEFAULT_LIST_LIMIT, DEFAULT_PROVIDER_ID, DEFAULT_SAVE_MIN_INTERVAL_MS, DEFAULT_STATE_MAX_RUNS, DEFAULT_WORKFLOW_SAVED_DIR, DEFAULT_WORKFLOW_TMP_DIR, DialogGlobalQueue, type DiscoveredResource, DiscoveryRoot, DisplayItem, DoneReason, EnginePort, type EngineRouteOptions, type EngineRouteResult, type EngineRouting, type EngineRoutingInput, type EngineRoutingSource, ExecutionMode, ExecutionOutcome, ExecutionRecord, ExecutionStatus, ExecutionTraceNode, ExternalState, FORK_FROM_DEFAULT_PROMPT, FileRunStore, type FinalizeRunOptions, type ForkFromHandlerInput, type ForkFromHandlerResult, ForkFromResponse, type GenerateWorkflowScriptOptions, type GenerateWorkflowScriptResult, GitRunError, type GlobalConfigReadResult, IDENTITY_CUSTOM_TYPE, INDEX_FILENAME, type InFlightListener, type InFlightSnapshot, type InvalidAgentRefMessageOptions, type LauncherDeps, type LifecycleDeps, type LintFinding, type LintResult, type ListFormatOptions, type ListHandlerInput, type ListHandlerResult, ListResponse, type ListWorktreePorcelainOptions, MAX_LIST_LIMIT, MAX_RETAINED_DONE_RUNS, MAX_TIMER_DELAY_MS, type MessageHandlerInput, type MessageHandlerResult, MessageResponse, ModelConfigService, type ModelConfigServiceInit, type ModelEntry, ModelInfo, type ModelListFormatOptions, type ModelReasoningInfo, NOTIFY_CONTRACT, type NormalizeWorkflowRefOptions, type NormalizedArgs, type NormalizedWorkflowRef, type NotifyDomainPorts, type NotifyLedgerHost, type PatchBaselineAnchor, type PruneStateDeps, type QueuePolicy, RecordStore, type RecordStorePi, type RecoverCrashedRunsHooks, type RecoverCrashedRunsResult, type ResourceKind, type ResourceSource, type RunSnapshot, type RunSpec, type RunState, RunStatus, type RunStore, SAFE_ID_RE, SNAPSHOT_VERSION, SUBAGENT_RECORD_CUSTOM_TYPE, type ScanConfig, type StartHandlerInput, type StartHandlerResult, type StatusFilter, type SubagentIdentityData, SubagentListItem, SubagentRecord, type SubagentRecordEntryData, SubagentService, type SubagentServiceInit, SubagentStream, SubprocessAgentRunner, THINKING_ORDER, Trace, WORKFLOW_REF_EXT, WORKFLOW_REF_RESERVED_NAMES, type WorkerHandlers, type WorkerHost, WorkerHostImpl, WorkerLogEntry, type WorkflowDirOptions, type WorkflowEntry, type WorkflowMeta, type WorkflowRefInvalidReason, WorkflowRun, type WorkflowRunMeta, type WorkflowRunResult, type WorkflowRunSummary, type WorkflowScanConfig, WorkflowScript, type WorkflowScriptRegistry, WorkflowScriptRegistryImpl, type WorkflowSource, WorktreeManager, type WorktreePatchResult, ZCODE_FALLBACK_DEFAULT_MODEL, type ZcodeEngineDeps, abortRun, argKeysFromMeta, assertSafeId, atomicTmpPathFor, bestEffort, bindNotifyLedgerHost, boundedPrettySerialize, buildEngineModelsPromptAppend, buildSubagentEngineSection, cancelHandler, cleanupStaleTmpFiles, cleanupWorktree, clearSkillPathCache, closeHandler, closeOutInFlightCalls, collectWorktreePatch, computeElapsedSeconds, configureNotifyDomain, countAllToolCalls, createConcurrencyPool, createSubagentService, createUiRequestHandlerForMode, createZcodeEngine, deleteWorkflow, deriveOutcome, discoverAgents, discoverResources, discoverWorkflows, displayAgentName, endedMessageGuard, escapeXml, evictDoneRunsBeyondCap, executeNestedWorkflow, finalizeRun, findFlattenedArgKeys, findWorkspaceRoot, forkFromHandler, formatAgentList, formatModelList, formatWorkflowList, fromRunSnapshot, generateWorkflowScript, getAllToolCalls, getBoundNotifyLedger, getCachedFileContent, getCachedParsed, getInFlightSnapshot, getModelConfigService, getOrCreateChannelRegistry, getSubagentService, getWorkflow, getWorkflowByPath, gitRun, hasApiKey, invalidAgentRefMessage, invalidateCache, isProcessAlive, isResumable, isSafeId, isScriptRunning, isTreeDirty, killAllSpawnedChildren, killRecordChildWithEscalation, lintScript, listHandler, listStaleTmpFiles, listWorktreePorcelain, loadWorkflowScriptByPath, loadWorkflows, makeSerializeFailedResult, mapExternalState, maxTurnsToWatchdogMs, maybeCleanupExpiredSessionFiles, messageHandler, normalizeArgsByMeta, normalizeRef, normalizeWorkflowRef, notifyGateAllowsDelivery, parseAgentProfile, parseAtomicTmpPath, parseEngineHandle, parseResourceMeta, parseResourceMetaDetailed, postBudgetUpdate, projectLiveProgress, projectOutcome, pruneStateFilesBeyondCap, readGlobalConfig, readSubagentHistoryMessages, recordToListItem, recoverCrashedRuns, registerNativeSessionReader, registerZcodeEngine, renderXmlSection, resetRebuildFailureInjectionForTest, routeEngine, runAndWait, runSummary, runWorkflow, saveWorkflow, scheduleTimeBudget, setEngineDiscoveryRescanOptions, setInFlightListener, setModelConfigService, setSubagentService, sortByCodepoint, splitZcodeModelRef, startHandler, summarizeDescription, syncEnginesFile, terminateRunningRuns, toRunSnapshot, toSubagentRecordEntry, wrapForkFromPrompt, writeAtomicFile, writeAtomicFileSync };
+export { AGENT_REF_EXT, AgentCall, AgentCallOpts, type AgentEntry, type AgentEventLogEntry, type AgentProfile, AgentRegistry, AgentResult$1 as AgentResult, type AgentRunner, type ArgKeySet, type ArgMetaOptions, type ArgMetaWarning, type AtomicTmpRef, type AtomicWriteFileOptions, type AtomicWriteOptions, BG_MESSAGE, type BgResponse, Budget, CLOSED_REASONS, CORE_PACKAGE_VERSION, type CachedWorkflowMeta, type CancelHandlerInput, type CancelHandlerResult, type CancelResponse, type ChangeListener, type CleanupStaleTmpOptions, type CleanupStaleTmpResult, type CleanupWorktreeOptions, type CloseHandlerInput, type CloseHandlerResult, type CloseResponse, type ClosedReason, type CollectWorktreePatchOptions, type ConcurrencyPool, type CreateConcurrencyPoolOptions, type D8CompatZcodeEngineDeps, DEFAULT_AGENT_NAME, DEFAULT_LIST_LIMIT, DEFAULT_PROVIDER_ID, DEFAULT_SAVE_MIN_INTERVAL_MS, DEFAULT_STATE_MAX_RUNS, DEFAULT_WORKFLOW_SAVED_DIR, DEFAULT_WORKFLOW_TMP_DIR, DialogGlobalQueue, DirtyWorktreeError, type DiscoveredResource, DiscoveryRoot, type DisplayItem, DoneReason, EnginePort, type EngineRouteOptions, type EngineRouteResult, type EngineRouting, type EngineRoutingInput, type EngineRoutingSource, type ExecutionMode, type ExecutionOutcome, type ExecutionRecord, type ExecutionStatus, ExecutionTraceNode, type ExternalState, FORK_FROM_DEFAULT_PROMPT, FileRunStore, type FinalizeRunOptions, ForkDepthExceededError, type ForkFromHandlerInput, type ForkFromHandlerResult, type ForkFromResponse, type GenerateWorkflowScriptOptions, type GenerateWorkflowScriptResult, GitRunError, type GlobalConfigReadResult, IDENTITY_CUSTOM_TYPE, INDEX_FILENAME, type InFlightListener, type InFlightSnapshot, type InvalidAgentRefMessageOptions, type LauncherDeps, type LifecycleDeps, type LintFinding, type LintResult, type ListFormatOptions, type ListHandlerInput, type ListHandlerResult, type ListResponse, type ListWorktreePorcelainOptions, MAX_LIST_LIMIT, MAX_RETAINED_DONE_RUNS, MAX_TIMER_DELAY_MS, type MessageHandlerInput, type MessageHandlerResult, type MessageResponse, ModelConfigService, type ModelConfigServiceInit, type ModelEntry, ModelInfo, type ModelListFormatOptions, type ModelReasoningInfo, NOTIFY_CONTRACT, type NormalizeWorkflowRefOptions, type NormalizedArgs, type NormalizedWorkflowRef, type NotifyDomainPorts, type NotifyLedgerHost, type PatchBaselineAnchor, type PruneStateDeps, type QueuePolicy, RecordStore, type RecordStorePi, type RecoverCrashedRunsHooks, type RecoverCrashedRunsResult, type ResourceKind, type ResourceSource, ResurrectDeniedError, type RunSnapshot, type RunSpec, type RunState, RunStatus, type RunStore, SAFE_ID_RE, SNAPSHOT_VERSION, SUBAGENT_RECORD_CUSTOM_TYPE, type ScanConfig, type StartHandlerInput, type StartHandlerResult, type StatusFilter, type SubagentIdentityData, type SubagentListItem, type SubagentRecord, type SubagentRecordEntryData, SubagentService, type SubagentServiceInit, SubagentStream, type SubagentToolResult, SubprocessAgentRunner, THINKING_ORDER, Trace, WORKFLOW_REF_EXT, WORKFLOW_REF_RESERVED_NAMES, type WorkerHandlers, type WorkerHost, WorkerHostImpl, WorkerLogEntry, type WorkflowDirOptions, type WorkflowEntry, type WorkflowMeta, type WorkflowRefInvalidReason, WorkflowRun, type WorkflowRunMeta, type WorkflowRunResult, type WorkflowRunSummary, type WorkflowScanConfig, WorkflowScript, type WorkflowScriptRegistry, WorkflowScriptRegistryImpl, type WorkflowSource, WorktreeManager, type WorktreePatchResult, ZCODE_FALLBACK_DEFAULT_MODEL, type ZcodeEngineDeps, abortRun, argKeysFromMeta, assertSafeId, atomicTmpPathFor, bestEffort, bindNotifyLedgerHost, boundedPrettySerialize, buildEngineModelsPromptAppend, buildSubagentEngineSection, cancelHandler, cleanupStaleTmpFiles, cleanupWorktree, clearSkillPathCache, closeHandler, closeOutInFlightCalls, collectWorktreePatch, computeElapsedSeconds, configureNotifyDomain, countAllToolCalls, createConcurrencyPool, createSubagentService, createUiRequestHandlerForMode, createZcodeEngine, deleteWorkflow, deriveOutcome, discoverAgents, discoverResources, discoverWorkflows, displayAgentName, endedMessageGuard, escapeXml, evictDoneRunsBeyondCap, executeNestedWorkflow, finalizeRun, findFlattenedArgKeys, findWorkspaceRoot, forkFromHandler, formatAgentList, formatModelList, formatWorkflowList, fromRunSnapshot, generateWorkflowScript, getAllToolCalls, getBoundNotifyLedger, getCachedFileContent, getCachedParsed, getInFlightSnapshot, getModelConfigService, getOrCreateChannelRegistry, getSubagentService, getWorkflow, getWorkflowByPath, gitRun, hasApiKey, invalidAgentRefMessage, invalidateCache, isProcessAlive, isResumable, isSafeId, isScriptRunning, isTreeDirty, killAllSpawnedChildren, killRecordChildWithEscalation, lintScript, listHandler, listStaleTmpFiles, listWorktreePorcelain, loadWorkflowScriptByPath, loadWorkflows, makeSerializeFailedResult, mapExternalState, maxTurnsToWatchdogMs, maybeCleanupExpiredSessionFiles, messageHandler, normalizeArgsByMeta, normalizeRef, normalizeWorkflowRef, notifyGateAllowsDelivery, parseAgentProfile, parseAtomicTmpPath, parseEngineHandle, parseResourceMeta, parseResourceMetaDetailed, postBudgetUpdate, projectLiveProgress, projectOutcome, pruneStateFilesBeyondCap, readGlobalConfig, readSubagentHistoryMessages, recordToListItem, recoverCrashedRuns, registerNativeSessionReader, registerZcodeEngine, renderXmlSection, resetRebuildFailureInjectionForTest, routeEngine, runAndWait, runSummary, runWorkflow, saveWorkflow, scheduleTimeBudget, setEngineDiscoveryRescanOptions, setInFlightListener, setModelConfigService, setSubagentService, sortByCodepoint, splitZcodeModelRef, startHandler, summarizeDescription, syncEnginesFile, terminateRunningRuns, toRunSnapshot, toSubagentRecordEntry, wrapForkFromPrompt, writeAtomicFile, writeAtomicFileSync };