@zhushanwen/subagent-core 0.7.1 → 0.9.0

package/src/execution/__tests__/chat-engine-routing.test.ts

@@ -334,6 +334,21 @@ describe("chat 工具域引擎路由分叉（U0：D4/D5/D10）", () => {
   // 2. pi 缺省守护（D5 字节级）
   // ============================================================
 
+  it("[F6] pi 路由 kickOffChatRound：runCtx 带 sessionRootId（initSession 注入的根 id，relay 归属键权威源）", async () => {
+    // [S5 同根] initSession 读 env PI_SUBAGENT_ROOT_SESSION_ID 优先于 init.sessionId——
+    // 在 pi subagent 进程内跑测试（该 env 已注入）必红。显式 stub 为 undefined（空串
+    // 会被条件 spread 过滤为缺键，同样破坏断言），不依赖外层环境。
+    vi.stubEnv("PI_SUBAGENT_ROOT_SESSION_ID", undefined);
+    const { service, piEngine } = setup(agentDir);
+    const handle = await service.execute(baseOpts(agentDir));
+    await vi.waitFor(() => expect(piEngine.runs.length).toBe(1));
+    // initSession({sessionId: "test-session"}) 无 env → sessionRootId = "test-session"；
+    // kickOffChatRound 是 pi 引擎 background 派发主路径（isPiRoute 恒路由至此，含
+    // workflow 域一次性 run），漏注 = GUI pi 派发 relay 拒绝 exit 13（Gate B F6 形态）。
+    expect(piEngine.runs[0]!.ctx.sessionRootId).toBe("test-session");
+    vi.unstubAllEnvs();
+  });
+
   it("[D5] 全缺省 pi record：engine===undefined 且 entry JSON 不含 engine 键", async () => {
     const { service, piEngine } = setup(agentDir);
     const handle = await service.execute(baseOpts(agentDir));
@@ -367,7 +382,7 @@ describe("chat 工具域引擎路由分叉（U0：D4/D5/D10）", () => {
       .execute(baseOpts(agentDir, { engine: "zcode", conversation: true }))
       .catch((e: unknown) => e);
     expect(err).toBeInstanceOf(Error);
-    expect((err as Error).message).toContain("不支持 conversation");
+    expect((err as Error).message).toContain("不支持 resume 续聊");
     // 恢复指引（EngineError.recovery）：W3 协议化口径——调参数 / 修 manifest / 升级
     // 引擎包（引擎包是能力声明载体；「改用 engine: pi」内置兜底指引已随协议化删除）
     expect((err as { recovery?: string }).recovery).toContain("去掉 conversation 参数");
@@ -519,6 +534,47 @@ describe("chat 工具域引擎路由分叉（U0：D4/D5/D10）", () => {
     // 按句移除断言（W10 注）：inproc 双模不回灌 childStateChanged，镜像移除由
     // protocol-blackbox 承载（同 subprocess-agent-runner-routing D10 注）。
   });
+
+  // ============================================================
+  // 6. [F6] sessionRootId 注入（execute / executeAndAwait 两 runCtx 构造点）
+  // ============================================================
+
+  it("[F6] service.sessionRootId 注入 runCtx（根 session id 贯穿引擎派发——relay 归属键 SESSION_ID 权威源）", async () => {
+    // 根进程形态：env 无 PI_SUBAGENT_ROOT_SESSION_ID 时 sessionRootId = init.sessionId。
+    // 删除防外层 env 污染（该键存在时 initSession 走子进程形态，断言基准漂移）。
+    const prevRootEnv = process.env["PI_SUBAGENT_ROOT_SESSION_ID"];
+    delete process.env["PI_SUBAGENT_ROOT_SESSION_ID"];
+    try {
+      const { service, zcode, piEngine } = setup(agentDir);
+      zcode.runImpl = () => Promise.resolve({ handle: fakeHandle(), outcome: doneOutcome("ok") });
+      piEngine.runImpl = () => Promise.resolve({ handle: fakeHandle(), outcome: doneOutcome("ok") });
+
+      // chat 域 background 派发（runEngineTask 的 runCtx 构造点）
+      await service.execute(baseOpts(agentDir, { engine: "zcode" }));
+      await vi.waitFor(() => expect(zcode.runs.length).toBe(1));
+      expect(zcode.runs[0].ctx.sessionRootId).toBe("test-session");
+
+      // workflow 域 sync 派发（runAndFinalize 的 runCtx 构造点；其引擎解析恒走
+      // registry 'pi'——resolveChatEnginePort，不消费 opts.engine）。fire-and-forget：
+      // 本 harness 无 idle-notify 驱动面，收尾链（finalizeRoundToIdle）不收敛——
+      // 只断言构造点（runs 捕获在收尾之前），与既有用例的挂起 record 同等形态。
+      let awaitErr: unknown;
+      void service
+        .executeAndAwait(baseOpts(agentDir, { slug: "f6-await" }))
+        .catch((e: unknown) => {
+          awaitErr = e;
+        });
+      await vi.waitFor(() => {
+        if (awaitErr !== undefined) {
+          throw new Error(`executeAndAwait rejected before engine.run: ${String(awaitErr)}`);
+        }
+        expect(piEngine.runs.length).toBe(1);
+      });
+      expect(piEngine.runs[0].ctx.sessionRootId).toBe("test-session");
+    } finally {
+      if (prevRootEnv !== undefined) process.env["PI_SUBAGENT_ROOT_SESSION_ID"] = prevRootEnv;
+    }
+  }, 10_000);
 });
 
 // ============================================================
@@ -676,6 +732,66 @@ describe("chat 引擎分支 U2：probe 兜底 / journal / engineHandle", () => {
     await vi.waitFor(() => expect(service["findRecord"](handle.subagentId)).toBeUndefined());
   }, 10_000);
 
+  it("[onHandleReady F1] sessionId 先落 + 迟到只补 sessionFile → 按字段补缺落位；已有值不被迟到值覆盖（幂等）", async () => {
+    process.env.XYZ_AGENT_DATA_DIR = agentDir;
+    const { service, zcode, pi } = setup(agentDir);
+    const POOL = "zcode-appserver-home";
+    const LATE_SESSION_FILE = "/tmp/late/session-abc.jsonl";
+    let releaseRun!: (v: { handle: EngineHandle; outcome: AgentOutcome }) => void;
+    zcode.runImpl = (task, ctx) => {
+      ctx.onPoolResolved?.(POOL);
+      // ① create 应答：只带 sessionId（本 replay 批次新打通的可达面——close 期 LC-4
+      // 后缀反查在 sessionId 已知后才补发 sessionFile）。
+      ctx.onHandleReady?.({
+        sessionRef: { dbPath: ".zcode/cli/db/db.sqlite", sessionId: "sess-live-1" },
+        poolKey: POOL,
+      });
+      // ② 迟到 handleReady：只补 sessionFile——旧守卫「有 sessionId 即整条 return」
+      // 会把它整条吞掉，sessionFile 永不落位（消费点：冷续 resume 锚点 / interact 定位）。
+      ctx.onHandleReady?.({
+        sessionRef: { sessionId: "sess-live-1", sessionFile: LATE_SESSION_FILE },
+        poolKey: POOL,
+      });
+      // ③ 再迟到一次且带冲突值：已有值必须原样保留（幂等），poolKey 不被重置。
+      ctx.onHandleReady?.({
+        sessionRef: { sessionId: "sess-OVERWRITE", sessionFile: "/tmp/late/other.jsonl" },
+        poolKey: "hijacked-pool",
+      });
+      return new Promise((resolve) => {
+        releaseRun = resolve;
+      });
+    };
+    const handle = await service.execute(baseOpts(agentDir, { engine: "zcode" }));
+    await vi.waitFor(() => expect(zcode.runs.length).toBe(1));
+
+    const running = service["collectRecords"](10, "running").find((r) => r.id === handle.subagentId);
+    // 补缺落位：sessionFile 进 record.engineHandle（①级会话取证 / 冷续 resume 锚点钥匙）
+    expect(running?.engineHandle?.sessionRef["sessionFile"]).toBe(LATE_SESSION_FILE);
+    expect(running?.engineHandle).toEqual({
+      sessionRef: {
+        dbPath: ".zcode/cli/db/db.sqlite",
+        sessionId: "sess-live-1",
+        sessionFile: LATE_SESSION_FILE,
+      },
+      poolKey: POOL,
+      journalPath: resolveJournalPath(agentDir, "zcode", POOL, handle.subagentId),
+    });
+    // 补缺经 entry 持久化（运行中 GUI 经 entry 重建 record 即可见），且 ③ 的
+    // 「无新字段」重复回调不产生第二条写噪（同 sessionFile 恰好一条）。
+    const entries = pi.appendEntry.mock.calls.filter((c) => c[0] === "subagent-record");
+    const withLateSessionFile = entries.filter(
+      (c) =>
+        ((c[1] as Record<string, unknown>).engineHandle as
+          | { sessionRef?: Record<string, string> }
+          | undefined)?.sessionRef?.["sessionFile"] === LATE_SESSION_FILE,
+    );
+    expect(withLateSessionFile).toHaveLength(1);
+
+    // 终态收口（防 dangling）
+    releaseRun({ handle: fakeHandle(), outcome: doneOutcome("ok") });
+    await vi.waitFor(() => expect(service["findRecord"](handle.subagentId)).toBeUndefined());
+  }, 10_000);
+
   it("[onHandleReady] 引擎不回调（spawn 形态）时零回填——终态回填仍兜底（行为不变）", async () => {
     process.env.XYZ_AGENT_DATA_DIR = agentDir;
     const { service, zcode, pi } = setup(agentDir);

package/src/execution/__tests__/{cold-resurrect.test.ts → cold-lookup.test.ts}

@@ -1,17 +1,21 @@
-// src/execution/__tests__/cold-resurrect.test.ts
+// src/execution/__tests__/cold-lookup.test.ts
 //
 // [D4-③] coldLookupForAction 单元测试（依赖注入直测）。
 //
-// 背景：cold-resurrect.ts 自 SubagentService 搬移后按 ColdResurrectDeps 依赖注入
-// 设计，此前仅有经 subagent-service 集成路径的 running 重建覆盖——closed 可重连
-// 候选的「恢复失败守卫 / 部分恢复回边」（assertReconnectAllowed / resurrectColdRecord
-// 的 wasClosed 分支）零直测。本文件锁定这些路径的可观察行为：
+// 背景：冷查链自 SubagentService 搬移后按 ColdLookupDeps 依赖注入设计，此前仅有经
+// subagent-service 集成路径的 running 重建覆盖——closed 可重连候选的「恢复失败守卫 /
+// 部分恢复回边」（assertReconnectAllowed / resurrectColdRecord 的 wasClosed 分支）
+// 零直测。[H1 U6] 文件随 cold-resurrect.ts → cold-lookup.ts 改名（chatMode 无条件
+// 置位语义迁 Continuation D4 revive 格 + D5 gate，重建只水合持久化 chatMode）。
+// 本文件锁定这些路径的可观察行为：
 //   - 恢复失败：worktree 绑定丢失 / 异进程活实例（closed 与 running 候选）→
 //     ResurrectDeniedError 且内存无残留（register 不被调用）；
 //   - 部分恢复：closed 可重连记录 → resurrectClosed 回边翻回 running + 磁盘终态位
-//     同步翻转（.finalized 删除 + .alive 刷新当前进程）+ register/transition 上报；
-//   - 恢复源缺失：sessionFile 缺失 / sidecar 翻转失败（目录不存在）均不阻断重生
-//     （best-effort 语义）。
+//     同步翻转（.state（L4 现行终态载体）与 legacy .finalized 删除 + .alive 刷新当前
+//     进程）+ register/transition 上报——[U2a/B4] 回边三件套整体收编
+//     store.markResurrected（deps 注入真实 RecordStore 实例承载）；
+//   - [B4/D3c] 恢复源缺失（sessionFile 缺失 / marker 写失败）→ 响亮抛错中止重生主流程
+//     （旧「单 try 吞错续跑」形态消灭——acquire 失败 = 双写风险敞口，§3.4）。
 //
 // fixture 一律 mkdtempSync 自建自删（tmpdir），不触碰真实数据目录。
 
@@ -22,10 +26,16 @@ import * as path from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { readAliveMarker, writeAliveMarker } from "../alive-store.ts";
-import { COLD_LOOKUP_SCAN_LIMIT, coldLookupForAction, type ColdResurrectDeps } from "../cold-resurrect.ts";
+import { COLD_LOOKUP_SCAN_LIMIT, coldLookupForAction, type ColdLookupDeps } from "../cold-lookup.ts";
+import { RecordStore } from "../record-store.ts";
 import type { SubagentRecord } from "../types.ts";
 import { ResurrectDeniedError } from "../types.ts";
 
+/** [U1/A4] 「异进程且存活」的确定性模拟 pid：1 号进程（launchd/init）必然存在且非
+ *  本测试进程——kill(1, 0) 对普通用户返回 EPERM，isProcessAlive 按「存在但无权限」
+ *  保守判活（self-pid 排除后不能再以本进程 pid 模拟异进程实例）。 */
+const FOREIGN_LIVE_PID = 1;
+
 /** 磁盘/索引侧候选记录（SubagentRecord 最小合法形状 + closed 可重连缺省）。 */
 function makeFound(overrides: Partial<SubagentRecord> = {}): SubagentRecord {
   return {
@@ -62,13 +72,20 @@ interface DepOverrides {
   baseline?: string;
 }
 
-/** 构造依赖注入桩（register / reportRecordTransition 可断言副作用）。 */
-function makeDeps(o: DepOverrides = {}): ColdResurrectDeps {
+/** 构造依赖注入桩。markResurrected 经真实 RecordStore 承载（[U2a/B4] 回边收编 store
+ *  原语——磁盘三件套/内存翻回/register 需真实落盘语义，stub 无法验证）；register 用
+ *  spy 包住 store.register 供「内存无残留」断言（markResurrected 内部 register 与
+ *  spy 同一入口）。sessionsDir 经 beforeEach 刷新（describe 作用域变量模块级桥接）。 */
+let currentSessionsDir = "";
+function makeDeps(o: DepOverrides = {}): ColdLookupDeps {
+  const store = new RecordStore(currentSessionsDir);
+  const registerSpy = vi.spyOn(store, "register");
   return {
     findLightById: vi.fn(() => o.direct),
     collectRecords: vi.fn(() => o.disk ?? []),
-    register: vi.fn(),
+    register: registerSpy,
     reportRecordTransition: vi.fn(),
+    markResurrected: (record, wasClosed) => store.markResurrected(record, wasClosed),
     getSessionRootId: vi.fn(() => o.rootId ?? "root-session"),
     getBaselineRecordId: vi.fn(() => o.baseline),
   };
@@ -78,17 +95,24 @@ describe("[D4-③] coldLookupForAction 冷查/复活链", () => {
   let dir: string;
 
   beforeEach(() => {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), "cold-resurrect-"));
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "cold-lookup-"));
+    currentSessionsDir = dir;
   });
 
   afterEach(() => {
     fs.rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
-  /** tmpdir 下建 session 文件 + 可选 .finalized sidecar，返回 sessionFile 路径。 */
-  function writeSessionFixture(opts: { finalized?: string; aliveMarker?: string } = {}): string {
+  /** tmpdir 下建 session 文件 + 可选终态 sidecar（.state / legacy .finalized）+ 可选
+   *  .alive sidecar，返回 sessionFile 路径。 */
+  function writeSessionFixture(
+    opts: { state?: string; finalized?: string; aliveMarker?: string } = {},
+  ): string {
     const sessionFile = path.join(dir, "20260901T000000-000_sa-cold-1.jsonl");
     fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+    if (opts.state !== undefined) {
+      fs.writeFileSync(`${sessionFile}.state`, opts.state, "utf-8");
+    }
     if (opts.finalized !== undefined) {
       fs.writeFileSync(`${sessionFile}.finalized`, opts.finalized, "utf-8");
     }
@@ -111,8 +135,9 @@ describe("[D4-③] coldLookupForAction 冷查/复活链", () => {
     expect(record.status).toBe("running");
     expect(record.closedReason).toBeUndefined();
     expect(record.endedAt).toBeUndefined();
-    // [v4 A-3] 跨重启恢复入口：chatMode 无条件 true
-    expect(record.chatMode).toBe(true);
+    // [v4 A-3 → H1 U6 / D4-D5] 水合保留持久化 chatMode：候选未持久化 chatMode
+    //（undefined）→ 重建 false（升级置位归 Continuation revive 格 + gate，不在重建层）
+    expect(record.chatMode).toBe(false);
     // 身份/续聊字段从磁盘候选回填
     expect(record.sessionFile).toBe(sessionFile);
     expect(record.round).toBe(2);
@@ -130,6 +155,42 @@ describe("[D4-③] coldLookupForAction 冷查/复活链", () => {
     expect(vi.mocked(deps.collectRecords)).toHaveBeenCalledWith(COLD_LOOKUP_SCAN_LIMIT, "all", undefined);
   });
 
+  it("[L4] 磁盘 .state（现行终态载体）+ legacy .finalized 残留 → 重生回边两者同步删除（否则磁盘扫描翻回 closed）", () => {
+    // [review MF-8] 残留任一终态 sidecar 都会让 record-store buildRecord 终态分支
+    // （分支 1，.state 优先 / 旧名兼容归一）压过 .alive 活态分支——reload / 异进程 /
+    // session-reader 全部把 running record 报成 closed，并为跨进程二次 resurrect 开门。
+    const sessionFile = writeSessionFixture({
+      state: JSON.stringify({ status: "finalized", reason: "parent-shutdown" }),
+      finalized: JSON.stringify({ reason: "parent-shutdown" }),
+    });
+    const deps = makeDeps({ disk: [makeFound({ sessionFile, closedReason: "parent-shutdown" })] });
+
+    const record = coldLookupForAction(deps, "sa-cold-1", true)!;
+
+    expect(record.status).toBe("running");
+    expect(record.closedReason).toBeUndefined();
+    // 终态 sidecar 双双清除（现行 .state + legacy .finalized），磁盘扫描不再翻回 closed
+    expect(fs.existsSync(`${sessionFile}.state`)).toBe(false);
+    expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(false);
+    expect(vi.mocked(deps.register)).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(deps.reportRecordTransition)).toHaveBeenCalledTimes(1);
+  });
+
+  it("负向对照：重生被守卫拒绝（worktree 绑定丢失）→ 终态 sidecar 不被误删", () => {
+    // 守卫先于任何状态突变与副作用（[v8.5 D] / [review MF-9]）：拒绝路径不得触碰磁盘
+    const sessionFile = writeSessionFixture({
+      state: JSON.stringify({ status: "finalized", reason: "parent-shutdown" }),
+      finalized: JSON.stringify({ reason: "parent-shutdown" }),
+    });
+    const deps = makeDeps({ disk: [makeFound({ sessionFile, worktree: true })] });
+
+    expect(() => coldLookupForAction(deps, "sa-cold-1", true)).toThrow(ResurrectDeniedError);
+
+    expect(fs.existsSync(`${sessionFile}.state`)).toBe(true);
+    expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(true);
+    expect(vi.mocked(deps.register)).not.toHaveBeenCalled();
+  });
+
   it("idToFile 索引直查返回非 running 态 → 回退磁盘全扫兜底定位（closed 候选仍可重连）", () => {
     const sessionFile = writeSessionFixture();
     const found = makeFound({ sessionFile });
@@ -143,6 +204,17 @@ describe("[D4-③] coldLookupForAction 冷查/复活链", () => {
     expect(vi.mocked(deps.register)).toHaveBeenCalledWith(record);
   });
 
+  it("候选持久化 chatMode=true（chat 容器）→ 水合保留 true（续聊直接走，无需升级格）", () => {
+    const sessionFile = writeSessionFixture();
+    const deps = makeDeps({ disk: [makeFound({ sessionFile, status: "running", chatMode: true })] });
+
+    const record = coldLookupForAction(deps, "sa-cold-1", true)!;
+
+    expect(record.status).toBe("running");
+    expect(record.chatMode).toBe(true);
+    expect(vi.mocked(deps.register)).toHaveBeenCalledTimes(1);
+  });
+
   it("closed disconnected（.finalized 空内容兜底死因）同样落在可重连集内", () => {
     const sessionFile = writeSessionFixture({ finalized: "" });
     const deps = makeDeps({ disk: [makeFound({ sessionFile, closedReason: "disconnected" })] });
@@ -165,9 +237,10 @@ describe("[D4-③] coldLookupForAction 冷查/复活链", () => {
   });
 
   it("closed 候选仍有异进程活实例（.alive 指向活 pid）→ 拒绝双写，register 不残留", () => {
-    // 用本测试进程 pid 模拟「另一进程的活跃实例」——isProcessAlive 判活为真
+    // [U1/A4] 探针已补 self-pid 排除——「异进程」模拟不能再用本测试进程 pid，改用
+    // 恒活的外部 pid 1（launchd/init：kill(1,0) → EPERM → isProcessAlive 判活为真）。
     const sessionFile = writeSessionFixture();
-    writeAliveMarker(sessionFile, { pid: process.pid, id: "sa-cold-1", startedAt: Date.now() });
+    writeAliveMarker(sessionFile, { pid: FOREIGN_LIVE_PID, id: "sa-cold-1", startedAt: Date.now() });
     const deps = makeDeps({ disk: [makeFound({ sessionFile })] });
 
     expect(() => coldLookupForAction(deps, "sa-cold-1", true)).toThrow(ResurrectDeniedError);
@@ -179,7 +252,7 @@ describe("[D4-③] coldLookupForAction 冷查/复活链", () => {
 
   it("running 候选仍有异进程活实例（父进程重启后旧子进程尚存窗口）→ 拒绝并给恢复指引", () => {
     const sessionFile = writeSessionFixture();
-    writeAliveMarker(sessionFile, { pid: process.pid, id: "sa-cold-1", startedAt: Date.now() });
+    writeAliveMarker(sessionFile, { pid: FOREIGN_LIVE_PID, id: "sa-cold-1", startedAt: Date.now() });
     const deps = makeDeps({ disk: [makeFound({ sessionFile, status: "running" })] });
 
     expect(() => coldLookupForAction(deps, "sa-cold-1", true)).toThrow(ResurrectDeniedError);
@@ -253,31 +326,58 @@ describe("[D4-③] coldLookupForAction 冷查/复活链", () => {
     expect(vi.mocked(deps.register)).not.toHaveBeenCalled();
   });
 
-  // ── 恢复源缺失（best-effort 不阻断重生主流程）──
+  // ── 恢复源缺失（[B4/D3c] 响亮失败——吞错续跑形态消灭）──
 
-  it("sessionFile 缺失的 closed 候选 → 跳过 sidecar 翻转，重生照常完成（register + transition 上报）", () => {
+  it("[B4] sessionFile 缺失的 closed 候选 → markResurrected 响亮抛错中止重生（无锚点无法声明写权）", () => {
     const deps = makeDeps({ disk: [makeFound({ sessionFile: undefined })] });
 
-    const record = coldLookupForAction(deps, "sa-cold-1", true)!;
-
-    expect(record.status).toBe("running");
-    expect(record.sessionFile).toBeUndefined();
-    expect(vi.mocked(deps.register)).toHaveBeenCalledTimes(1);
-    expect(vi.mocked(deps.reportRecordTransition)).toHaveBeenCalledTimes(1);
+    // acquire 失败 = 双写风险敞口，禁止 best-effort 吞错续跑（§3.4/D3c——旧形态
+    // 「跳过 sidecar 翻转、重生照常完成」随回边收编消灭：无锚点的 running record
+    // 缺跨进程写权声明，正是 D3 要防的事故形态入口）。
+    expect(() => coldLookupForAction(deps, "sa-cold-1", true)).toThrow(/no sessionFile anchor/);
+    expect(vi.mocked(deps.register)).not.toHaveBeenCalled();
+    expect(vi.mocked(deps.reportRecordTransition)).not.toHaveBeenCalled();
   });
 
-  it("sidecar 翻转失败（sessionFile 所在目录不存在，writeAliveMarker ENOENT）→ best-effort 吞错，重生不中断", () => {
+  it("[B4] sidecar 翻转失败（sessionFile 所在目录不存在，writeAliveMarker ENOENT）→ 响亮中止，终态位未被误删", () => {
     // 恢复源缺失形态：sessionFile 指向已消失的目录（推导路径过期 / 目录被清理）
     const sessionFile = path.join(dir, "vanished-dir", "20260901T000000-000_sa-cold-1.jsonl");
+    // 离线预置终态位（目录存在时才可写——改为断言 acquire-first 失败后磁盘保持旧形态
+    // 的推演基础：无终态位可删的目录缺失形态下，响亮失败即全部可观察行为）
     const deps = makeDeps({ disk: [makeFound({ sessionFile })] });
 
+    // acquire-first 写权声明失败 → 整体响亮抛错（单 try 域原子收敛，D3c）。
+    expect(() => coldLookupForAction(deps, "sa-cold-1", true)).toThrow(
+      /write-lease acquire\/terminal-position flip failed/,
+    );
+    expect(vi.mocked(deps.register)).not.toHaveBeenCalled();
+    expect(vi.mocked(deps.reportRecordTransition)).not.toHaveBeenCalled();
+    // marker 写入确实失败（目录不存在，未落盘）
+    expect(fs.existsSync(`${sessionFile}.alive`)).toBe(false);
+  });
+
+  it("[B4/D3c] acquire-first 失败后磁盘保持旧形态（终态位未删，重生可重试）", () => {
+    // acquire 成功但终态位删除失败不可构造（rmSync force 幂等）——验证 acquire-first
+    // 顺序的可观察等价面：目录存在 + 终态位在，marker 写成功路径下才执行删除。
+    // 本用例钉失败方向的可重试性：closed 候选 + 守卫通过 + 目录消失 → 响亮中止后
+    // .state 残留形态不变（无「半翻」状态）。
+    const sessionFile = path.join(dir, "gone", "20260901T000000-000_sa-cold-1.jsonl");
+    const deps = makeDeps({ disk: [makeFound({ sessionFile })] });
+    expect(() => coldLookupForAction(deps, "sa-cold-1", true)).toThrow();
+    // 磁盘面零触碰（目录本不存在——构造性「保持旧形态」）
+    expect(fs.existsSync(sessionFile)).toBe(false);
+  });
+
+  it("[B4/D3c] running 候选接管（wasClosed=false）→ 仍 acquire marker（接管即声明，B/C 双写窗闭合）", () => {
+    const sessionFile = writeSessionFixture();
+    const deps = makeDeps({ disk: [makeFound({ sessionFile, status: "running" })] });
+
     const record = coldLookupForAction(deps, "sa-cold-1", true)!;
 
-    // best-effort：sidecar 翻转失败不阻断重生主流程（状态回边与注册照常）
     expect(record.status).toBe("running");
+    // 「接管即声明」：running 接管形态无终态位可删，但 acquire 照做——A 崩溃（marker
+    // pid 死）→ B 接管刷新 pid=B → C 再触达被拦（S8⑤ 验收锚点的磁盘面前置）。
+    expect(readAliveMarker(sessionFile)).toMatchObject({ pid: process.pid, id: "sa-cold-1" });
     expect(vi.mocked(deps.register)).toHaveBeenCalledTimes(1);
-    expect(vi.mocked(deps.reportRecordTransition)).toHaveBeenCalledTimes(1);
-    // marker 写入确实失败（目录不存在，未落盘）
-    expect(fs.existsSync(`${sessionFile}.alive`)).toBe(false);
   });
 });

package/src/execution/__tests__/collect-coordinator-service.test.ts

@@ -159,7 +159,7 @@ describe("collectCoordinator service integration (U2)", () => {
     expect(batches[0]!.map((m) => m.id)).toEqual([handle.subagentId]);
   });
 
-  it("flushBatch accepted=false（幂等拒绝）时不落标：零带 batchFinalized 的 entry", async () => {
+  it("flushBatch accepted=false（幂等拒绝）时落标已前置完成（U3 归口：合一原语幂等覆写）", async () => {
     const spy = spyNotifier(service);
     spy.notifyBatch.mockReturnValue(false); // 模拟同成员集批已在账（E1 重建重发形态）
     const handle = await service.execute({ task: "collect me", slug: "collect-me", collect: "sync" });
@@ -167,14 +167,16 @@ describe("collectCoordinator service integration (U2)", () => {
     await settleLast();
     await until(() => spy.notifyBatch.mock.calls.length > 0);
     expect(handle.subagentId).toMatch(/^sa-/);
-    // 落标出口①绑「写账成功」：accepted=false → 无带 batchFinalized 标记的 subagent-record
-    // entry（register/archive 常规 entry 经 recordToSubagent 投影携带 batchFinalized=
-    // undefined——未离场成员，非 true；U5 投影扩展后缺省键不落值，断言语义不变）
+    // [U3 批写归口] 落标随 markBatchFinalized 前置到写账前（合一原语形态下「屏障 →
+    // 写账 → 落标」三段不可兼得，构造性 barrier 优先）：accepted=false（同成员集批
+    // 已在账 = 该批此前成功投递时已落标）时本次落标属幂等覆写（appendEntry
+    // last-writer-wins），E1 排除判据（collectMode=sync + batchFinalized）不受写账
+    // 拒绝影响——防该成员以无标记形态被 E1 重收（异成员集 hash 不触发账本幂等）。
     const recordEntries = pi.appendEntry.mock.calls
       .filter((c) => c[0] === "subagent-record")
       .map((c) => c[1] as Record<string, unknown>);
     expect(recordEntries.length).toBeGreaterThan(0); // execute 链自身的 register/archive 在场
-    expect(recordEntries.some((d) => d["batchFinalized"] === true)).toBe(false);
+    expect(recordEntries.some((d) => d["id"] === handle.subagentId && d["batchFinalized"] === true)).toBe(true);
   });
 
   it("routes an async member through the same notifyAsync path (现状直通)", async () => {