@zhushanwen/subagent-core 0.5.1 → 0.7.0

package/src/execution/__tests__/reconcile-sweep.test.ts

@@ -0,0 +1,200 @@
+// src/execution/__tests__/reconcile-sweep.test.ts
+//
+// [W4] 注册对账 sweep 单测：差集判据（record 终态 ∪ 已归档/不存在 → 补发；
+// active → 跳过）、类型分流（[F2]：workflow/畸形走 workflow run 判据——终态 ∪
+// store 查不到 → 补注销，running → 跳过；bash 无收口通道保守跳过——显式偏差；
+// 未注入 workflow 判据时保守跳过）、写法（appendEntry 权威落盘 + 尽力 emit；
+// appendEntry 抛错不计入且不 emit）。差集输入 session 文件用
+// mkdtempSync 自建自删（禁触真实数据目录）。
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { runReconcileSweep, type SupervisedRecordState } from "../round-supervisor/reconcile-sweep.ts";
+
+let tmpDir: string;
+let sessionFile: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "round-sweep-"));
+  sessionFile = path.join(tmpDir, "session.jsonl");
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  vi.restoreAllMocks();
+});
+
+function writeSessionFile(lines: unknown[]): void {
+  fs.writeFileSync(sessionFile, lines.map((l) => JSON.stringify(l)).join("\n") + "\n", "utf-8");
+}
+
+function reg(id: string, type = "subagent"): unknown {
+  return { customType: "pending:register", data: { id, type, name: id, registeredAt: 1, sessionId: "sess" } };
+}
+
+function unreg(id: string): unknown {
+  return { customType: "pending:unregister", data: { id, reason: "completed" } };
+}
+
+function makeDeps(overrides: {
+  states?: Map<string, SupervisedRecordState>;
+  workflowStates?: Map<string, SupervisedRecordState>;
+  injectWorkflowLookup?: boolean;
+  appendEntry?: (customType: string, data: unknown) => void;
+  emit?: (channel: string, data: unknown) => void;
+  sessionFile?: string;
+} = {}) {
+  const states = overrides.states ?? new Map<string, SupervisedRecordState>();
+  const workflowStates = overrides.workflowStates;
+  const appended: Array<{ customType: string; data: unknown }> = [];
+  const emitted: Array<{ channel: string; data: unknown }> = [];
+  const deps = {
+    sessionFile: overrides.sessionFile ?? sessionFile,
+    lookupRecordState: (id: string): SupervisedRecordState => states.get(id) ?? "missing",
+    // [F2] workflow 判据：显式注入（injectWorkflowLookup !== false 或给了
+    // workflowStates）时按 Map 查；否则缺席（向后兼容形态）。
+    ...(overrides.injectWorkflowLookup === false && workflowStates === undefined
+      ? {}
+      : {
+          lookupWorkflowRunState: (id: string): SupervisedRecordState =>
+            workflowStates?.get(id) ?? "missing",
+        }),
+    appendEntry: overrides.appendEntry ?? ((customType: string, data: unknown) => appended.push({ customType, data })),
+    emit: overrides.emit ?? ((channel: string, data: unknown) => emitted.push({ channel, data })),
+  };
+  return { deps, appended, emitted };
+}
+
+describe("runReconcileSweep 差集补发", () => {
+  it("register(subagent) × record 终态 → 补发 unregister（appendEntry 权威 + 尽力 emit），reason 取 closedReason", () => {
+    writeSessionFile([reg("bg-1")]);
+    const { deps, appended, emitted } = makeDeps({
+      states: new Map([["bg-1", { terminal: true, closedReason: "cancelled" }]]),
+    });
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["bg-1"]);
+    expect(appended).toEqual([
+      { customType: "pending:unregister", data: { id: "bg-1", reason: "cancelled", status: "cancelled" } },
+    ]);
+    expect(emitted).toHaveLength(1);
+  });
+
+  it("record 已归档/不存在（查不到）→ 视同终态补注销（reason=expired）", () => {
+    writeSessionFile([reg("bg-gone")]);
+    const { deps, appended } = makeDeps({ states: new Map() }); // lookup 恒 missing
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["bg-gone"]);
+    expect(appended[0].data).toEqual({ id: "bg-gone", reason: "expired", status: "expired" });
+  });
+
+  it("record 活跃 → 保守跳过（不写不 emit）", () => {
+    writeSessionFile([reg("bg-live")]);
+    const { deps, appended, emitted } = makeDeps({ states: new Map([["bg-live", "active"]]) });
+    const result = runReconcileSweep(deps);
+    expect(result.skippedActive).toEqual(["bg-live"]);
+    expect(appended).toHaveLength(0);
+    expect(emitted).toHaveLength(0);
+  });
+
+  it("[F2] type=workflow × workflow run 终态 → 补注销（reason 取 run state reason）", () => {
+    writeSessionFile([reg("wf-1", "workflow")]);
+    const { deps, appended, emitted } = makeDeps({
+      workflowStates: new Map([["wf-1", { terminal: true, closedReason: "aborted" }]]),
+    });
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["wf-1"]);
+    expect(appended).toEqual([
+      { customType: "pending:unregister", data: { id: "wf-1", reason: "aborted", status: "aborted" } },
+    ]);
+    expect(emitted).toHaveLength(1);
+  });
+
+  it("[F2] type=workflow × workflow run running → 保守跳过（宁挂账不误注销活跃 run）", () => {
+    writeSessionFile([reg("wf-live", "workflow")]);
+    const { deps, appended } = makeDeps({
+      workflowStates: new Map([["wf-live", "active"]]),
+    });
+    const result = runReconcileSweep(deps);
+    expect(result.skippedActive).toEqual(["wf-live"]);
+    expect(result.reconciled).toEqual([]);
+    expect(appended).toHaveLength(0);
+  });
+
+  it("[F2] 畸形条目（type 缺失/未知，normalizePendingType 归 workflow）× store 查不到 → 视同终态补注销", () => {
+    writeSessionFile([reg("bad-1", "mystery")]);
+    const { deps, appended } = makeDeps({}); // workflowStates 缺省 = 恒 missing
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["bad-1"]);
+    expect(appended[0].data).toEqual({ id: "bad-1", reason: "expired", status: "expired" });
+  });
+
+  it("[F2] type=bash → 保守跳过（无 record/store 可查，显式偏差——宁挂账不失明）", () => {
+    writeSessionFile([reg("bt-1", "bash")]);
+    const { deps, appended } = makeDeps({});
+    const result = runReconcileSweep(deps);
+    expect(result.skippedNonSubagent).toEqual(["bt-1"]);
+    expect(appended).toHaveLength(0);
+  });
+
+  it("[F2] deps 未注入 workflow 判据 → workflow/未知类型保守跳过（判据缺席 ≠ 可注销）", () => {
+    writeSessionFile([reg("wf-1", "workflow"), reg("bad-1", "mystery")]);
+    const { deps, appended } = makeDeps({ injectWorkflowLookup: false });
+    const result = runReconcileSweep(deps);
+    expect(result.skippedNonSubagent.sort()).toEqual(["bad-1", "wf-1"]);
+    expect(appended).toHaveLength(0);
+  });
+
+  it("已注销的 id 不出现在差集 → 不补发", () => {
+    writeSessionFile([reg("bg-1"), unreg("bg-1")]);
+    const { deps, appended } = makeDeps();
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual([]);
+    expect(appended).toHaveLength(0);
+  });
+
+  it("unregister 之后的重注册重新进差集（同 id 重 register = 后写胜出）", () => {
+    writeSessionFile([reg("bg-1"), unreg("bg-1"), reg("bg-1")]);
+    const { deps, appended } = makeDeps();
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["bg-1"]);
+    expect(appended).toHaveLength(1);
+  });
+
+  it("sessionFile 缺失 → 空跑（不抛）", () => {
+    const { deps } = makeDeps({ sessionFile: undefined });
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual([]);
+  });
+
+  it("session 文件不可读（未 flush/被删）→ 空跑", () => {
+    const { deps } = makeDeps({ sessionFile: path.join(tmpDir, "nope.jsonl") });
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual([]);
+  });
+
+  it("appendEntry 抛错 → 不计 reconciled、不 emit（差集残留交下次 sweep 重试）", () => {
+    writeSessionFile([reg("bg-1"), reg("bg-2")]);
+    const { deps, emitted } = makeDeps({
+      appendEntry: (customType, data) => {
+        if ((data as { id: string }).id === "bg-1") throw new Error("EACCES");
+      },
+    });
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["bg-2"]);
+    expect(emitted.map((e) => (e.data as { id: string }).id)).toEqual(["bg-2"]);
+  });
+
+  it("坏行（截断 JSON）跳过不拖垮其余条目", () => {
+    fs.writeFileSync(sessionFile, [JSON.stringify(reg("bg-1")), '{"customType":"pending:regis'].join("\n"), "utf-8");
+    const { deps, appended } = makeDeps({
+      states: new Map([["bg-1", { terminal: true, closedReason: "gc" }]]),
+    });
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["bg-1"]);
+    expect(appended).toHaveLength(1);
+  });
+});

package/src/execution/__tests__/record-entry-collect.test.ts

@@ -0,0 +1,102 @@
+// src/execution/__tests__/record-entry-collect.test.ts
+//
+// subagent-record entry 序列化白名单：collectMode / batchFinalized 两字段
+// （subagent-sync-collect U1 foundation）。
+//
+// 锁三件事（设计 §3.1.3）：
+//   1. 持久化：两字段在 entry data 中如实透传（round-trip 经 JSON 序列化不丢）；
+//   2. 零迁移：无字段（旧 record 形态）的 entry 产物不含新键（JSON.stringify 自然缺省），
+//      与改动前逐字节一致；
+//   3. customType 稳定：SUBAGENT_RECORD_CUSTOM_TYPE 不因扩字段漂移。
+
+import { describe, expect, it } from "vitest";
+
+import {
+  SUBAGENT_RECORD_CUSTOM_TYPE,
+  toSubagentRecordEntry,
+  type SubagentRecordEntryData,
+} from "../record-entry.ts";
+import type { SubagentRecord } from "../types.ts";
+
+/** 最小合法 SubagentRecord（缺省无 collect 两字段 = 旧记录形态）。 */
+function makeRecord(over: Partial<SubagentRecord> = {}): SubagentRecord {
+  return {
+    id: "sa-1",
+    agent: "/home/u/agents/worker.md",
+    task: "t",
+    slug: "worker",
+    status: "running",
+    mode: "background",
+    startedAt: 1000,
+    rootSessionId: "root-A",
+    parentRecordId: undefined,
+    depth: 0,
+    endedAt: undefined,
+    turns: 1,
+    totalTokens: 42,
+    model: "prov/m1",
+    thinkingLevel: undefined,
+    eventLog: [],
+    displayItems: [],
+    sessionFile: "sess-1.jsonl",
+    ...over,
+  } as SubagentRecord;
+}
+
+/** entry data 的 JSONL 形态字符串（appendEntry 落盘即此产物）。 */
+function serialize(entry: SubagentRecordEntryData): string {
+  return JSON.stringify(entry);
+}
+
+describe("record-entry serialization: collect fields (U1 foundation)", () => {
+  it("keeps SUBAGENT_RECORD_CUSTOM_TYPE stable", () => {
+    expect(SUBAGENT_RECORD_CUSTOM_TYPE).toBe("subagent-record");
+  });
+
+  it("passes collectMode through for a sync record", () => {
+    const entry = toSubagentRecordEntry(makeRecord({ collectMode: "sync" }));
+    expect(entry.collectMode).toBe("sync");
+    expect(entry.batchFinalized).toBeUndefined();
+  });
+
+  it("passes batchFinalized through for a member that left the batch", () => {
+    const entry = toSubagentRecordEntry(
+      makeRecord({
+        collectMode: "sync",
+        batchFinalized: true,
+        status: "closed",
+        endedAt: 2000,
+      }),
+    );
+    expect(entry.collectMode).toBe("sync");
+    expect(entry.batchFinalized).toBe(true);
+    expect(entry.status).toBe("closed");
+  });
+
+  it("round-trips both fields through JSON serialization (persisted form)", () => {
+    const entry = toSubagentRecordEntry(
+      makeRecord({ collectMode: "sync", batchFinalized: true }),
+    );
+    const revived = JSON.parse(serialize(entry)) as SubagentRecordEntryData;
+    expect(revived.collectMode).toBe("sync");
+    expect(revived.batchFinalized).toBe(true);
+    expect(revived.v).toBe(1);
+  });
+
+  it("emits no new keys for legacy records (旧记录零迁移)", () => {
+    const json = serialize(toSubagentRecordEntry(makeRecord()));
+    expect(json).not.toContain("collectMode");
+    expect(json).not.toContain("batchFinalized");
+    const revived = JSON.parse(json) as SubagentRecordEntryData;
+    expect(revived.collectMode).toBeUndefined();
+    expect(revived.batchFinalized).toBeUndefined();
+  });
+
+  it("still emits the full legacy whitelist for legacy records (既有字段不受扩字段影响)", () => {
+    const entry = toSubagentRecordEntry(makeRecord());
+    expect(entry.id).toBe("sa-1");
+    expect(entry.status).toBe("running");
+    expect(entry.model).toBe("prov/m1");
+    expect(entry.sessionFile).toBe("sess-1.jsonl");
+  });
+});

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

@@ -36,7 +36,7 @@ vi.mock("../sessions-index.ts", async (importOriginal) => {
 });
 
 import { writeAliveMarker } from "../alive-store.ts";
-import { completeRecord, createRecord, tryTransition } from "../execution-record.ts";
+import { completeRecord, createRecord, projectOutcome, tryTransition } from "../execution-record.ts";
 import { writeFinalized } from "../finalized-marker.ts";
 import type { ManifestRecord } from "../manifest-store.ts";
 import { ManifestStore } from "../manifest-store.ts";
@@ -817,7 +817,7 @@ describe("RecordStore", () => {
       return { store, appended };
     }
 
-    it("末行完整 → closed 终态 entry + .finalized sidecar（防重锚）", () => {
+    it("末行完整（in-flight，无 resumable）→ closed + 重启中断 error，投影 failed（[F3] 表 3 行 2）", () => {
       const sessionFile = path.join(tmpDir, "orphan-done.jsonl");
       writeSessionJsonl(sessionFile, {
         id: "sa-orphan-1", agent: "worker", mode: "background", task: "orphan done",
@@ -831,7 +831,14 @@ describe("RecordStore", () => {
       expect(entry?.data.status).toBe("closed");
       expect(entry?.data.closedReason).toBe("gc");
       expect(entry?.data.endedAt).toEqual(expect.any(Number));
-      expect(entry?.data.error).toBeUndefined();
+      // [F3] in-flight 直断 = boot 直断 failed 语义：任务因宿主重启中断，不得投影
+      // completed（事故环 3 残留）。error 载体 → deriveOutcome("gc", error) = failed。
+      expect(entry?.data.error).toContain("host restart");
+      expect(projectOutcome({
+        status: "closed",
+        closedReason: entry?.data.closedReason as never,
+        error: entry?.data.error as string | undefined,
+      })).toBe("failed");
       expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(true);
       // 防重：sidecar 使下次重建走分支 2（closed），不再进判定
       const again = [...appended];
@@ -841,7 +848,51 @@ describe("RecordStore", () => {
       expect(found?.status).toBe("closed");
     });
 
-    it("末行截断 → closed + error（保守方向）", () => {
+    it("SP-5 完成态（resumable + result 有值）→ completed 无 error（不误标重启失败，[F3] 不回归）", () => {
+      const sessionFile = path.join(tmpDir, "orphan-sp5.jsonl");
+      writeSessionJsonl(sessionFile, {
+        id: "sa-orphan-sp5", agent: "worker", mode: "background", task: "sp5 done",
+        startedAt: 6000, rootSessionId: "sess-orphan",
+      });
+      // 主 session 末条 entry（v2 D3 merge 数据源）携 resumable+result——W4 起轮终
+      // 执行态信号随 entry 保留，子文件侧重建不带该信号。data 需过 rebuildEntryRecord
+      // 形状守卫（agent/task/startedAt 必带）。
+      const mainFile = writeMainSession([
+        { id: "sa-orphan-sp5", agent: "worker", task: "sp5 done", startedAt: 6000, status: "running", resumable: true, result: "final answer text" },
+      ]);
+      const { store, appended } = makeRecoveryStore();
+      store.recoverOrphanRecords("sess-orphan", mainFile);
+
+      const entry = appended.find((c) => c.data.id === "sa-orphan-sp5");
+      expect(entry?.data.status).toBe("closed");
+      expect(entry?.data.error).toBeUndefined();
+      expect(projectOutcome({
+        status: "closed",
+        closedReason: entry?.data.closedReason as never,
+        error: entry?.data.error as string | undefined,
+      })).toBe("completed");
+    });
+
+    it("resumable 无产出 → 保持 running 落 resumable entry（W4 死亡纳管态跨重启，boot 重认领源，不直断）", () => {
+      const sessionFile = path.join(tmpDir, "orphan-resumable.jsonl");
+      writeSessionJsonl(sessionFile, {
+        id: "sa-orphan-res", agent: "worker", mode: "background", task: "resumable orphan",
+        startedAt: 7000, rootSessionId: "sess-orphan",
+      });
+      const mainFile = writeMainSession([
+        { id: "sa-orphan-res", agent: "worker", task: "resumable orphan", startedAt: 7000, status: "running", resumable: true },
+      ]);
+      const { store, appended } = makeRecoveryStore();
+      store.recoverOrphanRecords("sess-orphan", mainFile);
+
+      const entry = appended.find((c) => c.data.id === "sa-orphan-res");
+      expect(entry?.data.status).toBe("running");
+      expect(entry?.data.resumable).toBe(true);
+      // 保留分支不写终态 sidecar
+      expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(false);
+    });
+
+    it("末行截断 → closed + error（保守方向；[F3] in-flight 同时携重启中断语义）", () => {
       const sessionFile = path.join(tmpDir, "orphan-truncated.jsonl");
       writeSessionJsonl(sessionFile, {
         id: "sa-orphan-2", agent: "worker", mode: "background", task: "orphan truncated",
@@ -855,10 +906,11 @@ describe("RecordStore", () => {
       const entry = appended.find((c) => c.data.id === "sa-orphan-2");
       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);
     });
 
-    it("末行 >64KB 完整 JSON → 不误判截断，判 done（V1 探针实测回归）", () => {
+    it("末行 >64KB 完整 JSON → 不误判截断，[F3] in-flight 携重启中断 error（无 truncated）", () => {
       const sessionFile = path.join(tmpDir, "orphan-longline.jsonl");
       writeSessionJsonl(sessionFile, {
         id: "sa-orphan-5", agent: "worker", mode: "background", task: "orphan long line",
@@ -877,7 +929,9 @@ describe("RecordStore", () => {
 
       const entry = appended.find((c) => c.data.id === "sa-orphan-5");
       expect(entry?.data.status).toBe("closed");
-      expect(entry?.data.error).toBeUndefined();
+      // [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);
     });
 

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

@@ -27,7 +27,6 @@ import {
   finalizedMarkerModule,
   fsSyncModule,
   manifestStoreModule,
-  tempPromptModule,
 } from "./helpers/subagent-service-mocks.ts";
 
 // ── mock modules（同 execute-nesting.test.ts）──
@@ -37,11 +36,11 @@ vi.mock("node:fs", async (importOriginal) => fsSyncModule(await importOriginal<t
 vi.mock("../alive-store.ts", async (importOriginal) => aliveStoreModule(await importOriginal<typeof import("../alive-store.ts")>()));
 vi.mock("../finalized-marker.ts", () => finalizedMarkerModule());
 vi.mock("../manifest-store.ts", () => manifestStoreModule());
-vi.mock("../engine/engines/pi/temp-prompt.ts", () => tempPromptModule());
 
 import { spawn } from "node:child_process";
 
-import { waitForSpawn, lastSpawnedChild } from "./helpers/spawn-mock.ts";
+import { registerFakePiEngine, type FakePiEnginePort } from "./helpers/fake-engine-port.ts";
+import { clearEngines } from "../engine/registry.ts";
 import { ModelConfigService } from "../model-config-service.ts";
 import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
 import { ManifestStore } from "../manifest-store.ts";
@@ -62,6 +61,13 @@ function getLastSpawnEnv(): Record<string, string | undefined> {
   return (mockSpawn.mock.calls.at(-1)?.[2]?.env as Record<string, string | undefined>) ?? {};
 }
 
+/** [W3] 协议替身：execute → engine.run 挂起不 settle——record 保持 running 在 store
+ *  可观察（原 FakeChild 挂起不推进的等价形态）。 */
+function registerHangingEngine(): FakePiEnginePort {
+  clearEngines();
+  return registerFakePiEngine();
+}
+
 // ── 辅助：service 构造 ──
 
 function makeEmptyRegistry(): ModelRegistryLike {
@@ -122,6 +128,7 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
     process.env[ENV_DEPTH] = "1";
 
     const { service, store } = setup({});
+    registerHangingEngine();
 
     // 不在 execCtxAls.run 内调用（模拟 ALS 断裂：事件回调上下文读不到 store）
     const handle = await service.execute({ task: "child of parent", slug: "test", ctxModel });
@@ -143,6 +150,7 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
 
   it("[顶层] 无 env（根进程）：parentRecordId undefined / depth 0", async () => {
     const { service, store } = setup({});
+    registerHangingEngine();
 
     const handle = await service.execute({ task: "top level", slug: "test", ctxModel });
 
@@ -158,6 +166,7 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
     process.env[ENV_DEPTH] = "0";
 
     const { service, store } = setup({});
+    registerHangingEngine();
     const execNesting = Reflect.get(service, "execNesting") as ExecCtxAls;
 
     const handle = await execNesting.run({ recordId: "sa-inline-parent", depth: 3 }, () =>
@@ -170,24 +179,22 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
     expect(rec!.depth).toBe(4);
   });
 
-  it("[forkDepth 基线] env PI_SUBAGENT_FORK_DEPTH=1 + fork：spawn env 递增为 2（读点兜底基线生效）", async () => {
+  it("[forkDepth 基线] env PI_SUBAGENT_FORK_DEPTH=1 → initSession 建立基线（读点兜底基线生效）", async () => {
+    // [W3 改写] spawn env 注入（PI_SUBAGENT_FORK_DEPTH 递增写子 env）属 inproc
+    // runSpawn 机制，随 inproc pi 引擎目录 删除迁入引擎包（pi-subagent-cli spawn 链）；core
+    // 侧存留语义 = initSession 从 env 建立基线（ALS 断裂时的读点兜底），本用例锁定它。
     process.env[ENV_ROOT_SESSION_ID] = "root-main";
     process.env[ENV_SELF_RECORD_ID] = "sa-fork-parent";
     process.env[ENV_DEPTH] = "0";
     process.env[ENV_FORK_DEPTH] = "1";
 
     const { service } = setup({});
+    registerHangingEngine();
 
-    const execPromise = service.execute({ task: "fork child", slug: "test", ctxModel, fork: true });
-    await waitForSpawn(mockSpawn);
-    const childEnv = getLastSpawnEnv();
-
-    // 742 行 parentDepth = forkDepthAls.getStore() ?? forkDepthBaseline —— ALS 断裂时基线=1，+1 → 2
-    expect(childEnv.PI_SUBAGENT_FORK_DEPTH).toBe("2");
+    expect(Reflect.get(service, "forkDepthBaseline")).toBe(1);
 
-    const child = lastSpawnedChild(mockSpawn);
-    child.emit("close", 0);
-    await execPromise;
+    // fork 请求照常派发（引擎侧承载深度传递）——不因基线读取抛错
+    await expect(service.execute({ task: "fork child", slug: "test", ctxModel, fork: true })).resolves.toBeDefined();
   });
 
   it("[嵌套护栏] 基线 depth 参与 execute 入口嵌套护栏（depth>MAX 拒绝）", async () => {

package/src/execution/__tests__/relay-env.test.ts

@@ -25,7 +25,18 @@ describe('relay env SSOT', () => {
     expect(isRelayActive({ ...full, [RELAY_ENV_SOCKET]: '' })).toBe(false);
     expect(isRelayActive({ ...full, [RELAY_ENV_NODE]: undefined })).toBe(false);
     expect(isRelayActive({})).toBe(false);
-    expect(isRelayActive(process.env)).toBe(false);
+    // [验收门修复] 宿主（pi 子进程链）可能注入 RELAY env——断言对象改为「清空 RELAY
+    // 键后的副本」：保留真实环境形态意图的同时对泄漏免疫（与 pi-invocation.test.ts
+    // 的 beforeEach 清理同病同修，不依赖 runner 环境）。
+    const sanitized: Record<string, string | undefined> = {
+      ...process.env,
+      [RELAY_ENV_SOCKET]: undefined,
+      [RELAY_ENV_NODE]: undefined,
+      [RELAY_ENV_SCRIPT]: undefined,
+      [RELAY_ENV_SESSION_ID]: undefined,
+      [RELAY_ENV_RECORD_ID]: undefined,
+    };
+    expect(isRelayActive(sanitized)).toBe(false);
   });
 
   it('env 名与退出码稳定（relay.mjs 镜像一致性由 conformance relay 断言锁定）', () => {