@zhushanwen/subagent-core 0.2.0

package/src/execution/__tests__/helpers/spawn-mock.ts

@@ -0,0 +1,242 @@
+// src/execution/__tests__/helpers/spawn-mock.ts
+//
+// run-spawn-* 三文件（integration/edges/rpc-mode）共享的 FakeChild + 工具函数。
+//
+// 背景：vitest 的 vi.mock 会被提升到文件顶部，工厂函数体内**不能引用顶层 import 的变量**
+//（vitest 官方文档明确警告）。例外：async 工厂内可用 `await import()`（在模块需求时执行，
+// 此时所有模块已加载）。故本 helper 不导出「mock 工厂函数」（无法被 vi.mock 顶层引用），
+// 而是导出 **FakeChild class + 工具函数**，让各测试文件的 vi.mock 工厂用 `await import`
+// 动态取回 FakeChild。这样每个 vi.mock 工厂从 ~15 行（定义 class + vi.fn）缩到 ~4 行，
+// 且 FakeChild 定义只有一个权威来源。
+//
+// 共享内容（原 ~80 行 × 3 重复）：
+//   - FakeChild：EventEmitter + PassThrough stdout/stderr/stdin + kill 记录（class 定义）
+//   - lastSpawnedChild(mockSpawn)：从 mock.results 取回最近 spawn 返回的 FakeChild
+//   - waitForSpawn(mockSpawn)：轮询等 spawn 被调（比 vi.waitFor 在该 vitest 版本下可靠）
+//   - emitStdoutLine / sessionHeader：构造 stdout 行的辅助
+//   - makeRecord / makeOpts / makeCtx：构造最小合法的 record/opts/ctx（3 文件一致）
+//
+// 各测试文件 vi.mock 模式（每文件独立声明，vitest 的 vi.mock 是文件作用域）：
+//   ```ts
+//   vi.mock("node:child_process", async () => {
+//     const { EventEmitter } = await import("node:events");
+//     const events = { EventEmitter }; // 兼容旧注释
+//     const { FakeChild } = await import("./helpers/spawn-mock.ts");
+//     return {
+//       spawn: vi.fn(() => new FakeChild()),
+//       // buildEnvBlock 用 execFile 异步取 git branch：默认 err-first 兜底（catch → branch=""），
+//       // 形态同 worktree-manager.test.ts 的 setupExecFile
+//       execFile: vi.fn(
+//         (
+//           _cmd: string,
+//           _args: readonly string[],
+//           _opts: unknown,
+//           cb: (err: Error | null, stdout?: string, stderr?: string) => void,
+//         ) => cb(new Error("execFile not configured in this test")),
+//       ),
+//     };
+//   });
+//   vi.mock("node:fs", async () => {
+//     const actual = await import("node:fs");
+//     return {
+//       default: { ...actual, mkdirSync: vi.fn(), existsSync: vi.fn(() => false),
+//                   appendFileSync: vi.fn(), writeFileSync: vi.fn(), readdirSync: vi.fn(() => []) },
+//       mkdirSync: vi.fn(), existsSync: vi.fn(() => false),
+//       appendFileSync: vi.fn(), writeFileSync: vi.fn(), readdirSync: vi.fn(() => []),
+//       promises: actual.promises,
+//     };
+//   });
+//   vi.mock("../alive-store.ts", () => ({ writeAliveMarker: vi.fn() }));
+//   vi.mock("../temp-prompt.ts", () => ({
+//     writePromptToTempFile: vi.fn(async (agent: string) => {
+//       const safeName = agent.replace(/[^\w.-]+/g, "_");
+//       return { dir: `/tmp/fake-${safeName}`, filePath: `/tmp/fake-${safeName}/prompt-${safeName}.md` };
+//     }),
+//     cleanupTempPrompt: vi.fn(async () => {}),
+//   }));
+//   ```
+
+import type { ChildProcess } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+
+import { createRecord } from "../../execution-record.ts";
+import type { RunOptions, SessionRunnerContext } from "../../session-runner.ts";
+
+/** FakeChild 的假 pid（满足 ChildProcess.pid 形状，无真实进程语义）。 */
+const FAKE_PID = 12345;
+
+/** waitForSpawn 默认超时（ms），超时说明 spawn 未被调（runSpawn 前置 await 卡死）。 */
+const WAIT_SPAWN_TIMEOUT_MS = 1000;
+
+/** waitForSpawn 轮询间隔（ms），微任务级等待的粒度。 */
+const SPAWN_POLL_INTERVAL_MS = 5;
+
+/**
+ * FakeChild：模拟 ChildProcess（EventEmitter + PassThrough streams）。
+ *
+ * 测试通过 mockSpawn.mock.results.at(-1).value 取回实例，控制 emit data/close/error 时序。
+ *
+ * 导出 class（而非只在工厂内部定义）是为了：
+ *   1. vi.mock 工厂内 `await import("./helpers/spawn-mock.ts")` 后 `new FakeChild()` 与
+ *      测试侧 `instanceof FakeChild` / 类型断言用同一个 class。
+ *   2. C13 e2e 测试可直接 `new FakeChild()` 手动构造 child 喂给 ui-request-queue（不经 spawn）。
+ */
+export class FakeChild extends EventEmitter {
+  pid = FAKE_PID;
+  stdout = new PassThrough();
+  stderr = new PassThrough();
+  stdin = new PassThrough();
+  killed = false;
+  killSignal: string | undefined;
+  // [race-F4] SIGKILL 升级判定读真 ChildProcess 的 exitCode/signalCode（未退出时均为
+  // null）——FakeChild 同形提供，测试可赋值模拟已死进程（如 deliverMessage 写后死检测）。
+  exitCode: number | null = null;
+  signalCode: string | null = null;
+  kill(sig?: string): boolean {
+    this.killed = true;
+    this.killSignal = sig;
+    return true;
+  }
+}
+
+/**
+ * spawn mock 返回的 fake child 类型（结构子集）。
+ *
+ * 测试文件优先 import { FakeChild } 用真实 class 类型；此 interface 仅为兼容现有
+ * describe 块内 `child: FakeChild` 的类型注解风格（与原代码一致，降低 diff 噪声）。
+ */
+export interface FakeChildLike {
+  pid: number;
+  stdout: PassThrough;
+  stderr: PassThrough;
+  stdin: PassThrough;
+  killed: boolean;
+  killSignal: string | undefined;
+  kill(sig?: string): boolean;
+  emit(event: string, ...args: unknown[]): boolean;
+}
+
+/**
+ * 从最近一次 spawn 调用取回返回的 FakeChild（测试控制器）。
+ *
+ * @param mockSpawn 调用方用 `vi.mocked(spawn)` 取回的 mock 引用
+ */
+export function lastSpawnedChild<
+  T extends { mock: { results: Array<{ value: ChildProcess | unknown }> } },
+>(mockSpawn: T): FakeChild {
+  const result = mockSpawn.mock.results.at(-1);
+  if (!result) throw new Error("spawn was not called yet");
+  return result.value as FakeChild;
+}
+
+/**
+ * 等待 runSpawn 内部调到 spawn（拿到 child 控制器）。
+ *
+ * runSpawn 是 async，spawn 在 buildEnvBlock + writePromptToTempFile 两个 await 之后才调
+ *（均为微任务级延迟）。用 setTimeout 轮询 mockSpawn.mock.results，比 vi.waitFor 在该
+ * vitest 版本下更可靠（vi.waitFor 偶发过早 resolve 导致后续读取竞态）。
+ *
+ * [快照语义] 等待的是「调用时刻之后**新发生**的一次 spawn」，而非「任意历史 spawn」。
+ * 旧实现只在 results 为空时等待（即只在文件/测试内首次 spawn 有效）：同一文件第二次
+ * runSpawn 时立即返回，而新 runSpawn 尚未跨过 await 到达 spawn → lastSpawnedChild 取回
+ * **上一次**的 child，stdout/close 事件发给已死的旧 child，当前 runSpawn 永远收不到
+ * close → 测试超时。buildEnvBlock 异步化（多一个 await 微任务）后该隐式时序假设失效，
+ * 故改为快照 baseline：等待 results.length 超过调用时的快照值，天然对「每测试/每文件
+ * N 次 spawn」都正确（调用前先记 baseline，本次 runSpawn 的 spawn 必然使 length 增长）。
+ *
+ * @param mockSpawn 调用方用 `vi.mocked(spawn)` 取回的 mock 引用
+ */
+export async function waitForSpawn<
+  T extends { mock: { results: unknown[] } },
+>(mockSpawn: T, timeoutMs: number = WAIT_SPAWN_TIMEOUT_MS): Promise<void> {
+  const start = Date.now();
+  const baseline = mockSpawn.mock.results.length;
+  while (mockSpawn.mock.results.length <= baseline) {
+    if (Date.now() - start > timeoutMs) {
+      throw new Error(`spawn was not called within ${timeoutMs}ms`);
+    }
+    await new Promise((r) => setTimeout(r, SPAWN_POLL_INTERVAL_MS));
+  }
+}
+
+/** 向 stdout 写一行（自动补换行，runSpawn 按 \n split 行）。 */
+export function emitStdoutLine(child: FakeChild, obj: Record<string, unknown>): void {
+  child.stdout.write(`${JSON.stringify(obj)}\n`);
+}
+
+/** 构造 session header 行（stdout 首行）。 */
+export function sessionHeader(id = "sess-abc"): Record<string, unknown> {
+  return {
+    type: "session",
+    id,
+    timestamp: "2026-07-03T12-00-00-000Z",
+    cwd: "/tmp/test",
+  };
+}
+
+/**
+ * 让 sessionFile 存在校验通过——runSpawn 在进程退出后用 existsSync(record.sessionFile)
+ * 判断是否补写 identity。默认 mock existsSync 返回 false（兜底查找），此 helper 在指定
+ * 路径返回 true。
+ */
+export function mockSessionFileExists(
+  mockExistsSync: { mockImplementation: (fn: (p: unknown) => boolean) => void },
+  sessionFilePath: string,
+): void {
+  mockExistsSync.mockImplementation((p: unknown) => String(p) === sessionFilePath);
+}
+
+// ── record / opts / ctx 构造（3 文件一致的最小合法形状）──
+
+/** 构造最小合法的 ExecutionRecord（runSpawn 入参）。 */
+export function makeRecord(id = "run-1") {
+  return createRecord(id, {
+    agent: "general-purpose",
+    model: "test-model",
+    mode: "sync",
+    task: "do something",
+    startedAt: 1_000_000,
+    rootSessionId: "root-session",
+    parentRecordId: undefined,
+    depth: 0,
+  });
+}
+
+/** 构造最小合法的 RunOptions（runSpawn 入参，可 override 关键字段）。 */
+export function makeOpts(overrides: Partial<RunOptions> = {}): RunOptions {
+  return {
+    resolved: {
+      model: {
+        id: "test-model",
+        name: "Test Model",
+        provider: "test",
+        reasoning: false,
+      },
+      thinkingLevel: undefined,
+    },
+    agentConfig: undefined,
+    appendSystemPrompt: undefined,
+    skillPath: undefined,
+    schema: undefined,
+    maxTurns: undefined,
+    graceTurns: undefined,
+    signal: undefined,
+    onEvent: undefined,
+    ...overrides,
+  };
+}
+
+/** 构造最小合法的 SessionRunnerContext（runSpawn 入参，可 override 关键字段）。 */
+export function makeCtx(overrides: Partial<SessionRunnerContext> = {}): SessionRunnerContext {
+  return {
+    cwd: "/tmp/test",
+    agentDir: "/tmp/test/agents",
+    skillDirs: [],
+    mainCwd: "/tmp/test",
+    mainSessionFile: undefined,
+    sessionRootId: "root-session-test",
+    rootCwd: "/tmp/test",
+    ...overrides,
+  };
+}

package/src/execution/__tests__/host-mode.test.ts

@@ -0,0 +1,87 @@
+// src/__tests__/host-mode.test.ts
+//
+// W1 红灯测试：host-mode.ts 主进程运行模式分类工具。
+//
+// 测试对象：extensions/universal/subagent-workflow/src/execution/host-mode.ts（新建）
+// 契约来源：.fix-plans/00-master-summary.md §一 冲突 4 + §2.5（W4 守卫消费点）
+//
+// 三个导出：
+//   - resolveHostMode(mode): ExtensionMode | undefined → "tui" | "gui" | "headless"
+//   - willRespondToAskUser(mode): boolean（tui/gui → true，headless → false）
+//   - hasInteractiveUI(mode): boolean（非 headless → true）
+//
+// 红灯原因：host-mode.ts 尚未创建，import 失败。
+
+import { describe, expect, it } from "vitest";
+
+import {
+  hasInteractiveUI,
+  resolveHostMode,
+  willRespondToAskUser,
+} from "../host-mode.ts";
+
+describe("resolveHostMode — ExtensionMode 聚合为 HostMode", () => {
+  it('"tui" → "tui"（纯 Pi TUI，ctx.ui.custom 可用）', () => {
+    expect(resolveHostMode("tui")).toBe("tui");
+  });
+
+  it('"rpc" → "gui"（xyz-agent GUI，sidecar 通道）', () => {
+    expect(resolveHostMode("rpc")).toBe("gui");
+  });
+
+  it('"json" → "headless"（无交互通道）', () => {
+    expect(resolveHostMode("json")).toBe("headless");
+  });
+
+  it('"print" → "headless"（无交互通道）', () => {
+    expect(resolveHostMode("print")).toBe("headless");
+  });
+
+  it('undefined → "headless"（向后兼容：mode 未穿透时按 headless）', () => {
+    expect(resolveHostMode(undefined)).toBe("headless");
+  });
+});
+
+describe("willRespondToAskUser — 主进程是否响应子进程 ask_user", () => {
+  it("tui → true（冲突 3 裁决：TUI 必须注入 handler）", () => {
+    expect(willRespondToAskUser("tui")).toBe(true);
+  });
+
+  it("rpc → true（GUI 透传所有 UI）", () => {
+    expect(willRespondToAskUser("rpc")).toBe(true);
+  });
+
+  it("json → false（headless 无 UI 通道）", () => {
+    expect(willRespondToAskUser("json")).toBe(false);
+  });
+
+  it("print → false（headless 无 UI 通道）", () => {
+    expect(willRespondToAskUser("print")).toBe(false);
+  });
+
+  it("undefined → false（向后兼容）", () => {
+    expect(willRespondToAskUser(undefined)).toBe(false);
+  });
+});
+
+describe("hasInteractiveUI — 是否有交互 UI 通道", () => {
+  it("tui → true", () => {
+    expect(hasInteractiveUI("tui")).toBe(true);
+  });
+
+  it("rpc → true", () => {
+    expect(hasInteractiveUI("rpc")).toBe(true);
+  });
+
+  it("json → false", () => {
+    expect(hasInteractiveUI("json")).toBe(false);
+  });
+
+  it("print → false", () => {
+    expect(hasInteractiveUI("print")).toBe(false);
+  });
+
+  it("undefined → false", () => {
+    expect(hasInteractiveUI(undefined)).toBe(false);
+  });
+});

package/src/execution/__tests__/lifecycle-manager-lock.test.ts

@@ -0,0 +1,211 @@
+// acquireActivateLock 30s 超时兜底单测 —— v4-lifecycle-convergence.md §3.3 A-2。
+//
+// 验证：前序 holder 持锁不 release（崩溃/死锁模拟）时，waiter
+//   - 等待 29999ms 仍 pending（未误伤正常排队）
+//   - 到 30001ms 抛含恢复指引的超时错误（'activation timed out' + 'retry action: message'）
+//
+// 测试策略：纯 Promise 链 + setTimeout 超时，用 vi.useFakeTimers() 控时，
+// advanceTimersByTimeAsync 同时推进 fake timer 与 microtask flush。
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  _getActivateLockTailCountForTest,
+  _resetLifecycleState,
+  acquireActivateLock,
+} from "../lifecycle-manager.ts";
+
+describe("acquireActivateLock 30s 超时兜底 (v4 A-2)", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    _resetLifecycleState();
+  });
+
+  afterEach(() => {
+    _resetLifecycleState();
+    vi.useRealTimers();
+  });
+
+  it("waiter 等待 29999ms 仍 pending；到 30001ms 抛含恢复指引的超时错误", async () => {
+    // 第一个 holder 持锁后不 release（模拟崩溃/死锁）
+    await acquireActivateLock("sa-stuck");
+
+    // 第二个 waiter 必然排队（前序未 release）
+    let errMsg: string | null = null;
+    let gotRelease: (() => void) | null = null;
+    const waiter = acquireActivateLock("sa-stuck")
+      .then((release) => {
+        gotRelease = release;
+      })
+      .catch((err: unknown) => {
+        errMsg = err instanceof Error ? err.message : String(err);
+      });
+
+    // flush microtask：waiter 进入 prev.then 等待链
+    await vi.advanceTimersByTimeAsync(0);
+    expect(gotRelease).toBe(null); // 尚未拿到锁
+    expect(errMsg).toBe(null);
+
+    // 29999ms：未满 30s，waiter 仍 pending
+    await vi.advanceTimersByTimeAsync(29999);
+    expect(gotRelease).toBe(null);
+    expect(errMsg).toBe(null);
+
+    // 再推进 2ms（累计 30001ms）：超时 timer 触发 → reject
+    await vi.advanceTimersByTimeAsync(2);
+    await waiter;
+
+    // 超时：未拿到锁，抛含恢复指引的错误
+    expect(gotRelease).toBe(null);
+    expect(errMsg).not.toBe(null);
+    expect(errMsg).toContain("activation timed out");
+    expect(errMsg).toContain("retry action: message");
+    expect(errMsg).toContain("sa-stuck");
+  });
+
+  it("首次 acquire（无前序 holder）立即返回 release，不触发超时", async () => {
+    // 首次 acquire：prev=Promise.resolve()，立即 resolve，timer 被 clearTimeout 取消
+    const release = await acquireActivateLock("sa-fresh");
+    expect(typeof release).toBe("function");
+
+    // 推进远超 30s，不应有任何未捕获的超时 reject（timer 已清除）
+    await vi.advanceTimersByTimeAsync(60000);
+    release();
+  });
+
+  it("[review 修复] 超时后前序 release → 链可推进：二次 acquire 立即获锁（锁链不瘫痪）", async () => {
+    // 瘫痪路径回归：waiter 超时 reject 后，若其 current 永久 pending，tail 永久
+    // pending → 前序 release 后后续 acquire 也只能 30s 超时（只能重启恢复）。
+    // 修复后超时回调 resolve 自身 current 放行链尾：release1 后 tail settle，
+    // 二次 acquire 的 prev 已 settle → 立即拿到 releaseFn。
+    const release1 = await acquireActivateLock("sa-recover");
+
+    let waiterErr: string | null = null;
+    const waiter = acquireActivateLock("sa-recover").catch((err: unknown) => {
+      waiterErr = err instanceof Error ? err.message : String(err);
+    });
+    await vi.advanceTimersByTimeAsync(0); // waiter 挂链
+    await vi.advanceTimersByTimeAsync(30001); // 超时 reject（+ 超时放行链尾）
+    await waiter;
+    expect(waiterErr).toContain("activation timed out");
+
+    release1(); // 前序释放 → tail settle（current 已被超时放行 resolve）
+    await vi.advanceTimersByTimeAsync(0); // flush microtask 链
+
+    // 二次 acquire：prev 是已 settle 的 tail → 立即拿到锁，不等 30s
+    const release2 = await acquireActivateLock("sa-recover");
+    expect(typeof release2).toBe("function");
+    release2();
+    await vi.advanceTimersByTimeAsync(0);
+  });
+
+  it("[review 修复] 前序持续持锁时超时不放行后续 waiter 提前获锁（互斥保持）", async () => {
+    // 超时放行只 resolve 自身 current（tail 仍等 prev）；前序未 release 时，
+    // 新 acquire 依然排队等待，不会与前序 holder 形成双写者。
+    const release1 = await acquireActivateLock("sa-mutex");
+
+    const waiter1 = acquireActivateLock("sa-mutex").catch(() => {});
+    await vi.advanceTimersByTimeAsync(30001); // waiter1 超时放行自身 current
+    await waiter1;
+
+    // 前序仍持锁：新 acquire 的 prev（= waiter1 的 tail）等待 release1，不提前获锁
+    let gotRelease2 = false;
+    const waiter2 = acquireActivateLock("sa-mutex").then(() => {
+      gotRelease2 = true;
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(gotRelease2).toBe(false); // 未提前获锁
+
+    release1();
+    await vi.advanceTimersByTimeAsync(0);
+    await waiter2; // release1 后链推进，waiter2 获锁
+    expect(gotRelease2).toBe(true);
+  });
+
+  it("[review 修复] 超时者对称自清：前序 release 推进链尾后 Map 条目回收；前序持锁期间不提前删", async () => {
+    // round2 INFO 残留：超时者 releaseFn 永不被调用，原实现条目滞留 Map 直到下次
+    // 同 recordId acquire 覆盖。修复后挂 tail 尾部自清——tail settle（前序已
+    // release）时回收；tail pending（前序仍持锁）时回调不执行，条目保留（后续
+    // acquire 仍排队等待，互斥不被破坏）。
+    const release1 = await acquireActivateLock("sa-timeout-gc");
+
+    const waiter = acquireActivateLock("sa-timeout-gc").catch(() => {});
+    await vi.advanceTimersByTimeAsync(0); // waiter 挂链，Map 链尾已覆盖为 waiter 的 tail
+    expect(_getActivateLockTailCountForTest()).toBe(1);
+
+    await vi.advanceTimersByTimeAsync(30001); // 超时：reject + settleCurrent + tail.then 自清排队
+    await waiter;
+    // 前序仍持锁 → tail 仍 pending → 自清回调未执行 → 条目仍在
+    expect(_getActivateLockTailCountForTest()).toBe(1);
+
+    release1(); // 前序释放 → tail settle → 自清回调执行（identity 匹配，无新 waiter）
+    await vi.advanceTimersByTimeAsync(0);
+    expect(_getActivateLockTailCountForTest()).toBe(0);
+  });
+});
+
+describe("activateLockTails tail-identity 自清（release 后回收）", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    _resetLifecycleState();
+  });
+
+  afterEach(() => {
+    _resetLifecycleState();
+    vi.useRealTimers();
+  });
+
+  it("W3TC14: 无 waiter 时 release 后 Map 空 + release 后可再次 acquire", async () => {
+    const release = await acquireActivateLock("sa-gc");
+    // 自清新增的 test-only 观察点：acquire 后 Map 有 1 条链尾
+    expect(_getActivateLockTailCountForTest()).toBe(1);
+
+    release();
+    // 自清经 queueMicrotask 异步执行——advanceTimersByTimeAsync(0) flush microtask
+    await vi.advanceTimersByTimeAsync(0);
+    // 无 waiter：Map 中链尾即本链尾，identity 匹配 → delete 回收
+    expect(_getActivateLockTailCountForTest()).toBe(0);
+
+    // release 后可再次 acquire：prev 回落 Promise.resolve()，立即 resolve 返回 release
+    const release2 = await acquireActivateLock("sa-gc");
+    expect(typeof release2).toBe("function");
+    release2();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(_getActivateLockTailCountForTest()).toBe(0);
+  });
+
+  it("W3TC15: 有 waiter 排队不删、最后释放者回收；不同 recordId 链独立", async () => {
+    const release1 = await acquireActivateLock("sa-q");
+
+    // 发起 acquire#2 同 recordId（不 await，.then 捕获 release2）
+    let release2: (() => void) | null = null;
+    const waiter = acquireActivateLock("sa-q").then((r) => {
+      release2 = r;
+    });
+    // #2 进入等待链——此刻 Map 链尾已被 #2 覆盖
+    await vi.advanceTimersByTimeAsync(0);
+
+    release1();
+    await vi.advanceTimersByTimeAsync(0);
+    // ES7 核心：waiter 的链尾仍在——identity 不匹配不删
+    expect(_getActivateLockTailCountForTest()).toBe(1);
+
+    // acquire#2 在 release1 后正常 resolve（等待链不被 delete 破坏——waiter 持
+    // acquire 时刻捕获的 prev Promise 引用而非 Map 查询）
+    await waiter;
+    expect(typeof release2).toBe("function");
+
+    // 另一 recordId 独立链：同时持有时各自独立计数
+    const releaseA = await acquireActivateLock("sa-a");
+    expect(_getActivateLockTailCountForTest()).toBe(2); // sa-q + sa-a
+
+    release2!();
+    await vi.advanceTimersByTimeAsync(0);
+    // 最后释放者回收：release2 的 identity 匹配 → sa-q 条目回收，sa-a 仍在
+    expect(_getActivateLockTailCountForTest()).toBe(1);
+
+    releaseA();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(_getActivateLockTailCountForTest()).toBe(0);
+  });
+});