@zhushanwen/subagent-core 0.8.0 → 0.9.0

package/src/execution/__tests__/record-store-orphan-revive.test.ts

@@ -3,7 +3,7 @@
 // [PS-10/T6④] revive() 复位 orphanJudged——落实 recoverOrphanRecords 注释承诺
 // 「IO 恢复后重开可重判」。
 //
-// 缺陷（设计 §4.3 PS-10）：resumable 形态（IO-error 保守分支）无 .finalized sidecar
+// 缺陷（设计 §4.3 PS-10）：resumable 形态（IO-error 保守分支）无 .state sidecar
 // 锚，重判资格完全由 orphanJudged 实例级缓存承载；dispose 有 clear 但 /new 复活路径
 // revive() 此前不复位 → 同进程内曾经的 IO 失败记录永久停留 resumable。
 //
@@ -36,6 +36,7 @@ vi.mock("node:fs", async (importOriginal) => {
 vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
 
 import { RecordStore } from "../record-store.ts";
+import { writeAliveMarker } from "../alive-store.ts";
 
 let tmpDir = "";
 
@@ -114,7 +115,7 @@ describe("[PS-10] revive() 复位 orphanJudged（IO 恢复后重开可重判）"
     expect(appended[0]?.customType).toBe("subagent-record");
     expect(appended[0]?.data.status).toBe("running");
     expect(appended[0]?.data.resumable).toBe(true);
-    expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(false); // 保守分支无 sidecar 锚
+    expect(fs.existsSync(`${sessionFile}.state`)).toBe(false); // 保守分支无 sidecar 锚
 
     // ── 阶段 2：IO 恢复 + /new 复活（revive 复位 orphanJudged）→ 重判收敛终态 ──
     allowReads = Infinity;
@@ -126,7 +127,7 @@ describe("[PS-10] revive() 复位 orphanJudged（IO 恢复后重开可重判）"
     expect(rejudged?.data.status).toBe("closed");
     expect(rejudged?.data.closedReason).toBe("gc");
     expect(rejudged?.data.resumable).toBeUndefined(); // 不再停留 resumable
-    expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(true); // 终态防重锚落盘
+    expect(fs.existsSync(`${sessionFile}.state`)).toBe(true); // 终态防重锚落盘
   });
 
   it("未 revive 时重判资格保持（防重缓存语义不回归）：重复 recover 零新 entry", () => {
@@ -157,3 +158,70 @@ describe("[PS-10] revive() 复位 orphanJudged（IO 恢复后重开可重判）"
     expect(appended).toHaveLength(1);
   });
 });
+
+// ── [U4a / D3b (a″)] 孤儿恢复活实例跳过：findForeignLiveInstance 现查探针 ──
+//
+// 原判据 = 重建时缓存的 rec.externalInstance（分支 3 填充）；externalInstance 字段链
+// 删除后换直接探针（pid 单判据 + self-pid 排除）。验收（F2）：
+//   - 探针活（异宿主 pid 在持声明）→ 跳过终态化——boot 不得误杀异宿主持有中 record
+//     （同 root 双宿主形态下，宿主 A 的 boot 把宿主 B 持有中的 record 直断 gc 会
+//     击穿跨进程写权防御，设计 D3b (a″)）；
+//   - pid 死（无在持声明）→ 正常终态化（closed+gc + .state 防重锚）。
+describe("[U4a / D3b (a″)] 孤儿恢复活实例跳过：现查探针（pid 单判据）", () => {
+  /** openSync 透传真实实现（本 describe 的判定路径需要真实 IO；mockReset 后默认
+   *  实现返回 undefined，readLastJsonlLine 会拿到非法 fd）。 */
+  function passthroughOpenSync(): void {
+    const realOpenSync = fsActualHolder.fs!.openSync;
+    openSyncMock.mockImplementation(
+      (p: Parameters<typeof realOpenSync>[0], flags: Parameters<typeof realOpenSync>[1]) =>
+        realOpenSync(p, flags),
+    );
+  }
+
+  it("探针活（异宿主 pid 在持声明）→ 跳过终态化：零 entry + 无 .state 防重锚", () => {
+    const sessionFile = path.join(tmpDir, "orphan-foreign-live.jsonl");
+    writeOrphanSession(sessionFile, "sa-probe-1");
+    // pid 1（launchd）必然存活且非本测试进程——异宿主「在持声明」的确定性形态
+    writeAliveMarker(sessionFile, { pid: 1, id: "sa-probe-1", startedAt: Date.now() });
+    passthroughOpenSync();
+
+    const { store, appended } = makeStore();
+    store.recoverOrphanRecords("sess-orphan");
+
+    expect(appended).toHaveLength(0); // 跳过：不落任何终态/resumable entry
+    expect(fs.existsSync(`${sessionFile}.state`)).toBe(false); // 未终态化 = 无防重锚
+  });
+
+  it("pid 死（marker 残留但持有者已退）→ 正常终态化：closed+gc entry + .state 防重锚", () => {
+    const sessionFile = path.join(tmpDir, "orphan-dead-pid.jsonl");
+    writeOrphanSession(sessionFile, "sa-probe-2");
+    // 大 pid 用户空间必然不存在（ESRCH 判死）——原持有宿主已退出的残留 marker 形态
+    writeAliveMarker(sessionFile, { pid: 9999999, id: "sa-probe-2", startedAt: Date.now() });
+    passthroughOpenSync();
+
+    const { store, appended } = makeStore();
+    store.recoverOrphanRecords("sess-orphan");
+
+    expect(appended).toHaveLength(1);
+    expect(appended[0]?.customType).toBe("subagent-record");
+    expect(appended[0]?.data.status).toBe("closed");
+    expect(appended[0]?.data.closedReason).toBe("gc");
+    expect(fs.existsSync(`${sessionFile}.state`)).toBe(true); // 终态防重锚落盘
+  });
+
+  it("self-pid marker（pid 复用到本进程的残留声明）→ 放行清理：原持有者已死，record 确为孤儿", () => {
+    const sessionFile = path.join(tmpDir, "orphan-self-pid.jsonl");
+    writeOrphanSession(sessionFile, "sa-probe-3");
+    // self-pid 排除：findForeignLiveInstance 视同无 foreign——复用窗口内残留 marker
+    // 不构成「异宿主在持」，record 是真孤儿应照常终态化
+    writeAliveMarker(sessionFile, { pid: process.pid, id: "sa-probe-3", startedAt: Date.now() });
+    passthroughOpenSync();
+
+    const { store, appended } = makeStore();
+    store.recoverOrphanRecords("sess-orphan");
+
+    expect(appended).toHaveLength(1);
+    expect(appended[0]?.data.status).toBe("closed");
+    expect(appended[0]?.data.closedReason).toBe("gc");
+  });
+});

package/src/execution/__tests__/record-store.test.ts

@@ -37,15 +37,15 @@ vi.mock("../sessions-index.ts", async (importOriginal) => {
 
 import { writeAliveMarker } from "../alive-store.ts";
 import { completeRecord, createRecord, projectOutcome, tryTransition } from "../execution-record.ts";
-import { writeFinalized } from "../finalized-marker.ts";
+import { writeCancelledState, writeFinalizedState } from "../state-marker.ts";
 import type { ManifestRecord } from "../manifest-store.ts";
 import { ManifestStore } from "../manifest-store.ts";
 import { getSubagentRecordsDir, getSubagentSessionDir } from "../path-encoding.ts";
 import { SUBAGENT_RECORD_CUSTOM_TYPE } from "../record-entry.ts";
 import type { StatusFilter } from "../record-store.ts";
 import { RecordStore } from "../record-store.ts";
-import { writeCancelledTombstone } from "../tombstone-store.ts";
 import type { AliveMarker, ExecutionRecord } from "../types.ts";
+import { writeLegacyCancelledSidecar, writeLegacyFinalizedSidecar } from "./helpers/legacy-sidecar.ts";
 
 /** 构造 ExecutionRecord（base 默认 running，over 覆盖任意字段）。 */
 function makeRecord(over: Partial<ExecutionRecord> = {}): ExecutionRecord {
@@ -187,12 +187,12 @@ describe("RecordStore", () => {
       expect(full?.status).toBe("running"); // 状态矩阵在全量路径同样套用
     });
 
-    it("磁盘 session.jsonl + .finalized sidecar → done", () => {
+    it("磁盘 session.jsonl + .state sidecar（finalized） → done", () => {
       const sessionFile = path.join(tmpDir, "2026-01-01-uuid-b.jsonl");
       writeSessionJsonl(sessionFile, {
         id: "bg-2", agent: "worker", mode: "background", task: "do it", startedAt: 5000,
       });
-      writeFinalized(sessionFile);
+      writeFinalizedState(sessionFile);
       const store = new RecordStore(tmpDir);
       const found = store.collectRecords(100).find((r) => r.id === "bg-2");
       expect(found).toBeDefined();
@@ -276,14 +276,12 @@ describe("RecordStore", () => {
   // cancelled tombstone override
   // ============================================================
   describe("cancelled tombstone", () => {
-    it("有 .cancelled sidecar → status override 为 closed + closedReason=cancelled", () => {
+    it("有 .state sidecar（cancelled） → status override 为 closed + closedReason=cancelled", () => {
       const sessionFile = path.join(tmpDir, "2026-01-01-uuid-a.jsonl");
       writeSessionJsonl(sessionFile, {
         id: "bg-1", agent: "worker", mode: "background", task: "do it", startedAt: 5000,
       });
-      writeCancelledTombstone(sessionFile, {
-        id: "bg-1", status: "cancelled", agent: "worker", startedAt: 5000, endedAt: 6000,
-      });
+      writeCancelledState(sessionFile, 6000);
       const store = new RecordStore(tmpDir);
       const found = store.collectRecords(100).find((r) => r.id === "bg-1");
       // v4 B-1：cancelled 折入 closed，closedReason='cancelled' 保留用户取消语义
@@ -302,12 +300,12 @@ describe("RecordStore", () => {
       // 内存 running record
       const running = makeRecord({ id: "run-1", mode: "background", startedAt: 3000, status: "running" });
       store.register(running);
-      // 磁盘 closed record（.finalized sidecar → closed，v4 B-1 统一终态）
+      // 磁盘 closed record（.state sidecar（finalized） → closed，v4 B-1 统一终态）
       const doneFile = path.join(tmpDir, "a.jsonl");
       writeSessionJsonl(doneFile, {
         id: "done-1", agent: "w", mode: "background", task: "t", startedAt: 5000,
       });
-      writeFinalized(doneFile);
+      writeFinalizedState(doneFile);
       const ids = store.collectRecords(100).map((r) => r.id);
       expect(ids[0]).toBe("run-1"); // running(0) 排在 closed(3) 前
     });
@@ -405,12 +403,10 @@ describe("RecordStore", () => {
       return sessionFile;
     }
 
-    // ── 分支 1: .cancelled ──
-    it(".cancelled sidecar → closed + closedReason=cancelled", () => {
+    // ── 分支 1: 终态 sidecar status=cancelled ──
+    it(".state sidecar（cancelled） → closed + closedReason=cancelled", () => {
       const sessionFile = writeBaseSession();
-      writeCancelledTombstone(sessionFile, {
-        id: SESSION_ID, status: "cancelled", agent: "worker", startedAt: STARTED_AT, endedAt: 6000,
-      });
+      writeCancelledState(sessionFile, 6000);
       const store = new RecordStore(tmpDir);
       const found = store.collectRecords(100).find((r) => r.id === SESSION_ID);
       // v4 B-1：cancelled 折入 closed（closedReason='cancelled' 区分用户取消）
@@ -420,17 +416,17 @@ describe("RecordStore", () => {
       expect(found?.endedAt).toBe(6000);
     });
 
-    // ── 分支 2: .finalized done ──
-    it(".finalized sidecar + stopReason=stop → done", () => {
+    // ── 分支 2: 终态 sidecar status=finalized（done）──
+    it(".state sidecar（finalized） + stopReason=stop → done", () => {
       const sessionFile = writeBaseSession();
-      writeFinalized(sessionFile);
+      writeFinalizedState(sessionFile);
       const store = new RecordStore(tmpDir);
       const found = store.collectRecords(100).find((r) => r.id === SESSION_ID);
       expect(found?.status).toBe("closed");
     });
 
-    // ── 分支 2: .finalized failed ──
-    it(".finalized sidecar + stopReason=error → failed", () => {
+    // ── 分支 2: 终态 sidecar status=finalized（failed）──
+    it(".state sidecar（finalized） + stopReason=error → failed", () => {
       // 写一个 stopReason=error 的 session.jsonl
       const sessionFile = path.join(tmpDir, "2026-01-01-uuid-fail.jsonl");
       const header = JSON.stringify({
@@ -455,22 +451,24 @@ describe("RecordStore", () => {
       });
       fs.writeFileSync(sessionFile, `${header}\n${identityEntry}\n${assistantMsg}\n`, "utf-8");
 
-      writeFinalized(sessionFile);
+      writeFinalizedState(sessionFile);
       const store = new RecordStore(tmpDir);
       const found = store.collectRecords(100).find((r) => r.id === SESSION_ID);
       expect(found?.status).toBe("closed");
     });
 
-    // ── 分支 3: .alive + 活 pid → running + externalInstance ──
-    it(".alive + 存活 pid → running + externalInstance=true", () => {
+    // ── 分支 3→4: .alive + 活 pid → running 兜底（U4a / D3b (a)：投影退役）──
+    it(".alive + 存活 pid → running 兜底，无 externalInstance 投影（探活读面走现查探针）", () => {
       const sessionFile = writeBaseSession();
-      const recentStartedAt = Date.now() - 1000; // 1 秒前，确保未超 24h
+      const recentStartedAt = Date.now() - 1000; // 1 秒前
       const marker: AliveMarker = { pid: process.pid, id: SESSION_ID, startedAt: recentStartedAt };
       writeAliveMarker(sessionFile, marker);
       const store = new RecordStore(tmpDir);
       const found = store.collectRecords(100).find((r) => r.id === SESSION_ID);
       expect(found?.status).toBe("running");
-      expect(found?.externalInstance).toEqual(marker);
+      // externalInstance 字段链已删（D3b (a)：重建投影不再携带探活缓存，
+      // fork-from 守卫/孤儿恢复改 findForeignLiveInstance 现查）。
+      expect(found).not.toHaveProperty("externalInstance");
     });
 
     // ── 分支 3→4: .alive + 死 pid → running（SP-2：跨重启可恢复）──
@@ -481,7 +479,7 @@ describe("RecordStore", () => {
       const store = new RecordStore(tmpDir);
       const found = store.collectRecords(100).find((r) => r.id === SESSION_ID);
       expect(found?.status).toBe("running");
-      expect(found?.externalInstance).toBeUndefined();
+      expect(found).not.toHaveProperty("externalInstance");
     });
 
     // ── 分支 4: 都无 sidecar → running（SP-2：跨重启可恢复）──
@@ -492,10 +490,10 @@ describe("RecordStore", () => {
       expect(found?.status).toBe("running");
     });
 
-    // ── 分支 4: >24h 软超时 → running（SP-2：跨重启可恢复，无视探活）──
-    it(">24h 软超时 → running（SP-2，即使 pid 存活）", () => {
+    // ── 分支 4: 老旧 .alive（原 >24h 软超时形态）→ running（status 与 .alive 解耦）──
+    it(".alive 存在即不影响 status 判定 → running 兜底（软超时/探活读面已退役）", () => {
       const sessionFile = writeBaseSession();
-      // startedAt 设为 25 小时前
+      // startedAt 设为 25 小时前（旧三判据形态下的软超时区——现已无判定参与）
       const oldStartedAt = Date.now() - 25 * 60 * 60 * 1000;
       const marker: AliveMarker = { pid: process.pid, id: SESSION_ID, startedAt: oldStartedAt };
       writeAliveMarker(sessionFile, marker);
@@ -509,27 +507,49 @@ describe("RecordStore", () => {
       const store = new RecordStore(tmpDir);
       const found = store.collectRecords(100).find((r) => r.id === SESSION_ID);
       expect(found?.status).toBe("running");
-      expect(found?.externalInstance).toBeUndefined();
+      expect(found).not.toHaveProperty("externalInstance");
     });
 
-    // ── 回归：.cancelled 优先于 .finalized ──
-    it(".cancelled 优先于 .finalized（即使两者共存）", () => {
+    // ── 兼容读回归：存量旧名共存时 .cancelled 优先于 .finalized ──
+    it("兼容读：旧 .cancelled 优先于旧 .finalized（存量共存形态，优先级对齐合并前）", () => {
       const sessionFile = writeBaseSession();
-      writeFinalized(sessionFile);
-      writeCancelledTombstone(sessionFile, {
+      writeLegacyFinalizedSidecar(sessionFile);
+      writeLegacyCancelledSidecar(sessionFile, {
         id: SESSION_ID, status: "cancelled", agent: "worker", startedAt: STARTED_AT, endedAt: 6000,
       });
       const store = new RecordStore(tmpDir);
       const found = store.collectRecords(100).find((r) => r.id === SESSION_ID);
-      // v4 B-1：.cancelled 优先级不变，但 status 折入 closed（closedReason='cancelled'）
+      // v4 B-1：cancelled 优先级不变，但 status 折入 closed（closedReason='cancelled'）
       expect(found?.status).toBe("closed");
       expect(found?.closedReason).toBe("cancelled");
     });
 
-    // ── 回归：旧 .cancelled 单分支行为不变 ──
-    it("旧 .cancelled 单分支行为不变（回归，status 折入 closed）", () => {
+    // ── 新名权威：.state 与存量旧名共存时 .state 胜出 ──
+    it(".state 优先于存量旧名（新写侧权威，旧文件残留不覆盖新终态）", () => {
+      const sessionFile = writeBaseSession();
+      writeLegacyCancelledSidecar(sessionFile, {
+        id: SESSION_ID, status: "cancelled", agent: "worker", startedAt: STARTED_AT, endedAt: 6000,
+      });
+      writeFinalizedState(sessionFile, "user-close");
+      const store = new RecordStore(tmpDir);
+      const found = store.collectRecords(100).find((r) => r.id === SESSION_ID);
+      expect(found?.status).toBe("closed");
+      expect(found?.closedReason).toBe("user-close");
+    });
+
+    // ── 回归：旧名单分支行为不变（存量 .finalized / .cancelled 仍被读出）──
+    it("兼容读：旧 .finalized 单分支行为不变（存量空文件 → disconnected）", () => {
       const sessionFile = writeBaseSession();
-      writeCancelledTombstone(sessionFile, {
+      writeLegacyFinalizedSidecar(sessionFile);
+      const store = new RecordStore(tmpDir);
+      const found = store.collectRecords(100).find((r) => r.id === SESSION_ID);
+      expect(found?.status).toBe("closed");
+      expect(found?.closedReason).toBe("disconnected");
+    });
+
+    it("兼容读：旧 .cancelled 单分支行为不变（回归，status 折入 closed）", () => {
+      const sessionFile = writeBaseSession();
+      writeLegacyCancelledSidecar(sessionFile, {
         id: SESSION_ID, status: "cancelled", agent: "worker", startedAt: STARTED_AT, endedAt: 7000,
       });
       const store = new RecordStore(tmpDir);
@@ -621,13 +641,13 @@ describe("RecordStore", () => {
   // endedAt 重建（问题 2 修复：终态耗时不再随墙钟增长）
   // ============================================================
   describe("endedAt 重建（耗时不再无限增长）", () => {
-    it(".finalized → light endedAt 用 mtime 近似，全量 endedAt 为最后 entry 时间戳", () => {
+    it(".state（finalized）→ light endedAt 用 mtime 近似，全量 endedAt 为最后 entry 时间戳", () => {
       const sessionFile = path.join(tmpDir, "fin.jsonl");
       writeSessionJsonl(sessionFile, {
         id: "bg-1", agent: "w", mode: "background", task: "t",
         startedAt: 5000, lastTs: 9000, rootSessionId: "sess-A",
       });
-      writeFinalized(sessionFile);
+      writeFinalizedState(sessionFile);
       const store = new RecordStore(tmpDir);
       const found = store.collectRecords(100, "all", "sess-A").find((r) => r.id === "bg-1");
       // [perf] light 分支 2：endedAt 用 jsonl mtime 近似（finalize 后文件不再变化，
@@ -768,14 +788,14 @@ describe("RecordStore", () => {
       expect(found?.endedAt).toBeUndefined();
     });
 
-    // TC-2: 有 .finalized marker 的 record 仍归档为 done（不回归）
-    it("TC-2: .finalized marker → done（分支 1/2 不回归）", () => {
+    // TC-2: 有 .state marker（finalized） 的 record 仍归档为 done（不回归）
+    it("TC-2: .state marker（finalized） → done（分支 1/2 不回归）", () => {
       const sessionFile = path.join(tmpDir, "sp2-tc2.jsonl");
       writeSessionJsonl(sessionFile, {
         id: "sa-sp2-2", agent: "worker", mode: "background", task: "finalized task",
         startedAt: 2000, rootSessionId: "sess-sp2",
       });
-      writeFinalized(sessionFile);
+      writeFinalizedState(sessionFile);
       const store = new RecordStore(tmpDir);
       const found = store.collectRecords(100, "all", "sess-sp2").find((r) => r.id === "sa-sp2-2");
       expect(found).toBeDefined();
@@ -784,16 +804,14 @@ describe("RecordStore", () => {
       expect(found?.endedAt).toBeDefined();
     });
 
-    // TC-2b: .cancelled marker → closed+cancelled（分支 1 不回归）
-    it("TC-2b: .cancelled marker → closed+cancelled reason（分支 1 不回归）", () => {
+    // TC-2b: .state marker（cancelled） → closed+cancelled（分支 1 不回归）
+    it("TC-2b: .state marker（cancelled） → closed+cancelled reason（分支 1 不回归）", () => {
       const sessionFile = path.join(tmpDir, "sp2-tc2b.jsonl");
       writeSessionJsonl(sessionFile, {
         id: "sa-sp2-2b", agent: "worker", mode: "background", task: "cancelled task",
         startedAt: 3000, rootSessionId: "sess-sp2",
       });
-      writeCancelledTombstone(sessionFile, {
-        id: "sa-sp2-2b", status: "cancelled", agent: "worker", startedAt: 3000, endedAt: 4000,
-      });
+      writeCancelledState(sessionFile, 4000);
       const store = new RecordStore(tmpDir);
       const found = store.collectRecords(100, "all", "sess-sp2").find((r) => r.id === "sa-sp2-2b");
       expect(found).toBeDefined();
@@ -839,7 +857,7 @@ describe("RecordStore", () => {
         closedReason: entry?.data.closedReason as never,
         error: entry?.data.error as string | undefined,
       })).toBe("failed");
-      expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(true);
+      expect(fs.existsSync(`${sessionFile}.state`)).toBe(true);
       // 防重：sidecar 使下次重建走分支 2（closed），不再进判定
       const again = [...appended];
       store.recoverOrphanRecords("sess-orphan");
@@ -889,7 +907,7 @@ describe("RecordStore", () => {
       expect(entry?.data.status).toBe("running");
       expect(entry?.data.resumable).toBe(true);
       // 保留分支不写终态 sidecar
-      expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(false);
+      expect(fs.existsSync(`${sessionFile}.state`)).toBe(false);
     });
 
     it("末行截断 → closed + error（保守方向；[F3] in-flight 同时携重启中断语义）", () => {
@@ -907,7 +925,7 @@ describe("RecordStore", () => {
       expect(entry?.data.status).toBe("closed");
       expect(entry?.data.error).toContain("truncated");
       expect(entry?.data.error).toContain("host restart");
-      expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(true);
+      expect(fs.existsSync(`${sessionFile}.state`)).toBe(true);
     });
 
     it("末行 >64KB 完整 JSON → 不误判截断，[F3] in-flight 携重启中断 error（无 truncated）", () => {
@@ -932,7 +950,7 @@ describe("RecordStore", () => {
       // [F3] in-flight 重启中断 error 必有；「不误判截断」= error 不含 truncated 标记
       expect(entry?.data.error).toContain("host restart");
       expect(entry?.data.error).not.toContain("truncated");
-      expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(true);
+      expect(fs.existsSync(`${sessionFile}.state`)).toBe(true);
     });
 
     it("chatMode 孤儿 → 不终态化，落 resumable entry（可续聊产品语义）", () => {
@@ -949,7 +967,7 @@ describe("RecordStore", () => {
       expect(entry?.data.resumable).toBe(true);
       expect(entry?.data.chatMode).toBe(true);
       // chat 分流不写终态 sidecar
-      expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(false);
+      expect(fs.existsSync(`${sessionFile}.state`)).toBe(false);
       // orphanJudged 缓存：同 store 重复调用不重复 append
       const count = appended.length;
       store.recoverOrphanRecords("sess-orphan");
@@ -962,7 +980,7 @@ describe("RecordStore", () => {
         id: "sa-orphan-4", agent: "worker", mode: "background", task: "already closed",
         startedAt: 4000, rootSessionId: "sess-orphan",
       });
-      writeFinalized(closedFile);
+      writeFinalizedState(closedFile);
       const { store, appended } = makeRecoveryStore();
       store.recoverOrphanRecords("sess-orphan");
       expect(appended.find((c) => c.data.id === "sa-orphan-4")).toBeUndefined();

package/src/execution/__tests__/recursive-visibility-baseline.test.ts

@@ -16,7 +16,7 @@
 //   4. forkDepth 基线：env PI_SUBAGENT_FORK_DEPTH → fork spawn env 递增
 //
 // mock 策略与 execute-nesting.test.ts 一致（spawn → FakeChild，fs 同步方法 mock，
-// temp-prompt / alive-store / finalized-marker / manifest-store mock；已收敛
+// temp-prompt / alive-store / state-marker / manifest-store mock；已收敛
 // ./helpers/subagent-service-mocks.ts 四文件共享单源）。
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -24,7 +24,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   aliveStoreModule,
   childProcessModule,
-  finalizedMarkerModule,
+  stateMarkerModule,
   fsSyncModule,
   manifestStoreModule,
 } from "./helpers/subagent-service-mocks.ts";
@@ -34,7 +34,7 @@ import {
 vi.mock("node:child_process", () => childProcessModule());
 vi.mock("node:fs", async (importOriginal) => fsSyncModule(await importOriginal<typeof import("node:fs")>()));
 vi.mock("../alive-store.ts", async (importOriginal) => aliveStoreModule(await importOriginal<typeof import("../alive-store.ts")>()));
-vi.mock("../finalized-marker.ts", () => finalizedMarkerModule());
+vi.mock("../state-marker.ts", () => stateMarkerModule());
 vi.mock("../manifest-store.ts", () => manifestStoreModule());
 
 import { spawn } from "node:child_process";
@@ -167,7 +167,9 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
 
     const { service, store } = setup({});
     registerHangingEngine();
-    const execNesting = Reflect.get(service, "execNesting") as ExecCtxAls;
+    // [R1 深绑改写] execNesting 随域 #2 聚合迁入 SessionBaselines，深绑路径改为
+    // service → baselines 聚合实例（断言对象与强度不变，路径对齐终态结构）。
+    const execNesting = (Reflect.get(service, "baselines") as { execNesting: ExecCtxAls }).execNesting;
 
     const handle = await execNesting.run({ recordId: "sa-inline-parent", depth: 3 }, () =>
       service.execute({ task: "inline nested", slug: "test", ctxModel }),
@@ -191,7 +193,8 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
     const { service } = setup({});
     registerHangingEngine();
 
-    expect(Reflect.get(service, "forkDepthBaseline")).toBe(1);
+    // [R1 深绑改写] forkDepthBaseline 经 baselines 聚合路径读取（同一权威字段，等价强度）。
+    expect((Reflect.get(service, "baselines") as { forkDepthBaseline: number }).forkDepthBaseline).toBe(1);
 
     // fork 请求照常派发（引擎侧承载深度传递）——不因基线读取抛错
     await expect(service.execute({ task: "fork child", slug: "test", ctxModel, fork: true })).resolves.toBeDefined();