@zhushanwen/subagent-core 0.7.1 → 0.9.0

package/src/execution/engine/types.ts

@@ -4,10 +4,11 @@
 // §3.3.5（EnginePort 与中立类型完整契约）+ §3.3.6（EngineHandle/journal/SessionView 格式）。
 //
 // [S4 簇 3 收编] 契约类型单源化（type-only）：AgentOutcome / EngineHandleData /
-// ReplayedTurn / SessionView / EngineCapabilities / ProbeReport / InteractAction /
-// InteractResult 的本地定义已删除，自 @zhushanwen/subagent-engine-sdk re-export
-// （SDK protocol/contract-types.ts 是类型闭包 SSOT，core 反向 re-export 保上层消费面
-// ——import 方路径零改动；结构等价由 protocol-closure.test.ts 断言族守卫）。
+// ReplayedTurn / SessionView / EngineCapabilities / ProbeReport 的本地定义已删除，
+// 自 @zhushanwen/subagent-engine-sdk re-export（SDK protocol/contract-types.ts 是
+// 类型闭包 SSOT，core 反向 re-export 保上层消费面——import 方路径零改动；结构等价
+// 由 protocol-closure.test.ts 断言族守卫）。[H1 U5/U6] InteractAction / InteractResult
+// 已随 chat 域 interact 面退役删除。
 // EngineHandle 留守本地：SDK 无此类型（协议面用裸 data 载荷），宿主侧句柄包装接口
 // 是 core 域概念。
 //
@@ -20,7 +21,7 @@
 
 import type { EngineHandleData } from "@zhushanwen/subagent-engine-sdk";
 
-// AgentEvent 8 种事件：权威定义在 SDK contract-types，经 execution/types.ts re-export
+// AgentEvent 9 种事件：权威定义在 SDK contract-types，经 execution/types.ts re-export
 // → shared/agent-event.ts 转发层 → 本文件（链条保持，维持「shared/ 是类型共享层」的
 // 架构约定）。新增粗粒度约束（coarse 引擎至少合成一次 message_end + 一次 turn_end）
 // 由 conformance 套件断言（P4），不在类型层编码。
@@ -34,26 +35,22 @@ export type {
   AgentOutcome,
   EngineCapabilities,
   EngineHandleData,
-  InteractAction,
-  InteractResult,
   ProbeReport,
   ReplayedTurn,
   SessionView,
 } from "@zhushanwen/subagent-engine-sdk";
 
 // ============================================================
-// EngineHandle（run/interact/read 三面的连接件，D1/§3.3.6）——core 域类型留宿主侧
+// EngineHandle（run/read 两面的连接件，D1/§3.3.6）——core 域类型留宿主侧
 // ============================================================
 
 /**
- * 引擎会话句柄（run 返回、interact/read 入参）。
+ * 引擎会话句柄（run 返回、read 入参；[H1 U5/U6] interact 面退役后不再有 interact
+ * 消费方）。
  *
  * 契约三条（D1）：不透明（上层不解构——唯一例外是 record 持久化层序列化 data 字段与
- * read 降级链）、可持久化（data 是纯 JSON，主会话 reload 后 read/interact 仍可用）、
- * 自描述（data 含 engineId + 引擎 session 定位符 + pool key + adapter 版本）。
- *
- * 对进程已死的 handle 调 interact 必须返回 engine_session_not_resumable（指向 cold
- * resume 路径），而非笼统失败——由各引擎 interact 实现保证。
+ * read 降级链）、可持久化（data 是纯 JSON，主会话 reload 后 read 仍可用）、自描述
+ * （data 含 engineId + 引擎 session 定位符 + pool key + adapter 版本）。
  */
 export interface EngineHandle {
   /** 持久化数据。上层不得解构其内部字段（见契约三条）。 */

package/src/execution/execution-record.ts

@@ -470,6 +470,10 @@ export function updateFromEvent(record: ExecutionRecord, event: AgentEvent): voi
     case "compaction":
       return;
 
+    // ── activity：纯活性信号，reducer no-op（协议语义见 SDK contract-types）──
+    case "activity":
+      return;
+
     default: {
       // 穷尽性检查：新增 AgentEvent variant 时编译期报错
       const _exhaustive: never = event;
@@ -612,50 +616,10 @@ export function getFullText(record: ExecutionRecord): string {
     .join("\n\n");
 }
 
-/**
- * [增量通知] 从 fromTurnIndex 起聚合 turn 文本（getFullText 的增量视图）。
- *
- * 语义：record.turns.slice(Math.max(0, fromTurnIndex)) 的 text 数组
- * filter(text => text.length > 0)（判据与 getFullText 逐字对齐——空白串 " " 按非空
- * 处理，不发散）后 join("\n\n")。
- *
- * 不变式（单测锁死）：
- *   - fromTurnIndex = 0 与 getFullText(record) 逐字节等价（one-shot/首轮回退零成本）
- *   - fromTurnIndex >= turns.length 返回 ""（不抛错、不回绕）
- *   - fromTurnIndex < 0 规范化为 0（防御，Math.max 不产生 slice 负偏移语义）
- *
- * 纯函数只读；getFullText 本体与既有调用方（collectResult 等）零改动。
- * 唯一调用点 onRoundSettled 的增量派生（record.roundBaseTurnIndex ?? 0）。
- */
-export function getFullTextFrom(record: ExecutionRecord, fromTurnIndex: number): string {
-  return record.turns
-    .slice(Math.max(0, fromTurnIndex))
-    .map((t) => t.text)
-    .filter((text) => text.length > 0)
-    .join("\n\n");
-}
-
-/**
- * [增量通知] 轮次边界推进公式（D1）：返回下一轮增量的 turns[] 起始下标。
- *
- * record.turns.length - (末 turn 存在且 !closed 且 text.length === 0 ? 1 : 0)
- *
- * - 末 turn 已闭合（pi 现序常态：带 usage 的 message_end 恒先于 turn_end，settle 时
- *   全闭合）→ 返回 length，下一轮从新 turn 起。
- * - 末 turn 是滞后 message_end 开出的空 turn（防御分支，pi 现序不可达）→ 不计入边界
- *   （-1），留在下一轮增量内：新轮首个 text_delta 经 currentTurn 复用该空 turn，复用
- *   累积被 slice(from) 覆盖；若直用 turns.length 会把这段文本挤出 slice 范围静默丢失（D1）。
- * - 末 turn 未闭合且 text 非空（防御形态，pi 现序不可达）→ 计入本轮返回 length（该形态
- *   即 onRoundSettled 推进前观测哨 logger.warn 的触发条件）。
- *
- * 纯函数只读不写 record；唯一调用点 onRoundSettled 第 5 步（notify 之后推进）。
- */
-export function nextRoundBaseTurnIndex(record: ExecutionRecord): number {
-  const last = record.turns[record.turns.length - 1];
-  const trailingOpenEmpty =
-    last !== undefined && !last.closed && last.text.length === 0 ? 1 : 0;
-  return record.turns.length - trailingOpenEmpty;
-}
+// [H1 U6 / D7 ③] getFullTextFrom / nextRoundBaseTurnIndex（增量通知 base 死记账族）
+// 已退役删除：唯一调用点 onRoundSettled（inproc 时代）消亡后生产零调用，写点
+// settleChatRoundFromResponse 随载体删除；「notify 失败 base 不推进」防丢文本语义由
+// record.result 恒写承接（D7 ③ 退役不迁移）。getFullText 本体与既有调用方零改动。
 
 /**
  * 聚合所有 turn 的 toolCalls（扁平化），并 strip InternalToolCall 的内部字段。
@@ -990,8 +954,8 @@ function translateMessageUpdate(raw: JsonlEvent): AgentEvent[] {
 /**
  * 把一条 JSONL 事件翻译成 AgentEvent。
  *
- * 返回 undefined 表示该事件不映射到任何 AgentEvent（如 session header、message_start、
- * tool_execution_update），调用方应跳过。
+ * 返回 undefined 表示该事件不映射到任何 AgentEvent（如 session header、message_start），
+ * 调用方应跳过。
  *
  * 一个 JSONL 事件可能产出**多条** AgentEvent（message_end 的 usage + error 各一条），
  * 故返回数组。绝大多数情况长度为 0 或 1；message_end 最多 2 条。
@@ -1003,9 +967,13 @@ export function jsonlToAgentEvent(raw: JsonlEvent): AgentEvent[] {
     case "session":
     case "message_start":
     case "turn_start":
-    case "tool_execution_update":
       return [];
 
+    // 工具执行期活性信号（与 pi 侧 spawn-event-translator 的 TOOL_ACTIVITY_EVENT 同
+    // 语义）：不产数据，只驱动宿主无进展守护刷新。
+    case "tool_execution_update":
+      return [{ type: "activity" }];
+
     case "tool_execution_start":
       return translateToolExecutionStart(raw);
 

package/src/execution/finalize-record.ts

@@ -2,32 +2,30 @@
 //
 // 时序收尾逻辑（从 subagent-service.ts 提取，降低主文件行数 < 1000 上限）。
 //
-// D-017 时序：collectPatch → completeRecord → archive → cleanup(finalized+worktree+
-// aliveMarker+pending注销) → manifest(最后 best-effort)。
+// [U2a / §3.1 意图 API 迁移] 终态持久化四件套（.state 写 + entry/archive + manifest +
+// .alive 删）归口 store.markFinalized / markCancelled——本文件降级为**副作用编排层**
+// （collectPatch / completeRecord / worktree cleanup / pending 注销① / onFinalized 钩子，
+// §3.1 副作用归属边界）。文件布局知识（写哪个文件、什么顺序）不再散落此处：D8 v7 写序
+//（.state writeSync 先 → manifest writeSync 后 → .alive 删）由 store 内部单点保证。
 //
-// [Critical #1 / PR #85] cleanup 全部在 manifest 写之前执行——manifest 是 sa- id 反查
-// 索引（最新已知快照），非正确性依赖，写失败仅记录不阻断。旧实现 Step 2.5 throw 会跳过
-// Step 3 cleanup，导致磁盘满/权限错时 worktree 泄漏 + finalized marker 不写 + alive
-// marker 残留 + pending 记账错乱。现 manifest 写移到 Step 4（最后），best-effort
-//（console.error + appendEntry，不 throw）。
+// [Critical #1 / PR #85 精神保持] manifest 写失败响亮上报不阻断（logger.error +
+// subagent:manifest-write-failed entry，§3.4 manifest 面）与终态原语返回 false 均不
+// 得跳过 worktree cleanup——磁盘满/权限错时 worktree 泄漏比索引缺失严重；终态写失
+// 败时 record 留 running 形态（磁盘无终态位），下次 boot 孤儿恢复终态化承接（§3.4）。
 //
-// B9 兜底：completeRecord/archive 抛错→后续 cleanup/manifest 仍执行。
+// B9 兜底：completeRecord/终态原语抛错→后续 cleanup 仍执行。
 
 import * as fs from "node:fs";
 import * as path from "node:path";
 
 import { getLogger } from "../core/logger.ts";
 
-import { removeAliveMarker } from "./alive-store.ts";
 import { bestEffort } from "./best-effort.ts";
 import { completeRecord } from "./execution-record.ts";
-import { writeFinalized } from "./finalized-marker.ts";
-import type { ManifestStore } from "./manifest-store.ts";
 import type { ModelConfigService } from "./model-config-service.ts";
 import { getSubagentSessionDir } from "./path-encoding.ts";
 import type { RecordStore } from "./record-store.ts";
 import { readIdentityHeader, readIdentityTail } from "./session-reconstructor.ts";
-import { writeCancelledTombstone } from "./tombstone-store.ts";
 import type { AgentResult, ClosedReason, ExecutionRecord } from "./types.ts";
 import type { WorktreeManager } from "./worktree-manager.ts";
 
@@ -35,31 +33,30 @@ const logger = getLogger("subagents");
 
 /** doFinalizeRecord 的依赖（从 SubagentService 注入，避免 this 绑定 + 解耦可测试）。 */
 export interface FinalizeDeps {
-  manifestStore: ManifestStore;
   worktreeManager: WorktreeManager;
   store: RecordStore;
   modelService: ModelConfigService;
-  /** Pi ExtensionAPI（仅用 appendEntry 记录 manifest 写失败事件）。null 在 dispose 后。 */
+  /** Pi ExtensionAPI（终态写失败的响亮 entry 上报）。null 在 dispose 后。 */
   pi: { appendEntry?: (type: string, data: unknown) => void } | null;
   /** pending-notifications 终态注销（绑定 pi.events.emit，由调用方闭包提供）。 */
   emitUnregister(id: string, status: string): void;
   /**
    * [F-5 修复] record 终态化的宿主侧收口钩子（recordId；best-effort，抛错由调用方
    * 在闭包内自行兜底）。单一汇聚点：doFinalizeRecord 是全部 closed 终态的必经路径
-   * （finalizeRecord / closeChatIdle / closeAfterRoundSettled / finalizeFailed /
-   * finalizeAborted / consumeCloseAfterRound），chat 轮路由注销（chatRoundRoutes）
-   * 由 SubagentService 经此钩子统一执行——此前仅 cancelBackground 注销，chat record
-   * 经 finalize 链终态化后路由闭包（持 record/stream/守护引用）泄漏。finalizeRoundToIdle
-   * 不经本钩子（回 idle 非终态，续聊仍需路由）。
+   *（finalizeRecord / closeChatIdle / finalizeFailed / finalizeAborted /
+   * consumeCloseAfterRound）。收口面现 = Continuation 实例清理（[H1 U6] 旧 chat 轮
+   * 路由注销面已随 interact 面退役）。finalizeRoundToIdle 不经本钩子（回 idle 非终态，
+   * 续聊仍需容器）。
    */
   onFinalized?: (recordId: string) => void;
   /**
    * [T1/PS-9] subagent sessionDir（getSubagentSessionDir(agentDir, rootCwd)，调用方注入）。
    *
    * record.sessionFile 缺失（RC-1 握手失败 + LC-4 反查也未命中的残余形态）时用于磁盘
-   * 反查：按 identity（record.id）扫目录找真实 session 文件，作为 tombstone/finalized
-   * sidecar 与 removeAliveMarker 的依据——消除「sessionFile 缺失 → 终态原因丢失 +
-   * alive marker 残留」。undefined = 调用方无法提供（反查跳过，行为退回修复前）。
+   * 反查：按 identity（record.id）扫目录找真实 session 文件，作为终态原语
+   * （store.markFinalized/markCancelled 的 .state/manifest/.alive 面）的锚点依据——
+   * 消除「sessionFile 缺失 → 终态原因丢失 + alive marker 残留」。undefined = 调用方
+   * 无法提供（反查跳过，行为退回修复前）。
    */
   sessionDir?: string;
   // [review 修复] 已删除 redeliverPending 回调（MF-1 消费确认制补投）：pendingMessages
@@ -98,11 +95,10 @@ function findSessionFileByRecordIdentity(
 /**
  * [T1/PS-9] Step 序言：sessionFile 缺失时按 record 身份在 sessionDir 反查回填。
  *
- * 放在一切步骤前，让 archive 投影 / Step 3 marker / Step 4 manifest 统一受益。
- * RC-1（握手失败）+ LC-4（收尾反查未命中）的残余形态下，磁盘上 session 文件仍可能
- * 真实存在（identity 携带 record.id）——反查命中则 tombstone/finalized sidecar 与
- * removeAliveMarker 有了依据，终态原因不再丢失、alive marker 不再残留；未命中则
- * 保持旧行为（best-effort 跳过）。
+ * 放在一切步骤前，让终态原语（archive 投影 / .state / manifest / .alive release）
+ * 统一受益。RC-1（握手失败）+ LC-4（收尾反查未命中）的残余形态下，磁盘上 session
+ * 文件仍可能真实存在（identity 携带 record.id）——反查命中则终态原语有了锚点，
+ * 终态原因不再丢失、alive marker 不再残留；未命中则保持旧行为（best-effort 跳过）。
  */
 function resolveMissingSessionFile(deps: FinalizeDeps, record: ExecutionRecord): void {
   if (record.sessionFile || !deps.sessionDir) return;
@@ -136,34 +132,9 @@ async function collectPatchIfWorktree(deps: FinalizeDeps, record: ExecutionRecor
   }
 }
 
-/**
- * Step 3a: finalized/tombstone sidecar（best-effort 幂等，仅 sessionFile 存在时执行）。
- * MF-1 fix / v4 B-1: cancelled（closedReason='cancelled'）写 tombstone 而非 finalized，
- * 防重建丢失 cancelled；其余 reason 写 finalized sidecar（真实 reason 进 sidecar 内容，
- * 磁盘重建用它还原 closedReason，不再一律硬编码 gc）。
- */
-function writeFinalizedOrTombstone(record: ExecutionRecord, closedReason: ClosedReason | undefined): void {
-  if (!record.sessionFile) return;
-  try {
-    if (closedReason === "cancelled") {
-      writeCancelledTombstone(record.sessionFile, {
-        id: record.id,
-        status: "cancelled",
-        agent: record.agent,
-        startedAt: record.startedAt,
-        endedAt: record.endedAt ?? Date.now(),
-      });
-    } else {
-      writeFinalized(record.sessionFile, closedReason);
-    }
-  } catch (err) {
-    bestEffort(err, "writeFinalized/tombstone (finalizeRecord Step3)");
-  }
-}
-
 /**
  * Step 3b: worktree cleanup（best-effort 幂等，仅 worktree 绑定时执行）。
- * [Critical] 绝不能因 manifest 写失败而跳过（否则 worktree 泄漏）。
+ * [Critical] 绝不能因终态原语失败（含 manifest 写失败）而跳过（否则 worktree 泄漏）。
  */
 async function cleanupWorktreeIfBound(deps: FinalizeDeps, record: ExecutionRecord): Promise<void> {
   if (!record.worktreeHandle) return;
@@ -174,59 +145,17 @@ async function cleanupWorktreeIfBound(deps: FinalizeDeps, record: ExecutionRecor
   }
 }
 
-/** Step 3c: 删 .alive marker（best-effort 幂等，仅 sessionFile 存在时执行）。 */
-function removeAliveMarkerIfPresent(record: ExecutionRecord): void {
-  if (!record.sessionFile) return;
-  try {
-    removeAliveMarker(record.sessionFile);
-  } catch (err) {
-    bestEffort(err, "removeAliveMarker (finalizeRecord Step3)");
-  }
-}
-
 /**
- * Step 4 (last): manifest 持久化（best-effort，不阻断、不 throw）。
+ * 时序收尾（D-017，[U2a] 终态持久化面归口 store 意图原语后的编排形态）。
  *
- * [Critical #1] manifest 是 sa- id 反查索引（最新已知快照），不是正确性依赖。本步骤
- * 写终态快照；sync 批成功成员不经此处——落标出口（subagent-service
- * appendBatchFinalizedEntry）已先行补写，message upgrade 到终态时被本步骤原子
- * 覆盖。写失败时仅记录（console.error + appendEntry），绝不让 manifest 写失败
- * 跳过 Step 3 cleanup 或抛出打断 finalize 链。旧实现 Step 2.5 throw 会
- * 跳过 Step 3 cleanup。task/slug/model 从 ExecutionRecord 抓取（配合
- * ManifestRecord 补字段），manifestToSubagent 投影时用真实值而非硬编码空串。
- */
-async function writeManifestBestEffort(deps: FinalizeDeps, record: ExecutionRecord): Promise<void> {
-  try {
-    await deps.manifestStore.writeManifest({
-      id: record.id,
-      rootSessionId: record.rootSessionId ?? "",
-      parentRecordId: record.parentRecordId,
-      agentName: record.agent,
-      // v4 B-1: manifest status 统一为 closed（cancelled 折入 closed，区分靠 tombstone sidecar）
-      status: "closed",
-      createdAt: record.startedAt,
-      completedAt: record.endedAt ?? Date.now(),
-      sessionFile: record.sessionFile,
-      task: record.task,
-      slug: record.slug,
-      model: record.model,
-    });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger.error(`[subagent] manifest 写入失败 (record=${record.id}): ${msg}`);
-    deps.pi?.appendEntry?.("subagent:manifest-write-failed", {
-      id: record.id,
-      error: msg,
-    });
-  }
-}
-
-/**
- * 时序收尾（D-017）。步骤 0→4 全部 best-effort 互不阻断（除 manifest 外都幂等）。
+ * 步骤：序言 sessionFile 反查 → Step 0 collectPatch → Step 1 completeRecord →
+ * Step 2 终态原语（store.markFinalized / markCancelled：.state writeSync + entry/
+ * archive + manifest + .alive 删，D8 v7 写序）→ Step 3b worktree cleanup →
+ * pending 注销① → onFinalized 钩子。
  *
- * [Critical #1] Step 3 cleanup 全部在 Step 4 manifest 之前——manifest 写失败仅 console.error +
- * appendEntry，不 throw 不跳过 cleanup。task/slug/model 从 ExecutionRecord 抓取（配合 ManifestRecord
- * 补字段），manifestToSubagent 投影真实值而非硬编码空串。
+ * [Critical #1] 终态原语失败（返回 false = .state 重试耗尽；或意外抛错）不得跳过
+ * worktree cleanup——写失败时 record 留 running（磁盘无终态位），副作用清理照常
+ * （幂等）；§3.4 响亮 entry 上报由本编排层接线（store 层已 logger.error）。
  */
 export async function doFinalizeRecord(
   deps: FinalizeDeps,
@@ -248,132 +177,100 @@ export async function doFinalizeRecord(
     bestEffort(err, "completeRecord (finalizeRecord B9)", "error");
   }
 
-  // ── Step 2: archive（B9: 抛错→后续仍执行）──
+  // ── Step 2: 终态持久化四件套归口（B1 迁移点）──
+  // cancelled 走 markCancelled（.state 载荷 status:"cancelled" + 精确 endedAt），其余
+  // markFinalized。两原语内部写序 = .state writeSync 先 → binding/archive/manifest →
+  // .alive 删（release 出口①，D8 v7）。生产路径恒 manifestDir 接线（subagent-service
+  // 构造点）；缺省异步分支仅纯内存测试形态。
+  let persisted = false;
   try {
-    deps.store.archive(record);
+    persisted =
+      closedReason === "cancelled"
+        ? deps.store.markCancelled(record)
+        : deps.store.markFinalized(record, closedReason);
   } catch (err) {
-    bestEffort(err, "store.archive (finalizeRecord B9)", "error");
+    bestEffort(err, "store terminal primitive (finalizeRecord B9)", "error");
+  }
+  if (!persisted) {
+    // [§3.4 / U1 偏差 6 接线] 终态写失败（重试耗尽）响亮 entry 上报——GUI 通知面腿；
+    // 日志 error 级腿已由 state-marker 内部完成。record 留 running 形态（磁盘无终态
+    // 位、未 archive），下次 boot 孤儿恢复终态化承接。
+    const reasonDesc = closedReason ?? record.closedReason ?? "gc";
+    logger.error(
+      `[subagent] terminal state write failed after retries (record=${record.id}, reason=${reasonDesc}); ` +
+        `record stays running on disk — boot orphan recovery will finalize it`,
+    );
+    deps.pi?.appendEntry?.("subagent:state-write-failed", {
+      id: record.id,
+      status,
+      closedReason: reasonDesc,
+    });
   }
 
-  // ── Step 3: finalized + cleanup + aliveMarker（全部先执行，幂等）──
-  // [Critical] 清理必须在 manifest 写入之前：worktree cleanup / finalized marker / aliveMarker
-  //   都是幂等且不可跳过的副作用。绝不能因 manifest 写失败而跳过 worktree cleanup
-  //   （否则 worktree 泄漏）。各件独立 try/catch，互不阻断。
-  writeFinalizedOrTombstone(record, closedReason);
+  // ── Step 3b: worktree cleanup（best-effort，不可被终态写失败跳过）──
   await cleanupWorktreeIfBound(deps, record);
-  removeAliveMarkerIfPresent(record);
 
   // pending-notifications：终态注销（只记 registry 状态，通知由 BgNotifier 发）
   // [W4 发射点枚举归属①] 注销合法发射点枚举（设计 D2）第 ① 处：subagent record
-  // 终态化（finalizeRecord 路径，含监督器放弃）。其余合法发射点：② chatMode 轮末
-  // idle（doFinalizeRoundToIdle，本文件下方）；③ workflow run 终态迁移
-  // （transition("done") 路径）；④ 监督器显式放弃（走本路径，终态化+注销同批）；
+  // 终态化（finalizeRecord 路径，含监督器放弃）。其余合法发射点：② = store
+  // .markRoundIdle 簿记⑧（U5 收口后编排层无直发；setPendingUnregister →
+  // emitPendingUnregister 唯一发射）；③ workflow run 终态迁移
+  //（transition("done") 路径）；④ 监督器显式放弃（走本路径，终态化+注销同批）；
   // ⑤ 注册对账 sweep 补发（round-supervisor/reconcile-sweep.ts）。进程退出本身
   // 永远不是注销理由（subagent-service disposeAllRecords 的 emit 属①——其同批
   // completeRecord+archive 终态化）。
   deps.emitUnregister(record.id, status);
 
   // [F-5 修复] 宿主侧终态收口钩子（chat 轮路由注销的单一汇聚点，见 FinalizeDeps
-  // .onFinalized 注释）。fire-and-forget：钩子失败不阻断 manifest 收尾（闭包内自查）。
+  // .onFinalized 注释）。fire-and-forget：钩子失败不阻断收尾（闭包内自查）。
   try {
     deps.onFinalized?.(record.id);
   } catch (err) {
     bestEffort(err, "onFinalized hook (finalizeRecord)");
   }
-
-  // ── Step 4 (last): manifest 持久化（best-effort，不阻断、不 throw）──
-  await writeManifestBestEffort(deps, record);
 }
 
+/**
+ * [H1 U2 / D7] 轮终处置的 outcome 入参（判别联合）。
+ *
+ * 命名与协议 AgentOutcome 同名不同物（设计 D7 v6：kind 判别联合消歧）——
+ * kind 判别轮终分流：成功轮正文来源 = Continuation 成功分支的 content（协议
+ * AgentOutcome.content 映射产物）；失败轮 reason = 失败原因原文。
+ */
+export type RoundSettlementOutcome =
+  | { kind: "success"; content: string }
+  | { kind: "failed"; reason: string };
+
 /**
  * 对话模式轮次完成收尾：record 进 idle 态（非终态化，等待续聊）。
  *
- * 与 doFinalizeRecord 的关键区别（M2-A idle 语义）：
+ * [U2a/B5] 轮终簿记全集（①-⑨）归口 store.markRoundIdle——本方法瘦身为编排薄壳。
+ * 簿记语义（细节与 result 写入规则见 record-store.markRoundIdle 方法头）：
  *   - 不调 completeRecord（record 不冻结，保留 turns[] 等运行时状态供续聊累积）
  *   - 不调 store.archive（record 留内存，getMutable 可查、list 可见）
  *   - 不 cleanup worktree（保留对话模式工作目录）
- *   - 不写 manifest：轮终回 running-resumable 非终态化，本方法无终态快照可写——
- *     manifest 是 sa- id 反查索引（最新已知快照），sync 批成员的先行快照由落标出口
- *     补写（subagent-service appendBatchFinalizedEntry），此处不重复
- *   - 删 .alive marker（进程已 SIGTERM 回收，不再是活进程）
- *   - emitUnregister（进程已死，从 pending 活跃后代差集移除；record 留内存不 archive）
- *
- * MF-2：设 record.result = result.text（否则 notifier idle 回复正文恒为 "(empty)"，
- *   G1/G2 多轮回复送达不成立）。失败轮次（result.success=false，MF-6 回退 idle 路径）
- *   error 优先于 text：collectResult 恒带 getFullText 全量正文，text 优先会把失败的
- *   恢复指引覆盖成轮内旧正文（Gate B S-B-1 实测：settled watchdog kill 后宿主收到
- *   成功形态通知，无从得知挂死与恢复方式）。
- *
- * 状态：record.status = "idle"（覆盖 tryTransition 设的 done/failed），record.round += 1。
- * 各步骤 best-effort 互不阻断（参照 doFinalizeRecord 的 bestEffort 用法）。
+ *   - 不写 manifest（轮终回 running-resumable 非终态化，无终态快照可写）
+ *   - **[B5/D3a] `.alive` 不再删除**——写权声明跨轮延续（release = 终态原语或
+ *     idle-GC 归档两出口；轮终 record 仍 resumable、随时续聊 spawn 写同一
+ *     sessionFile，删则轮后跨进程防御空窗）
+ *   - [A3] 终态簿记已冻结（endedAt 已设）的调用由 store 内硬断言 fail-fast
+ *     （复活终态的调用即 bug——S7 防御），throw 先于 store 簿记⑧的注销发射
  *
- * @param deps 与 doFinalizeRecord 同源（从 SubagentService 注入）
- * @param result 本轮 AgentResult（MF-2：result.text 写入 record.result 供 notifier idle 回复）
+ * @throws Error record 终态簿记已冻结（completeRecord 已跑）仍被调用（store.markRoundIdle
+ *   内硬断言——冻结权威判据 = endedAt 已设，写点枚举与两构造性调用面论证见其方法头）。
  */
 export async function doFinalizeRoundToIdle(
   deps: FinalizeDeps,
   record: ExecutionRecord,
-  result: AgentResult,
+  outcome: RoundSettlementOutcome,
 ): Promise<void> {
-  // MF-2：设 record.result 供 notifier idle 回复正文（否则恒 "(empty)"，G1/G2 不成立）。
-  // [T2-③ / LC-1] 失败轮 error 优先：collectResult 恒带 getFullText 全量正文（即使
-  // success=false），text 优先会把 watchdog 等失败的恢复指引覆盖成轮内正文（半成品 /
-  // 回补值），宿主无从得知失败与恢复方式（S-B-1 首轮 settled watchdog 实测）。
-  // [R2-1] 轮终写点恒写非空：one-shot 空文本成功完成（collectResult getFullText 返回 ""、
-  // success=true、真实可达，本写点被 subagent-service runAndFinalize 的成功分支共用）首轮
-  // result 前值 undefined，兜底补 "(empty)" 占位——措辞与 notifier buildLlmContent 的
-  // `record.result ?? "(empty)"` 兜底同款，通知文案逐字节不变（[增量 G2] G4 取舍保持）。
-  // 轮终信号优先：record.result 非 undefined 是 renderer hasRunning 排除「轮终
-  // running-resumable」的判据（shared SubagentRecord.result 契约），保持 undefined 会让
-  // 完成注入后末位 turn 永久「工作中」。续轮（前值存在）沿用前值：one-shot 无增量语义，
-  // record.result = 该 subagent 最终输出。chatMode 空增量轮 → 固定占位
-  // "(no output this round)"（D5：增量语义下沿用旧 record.result = 上一轮增量，本轮通知
-  // 正文 = 上一轮内容，父 agent 误读为原样重复回复）。
-  let nextResult: string | undefined;
-  if (result.error && (!result.success || !result.text)) {
-    nextResult = `round did not complete: ${result.error}`;
-  } else if (result.text) {
-    nextResult = result.text;
-  } else if (record.chatMode) {
-    nextResult = "(no output this round)";
-  } else {
-    nextResult = record.result ?? "(empty)";
-  }
-  record.result = nextResult;
-
-  // 删 .alive marker（进程已 SIGTERM 回收）。
-  // sessionFile 窗口期可能 undefined（极少——对话模式轮次完成意味着 session 已跑过），
-  // 缺失时跳过但仍设内存 idle（重启后磁盘重建会落到 crashed，边界可接受）。
-  if (record.sessionFile) {
-    try {
-      removeAliveMarker(record.sessionFile);
-    } catch (err) {
-      bestEffort(err, "removeAliveMarker (doFinalizeRoundToIdle)");
-    }
-  }
-
-  // pending-notifications：进程已死，从活跃后代差集移除（record 留内存不 archive，
-  // v4 B-1：record 现为 running-resumable，但 pending 注册的是进程活跃性，进程死了需注销）。
-  deps.emitUnregister(record.id, "running");
-
-  // 状态机（v4 B-1）：record 保持 running（旧 idle 折入 running，覆盖 tryTransition 设的 closed，
-  // 可冷路径 resume），轮次计数 +1。idleSince 时间戳独立保留供 GC 判据。
-  // [S10] closedReason 同步清除：调用方（runAndFinalize catch / MF-6 分支）先 tryTransition
-  // 设了 closed+closedReason 再回退 running——不清则 "gc"/"cancelled" 残留在 running record 上，
-  // 泄漏进 list 投影与后续 notify 载荷（toNotifyRecord 透传 record.closedReason），让一个
-  // 活跃 record 看起来像已被某原因关闭过。
-  record.status = "running";
-  record.closedReason = undefined;
-  record.round = (record.round ?? 0) + 1;
-  record.idleSince = Date.now();
-  // 执行态信号（residual-fixes）：轮终回 running-resumable = 无活进程驱动（idle timer
-  // 回收/保活等待续聊），GUI 侧据此判 waiting（非 streaming）。冷路径续轮（进程启动）清除。
-  record.resumable = true;
-
-  // W16 [D4]：轮终回 running-resumable 是类外状态写点（record 留内存不走 archive），
-  // 显式上报迁移——entry 携带新 round 与本轮 result，pi 文件的重建源不滞后。
-  deps.store.reportRecordTransition(record);
+  // 簿记①-⑨归口（含 A3 硬断言与⑨ reportRecordTransition entry 上报）。
+  // 返回 false = record 不在 store 内存（debug 留痕，无副作用）——两构造性调用面
+  //（Continuation 轮末分流 / settleOneShotOutcome SP-5）的 record 均在内存，false 即
+  // 调用方 bug，留痕足够。
+  deps.store.markRoundIdle(record.id, outcome);
 
-  // [review 修复] 已删除残留 pendingMessages 的 redeliverPending 补投段（MF-1 消费
-  // 确认安全网）：三段消费链随 deliverToRunning 一并移除，本段不可达。
+  // [W4 发射点②] pending 注销（进程已死，从活跃后代差集移除）已随 U5 收口进
+  // markRoundIdle 簿记⑧——SubagentService 构造点经 setPendingUnregister 注入
+  // notifyHost.emitPendingUnregister，本编排层不再双轨重复发射。
 }

package/src/execution/idle-gc.ts

@@ -54,8 +54,10 @@ export interface WorkflowRunGcStore {
  * 启动 idle record GC 定时器，返回 stop 函数（清理 interval；幂等）。
  * 每个扫描周期：
  *  - record 面：对 store 内全部 active record 中 resumable 的，锚点（idleSince
- *    优先，缺失回退 startedAt——[W4 锚扩展]）超过 IDLE_TTL_MS 的归档。archive
- *    单条失败不阻断其余（bestEffort 留痕）。**只归档不补注销**（见文件头注）。
+ *    优先，缺失回退 startedAt——[W4 锚扩展]）超过 IDLE_TTL_MS 的归档
+ *    （[U2b] markIdleArchived：archive 先 + `.alive` release 后——归档 = 放弃持有
+ *    即放弃写权声明，D3a release 出口②）。单条失败不阻断其余（bestEffort 留痕）。
+ *    **只归档不补注销**（见文件头注）。
  *  - workflow 面（注入 workflowRuns 时）：running 且 meta.startedAt 超
  *    IDLE_TTL_MS 的 run 终态化归档（transition + save），单 run 失败不阻断。
  *
@@ -83,7 +85,11 @@ export function startIdleGc(store: RecordStore, workflowRuns?: WorkflowRunGcStor
           `[subagents] GC: archiving idle record ${record.id} (idle for ${Math.round(age / MS_PER_DAY)}d)`,
         );
         try {
-          store.archive(record);
+          // [U2b / D3a release 出口②] 归口 markIdleArchived：store.archive 先、`.alive`
+          // release 后（写序在 store 内部——归档 = 放弃持有 = 放弃写权声明，残留声明
+          // 会把 idle 归档后的预期通道 fork-from/新 start 拦死至宿主退出，纯成本零防御
+          // 收益；归档 record 后续被接管时统一 acquireWriteLease 重新声明）。
+          store.markIdleArchived(record);
         } catch (err) {
           bestEffort(err, `GC archive record ${record.id}`);
         }