@zhushanwen/subagent-core 0.8.0 → 0.9.0

package/src/execution/relay-env.ts

@@ -1,9 +1,14 @@
 // src/execution/relay-env.ts
 //
-// relay 通道 env 名与协议常量的 re-export shim——单源在
+// relay 通道 env 名与协议常量的 **semver 子入口载体**——单源在
 // @zhushanwen/subagent-engine-sdk（round1-reuse R9 跨进程契约副本收编；core → SDK
-// 边界正向合法）。本文件保持路径不变以保住 package.json exports 的 ./relay-env
-// 子入口（semver 面：runtime/extension 消费方 import specifier 不变）。
+// 边界正向合法）。
+//
+// [L5 收窄] 本文件不再是 core 内部或引擎包的消费路径：core 内消费方（stream-sink /
+// d8-compat）与 pi-subagent-cli 已直连 SDK，pi 包的 relay-env shim 已删除。保留本
+// 文件的唯一理由 = package.json exports 的 ./relay-env 子入口（semver 面：runtime 与
+// subagent-workflow 经它消费，两包当前不依赖 SDK——删本文件须同时给两包加 SDK 依赖
+// 并改 import specifier，属独立的依赖面变更，未随 L5 执行）。
 // 代理脚本 relay.mjs 仍为内嵌镜像（零依赖脚本不能 import workspace 包），
 // 镜像一致性由 conformance relay 变体断言锁定。
 

package/src/execution/round-supervisor/domain.ts

@@ -27,16 +27,28 @@ export type SupervisorDomain =
   /** run 域一次性任务（非 chatMode record）——监督域主体。 */
   | "run"
   /** conversation/chat 形态（record.chatMode）——豁免，现状机制管辖。 */
-  | "conversation";
+  | "conversation"
+  /**
+   * [H2 W2] workflow 脚本 agent() record（origin="workflow"）——adopt 链豁免域：
+   * 引擎死亡即 run 失败即 record 终态化（service 分诊两处豁免），无脚本可回的
+   * resumable 等待无意义（adopt 链「唤醒→guidance→2h 看门狗→giveUp」全程死路，
+   * 还制造 2h 挂账）。豁免只覆盖 adopt 接管入口（adoptOnProcessDeath / boot 分区
+   * 重认领）——运行期记账（noteRunStarted/noteRunEnded）与 reconcile-sweep 对账
+   * 对 workflow record 照旧（H1 D8「非 chatMode 全量纳管」不因本豁免收窄）。
+   */
+  | "workflow";
 
 /**
  * 域分类（裁决表 conversation 行「任何触发不入监督域」的判定锚）。
+ * record.origin === "workflow" → workflow（adopt 链豁免域，[H2 W2]）；否则
  * record.chatMode === true → conversation（豁免）；否则 → run 域。
- * （workflow 域 resumable run 的活性收口 = kill-9 恢复链 + idle-gc startedAt 锚
- * 归档 + sweep 对账——workflow run 不在 RecordStore，其注册对账按 type=workflow
+ * （workflow run 不在 RecordStore，其注册对账按 type=workflow
  * 保守跳过，见 reconcile-sweep.ts。）
  */
-export function classifySupervisorDomain(record: Pick<ExecutionRecord, "chatMode">): SupervisorDomain {
+export function classifySupervisorDomain(
+  record: Pick<ExecutionRecord, "chatMode" | "origin">,
+): SupervisorDomain {
+  if (record.origin === "workflow") return "workflow";
   return record.chatMode === true ? "conversation" : "run";
 }
 
@@ -66,7 +78,7 @@ export function isAwakeWarrantedShape(
 /**
  * boot 分区「already-resumable-idle」重认领谓词（与裁决表同源——设计 D4 连带面 2
  * ②「启动扫描 resumable 且无进程驱动且非 conversation 形态」的单一权威实现；
- * cold-resurrect.ts 的 message 冷查链不承载启动扫描，本谓词即其「cold-resurrect
+ * cold-lookup.ts 的 message 冷查链不承载启动扫描，本谓词即其「cold-resurrect
  * 扩展」落点，record-store 孤儿恢复的保留分支与 supervisor.bootPartition 共同消费
  * 同一判据形态）。
  *

package/src/execution/round-supervisor/service-binding.test.ts

@@ -10,11 +10,12 @@
 //        分支，替身 getMutable 受控注入驱动契约）；
 //      - finalizeClosed 异常 best-effort（不向上抛、终止通知仍发）；
 //      - superseded：errorText 带替代 id、不发终止通知；
-//      - 磁盘态（boot 重认领后看门狗到期）：writeFinalized sidecar 落盘 +
-//        reportSubagentRecord 终态 entry（closed/gc/endedAt/error）、无 pi 通知；
-//      - 磁盘态无 sessionFile / writeFinalized 抛错（sidecar catch）/ 双 miss 收尾
-//        竞争 / reportSubagentRecord 抛错（entry catch，须先经 boot 重认领武装
-//        看门狗——无候选则 giveUp 不执行，用例空转）。
+//      - 磁盘态（boot 重认领后看门狗到期）：[U2b] store.markFinalized 归口——
+//        `.state` sidecar + subagent-record 终态 entry（closed/gc/endedAt/error）+
+//        `.alive` release 一体落齐、无 pi 通知；
+//      - 磁盘态无 sessionFile / writeFinalizedState 返回 false（§3.4 零持久化
+//        副作用 + 响亮 entry）/ 双 miss 收尾竞争 / entry 面抛错（appendEntry catch，
+//        须先经 boot 重认领武装看门狗——无候选则 giveUp 不执行，用例空转）。
 //   2. runPendingReconcileSweepForService 的 lookupRecordState 闭包 subagent 判据
 //      （workflow 判据回归钉在 workflow-state-root.test.ts，此处补 subagent 两方向：
 //      活跃 record 不被 sweep 注销 + 终态/missing 差集补发注销）。
@@ -32,11 +33,11 @@ import * as path from "node:path";
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-import { COLD_LOOKUP_SCAN_LIMIT } from "../cold-resurrect.ts";
-import * as finalizedMarker from "../finalized-marker.ts";
+import { COLD_LOOKUP_SCAN_LIMIT } from "../cold-lookup.ts";
+import * as stateMarker from "../state-marker.ts";
 import type { PiLike } from "../notify-host.ts";
-import type { RecordStore } from "../record-store.ts";
-import type { ExecutionRecord, SubagentRecord } from "../types.ts";
+import { RecordStore } from "../record-store.ts";
+import type { ClosedReason, ExecutionRecord, SubagentRecord } from "../types.ts";
 import { RoundSupervisor, ROUND_SUPERVISOR_WATCHDOG_DEFAULT_MS, type SupervisorCandidateRecord } from "./index.ts";
 import {
   createRoundSupervisorForService,
@@ -44,13 +45,13 @@ import {
   type RoundSupervisorBinding,
 } from "./service-binding.ts";
 
-// writeFinalized 实装自吞 IO 错（内部 try/catch，finalized-marker.ts），give-up
-// sidecar 的 catch（service-binding.ts:164）是防御分支——真实 ENOENT 无法驱动，
-// 仅本文件的 sidecar 抛错用例经模块替身注入抛错；默认委托真实实现，相邻用例行为
-// 不变（vi.spyOn 对跨模块具名导入绑定不可拦截，必须走 vi.mock）。
-vi.mock("../finalized-marker.ts", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../finalized-marker.ts")>();
-  return { ...actual, writeFinalized: vi.fn(actual.writeFinalized) };
+// writeFinalizedState 实装（U1 后）为响亮重试 + 失败返回 false（不抛——state-marker
+// 内部 3 次退避重试），give-up 的 §3.4 false 分支真实磁盘故障无法稳定驱动，仅本文件
+// 的「重试耗尽」用例经模块替身注入 false 返回；默认委托真实实现，相邻用例行为不变
+//（vi.spyOn 对跨模块具名导入绑定不可拦截，必须走 vi.mock）。
+vi.mock("../state-marker.ts", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../state-marker.ts")>();
+  return { ...actual, writeFinalizedState: vi.fn(actual.writeFinalizedState) };
 });
 
 // ============================================================
@@ -92,6 +93,8 @@ function makePi(): TestPi {
 
 interface StoreHarness {
   store: RecordStore;
+  /** 真实 RecordStore（磁盘态放弃分支 markFinalized 的委托目标——终态四面真写）。 */
+  realStore: RecordStore;
   memory: Map<string, ExecutionRecord>;
   disk: Map<string, SubagentRecord>;
   /** collectRecords 返回的候选（替身投影；默认从 memory 生成）。 */
@@ -100,14 +103,17 @@ interface StoreHarness {
   reported: SubagentRecord[];
 }
 
-/** duck-typed RecordStore 替身（service-binding 只消费 getMutable / findLightById /
- *  collectRecords / reportSubagentRecord 四个读写点）。 */
+/** duck-typed RecordStore 替身（service-binding 消费 getMutable / findLightById /
+ *  collectRecords / reportSubagentRecord / markFinalized 五个读写点——markFinalized
+ *  [U2b] 委托真实 store（`.state`/entry/manifest/marker release 真写），其余读点走
+ *  替身 map（真实磁盘发现需 session 文件扫描，与本文件断言面无关）。 */
 function makeStore(): StoreHarness {
   const memory = new Map<string, ExecutionRecord>();
   const disk = new Map<string, SubagentRecord>();
   const collectResult: SupervisorCandidateRecord[] = [];
   const collectCalls: StoreHarness["collectCalls"] = [];
   const reported: SubagentRecord[] = [];
+  const realStore = new RecordStore(path.join(tmpDir, "sessions"));
   const store = {
     getMutable: (id: string) => memory.get(id),
     findLightById: (id: string) => disk.get(id),
@@ -118,8 +124,10 @@ function makeStore(): StoreHarness {
     reportSubagentRecord: (record: SubagentRecord) => {
       reported.push(record);
     },
+    markFinalized: (record: ExecutionRecord, closedReason?: ClosedReason) =>
+      realStore.markFinalized(record, closedReason),
   };
-  return { store: store as unknown as RecordStore, memory, disk, collectResult, collectCalls, reported };
+  return { store: store as unknown as RecordStore, realStore, memory, disk, collectResult, collectCalls, reported };
 }
 
 interface BindingHarness {
@@ -329,6 +337,9 @@ describe("supervisorGiveUp 内存态（watchdog-expired / superseded / CAS）",
 describe("supervisorGiveUp 磁盘态（boot 重认领后看门狗到期）", () => {
   function makeDiskBinding(diskRecord: SubagentRecord): BindingHarness {
     const h = makeBinding({ sessionFile });
+    // [U2b] 终态 entry/manifest 面 = markFinalized 经真实 store 落 pi.appendEntry
+    //（archive 面），绑定 pi 注入真实 store。
+    h.store.realStore.setPi(h.pi ?? null);
     h.store.disk.set(diskRecord.id, diskRecord);
     // boot 分区候选（真实 collectRecords 的 running 投影形态）
     h.store.collectResult.push({
@@ -341,37 +352,54 @@ describe("supervisorGiveUp 磁盘态（boot 重认领后看门狗到期）", ()
     return h;
   }
 
-  it("writeFinalized sidecar 落盘 + reportSubagentRecord 终态 entry（closed/gc/endedAt/error）；磁盘态不发终止通知", async () => {
+  /** pi.appended 中 customType=subagent-record 的终态 entry 载荷。 */
+  function subagentEntries(pi: ReturnType<typeof makePi> | null): Array<Record<string, unknown>> {
+    return (pi?.appended ?? [])
+      .filter((a) => a.customType === "subagent-record")
+      .map((a) => a.data as Record<string, unknown>);
+  }
+
+  it("markFinalized 归口：.state sidecar + subagent-record 终态 entry（closed/gc/endedAt/error）+ .alive release 一体落齐；磁盘态不发终止通知", async () => {
     const diskRecord = makeDiskRecord(sessionFile);
     const h = makeDiskBinding(diskRecord);
+    // 持有期声明在位（boot 重认领形态——磁盘 running record 携带写权声明）。
+    h.store.realStore.acquireWriteLease(sessionFile, diskRecord.id);
+    expect(fs.existsSync(`${sessionFile}.alive`)).toBe(true);
     const supervisor = createRoundSupervisorForService(h.binding);
 
     // 纳管经磁盘兜底视图（内存 Map 空）——boot 分区重认领形态
     supervisor.bootPartition();
     await vi.advanceTimersByTimeAsync(ROUND_SUPERVISOR_WATCHDOG_DEFAULT_MS + 1);
 
-    // sidecar：sessionFile 旁 .finalized 内容 = "gc"；finalizeClosed 不适用（无内存 record）
-    expect(fs.readFileSync(`${sessionFile}.finalized`, "utf-8")).toBe("gc");
+    // sidecar：sessionFile 旁 .state 内容 = {status:finalized, reason:"gc"}；finalizeClosed 不适用（无内存 record）
+    expect(JSON.parse(fs.readFileSync(`${sessionFile}.state`, "utf-8"))).toEqual({
+      status: "finalized",
+      reason: "gc",
+    });
     expect(h.finalizeClosed).not.toHaveBeenCalled();
 
-    // 终态 entry 落盘（reportSubagentRecord）：磁盘 record + 终态语义位
-    expect(h.store.reported).toHaveLength(1);
-    const reported = h.store.reported[0]!;
-    expect(reported).toMatchObject({
+    // 终态 entry 落盘（markFinalized → archive → pi.appendEntry）：磁盘 record + 终态语义位
+    const entries = subagentEntries(h.pi);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]).toMatchObject({
       id: "bg-disk",
       status: "closed",
       closedReason: "gc",
       endedAt: expect.any(Number),
       error: expect.stringContaining("safe to re-dispatch"),
     });
-    expect(reported.error).not.toContain("superseded");
+    expect(String(entries[0]!["error"])).not.toContain("superseded");
+
+    // [D3a release 出口①] 终态原语删写权声明——磁盘态放弃同样释放（残留声明会
+    // 误拦异宿主接管）。
+    expect(fs.existsSync(`${sessionFile}.alive`)).toBe(false);
 
     // 磁盘态分支无终止通知（sent 仅 boot 重认领的 decision guidance 一条）
     expect(h.pi?.sent).toHaveLength(1);
     expect(h.pi?.sent.every((s) => !s.message.content.includes(TERMINATION_NOTICE_MARK))).toBe(true);
   });
 
-  it("磁盘态无 sessionFile → 跳过 sidecar，仍 reportSubagentRecord 终态化", async () => {
+  it("磁盘态无 sessionFile → 跳过 sidecar，仍终态 entry（markFinalized 无锚点降级路径）", async () => {
     const diskRecord = makeDiskRecord(undefined);
     const h = makeDiskBinding(diskRecord);
     const supervisor = createRoundSupervisorForService(h.binding);
@@ -379,19 +407,20 @@ describe("supervisorGiveUp 磁盘态（boot 重认领后看门狗到期）", ()
     supervisor.bootPartition();
     await vi.advanceTimersByTimeAsync(ROUND_SUPERVISOR_WATCHDOG_DEFAULT_MS + 1);
 
-    expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(false);
-    expect(h.store.reported).toHaveLength(1);
-    expect(h.store.reported[0]?.status).toBe("closed");
+    expect(fs.existsSync(`${sessionFile}.state`)).toBe(false);
+    const entries = subagentEntries(h.pi);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]).toMatchObject({ id: "bg-disk", status: "closed", closedReason: "gc" });
   });
 
-  it("reportSubagentRecord 抛错 → best-effort 吞掉不向上抛，sidecar 照常落盘", async () => {
+  it("entry 面抛错（pi.appendEntry 炸）→ best-effort 吞掉不向上抛，sidecar 照常落盘", async () => {
     // 候选入 collectResult → boot 重认领（readopted）武装看门狗——没有这一步
     // listCandidateRecords 返回空、giveUp 永不执行、entry catch 不可达（MF-R2-2）。
     const diskRecord = makeDiskRecord(sessionFile);
     const h = makeDiskBinding(diskRecord);
-    h.store.store.reportSubagentRecord = () => {
+    (h.pi!.appendEntry as ReturnType<typeof vi.fn>).mockImplementation(() => {
       throw new Error("entry write exploded");
-    };
+    });
     const supervisor = createRoundSupervisorForService(h.binding);
 
     const { readopted } = supervisor.bootPartition();
@@ -400,39 +429,46 @@ describe("supervisorGiveUp 磁盘态（boot 重认领后看门狗到期）", ()
     await vi.advanceTimersByTimeAsync(ROUND_SUPERVISOR_WATCHDOG_DEFAULT_MS + 1);
 
     // sidecar 与终态 entry 是两段独立 best-effort：entry 抛错不回滚已落 sidecar
-    expect(fs.readFileSync(`${sessionFile}.finalized`, "utf-8")).toBe("gc");
-    // 终态 entry 写入抛错被 give-up entry catch 吞掉 → reported 空
-    expect(h.store.reported).toHaveLength(0);
+    //（markFinalized 写序 = .state 先、archive/entry 后，D8）。
+    expect(JSON.parse(fs.readFileSync(`${sessionFile}.state`, "utf-8"))).toEqual({
+      status: "finalized",
+      reason: "gc",
+    });
+    expect(subagentEntries(h.pi)).toHaveLength(0);
   });
 
-  it("writeFinalized 抛错 → best-effort 吞掉，终态 entry 照常落盘", async () => {
-    const diskRecord = makeDiskRecord(path.join(tmpDir, "gone-dir", "s.jsonl"));
+  it("writeFinalizedState 返回 false（重试耗尽）→ 零持久化副作用：无终态 entry、无 state-write-failed 之外的写入面、响亮 entry 上报", async () => {
+    const diskRecord = makeDiskRecord(sessionFile);
     const h = makeDiskBinding(diskRecord);
     const supervisor = createRoundSupervisorForService(h.binding);
-    // 模块替身注入抛错（见文件头 vi.mock 注释）；finally 恢复委托真实实现。
-    const actual = await vi.importActual<typeof import("../finalized-marker.ts")>(
-      "../finalized-marker.ts",
+    // 模块替身注入失败返回（U1 后 writeFinalizedState 不抛——重试耗尽返回 false）；
+    // finally 恢复委托真实实现。
+    const actual = await vi.importActual<typeof import("../state-marker.ts")>(
+      "../state-marker.ts",
     );
-    const writeSpy = vi.mocked(finalizedMarker.writeFinalized);
-    writeSpy.mockImplementation(() => {
-      throw new Error("sidecar write exploded");
-    });
+    const writeSpy = vi.mocked(stateMarker.writeFinalizedState);
+    writeSpy.mockImplementation(() => false);
     try {
       supervisor.bootPartition();
       await vi.advanceTimersByTimeAsync(ROUND_SUPERVISOR_WATCHDOG_DEFAULT_MS + 1);
     } finally {
-      writeSpy.mockImplementation(actual.writeFinalized);
+      writeSpy.mockImplementation(actual.writeFinalizedState);
     }
 
-    // 替身确实被 giveUp 消费（否则异常被 writeFinalized 实装自吞，用例假绿）
+    // 替身确实被 giveUp 消费（否则用例假绿）
     expect(writeSpy).toHaveBeenCalled();
-    expect(fs.existsSync(`${diskRecord.sessionFile}.finalized`)).toBe(false);
-    expect(h.store.reported).toHaveLength(1);
-    expect(h.store.reported[0]).toMatchObject({ id: diskRecord.id, status: "closed", closedReason: "gc" });
+    // [§3.4] record 留 running：.state 未落 + 无终态 entry（零持久化副作用）
+    expect(fs.existsSync(`${sessionFile}.state`)).toBe(false);
+    expect(subagentEntries(h.pi)).toHaveLength(0);
+    // 响亮上报腿：subagent:state-write-failed entry（GUI 通知面，对齐 doFinalizeRecord）
+    const failNotices = (h.pi?.appended ?? []).filter((a) => a.customType === "subagent:state-write-failed");
+    expect(failNotices).toHaveLength(1);
+    expect(failNotices[0]?.data).toMatchObject({ id: diskRecord.id, status: "closed", closedReason: "gc" });
   });
 
   it("giveUp 执行时 record 已被 archive（内存移除 + 磁盘无 light）→ 双 miss 直接 return，零副作用", async () => {
     const h = makeBinding({ sessionFile });
+    h.store.realStore.setPi(h.pi ?? null);
     const rec = makeRecord();
     h.store.memory.set("bg-1", rec);
     // 视图检查（内存 running）之后、giveUp 磁盘兜底之前被 archive 的收尾竞争替身投影
@@ -451,8 +487,8 @@ describe("supervisorGiveUp 磁盘态（boot 重认领后看门狗到期）", ()
     expect(h.finalizeClosed).not.toHaveBeenCalled();
     expect(h.pi?.sent).toHaveLength(2); // 纳管期通知照常，终止通知不发（零通知放弃）
     expect(h.pi?.sent.every((s) => !s.message.content.includes(TERMINATION_NOTICE_MARK))).toBe(true);
-    expect(h.store.reported).toHaveLength(0);
-    expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(false);
+    expect(subagentEntries(h.pi)).toHaveLength(0);
+    expect(fs.existsSync(`${sessionFile}.state`)).toBe(false);
   });
 });
 

package/src/execution/round-supervisor/service-binding.ts

@@ -10,10 +10,10 @@
 // 全部依赖经 RoundSupervisorBinding 惰性闭包注入（session 级状态运行时可变——
 // 对齐 notify-host.ts createNotifyHost 的 deps 惰性求值先例）。
 
+import { getLogger } from "../../core/logger.ts";
 import { bestEffort } from "../best-effort.ts";
-import { COLD_LOOKUP_SCAN_LIMIT } from "../cold-resurrect.ts";
-import { tryTransition } from "../execution-record.ts";
-import { writeFinalized } from "../finalized-marker.ts";
+import { COLD_LOOKUP_SCAN_LIMIT } from "../cold-lookup.ts";
+import { createRecord, tryTransition } from "../execution-record.ts";
 import { hasLiveProcessHandle } from "../lifecycle-predicates.ts";
 import { FileRunStore } from "../../orchestration/file-run-store.ts";
 import { resolvePiWorkflowStateDir } from "../workflow-state-root.ts";
@@ -28,6 +28,8 @@ import {
   type SupervisorRecordView,
 } from "./index.ts";
 
+const logger = getLogger("subagents");
+
 /** 绑定面（SubagentService 供给；全部惰性——见文件头注）。 */
 export interface RoundSupervisorBinding {
   getStore(): RecordStore;
@@ -63,6 +65,7 @@ function supervisorRecordView(binding: RoundSupervisorBinding, id: string): Supe
       resumable: memory.resumable === true,
       hasResult: memory.result !== undefined,
       chatMode: memory.chatMode === true,
+      origin: memory.origin,
       rootSessionId: memory.rootSessionId,
       agent: memory.agent,
       slug: memory.slug,
@@ -78,6 +81,7 @@ function supervisorRecordView(binding: RoundSupervisorBinding, id: string): Supe
     resumable: disk.resumable === true,
     hasResult: disk.result !== undefined,
     chatMode: disk.chatMode === true,
+    origin: disk.origin,
     rootSessionId: disk.rootSessionId,
     agent: disk.agent,
     slug: disk.slug,
@@ -86,7 +90,13 @@ function supervisorRecordView(binding: RoundSupervisorBinding, id: string): Supe
   };
 }
 
-/** 本 root session 的 running record 候选（内存 ∪ 磁盘重建投影）。 */
+/** 本 root session 的 running record 候选（内存 ∪ 磁盘重建投影）。
+ *  [H2 W2] origin 透传——superseded 对账的 workflow 候选豁免判据（supervisor.evaluate
+ *  消费面，W1 已把 origin 投影进 SubagentRecord）。【双防注记 I2】本处的 collectRecords
+ *  不传 includeWorkflow（缺省过滤 workflow origin），而 supervisor.evaluate 的 superseded
+ *  对账另有 workflow 候选豁免判据——后者实为死判据：workflow 候选在本查询已结构性
+ *  豁免（缺省过滤），判据永不命中。刻意保留作防御纵深：若未来本查询改传 includeWorkflow
+ *  或 store 侧过滤语义变更，evaluate 侧判据立即接管，行为不回退。 */
 function supervisorCandidates(binding: RoundSupervisorBinding): SupervisorCandidateRecord[] {
   const rootFilter = binding.getSessionRootId() ?? undefined;
   return binding
@@ -98,6 +108,7 @@ function supervisorCandidates(binding: RoundSupervisorBinding): SupervisorCandid
       agent: r.agent,
       slug: r.slug,
       startedAt: r.startedAt,
+      origin: r.origin,
     }));
 }
 
@@ -109,9 +120,12 @@ function supervisorCandidates(binding: RoundSupervisorBinding): SupervisorCandid
  *    替代通知已由监督器先行发出。boot 直断不经本函数（孤儿恢复层直断 + in-flight
  *    的重启中断 error 语义由 finalizeOrphanRecord 落位，见 supervisor.bootPartition 头注）。
  *  - 磁盘态（内存无 + findLightById 命中，boot 重认领后看门狗到期的形态）：终态
- *    entry 落盘（reportSubagentRecord）+ finalized sidecar（best-effort，对齐孤儿
- *    恢复形态）——不走 finalizeRecord（无内存 record，archive/CAS 不适用），其注销
- *    由对账 sweep（发射点⑤「record 终态 → 差集补发」）收口。
+ *    写面归口 store.markFinalized（[U2b/G1 收口] `.state` writeSync + entry/archive +
+ *    manifest + `.alive` release，D8 写序——原 store 外终态 sidecar 直写 + 终态
+ *    entry 直写两段独立 best-effort 直写点消灭；`.state` 重试耗尽返回
+ *    false = 零持久化副作用，record 留 running 由 boot 孤儿恢复终态化承接，§3.4）
+ *    ——不走 finalizeRecord（无内存 record，archive/CAS 不适用），其注销由对账
+ *    sweep（发射点⑤「record 终态 → 差集补发」）收口。
  */
 async function supervisorGiveUp(
   binding: RoundSupervisorBinding,
@@ -157,21 +171,57 @@ async function supervisorGiveUp(
   // 磁盘态分支（boot 重认领后的放弃——record 不在内存）。
   const disk = store.findLightById(recordId);
   if (disk === undefined) return;
-  if (disk.sessionFile) {
-    try {
-      writeFinalized(disk.sessionFile, "gc");
-    } catch (err) {
-      bestEffort(err, `round supervisor give-up sidecar (${recordId})`);
-    }
-  }
+  // 终态投影 record 由磁盘 light 投影重建（createRecord 先例 = cold-lookup 的
+  // resurrectColdRecord：identity 域经 identity 入参、readonly engineHandle 经构造
+  // spread、运行态域随后补写——origin/parentRunId 不迁 [workflow origin 豁免 adopt
+  // 链，本分支不可达]）。markFinalized 的 entry 面 = recordToSubagent 投影，磁盘
+  // 投影的 result/turns/totalTokens 等终态快照字段随重建保真。
+  const record: ExecutionRecord = {
+    ...createRecord(recordId, {
+      agent: disk.agent,
+      model: disk.model,
+      thinkingLevel: disk.thinkingLevel,
+      mode: disk.mode,
+      task: disk.task,
+      slug: disk.slug,
+      startedAt: disk.startedAt,
+      rootSessionId: disk.rootSessionId,
+      parentRecordId: disk.parentRecordId,
+      depth: disk.depth,
+      chatMode: disk.chatMode === true,
+      engine: disk.engine,
+      engineFallback: disk.engineFallback,
+      collectMode: disk.collectMode,
+    }),
+    ...(disk.engineHandle !== undefined ? { engineHandle: disk.engineHandle } : {}),
+  };
+  record.sessionFile = disk.sessionFile;
+  record.round = disk.round;
+  record.resumable = disk.resumable;
+  record.hadWorktree = disk.worktree === true;
+  record.result = disk.result;
+  record.turnCount = disk.turns;
+  record.totalTokens = disk.totalTokens;
+  record.error = errorText;
+  record.endedAt = Date.now();
+  // 防御：createRecord 产物恒 running，CAS 失败不可达（不终态化直接返回）。
+  if (!tryTransition(record, "closed", "gc")) return;
   try {
-    store.reportSubagentRecord({
-      ...disk,
-      status: "closed",
-      closedReason: "gc",
-      endedAt: Date.now(),
-      error: errorText,
-    });
+    const persisted = store.markFinalized(record, "gc");
+    if (!persisted) {
+      // [§3.4] `.state` 重试耗尽：store 层已 error 级留痕，此处补调用方语境 + GUI
+      // 通知面腿（对齐 doFinalizeRecord 同款接线）——record 留 running 形态，boot
+      // 孤儿恢复终态化承接。
+      logger.error(
+        `[subagents] round supervisor give-up terminal write failed (record=${recordId}); ` +
+          `record stays running on disk — boot orphan recovery will finalize it`,
+      );
+      binding.getPi()?.appendEntry?.("subagent:state-write-failed", {
+        id: recordId,
+        status: "closed",
+        closedReason: "gc",
+      });
+    }
   } catch (err) {
     bestEffort(err, `round supervisor give-up entry (${recordId})`, "error");
   }

package/src/execution/round-supervisor/supervisor.ts

@@ -120,6 +120,8 @@ export interface SupervisorRecordView {
   /** 已有完成产出（record.result !== undefined）——SP-5 upgrade 等待态判据。 */
   hasResult: boolean;
   chatMode: boolean;
+  /** [H2 W2] 来源身份（adopt 链豁免域判据——classifySupervisorDomain 消费）。 */
+  origin?: "tool" | "workflow";
   rootSessionId: string | undefined;
   agent: string;
   slug: string;
@@ -141,6 +143,8 @@ export interface SupervisorCandidateRecord {
   agent: string;
   slug: string;
   startedAt: number;
+  /** [H2 W2] 来源身份（superseded 对账的 workflow 候选豁免判据）。 */
+  origin?: "tool" | "workflow";
 }
 
 /** RoundSupervisor 的依赖（SubagentService 注入；全部单测替身友好）。 */
@@ -231,9 +235,12 @@ export class RoundSupervisor {
     for (const candidate of this.deps.listCandidateRecords()) {
       const view = this.deps.getRecordView(candidate.id);
       if (view === undefined || view.status !== "running") continue;
-      if (view.chatMode) continue; // conversation 豁免（现状，轮终 idle 机制管辖）
+      // [H2 W2] adopt 链豁免域门（conversation 豁免 + workflow origin 豁免）：
+      // classifySupervisorDomain 不把 workflow record 归入可 adopt 域（"run"）——
+      // boot 重认领对 workflow 形态不生效（豁免落空面无「重认领后 2h 看门狗挂账」）。
+      if (classifySupervisorDomain(view) !== "run") continue;
       // boot 分区只处理「孤儿恢复保留下来的 resumable 且无完成产出的形态」（W4 死亡
-      // 纳管态跨重启）——in-flight 已被孤儿恢复直断（见头注时序），不再此处重复
+      // 纳管态跨重启）——in-flight 已被孤儿恢复直断（见头注），不再此处重复
       // 终态化（双收尾防线）；resumable 且 result 有值是 SP-5 完成态（已完成挂账，
       // idle-gc 锚归档收口，无需监督）。谓词与 record-store 孤儿恢复保留分支同源
       // （isBootReadoptable，domain.ts）。
@@ -314,16 +321,22 @@ export class RoundSupervisor {
       return;
     }
     // 该唤醒 → 通知对账（送指引前查替代）。
+    // [H2 W2 / superseded 豁免] workflow origin 候选不参与替代判定——parallel 同
+    // slug/同 agent 并行是 workflow 常态而非替代关系（replacedNotice「was already
+    // replaced by your new task」会把并行任务误述为替代并错误终态化原任务）。
     const windowMs = getSupervisorWatchdogMs();
     const verdict = classifyReplacement(
       { id: view.id, rootSessionId: view.rootSessionId, agentName: view.agent, slug: view.slug },
-      this.deps.listCandidateRecords().map((c) => ({
-        id: c.id,
-        rootSessionId: c.rootSessionId,
-        agentName: c.agent,
-        slug: c.slug,
-        startedAt: c.startedAt,
-      })),
+      this.deps
+        .listCandidateRecords()
+        .filter((c) => c.origin !== "workflow")
+        .map((c) => ({
+          id: c.id,
+          rootSessionId: c.rootSessionId,
+          agentName: c.agent,
+          slug: c.slug,
+          startedAt: c.startedAt,
+        })),
       windowMs,
       this.deps.now(),
     );
@@ -400,6 +413,7 @@ export class RoundSupervisor {
       resumable: record.resumable === true,
       hasResult: record.result !== undefined,
       chatMode: record.chatMode === true,
+      origin: record.origin,
       rootSessionId: record.rootSessionId,
       agent: record.agent,
       slug: record.slug,