@zhushanwen/subagent-core 0.5.1 → 0.6.0

package/src/execution/__tests__/notify-ledger.test.ts

@@ -1186,6 +1186,33 @@ describe("NotifyLedger — T4③ 重投止损（PS-6）", () => {
     ledger.dispose();
   });
 
+  it("同 notifyId 在账重复 record 幂等拒绝零副作用（⛔2 补强：U3 批 hash 幂等依赖）", () => {
+    const mock = makeLedgerHost();
+    const ledger = createNotifyLedger(mock.host);
+
+    expect(ledger.record("sa-dup", "content-v1", { notifyId: "sa-dup", agent: "first" })).toBe(true);
+    const ledgerEntriesBefore = mock.entries.filter((e) => e.customType === NOTIFY_LEDGER_CUSTOM_TYPE).length;
+    expect(ledgerEntriesBefore).toBe(1);
+
+    // 同 notifyId 二次 record：返回 false，零副作用（不新增 entry、账面不被覆盖）
+    expect(ledger.record("sa-dup", "content-v2-attempted-overwrite", { notifyId: "sa-dup", agent: "second" })).toBe(false);
+    expect(mock.entries.filter((e) => e.customType === NOTIFY_LEDGER_CUSTOM_TYPE)).toHaveLength(ledgerEntriesBefore);
+    expect(ledger.pendingCount()).toBe(1);
+
+    // 投递面零副作用：只送首条 content（后写不覆盖），回执匹配不受污染
+    mock.setIdle(true);
+    ledger.attemptDeliver();
+    expect(mock.sentMessages).toHaveLength(1);
+    expect(mock.sentMessages[0]?.content).toBe("content-v1");
+
+    // 销账后同号仍拒绝（已销账幂等，E1 补发窗口依赖）
+    fireSettled(mock);
+    expect(ledger.waitingReceiptCount()).toBe(0);
+    expect(ledger.record("sa-dup", "content-v1", { notifyId: "sa-dup" })).toBe(false);
+
+    ledger.dispose();
+  });
+
   it("③ 未达上限时正常重投行为不变：照常超时重投，回执到达后照常销账", () => {
     const mock = makeLedgerHost();
     // 前三轮回执不可匹配（重投路径）

package/src/execution/__tests__/pi-invocation.test.ts

@@ -3,10 +3,42 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
 import { getPiInvocation } from "../engine/engines/pi/pi-invocation.ts";
-import { RELAY_ENV_NODE, RELAY_ENV_SCRIPT, RELAY_ENV_SOCKET } from "../relay-env.ts";
+import {
+  RELAY_ENV_NODE,
+  RELAY_ENV_RECORD_ID,
+  RELAY_ENV_SCRIPT,
+  RELAY_ENV_SESSION_ID,
+  RELAY_ENV_SOCKET,
+} from "../relay-env.ts";
+
+// [验收门修复] getPiInvocation 的 relay 分支优先读宿主 RELAY env——根级 pnpm test
+// 进程若继承宿主（pi 子进程链）的 RELAY 身份，直连分支用例的 execPath/argv 断言
+// 会被改道（非自免疫，依赖 runner 环境）。文件级钩子对全部用例统一消毒：beforeEach
+// 删五键、afterEach 恢复原值——有泄漏无泄漏双向绿；第二组 relay 分支用例自设
+// RELAY_FULL 在清理之后执行，语义不受影响。
+const RELAY_ENV_KEYS = [
+  RELAY_ENV_SOCKET,
+  RELAY_ENV_NODE,
+  RELAY_ENV_SCRIPT,
+  RELAY_ENV_SESSION_ID,
+  RELAY_ENV_RECORD_ID,
+] as const;
+let savedRelayEnv: Record<string, string | undefined>;
+beforeEach(() => {
+  savedRelayEnv = {};
+  for (const key of RELAY_ENV_KEYS) savedRelayEnv[key] = process.env[key];
+  for (const key of RELAY_ENV_KEYS) delete process.env[key];
+});
+afterEach(() => {
+  for (const key of RELAY_ENV_KEYS) {
+    const value = savedRelayEnv[key];
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+});
 
 describe("getPiInvocation", () => {
   const originalArgv = process.argv;

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__/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 断言锁定）', () => {

package/src/execution/__tests__/session-file-gc.test.ts

@@ -34,7 +34,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
-  fs.rmSync(tmpAgentDir, { recursive: true, force: true });
+  fs.rmSync(tmpAgentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   vi.restoreAllMocks();
 });
 

package/src/execution/__tests__/spawn-event-adapter.test.ts

@@ -150,14 +150,14 @@ describe("findSessionFileByHeaderId", () => {
     fs.writeFileSync(expectedFile, "{}");
     const result = findSessionFileByHeaderId(tmpDir, "sid-456");
     expect(result).toBe(expectedFile);
-    fs.rmSync(tmpDir, { recursive: true });
+    fs.rmSync(tmpDir, { recursive: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("无匹配返回 undefined", () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "spawn-adapter-test-"));
     const result = findSessionFileByHeaderId(tmpDir, "nonexistent");
     expect(result).toBeUndefined();
-    fs.rmSync(tmpDir, { recursive: true });
+    fs.rmSync(tmpDir, { recursive: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("目录不存在返回 undefined（不抛错）", () => {

package/src/execution/__tests__/start-collect-guard.test.ts

@@ -0,0 +1,255 @@
+// src/execution/__tests__/start-collect-guard.test.ts
+//
+// startHandler 的 collect 语义（subagent-sync-collect U1 foundation）：
+//   1. E4 校验（设计 §3.1.5）：conversation:true + collect:"sync" → immediate throw，
+//      不产生半启动 record（execute 零调用）；文案指引「sync 仅支持 one-shot，
+//      去掉 conversation 或 collect」；
+//   2. 合法组合放行：collect 透传 service.execute（ExecuteOptions.collect）；
+//   3. start 响应 collect 段（设计 §3.1.1）：仅 resolved=sync 附段（async 响应字节
+//      零变化，G3）；pendingSyncCount = 未闭合批 sync 成员数（collectMode=sync 且无
+//      batchFinalized；U2 偏差#4 接线后 record 落 collectMode，枚举天然含本条，无 +1）。
+//
+// stub SubagentService 仅实现 handler 触达的方法子集（subagent-actions-core.test.ts
+// 同款形态）；真实 service 行为归属 subagent-service 各自测试。
+
+import { describe, expect, it, vi, type Mock } from "vitest";
+
+import { startHandler } from "../subagent-actions-core.ts";
+// SubagentService 的权威源是 subagent-service.ts（types.ts 只有 record/tool 契约）
+import type { SubagentService } from "../subagent-service.ts";
+import type { StatusFilter } from "../record-store.ts";
+import type {
+  ExecutionHandle,
+  SubagentRecord,
+  SubagentToolDetails,
+} from "../types.ts";
+
+function makeDetails(): SubagentToolDetails {
+  return {
+    status: "running",
+    mode: "background",
+    agent: "/home/u/agents/worker.md",
+    model: "prov/m1",
+    thinkingLevel: undefined,
+    slug: "src-slug",
+    turns: 0,
+    totalTokens: 0,
+    elapsedSeconds: 0,
+    eventLog: [],
+    displayItems: [],
+    result: undefined,
+    error: undefined,
+  } as SubagentToolDetails;
+}
+
+function makeHandle(): ExecutionHandle {
+  return { mode: "background", subagentId: "sa-new", sessionFile: undefined, details: makeDetails() };
+}
+
+/** collectRecords stub 数据行（只含 pendingSyncCount 口径判读所需字段）。 */
+function makeRec(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: [],
+    ...over,
+  } as SubagentRecord;
+}
+
+// Mock<T> 具名签名 + Omit 类原生同名成员：ReturnType<typeof vi.fn>
+// （= Mock<Procedure | Constructable>）与类方法签名交叉会收窄 never
+type ServiceStub = Omit<SubagentService, "execute" | "collectRecords" | "getCollectSyncDefault"> & {
+  // 带首参形态：断言消费 execute.mock.calls[0][0]（ExecuteOptions），零参签名为空元组取不到
+  execute: Mock<(opts: Record<string, unknown>) => Promise<SubagentRecord>>;
+  collectRecords: Mock<(limit: number, statusFilter?: StatusFilter) => SubagentRecord[]>;
+  getCollectSyncDefault: Mock<() => "async" | "sync">;
+};
+
+/** startHandler 的测试包装：stub → SubagentService 断言收口一处（类私有成员不可结构模拟）。 */
+function sh(svc: ServiceStub, input: Record<string, unknown>, signal?: AbortSignal) {
+  return startHandler(
+    svc as unknown as SubagentService,
+    input as Parameters<typeof startHandler>[1],
+    signal ?? undefined,
+  );
+}
+
+function makeService(
+  collectRecordsReturn: SubagentRecord[] = [],
+  collectSyncDefault: "async" | "sync" = "async",
+): ServiceStub {
+  const execute = vi.fn(async (_opts: Record<string, unknown>) => makeHandle());
+  const collectRecords = vi.fn(() => collectRecordsReturn);
+  const getCollectSyncDefault = vi.fn(() => collectSyncDefault);
+  // [D4-① 适配] countPendingSyncRecords 经查询面聚合读 collectRecords（dev 重构后
+  // service.collectRecords 收窄 private，public 出口 = service.queries.collectRecords）。
+  return {
+    execute,
+    queries: { collectRecords },
+    collectRecords,
+    getCollectSyncDefault,
+  } as unknown as ServiceStub;
+}
+
+const BASE_INPUT = { task: "do things", slug: "do-things" };
+
+// ============================================================
+// E4：conversation + collect:"sync" 即拒
+// ============================================================
+
+describe("startHandler E4 guard (conversation + collect:sync)", () => {
+  it("throws immediately and never calls execute (不产生半启动 record)", async () => {
+    const service = makeService();
+    await expect(
+      sh(service, { ...BASE_INPUT, conversation: true, collect: "sync" }, undefined),
+    ).rejects.toThrow();
+    expect(service.execute).not.toHaveBeenCalled();
+  });
+
+  it("error copy carries the design guidance verbatim (文案锚定)", async () => {
+    const service = makeService();
+    const err = await sh(service,
+      { ...BASE_INPUT, conversation: true, collect: "sync" },
+      undefined,
+    ).catch((e: unknown) => e as Error);
+    expect(err).toBeInstanceOf(Error);
+    expect((err as Error).message).toBe(
+      'collect:"sync" only supports one-shot subagents — it cannot be combined with conversation:true. ' +
+      'Remove either conversation or collect (use collect:"async", or omit it, for conversational subagents).',
+    );
+  });
+
+  it("allows conversation:true + collect:async (async 语义与 conversation 正交)", async () => {
+    const service = makeService();
+    const result = await sh(service,
+      { ...BASE_INPUT, conversation: true, collect: "async" },
+      undefined,
+    );
+    expect(result.subagentId).toBe("sa-new");
+    expect(service.execute).toHaveBeenCalledTimes(1);
+  });
+
+  it("allows collect:sync alone (one-shot sync 是合法主场景)", async () => {
+    const service = makeService();
+    const result = await sh(service, { ...BASE_INPUT, collect: "sync" }, undefined);
+    expect(result.subagentId).toBe("sa-new");
+    expect(service.execute).toHaveBeenCalledTimes(1);
+  });
+
+  it("E4 also blocks conversation when config default is sync (偏差#3 接线：resolved 含 config 默认)", async () => {
+    const service = makeService([], "sync");
+    await expect(
+      sh(service, { ...BASE_INPUT, conversation: true }, undefined),
+    ).rejects.toThrow('collect:"sync" only supports one-shot subagents');
+    expect(service.execute).not.toHaveBeenCalled();
+  });
+
+  it("config default=sync applies when collect omitted (缺省读真实 config，U2 偏差#3)", async () => {
+    const service = makeService([], "sync");
+    const result = await sh(service, { ...BASE_INPUT }, undefined);
+    expect(result.response.collect).toBeDefined();
+    expect(service.getCollectSyncDefault).toHaveBeenCalledTimes(1);
+  });
+
+  it("reads config default via service accessor when collect omitted (async 默认零附段)", async () => {
+    const service = makeService([], "async");
+    const result = await sh(service, { ...BASE_INPUT }, undefined);
+    expect(result.response.collect).toBeUndefined();
+    expect(service.getCollectSyncDefault).toHaveBeenCalledTimes(1);
+  });
+});
+
+// ============================================================
+// collect 透传 + 响应 collect 段
+// ============================================================
+
+describe("startHandler collect forwarding + response collect segment", () => {
+  it("forwards collect to service.execute via ExecuteOptions.collect", async () => {
+    const service = makeService();
+    await sh(service, { ...BASE_INPUT, collect: "sync" }, undefined);
+    const opts = service.execute.mock.calls[0]?.[0] as { collect?: string };
+    expect(opts.collect).toBe("sync");
+  });
+
+  it("omits collect in ExecuteOptions when not provided (resolved≠sync 时保持 undefined，async 缺省语义)", async () => {
+    const service = makeService();
+    await sh(service, { ...BASE_INPUT }, undefined);
+    const opts = service.execute.mock.calls[0]?.[0] as { collect?: string };
+    expect(opts.collect).toBeUndefined();
+  });
+
+  it("B1：config default=sync + 省略 collect → execute 收 collect:\"sync\"（缺省解析作用于 record 本体）", async () => {
+    // 修复前：execute 收原始 input.collect=undefined → createRecordForMode 只认
+    // ==="sync" → record 走 async 逐条通知而响应声称已入批（设计 §3.1.3/types.ts:689
+    // 承诺「缺省 = config 默认」作用于 record）。修复后 resolved=sync 落值。
+    const service = makeService([], "sync");
+    await sh(service, { ...BASE_INPUT }, undefined);
+    const opts = service.execute.mock.calls[0]?.[0] as { collect?: string };
+    expect(opts.collect).toBe("sync");
+  });
+
+  it("B1：config default=sync 时显式 collect:\"async\" 优先（execute 收 \"async\"）", async () => {
+    const service = makeService([], "sync");
+    await sh(service, { ...BASE_INPUT, collect: "async" }, undefined);
+    const opts = service.execute.mock.calls[0]?.[0] as { collect?: string };
+    expect(opts.collect).toBe("async");
+  });
+
+  it("attaches collect segment counting this very record from the enumeration (U2 偏差#4：无 +1 补偿)", async () => {
+    // 本条 record（id=sa-new）已由 createRecordForMode 落 collectMode 入枚举：
+    // stub 枚举返回本条 + 另一未闭合 sync → count=2（无 +1 补偿即含本条）
+    const service = makeService([
+      makeRec({ id: "sa-new", collectMode: "sync" }),
+      makeRec({ id: "sa-other", collectMode: "sync", status: "running" }),
+      makeRec({ id: "sa-gone", collectMode: "sync", batchFinalized: true }),
+    ]);
+    const result = await sh(service, { ...BASE_INPUT, collect: "sync" }, undefined);
+    expect(result.response.collect).toEqual({ mode: "sync", pendingSyncCount: 2 });
+  });
+
+  it("reports the enumeration verbatim when no sync records exist yet (如实反映，无补偿)", async () => {
+    const service = makeService([]);
+    const result = await sh(service, { ...BASE_INPUT, collect: "sync" }, undefined);
+    expect(result.response.collect).toEqual({ mode: "sync", pendingSyncCount: 0 });
+  });
+
+  it("counts pending unmarked sync members from the enumeration (跨轮续累口径)", async () => {
+    const service = makeService([
+      makeRec({ id: "sa-1", collectMode: "sync" }), // 未闭合（无 batchFinalized）→ 计入
+      makeRec({ id: "sa-2", collectMode: "sync", batchFinalized: true }), // 已离场 → 排除
+      makeRec({ id: "sa-3" }), // async → 排除
+      makeRec({ id: "sa-4", collectMode: "sync", batchFinalized: false }), // 显式 false → 计入
+    ]);
+    const result = await sh(service, { ...BASE_INPUT, collect: "sync" }, undefined);
+    expect(result.response.collect).toEqual({ mode: "sync", pendingSyncCount: 2 });
+  });
+
+  it("omits the collect segment for async starts (G3: async 响应字节零变化)", async () => {
+    for (const input of [{ ...BASE_INPUT }, { ...BASE_INPUT, collect: "async" as const }]) {
+      const service = makeService();
+      const result = await sh(service, input, undefined);
+      expect(result.response.collect).toBeUndefined();
+      // G3 字节锚：response 其余字段与既有形态全等
+      expect(result.response).toEqual({
+        status: "running",
+        mode: "background",
+        message: result.response.message,
+        notifyContract: "ledger+at-least-once",
+      });
+    }
+  });
+});

package/src/execution/__tests__/start-sync-model-guard.test.ts

@@ -93,7 +93,7 @@ describe("start 同步期裁决（U1 验收 3：非全等 → isError 且无 spa
 
   afterEach(() => {
     vi.restoreAllMocks();
-    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("小写变体入参 → execute 同步 reject（问句式报错），buildSpawnArgs/spawn/appendEntry 均未被调", async () => {

package/src/execution/__tests__/subagent-actions-core.test.ts

@@ -144,11 +144,17 @@ function makeService(over: Record<string, unknown> = {}): SubagentService {
     getRecordForAction: vi.fn(),
     closeSubagent: vi.fn(),
     deliverChatMessage: vi.fn(),
+    // [U2] startHandler 缺省 collect 解析读真实 config（偏差#3 接线）：stub 缺省 async
+    //（本文件不测 collect 语义，专项见 start-collect-guard.test.ts）。
+    getCollectSyncDefault: vi.fn(() => "async" as const),
     ...over,
   };
   return {
     execute: m.execute,
     cancel: m.cancel,
+    // [U2 偏差#3 接线] startHandler 经平铺访问器读 config 缺省 collect（真实 service
+    // 为平铺方法 subagent-service.ts:1786，非 queries 聚合面成员），stub 须同构挂载。
+    getCollectSyncDefault: m.getCollectSyncDefault,
     queries: {
       findRecord: m.findRecord,
       lookupRecordAnyState: m.lookupRecordAnyState,

package/src/execution/__tests__/subagent-service-multiproc-guard.test.ts

@@ -120,6 +120,19 @@ describe("T5③ cold-lookup running candidate foreign-instance guard", () => {
   let store: RecordStore;
 
   beforeEach(() => {
+    // 身份 env 剥离：initSession 会把 PI_SUBAGENT_ROOT_SESSION_ID 读作 sessionRootId 基线
+    //（env 优先于入参 sessionId）——宿主进程（xyz-agent 子 agent 环境）泄漏的身份 env
+    // 会让「root-session」桩记录归属校验恒不匹配 → 冷查用例误红（与 collect-coordinator-
+    // service.test.ts 同款剥离纪律）。
+    for (const k of [
+      "PI_SUBAGENT_ROOT_SESSION_ID",
+      "PI_SUBAGENT_SELF_RECORD_ID",
+      "PI_SUBAGENT_DEPTH",
+      "PI_SUBAGENT_ROOT_CWD",
+      "PI_SUBAGENT_FORK_DEPTH",
+    ] as const) {
+      delete process.env[k];
+    }
     foreignLiveSpy.mockReset();
     foreignLiveSpy.mockReturnValue(undefined);
     ({ agentDir, service, store } = setup());