@zhushanwen/subagent-core 0.7.1 → 0.9.0

package/src/execution/__tests__/chat-round-first-round-watchdog.test.ts

@@ -1,255 +0,0 @@
-// src/execution/__tests__/chat-round-first-round-watchdog.test.ts
-//
-// [F-2 修复] 首轮/冷续轮 settled-watchdog arm 重接 + [F-5 修复] chat 轮路由终态化注销。
-//
-// 背景：armMidRoundNoProgress 此前唯一调用点在 deliverChatMessage（热路径续聊轮）；
-// kickOffChatRound（spawn 首轮 + 冷续 resume 轮）内无任何 arm——被删的 inproc
-// stdout-pump 是首轮唯一中段守护，协议化后引擎侧 spawn-runner 仅 turn 计数无墙钟，
-// 首轮 wedged（LC-1 场景①：无事件行输出）无任何熔断。修复 = run 派发前补 arm
-//（refresh 源 = runId 键 ctx.onEvent 事件行 + ctx.onRoundLifecycle settled 交棒——
-// 引擎侧 spawn-runner 对 text_delta 同时走 onEvent 与 onDelta，刷新面与热路径等效）。
-//
-// [F-5] chat 轮路由（chatRoundRoutes）此前仅 cancelBackground 注销；finalize 链终态化
-// （closeChatIdle / closeAfterRoundSettled / finalizeRecord）不注销 → 路由闭包持
-// record/stream/守护引用泄漏。修复 = doFinalizeRecord 的 onFinalized 钩子单一汇聚点。
-//
-// 替身形态与 subagent-service-recovery-bounds.test.ts 同源（fake-engine-port 协议 seam）。
-
-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 } = vi.hoisted(() => ({ killChildSpy: vi.fn() }));
-vi.mock("../engine/host/spawned-children.ts", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../engine/host/spawned-children.ts")>();
-  return { ...actual, killRecordChildWithEscalation: killChildSpy };
-});
-
-import { clearEngines } from "../engine/registry.ts";
-import { registerFakePiEngine, type FakePiEnginePort } from "./helpers/fake-engine-port.ts";
-import { createRecord } from "../execution-record.ts";
-import { ModelConfigService } from "../model-config-service.ts";
-import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
-import type { RecordStore } from "../record-store.ts";
-import { SubagentService } from "../subagent-service.ts";
-import type { PiLike } from "../subagent-service.ts";
-import {
-  getSettledWatchdogPhase,
-  hasSettledWatchdog,
-  SETTLED_MID_ROUND_NO_PROGRESS_MS,
-  SETTLED_WATCHDOG_TIMEOUT_MS,
-  _resetSettledWatchdogsForTest,
-} from "../settled-watchdog.ts";
-import { _resetLifecycleState } from "../lifecycle-manager.ts";
-import { _resetCoreSpawnedChildrenMirrorForTest } from "../engine/host/spawned-children.ts";
-import type { ExecutionRecord } from "../types.ts";
-
-function makePi(): PiLike {
-  return {
-    appendEntry: vi.fn(),
-    events: { emit: vi.fn() },
-    sendMessage: vi.fn(),
-  } as unknown as PiLike;
-}
-
-interface ServiceInternals {
-  store: RecordStore;
-}
-
-const CTX_MODEL: ModelInfo = { id: "m", name: "M", provider: "p", reasoning: false };
-
-function makeEmptyRegistry(): ModelRegistryLike {
-  return { getAvailable: () => [], find: () => undefined, hasConfiguredAuth: () => true };
-}
-
-function setup(): { agentDir: string; service: SubagentService; store: RecordStore; pi: PiLike; fake: FakePiEnginePort } {
-  const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "chat-round-watchdog-"));
-  clearEngines();
-  const fake = registerFakePiEngine();
-  const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
-  modelService.initModel({ modelRegistry: makeEmptyRegistry(), sessionId: "root-session", ctxModel: CTX_MODEL });
-  const service = new SubagentService({ cwd: agentDir, modelService });
-  const pi = makePi();
-  service.initSession({ pi, sessionId: "root-session" });
-  const store = (service as unknown as ServiceInternals).store;
-  return { agentDir, service, store, pi, fake };
-}
-
-/** 模拟 kickOffChatRound 的路由注册面（Service map + fake 引擎两端同挂）。 */
-function registerRoute(service: SubagentService, fake: FakePiEnginePort, recordId: string): void {
-  const unregister = fake.registerChatRoundRoute(recordId, {
-    onStreamDelta: () => {},
-    onRoundLifecycle: () => {},
-  });
-  (
-    service as unknown as { chatRoundRoutes: Map<string, () => void> }
-  ).chatRoundRoutes.set(recordId, unregister);
-}
-
-function makeChatRecord(id: string): ExecutionRecord {
-  return createRecord(id, {
-    agent: "general-purpose",
-    model: "test/model",
-    mode: "background",
-    task: "test",
-    slug: "test",
-    startedAt: 1000,
-    rootSessionId: "root-session",
-    chatMode: true,
-    controller: new AbortController(),
-  });
-}
-
-describe("[F-2] 首轮/冷续轮 settled-watchdog arm（kickOffChatRound run 派发点）", () => {
-  let agentDir: string;
-  let service: SubagentService;
-  let store: RecordStore;
-  let pi: PiLike;
-  let fake: FakePiEnginePort;
-
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    killChildSpy.mockClear();
-    ({ agentDir, service, store, pi, fake } = setup());
-  });
-
-  afterEach(() => {
-    service.dispose();
-    clearEngines();
-    vi.useRealTimers();
-    _resetLifecycleState();
-    _resetSettledWatchdogsForTest();
-    _resetCoreSpawnedChildrenMirrorForTest();
-    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-  });
-
-  it("首轮 run 派发后中段守护 armed（修复前首轮无任何守护）", async () => {
-    const handle = await service.execute({ task: "first round", slug: "t", ctxModel: CTX_MODEL, conversation: true });
-    expect(fake.runs).toHaveLength(1);
-    expect(hasSettledWatchdog(handle.subagentId)).toBe(true);
-    expect(getSettledWatchdogPhase(handle.subagentId)).toBe("mid-round");
-  });
-
-  it("冷续轮进行中无产出 → 中段守护按既有超时语义触发：kill + 引擎 cancel + 回退 idle-resumable（fake timers）", async () => {
-    // fake timers 必须先于 arm 生效（useFakeTimers 不接管已存在的真实 timer）
-    vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
-    const record = makeChatRecord("sa-first");
-    record.sessionFile = path.join(agentDir, "prior-session.jsonl");
-    fs.writeFileSync(record.sessionFile, "{}\n", "utf-8");
-    store.register(record);
-    await (
-      service as unknown as { resumeColdRound: (r: ExecutionRecord, t: string) => void }
-    ).resumeColdRound(record, "cold resume text");
-    expect(fake.runs).toHaveLength(1); // 冷续轮 run 已派发
-    expect(hasSettledWatchdog(record.id)).toBe(true);
-
-    // 冷续轮全程静默（无协议事件行）满中段窗长
-    await vi.advanceTimersByTimeAsync(SETTLED_MID_ROUND_NO_PROGRESS_MS + 1);
-
-    expect(killChildSpy).toHaveBeenCalledWith(record.id, "settled watchdog (hot path)");
-    expect(hasSettledWatchdog(record.id)).toBe(false); // 到期自清
-    // chatMode MF-6：回退 idle-resumable（不销毁对话）
-    expect(record.resumable).toBe(true);
-    expect(record.status).toBe("running");
-    expect(record.result).toContain("settled watchdog");
-    expect(record.result).toContain("Recovery");
-    // 引擎侧终止意图（协议 interact cancel）
-    const cancel = fake.interacts.find((c) => c.action.kind === "cancel");
-    expect(cancel).toBeDefined();
-    void pi;
-  });
-
-  it("中段事件行（text_delta 经 onEvent）刷新静默计时：半窗 + 刷新 + 半窗不触发，再满窗才触发", async () => {
-    vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
-    const handle = await service.execute({ task: "streaming round", slug: "t", ctxModel: CTX_MODEL, conversation: true });
-    const run = fake.runs[0]!;
-
-    await vi.advanceTimersByTimeAsync(SETTLED_MID_ROUND_NO_PROGRESS_MS / 2);
-    // 首轮 runId 键协议事件行到达（text_delta——引擎侧同时走 onEvent 通道）
-    run.emitEvent({ type: "text_delta", delta: "chunk" });
-    await vi.advanceTimersByTimeAsync(SETTLED_MID_ROUND_NO_PROGRESS_MS / 2 + 1);
-    expect(hasSettledWatchdog(handle.subagentId)).toBe(true); // 刷新后未到期
-    expect(killChildSpy).not.toHaveBeenCalled();
-
-    // 刷新后再满整个静默窗才触发
-    await vi.advanceTimersByTimeAsync(SETTLED_MID_ROUND_NO_PROGRESS_MS + 1);
-    expect(killChildSpy).toHaveBeenCalledWith(handle.subagentId, "settled watchdog (hot path)");
-  });
-
-  it("首轮 settled 相位交棒：中段窗内相位到达 → 切收尾段（中段窗不再触发，收尾段硬顶触发）", async () => {
-    vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
-    const handle = await service.execute({ task: "stuck after settle", slug: "t", ctxModel: CTX_MODEL, conversation: true });
-    const run = fake.runs[0]!;
-
-    await vi.advanceTimersByTimeAsync(SETTLED_MID_ROUND_NO_PROGRESS_MS / 2);
-    // 首轮 runId 键 roundLifecycle settled 相位（W3 报告称已接——本用例核实链路生效）
-    run.emitLifecycle({ phase: "settled", usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0 } });
-    expect(getSettledWatchdogPhase(handle.subagentId)).toBe("settled"); // 已交棒收尾段
-
-    // 中段不再计时（交棒清掉，不继承——30min 静默判据对收尾段失效）；收尾段未满（<600s）不触发
-    await vi.advanceTimersByTimeAsync(SETTLED_WATCHDOG_TIMEOUT_MS - 1);
-    expect(killChildSpy).not.toHaveBeenCalled();
-    expect(hasSettledWatchdog(handle.subagentId)).toBe(true); // 收尾段仍在计时
-
-    // 收尾段硬顶（600s 默认）到期触发
-    await vi.advanceTimersByTimeAsync(2);
-    expect(killChildSpy).toHaveBeenCalledWith(handle.subagentId, "settled watchdog (hot path)");
-  });
-});
-
-describe("[F-5] chat 轮路由终态化注销（doFinalizeRecord onFinalized 汇聚点）", () => {
-  let agentDir: string;
-  let service: SubagentService;
-  let store: RecordStore;
-  let fake: FakePiEnginePort;
-
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    killChildSpy.mockClear();
-    ({ agentDir, service, store, fake } = setup());
-  });
-
-  afterEach(() => {
-    service.dispose();
-    clearEngines();
-    _resetLifecycleState();
-    _resetSettledWatchdogsForTest();
-    _resetCoreSpawnedChildrenMirrorForTest();
-    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-  });
-
-  it("closeChatIdle 终态化路径注销 chat 轮路由（修复前仅 cancelBackground 注销 → 泄漏）", async () => {
-    const record = makeChatRecord("sa-route-leak");
-    store.register(record);
-    // 模拟首轮已注册的 recordId 键路由（kickOffChatRound 注册面：Service map + fake 引擎两端）
-    registerRoute(service, fake, record.id);
-    // Path A：idle timer armed（进程保活等待续聊）→ closeSubagent(false) 走 closeChatIdle
-    const { armIdleTimer } = (await import("../lifecycle-manager.ts")) as typeof import("../lifecycle-manager.ts");
-    armIdleTimer(record.id, () => {}, 60_000);
-
-    await service.chatActions.closeSubagent(record, false);
-
-    expect(fake.chatRouteUnregisters).toContain(record.id);
-  });
-
-  it("closeAfterRoundSettled（优雅关闭消费）路径注销 chat 轮路由", async () => {
-    const record = makeChatRecord("sa-route-close-round");
-    store.register(record);
-    registerRoute(service, fake, record.id);
-    record.closeAfterRound = true;
-
-    await (
-      service as unknown as { closeAfterRoundSettled: (r: ExecutionRecord) => Promise<void> }
-    ).closeAfterRoundSettled(record);
-
-    expect(fake.chatRouteUnregisters).toContain(record.id);
-    expect(record.status).toBe("closed");
-  });
-});

package/src/execution/__tests__/finalized-marker.test.ts

@@ -1,104 +0,0 @@
-// src/__tests__/finalized-marker.test.ts
-//
-// finalized-marker 专属测试。
-// 覆盖：write→read 往返 / 缺 sidecar → false / best-effort IO 错静默 / .cancelled 互斥。
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-
-import { readFinalized, readFinalizedReason, writeFinalized } from "../finalized-marker.ts";
-
-describe("finalized-marker", () => {
-  let tmpDir: string;
-  let sessionFile: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fm-test-"));
-    sessionFile = path.join(tmpDir, "2026-01-01_uuid.jsonl");
-  });
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-  });
-
-  describe("write → read 往返", () => {
-    it("写入后 readFinalized 返回 true", () => {
-      writeFinalized(sessionFile);
-      expect(readFinalized(sessionFile)).toBe(true);
-    });
-
-    it("sidecar 路径 = sessionFile + '.finalized'", () => {
-      writeFinalized(sessionFile);
-      expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(true);
-    });
-
-    it("sidecar 内容为空（无 reason 时保持旧格式兼容）", () => {
-      writeFinalized(sessionFile);
-      const content = fs.readFileSync(`${sessionFile}.finalized`, "utf-8");
-      expect(content).toBe("");
-      expect(readFinalizedReason(sessionFile)).toBe("");
-    });
-
-    // [v8.5 A2] 携带真实 closedReason 写入 → 读取返回原值（trim 后）
-    it("带 reason 写入 → readFinalizedReason 返回原值", () => {
-      writeFinalized(sessionFile, "user-close");
-      expect(readFinalized(sessionFile)).toBe(true);
-      expect(readFinalizedReason(sessionFile)).toBe("user-close");
-
-      writeFinalized(sessionFile, "parent-shutdown");
-      expect(readFinalizedReason(sessionFile)).toBe("parent-shutdown");
-    });
-
-    it("带 reason 的内容含首尾空白时 trim 后返回", () => {
-      fs.writeFileSync(`${sessionFile}.finalized`, "  gc \n", "utf-8");
-      expect(readFinalizedReason(sessionFile)).toBe("gc");
-    });
-  });
-
-  describe("readFinalizedReason 无 sidecar", () => {
-    it("不存在 → undefined（与「存在但空串」区分）", () => {
-      expect(readFinalizedReason(sessionFile)).toBeUndefined();
-    });
-  });
-
-  describe("readFinalized 无 sidecar", () => {
-    it("不存在 → false", () => {
-      expect(readFinalized(sessionFile)).toBe(false);
-    });
-  });
-
-  describe("best-effort IO 错静默", () => {
-    it("writeFileSync 抛错时不抛出", () => {
-      // 目标路径不存在（不存在的父目录），writeFileSync 会抛
-      const badPath = path.join(tmpDir, "nonexistent-sub", "session.jsonl");
-      expect(() => writeFinalized(badPath)).not.toThrow();
-    });
-
-    it("写失败后 readFinalized 返回 false（sidecar 未写入）", () => {
-      const badPath = path.join(tmpDir, "nonexistent-sub", "session.jsonl");
-      writeFinalized(badPath); // 静默失败
-      expect(readFinalized(badPath)).toBe(false);
-    });
-  });
-
-  describe("与 .cancelled 互斥（BC-4）", () => {
-    it("写 finalized 时删除已有的 .cancelled", () => {
-      // 先写一个 .cancelled sidecar
-      fs.writeFileSync(`${sessionFile}.cancelled`, `{"id":"bg-1","status":"cancelled","agent":"w","startedAt":1,"endedAt":2}\n`, "utf-8");
-      expect(fs.existsSync(`${sessionFile}.cancelled`)).toBe(true);
-
-      // 写 finalized → .cancelled 应被删除
-      writeFinalized(sessionFile);
-      expect(fs.existsSync(`${sessionFile}.cancelled`)).toBe(false);
-      expect(readFinalized(sessionFile)).toBe(true);
-    });
-
-    it("无 .cancelled 时写 finalized 正常（不报错）", () => {
-      expect(fs.existsSync(`${sessionFile}.cancelled`)).toBe(false);
-      expect(() => writeFinalized(sessionFile)).not.toThrow();
-      expect(readFinalized(sessionFile)).toBe(true);
-    });
-  });
-});

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

@@ -1,211 +0,0 @@
-// 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);
-  });
-});