@zhushanwen/subagent-core 0.2.0 → 0.5.1

package/src/execution/__tests__/subagent-service-message-close.test.ts

@@ -13,25 +13,33 @@ import type { ChildProcess } from "node:child_process";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 // mock logger（doFinalizeRecord manifest 写入降级路径用）
-const { loggerMock } = vi.hoisted(() => ({
+const { loggerMock, killEscalationSpy } = vi.hoisted(() => ({
   loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+  killEscalationSpy: vi.fn(),
 }));
 vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
 
 // mock session-runner（import 链需要 runSpawn/killAllSpawnedChildren/getChildByRecord 存在）
-vi.mock("../session-runner.ts", () => ({
+vi.mock("../engine/engines/pi/session-runner.ts", () => ({
   runSpawn: vi.fn(),
   killAllSpawnedChildren: vi.fn(),
   getChildByRecord: vi.fn(() => undefined),
+  registerSpawnedChildForRecord: vi.fn(),
+  killRecordChildWithEscalation: killEscalationSpy,
+  spawnedChildren: new Map(),
 }));
 
 import { createRecord, updateFromEvent } from "../execution-record.ts";
+import { createNotifyHost } from "../notify-host.ts";
 import { ModelConfigService } from "../model-config-service.ts";
 import { RecordStore } from "../record-store.ts";
 import { SubagentService } from "../subagent-service.ts";
 import type { PiLike } from "../subagent-service.ts";
 import type { ExecutionRecord } from "../types.ts";
-import { getChildByRecord } from "../session-runner.ts";
+import { getChildByRecord } from "../engine/engines/pi/session-runner.ts";
+
+// [T2④] kill 收敛入口 spy（工厂引用，断言服务侧三条路径收敛到它）
+const killRecordChildWithEscalationMock = killEscalationSpy;
 import {
   armIdleTimer,
   disarmIdleTimer,
@@ -88,7 +96,7 @@ function setup(): {
   pi: MockPi;
 } {
   const agentDir = makeTmpAgentDir();
-  const modelService = new ModelConfigService({ agentDir });
+  const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
   const service = new SubagentService({ cwd: agentDir, modelService });
   // [C2] pi 提为外层引用（对照 real-chain :139-140 形态）——close 现状语义断言需读
   // pi.sendMessage.mock.calls（末条通知 content 指针行），内联构造不保留引用。
@@ -114,23 +122,23 @@ describe("getRecordForAction 归属守卫（决策 3）", () => {
 
   afterEach(() => {
     service.dispose();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("正常（rootSessionId 匹配）→ 返回可变 record", () => {
     const record = makeRecord({ rootSessionId: sessionRootId });
     store.register(record);
-    expect(service.getRecordForAction(record.id)).toBe(record);
+    expect(service.chatActions.getRecordForAction(record.id)).toBe(record);
   });
 
   it("不存在 → throw not found or not owned", () => {
-    expect(() => service.getRecordForAction("sa-nonexistent")).toThrow(/not found or not owned/);
+    expect(() => service.chatActions.getRecordForAction("sa-nonexistent")).toThrow(/not found or not owned/);
   });
 
   it("rootSessionId 不匹配 → throw not found or not owned（不区分 not found vs not owned，防信息泄露）", () => {
     const record = makeRecord({ id: "sa-other", rootSessionId: "other-session" });
     store.register(record);
-    expect(() => service.getRecordForAction("sa-other")).toThrow(/not found or not owned/);
+    expect(() => service.chatActions.getRecordForAction("sa-other")).toThrow(/not found or not owned/);
   });
 });
 
@@ -150,7 +158,7 @@ describe("closeSubagent 行为分流", () => {
 
   afterEach(() => {
     service.dispose();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("running + force:false + 有活进程 → 置 closeAfterRound=true（不立即终态，等轮完）", async () => {
@@ -160,7 +168,7 @@ describe("closeSubagent 行为分流", () => {
     const record = makeRecord({ status: "running" });
     store.register(record);
 
-    await service.closeSubagent(record, false);
+    await service.chatActions.closeSubagent(record, false);
 
     expect(record.closeAfterRound).toBe(true);
     expect(record.status).toBe("running"); // 仍 running
@@ -174,7 +182,7 @@ describe("closeSubagent 行为分流", () => {
     record.sessionFile = path.join(agentDir, "test.jsonl");
     store.register(record);
 
-    await service.closeSubagent(record, false);
+    await service.chatActions.closeSubagent(record, false);
 
     expect(record.status).toBe("closed");
     expect(store.getMutable(record.id)).toBeUndefined(); // archived
@@ -184,7 +192,7 @@ describe("closeSubagent 行为分流", () => {
     const record = makeRecord({ status: "running", sessionFile: path.join(agentDir, "run.jsonl") });
     store.register(record);
 
-    await service.closeSubagent(record, true);
+    await service.chatActions.closeSubagent(record, true);
 
     // v4 B-1：cancelled 折入 closed（closedReason='cancelled' 区分用户取消语义）
     expect(record.status).toBe("closed");
@@ -196,7 +204,7 @@ describe("closeSubagent 行为分流", () => {
     const record = makeRecord({ status: "closed" });
     store.register(record);
 
-    await service.closeSubagent(record, false);
+    await service.chatActions.closeSubagent(record, false);
 
     expect(record.status).toBe("closed"); // 不变
   });
@@ -207,9 +215,8 @@ describe("closeSubagent 行为分流", () => {
     // 旧代码 Path A 走 else 置 closeAfterRound，但 chatMode 轮完成恒经 agent_settled →
     // onRoundSettled → runAndFinalize early return（isIdle 恒 true），标志无人消费，
     // tool 却返回 {closed:true}（谎报）。
-    const killFn = vi.fn(() => true);
-    const child = { killed: false, kill: killFn } as unknown as ChildProcess;
-    vi.mocked(getChildByRecord).mockReturnValueOnce(child);
+    // [T2④] closeChatIdle 的 kill 收敛到 killRecordChildWithEscalation（recordId 入口），
+    // 不再读 child 句柄——无 child mock（Once mock 不被消费会泄漏劫持后续用例）
     const record = makeRecord({ status: "running", round: 1 });
     record.sessionFile = path.join(agentDir, "path-a.jsonl");
     store.register(record);
@@ -217,7 +224,7 @@ describe("closeSubagent 行为分流", () => {
     expect(hasIdleTimer(record.id)).toBe(true);
 
     try {
-      await service.closeSubagent(record, false);
+      await service.chatActions.closeSubagent(record, false);
     } finally {
       disarmIdleTimer(record.id); // 断言失败路径的兜底清理
     }
@@ -226,7 +233,8 @@ describe("closeSubagent 行为分流", () => {
     expect(record.status).toBe("closed");
     expect(record.closedReason).toBe("user-close");
     expect(store.getMutable(record.id)).toBeUndefined(); // archived
-    expect(killFn).toHaveBeenCalledWith("SIGTERM"); // 保活进程回收
+    // [T2④] kill 收敛到 killRecordChildWithEscalation（SIGTERM + 30s SIGKILL 升级）
+    expect(killRecordChildWithEscalationMock).toHaveBeenCalledWith(record.id, "closeChatIdle");
     expect(hasIdleTimer(record.id)).toBe(false); // timer disarmed
   });
 
@@ -235,7 +243,7 @@ describe("closeSubagent 行为分流", () => {
     record.sessionFile = path.join(agentDir, "path-b.jsonl");
     store.register(record);
 
-    await service.closeSubagent(record, false);
+    await service.chatActions.closeSubagent(record, false);
 
     expect(record.status).toBe("closed");
     expect(record.closedReason).toBe("user-close");
@@ -253,9 +261,8 @@ describe("closeSubagent 行为分流", () => {
   it("[M6] running + force:true + 活进程（热路径轮中）→ cancelBackground 显式 SIGTERM + disarm idle timer", async () => {
     // chatMode 首轮 agent_settled 后 runSpawn 提前 resolveRun(0) 返回，
     // abort→kill listener 已被 removeEventListener——热路径轮中 cancel 只能靠显式 kill。
-    const killFn = vi.fn(() => true);
-    const child = { killed: false, kill: killFn } as unknown as ChildProcess;
-    vi.mocked(getChildByRecord).mockReturnValueOnce(child);
+    // [T2④] cancelBackground 的 kill 收敛到 killRecordChildWithEscalation（recordId 入口），
+    // 不再读 child 句柄
     const record = makeRecord({ status: "running", sessionFile: path.join(agentDir, "hot.jsonl") });
     record.controller = new AbortController();
     store.register(record);
@@ -263,12 +270,13 @@ describe("closeSubagent 行为分流", () => {
     expect(hasIdleTimer(record.id)).toBe(true);
 
     try {
-      await service.closeSubagent(record, true);
+      await service.chatActions.closeSubagent(record, true);
     } finally {
       disarmIdleTimer(record.id); // 断言失败路径的兜底清理
     }
 
-    expect(killFn).toHaveBeenCalledWith("SIGTERM"); // 子进程收到 kill
+    // [T2④] kill 收敛到 killRecordChildWithEscalation（SIGTERM + 升级）
+    expect(killRecordChildWithEscalationMock).toHaveBeenCalledWith(record.id, "cancelBackground");
     expect(record.status).toBe("closed");
     expect(record.closedReason).toBe("cancelled");
     expect(hasIdleTimer(record.id)).toBe(false); // timer disarmed
@@ -276,6 +284,59 @@ describe("closeSubagent 行为分流", () => {
   });
 });
 
+// ============================================================
+// [A2-1] cancel 迟到：record 已终态（detached 已 finalize）→ CAS 拒绝
+// ============================================================
+
+describe("cancelBackground CAS 抢锁（A2-1）——cancel 迟到不覆写已完成 record", () => {
+  let agentDir: string;
+  let service: SubagentService;
+  let store: RecordStore;
+  let pi: MockPi;
+
+  beforeEach(() => {
+    ({ agentDir, service, store, pi } = setup());
+  });
+
+  afterEach(() => {
+    service.dispose();
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
+  it("record 已 closed 未 archive（doFinalizeRecord Step 0 await 窗口形态）→ cancel 返回 false，不覆写终态/不写 tombstone/不 notify/不 archive", () => {
+    const sessionFile = path.join(agentDir, "late-cancel.jsonl");
+    const record = makeRecord({ status: "closed", sessionFile });
+    // 模拟 detached 已 finalize 的终态快照（closedReason=gc 正常完成，非 cancelled）
+    record.closedReason = "gc";
+    record.endedAt = 5555;
+    record.result = "detached final result";
+    store.register(record); // 未 archive：恰好处于 finalize await 窗口（收尾后段才 archive）
+
+    const cancelled = service.cancel(record.id);
+
+    expect(cancelled).toBe(false); // CAS 没抢到——不谎报 true
+    expect(record.status).toBe("closed");
+    expect(record.closedReason).toBe("gc"); // 不被 completeRecord 改写为 cancelled
+    expect(record.endedAt).toBe(5555); // finalize 冻结的终态值不被重写
+    expect(record.result).toBe("detached final result"); // 不被空 cancelled result 覆写
+    // 不写 cancelled tombstone（与 finalized marker 双标 = record 双重终态化）
+    expect(fs.existsSync(`${sessionFile}.cancelled`)).toBe(false);
+    expect(store.getMutable(record.id)).toBe(record); // 不 archive（record 留内存）
+    expect(pi.sendMessage).not.toHaveBeenCalled(); // 不重复 notify（detached finalize 已发）
+  });
+
+  it("record running → cancel 返回 true 且终态化（CAS 正常路径不回归）", () => {
+    const sessionFile = path.join(agentDir, "cancel-ok.jsonl");
+    const record = makeRecord({ status: "running", sessionFile });
+    store.register(record);
+
+    expect(service.cancel(record.id)).toBe(true);
+    expect(record.status).toBe("closed");
+    expect(record.closedReason).toBe("cancelled");
+    expect(store.getMutable(record.id)).toBeUndefined(); // archived
+  });
+});
+
 // ============================================================
 // [M5] closeAfterRound 消费点：onRoundSettled（chatMode 热路径轮完成）
 // ============================================================
@@ -294,7 +355,7 @@ describe("[M5] closeAfterRound 消费点挂 onRoundSettled（chatMode 轮完成
   afterEach(() => {
     service.dispose();
     _resetLifecycleState();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   it("热路径轮完成（onRoundSettled）+ closeAfterRound=true → 消费标志终态化（closed+user-close + archive）", async () => {
@@ -325,7 +386,8 @@ describe("[M5] closeAfterRound 消费点挂 onRoundSettled（chatMode 轮完成
     expect(record.closeAfterRound).toBeUndefined(); // 标志已消费
     expect(record.status).toBe("closed");
     expect(record.closedReason).toBe("user-close");
-    expect(killFn).toHaveBeenCalledWith("SIGTERM"); // 保活进程回收
+    // [T2④] kill 收敛到 killRecordChildWithEscalation（SIGTERM + 升级）
+    expect(killRecordChildWithEscalationMock).toHaveBeenCalledWith(record.id, "closeAfterRoundSettled");
     expect(hasIdleTimer(record.id)).toBe(false);
   });
 
@@ -367,7 +429,7 @@ describe("[C2] close 现状语义 + sessionFile 条件透传", () => {
   afterEach(() => {
     service.dispose();
     _resetLifecycleState();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
 	it("close 语义：轮次通知（含指针行）发出后 closeAfterRoundSettled 终态化 + 终态通知，两条都送达", async () => {
@@ -412,8 +474,10 @@ describe("[C2] close 现状语义 + sessionFile 条件透传", () => {
 
     // running + 无活进程（getChildByRecord mock undefined）→ isResumable 放行 →
     // 非 chatMode 映射 closed 通知，立即 flush（无其他 running background）
-    const svc = service as unknown as { notifyComplete(r: ExecutionRecord): void };
-    svc.notifyComplete(record);
+    // [D4-①] notifyComplete 已随通知簇搬至 notify-host——按轴直接构造（同 pi/store
+    // 注入，行为与经 Service 的原路径等价；dedup 集为空与单次调用断言相容）
+    createNotifyHost({ getPi: () => pi, listRunning: () => store.listRunning(), getIsIdle: () => undefined })
+      .notifyComplete(record);
 
     expect(pi.sendMessage).toHaveBeenCalledTimes(1);
     const msg = pi.sendMessage.mock.calls[0]![0] as {
@@ -432,8 +496,8 @@ describe("[C2] close 现状语义 + sessionFile 条件透传", () => {
     record.sessionFile = path.join(agentDir, "c2-chat.jsonl");
     store.register(record);
 
-    const svc = service as unknown as { notifyComplete(r: ExecutionRecord): void };
-    svc.notifyComplete(record);
+    createNotifyHost({ getPi: () => pi, listRunning: () => store.listRunning(), getIsIdle: () => undefined })
+      .notifyComplete(record);
 
     expect(pi.sendMessage).toHaveBeenCalledTimes(1);
     const msg = pi.sendMessage.mock.calls[0]![0] as {
@@ -465,7 +529,7 @@ describe("[C-4] onRoundSettled 轮次增量 + [C-1] close 终态通知", () => {
   afterEach(() => {
     service.dispose();
     _resetLifecycleState();
-    fs.rmSync(agentDir, { recursive: true, force: true });
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
   /** 真实回调链（与生产一致：agent_settled → onRoundSettled），turns 经 updateFromEvent 累积。 */
@@ -540,7 +604,7 @@ describe("[C-4] onRoundSettled 轮次增量 + [C-1] close 终态通知", () => {
       updateFromEvent(record, { type: "text_delta", delta: "LAST-ROUND-INCREMENT" });
       updateFromEvent(record, { type: "turn_end" });
       settleRound(record); // 第 1 条：轮次通知
-      await service.closeSubagent(record, false); // idle close（D2 路径②）
+      await service.chatActions.closeSubagent(record, false); // idle close（D2 路径②）
     } finally {
       disarmIdleTimer(record.id);
     }
@@ -590,7 +654,7 @@ describe("[C-4] onRoundSettled 轮次增量 + [C-1] close 终态通知", () => {
     record.sessionFile = path.join(agentDir, "oneshot-close.jsonl");
     store.register(record);
 
-    await service.closeSubagent(record, false); // resumable → closeChatIdle → notifyClosed 拒绝
+    await service.chatActions.closeSubagent(record, false); // resumable → closeChatIdle → notifyClosed 拒绝
 
     expect(record.status).toBe("closed");
     expect(pi.sendMessage).not.toHaveBeenCalled();
@@ -611,7 +675,7 @@ describe("[C-4] onRoundSettled 轮次增量 + [C-1] close 终态通知", () => {
       updateFromEvent(record, { type: "turn_end" });
       settleRound(record); // 轮终：onRoundSettled 写 record.result = "ok"
       expect(record.result).toBe("ok"); // 前提锚点：轮终真实值在位
-      await service.closeSubagent(record, false); // idle close → completeRecord + archive
+      await service.chatActions.closeSubagent(record, false); // idle close → completeRecord + archive
     } finally {
       disarmIdleTimer(record.id);
     }

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

@@ -0,0 +1,174 @@
+// src/execution/__tests__/subagent-service-multiproc-guard.test.ts
+//
+// [u-svc / T5] 多进程共享文件守卫（subagent-service 侧两项）：
+//   - T5①/PS-8：子进程 initSession 跳过 recoverOrphanRecords（env PI_SUBAGENT_SELF_RECORD_ID
+//     判子进程身份）——恢复机制假设「单扫描者」，env 贯穿让每个子进程都成了扫描者，
+//     兄弟记录 marker 缺失/超软超时被无关进程盖终态 sidecar；
+//   - T5③/PS-7b：running 候选冷查补 findForeignLiveInstance 探针守卫——异进程活实例在册
+//     时拒绝 resurrect + resume spawn（防双写者窗口）。
+//
+// mock 形态沿用 subagent-service-message-close.test.ts；alive-store mock（findForeignLiveInstance
+// 换 spy 控制探针命中）。
+
+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";
+
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
+
+const { killChildSpy, foreignLiveSpy } = vi.hoisted(() => ({
+  killChildSpy: vi.fn(),
+  foreignLiveSpy: vi.fn<() => { pid: number; id: string; startedAt: number } | undefined>(),
+}));
+vi.mock("../alive-store.ts", () => ({
+  writeAliveMarker: vi.fn(),
+  removeAliveMarker: vi.fn(),
+  readAliveMarker: vi.fn(() => undefined),
+  isProcessAlive: vi.fn(() => false),
+  ALIVE_SOFT_TIMEOUT_MS: 3_600_000,
+  findForeignLiveInstance: foreignLiveSpy,
+}));
+
+vi.mock("../engine/engines/pi/session-runner.ts", () => ({
+  runSpawn: vi.fn(),
+  killAllSpawnedChildren: vi.fn(),
+  getChildByRecord: vi.fn(() => undefined),
+  registerSpawnedChildForRecord: vi.fn(),
+  spawnedChildren: new Map(),
+  killRecordChildWithEscalation: killChildSpy,
+}));
+
+import { ModelConfigService } from "../model-config-service.ts";
+import type { RecordStore } from "../record-store.ts";
+import { SubagentService } from "../subagent-service.ts";
+import { ResurrectDeniedError } from "../types.ts";
+import type { PiLike } from "../subagent-service.ts";
+
+function makeTmpAgentDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "svc-multiproc-"));
+}
+
+function makePi(): PiLike {
+  return {
+    appendEntry: vi.fn(),
+    events: { emit: vi.fn() },
+    sendMessage: vi.fn(),
+  } as unknown as PiLike;
+}
+
+function setup(): { agentDir: string; service: SubagentService; store: RecordStore } {
+  const agentDir = makeTmpAgentDir();
+  const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
+  const service = new SubagentService({ cwd: agentDir, modelService });
+  service.initSession({ pi: makePi(), sessionId: "root-session" });
+  const store = (service as unknown as { store: RecordStore }).store;
+  return { agentDir, service, store };
+}
+
+describe("T5① child process skips orphan recovery scan", () => {
+  let agentDir: string;
+
+  /** 构造 service 并在其 store 上挂 spy 后再 initSession（spy 必须先于触发点）。 */
+  const makeServiceWithRecoverySpies = (): {
+    service: SubagentService;
+    recover: ReturnType<typeof vi.spyOn>;
+    entryOnly: ReturnType<typeof vi.spyOn>;
+  } => {
+    const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
+    const svc = new SubagentService({ cwd: agentDir, modelService });
+    const store = (svc as unknown as { store: RecordStore }).store;
+    const recover = vi.spyOn(store, "recoverOrphanRecords").mockImplementation(() => {});
+    const entryOnly = vi.spyOn(store, "recoverEntryOnlyOrphans").mockImplementation(() => {});
+    return { service: svc, recover, entryOnly };
+  };
+
+  beforeEach(() => {
+    vi.stubEnv("PI_SUBAGENT_SELF_RECORD_ID", "");
+    agentDir = makeTmpAgentDir();
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    vi.restoreAllMocks();
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
+  it("root process (no self-record env) runs the orphan recovery scan", () => {
+    const { service: root, recover, entryOnly } = makeServiceWithRecoverySpies();
+    root.initSession({ pi: makePi(), sessionId: "root-session-2" });
+    expect(recover).toHaveBeenCalledTimes(1);
+    expect(entryOnly).toHaveBeenCalledTimes(1);
+  });
+
+  it("child process (PI_SUBAGENT_SELF_RECORD_ID set) skips the scan entirely", () => {
+    vi.stubEnv("PI_SUBAGENT_SELF_RECORD_ID", "sa-child-self");
+    const { service: child, recover, entryOnly } = makeServiceWithRecoverySpies();
+    child.initSession({ pi: makePi(), sessionId: "child-session" });
+    expect(recover).not.toHaveBeenCalled();
+    expect(entryOnly).not.toHaveBeenCalled();
+  });
+});
+
+describe("T5③ cold-lookup running candidate foreign-instance guard", () => {
+  let agentDir: string;
+  let service: SubagentService;
+  let store: RecordStore;
+
+  beforeEach(() => {
+    foreignLiveSpy.mockReset();
+    foreignLiveSpy.mockReturnValue(undefined);
+    ({ agentDir, service, store } = setup());
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
+  const stubColdCandidate = (record: {
+    id: string;
+    status: "running";
+    sessionFile: string;
+    rootSessionId: string;
+    parentRecordId?: string;
+  }): void => {
+    vi.spyOn(store, "findLightById").mockReturnValue(undefined);
+    vi.spyOn(store, "collectRecords").mockReturnValue([record] as never);
+  };
+
+  it("denies resurrection with ResurrectDeniedError when a foreign live instance holds the session", () => {
+    stubColdCandidate({
+      id: "sa-foreign",
+      status: "running",
+      sessionFile: "/tmp/fake-session.jsonl",
+      rootSessionId: "root-session",
+    });
+    foreignLiveSpy.mockReturnValue({ pid: 4242, id: "sa-foreign", startedAt: Date.now() });
+
+    expect(() => service["getRecordForAction"]("sa-foreign")).toThrow(ResurrectDeniedError);
+    try {
+      service["getRecordForAction"]("sa-foreign");
+    } catch (err) {
+      expect((err as Error).message).toContain("4242");
+      expect((err as Error).message).toContain("double-write");
+      expect((err as Error).message).toContain("Recovery");
+    }
+    expect(foreignLiveSpy).toHaveBeenCalledWith("/tmp/fake-session.jsonl");
+  });
+
+  it("allows cold lookup when no foreign live instance (marker dead/stale)", () => {
+    stubColdCandidate({
+      id: "sa-cold",
+      status: "running",
+      sessionFile: "/tmp/fake-session-2.jsonl",
+      rootSessionId: "root-session",
+    });
+    const found = service["getRecordForAction"]("sa-cold");
+    expect(found.id).toBe("sa-cold");
+  });
+});