@zhushanwen/subagent-core 0.6.0 → 0.7.1

package/src/execution/__tests__/run-spawn-stdout-callback-throw.test.ts

@@ -1,207 +0,0 @@
-// src/execution/__tests__/run-spawn-stdout-callback-throw.test.ts
-//
-// [F-R2] stdout data 同步回调链内 fail-fast throw 不逃逸（不升级为 uncaughtException 崩宿主）。
-//
-// 背景：session-runner 的两处 timer 安全校验调用位于 child.stdout.on("data") 同步回调链内：
-//   ① agent_end keep-alive 分支的 resolveSpawnWatchdogMs（→ assertSafeTimerDelay fail-fast）
-//   ② chatMode agent_settled 分支的 armIdleTimer（→ assertSafeTimerDelay fail-fast）
-// 旧实现任一处 throw 都会逃出事件回调 = Node uncaughtException 崩宿主进程。
-// 修复：调用点包 try/catch 降级（不挂 timer），错误经 bestEffort("error") 可见。
-//
-// mock 结构与 run-spawn-chatmode-settled.test.ts 一致（FakeChild + lifecycle-manager 真实模块）。
-// logger 整体 mock（loggerMock spy）断言错误可见——「fail-fast 语义保留（错误可见、行为明确）
-// 但不升级为进程崩溃」。
-import { spawn } from "node:child_process";
-import * as fs from "node:fs";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-// logger mock：bestEffort / session-runner 共享同一 loggerMock（断言错误可见性）。
-// vi.hoisted：vi.mock 工厂被提升到顶层 const 之前执行，loggerMock 必须经 vi.hoisted 创建。
-const { loggerMock } = vi.hoisted(() => ({
-  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
-
-vi.mock("node:child_process", async () => {
-  const { FakeChild } = await import("./helpers/spawn-mock.ts");
-  return {
-    spawn: vi.fn(() => new FakeChild()),
-    // buildEnvBlock 的 git branch 调用（execFile 异步）：默认 err-first 兜底 → catch → branch=""
-    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(),
-  // [T5②] keep-alive 心跳刷新读取现有 marker id（缺失兜底 record.id）
-  readAliveMarker: vi.fn(() => undefined),
-  isProcessAlive: vi.fn(() => false),
-}));
-
-// 场景 ① 依赖 keep-alive 分支命中：count=1（有活跃后代 → 不 kill → 重挂 watchdog）
-vi.mock("../session-pending.ts", () => ({
-  readActivePendingFromSessionFile: vi.fn(() => ({ count: 1 })),
-  prunePendingCursor: vi.fn(),
-}));
-
-vi.mock("../engine/engines/pi/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 { runSpawn, SPAWN_WATCHDOG_ENV } from "../engine/engines/pi/session-runner.ts";
-import type { SessionRunnerContext } from "../engine/engines/pi/session-runner.ts";
-import { hasIdleTimer, _resetLifecycleState } from "../lifecycle-manager.ts";
-import { createRecord } from "../execution-record.ts";
-import type { ExecutionRecord } from "../types.ts";
-import {
-  emitStdoutLine,
-  type FakeChild,
-  lastSpawnedChild as lastSpawnedChildOf,
-  makeCtx,
-  makeOpts,
-  makeRecord,
-  sessionHeader,
-  waitForSpawn as waitForSpawnOf,
-} from "./helpers/spawn-mock.ts";
-
-const mockSpawn = vi.mocked(spawn);
-
-const lastSpawnedChild = (): FakeChild => lastSpawnedChildOf(mockSpawn);
-const waitForSpawn = (timeoutMs = 1000): Promise<void> => waitForSpawnOf(mockSpawn, timeoutMs);
-
-/** 构造 chatMode record（idleTimeoutMs 设为超出 setTimeout 安全域的值 → assertSafeTimerDelay throw）。 */
-function makeChatModeRecord(id = "sa-f2-idle"): ExecutionRecord {
-  return createRecord(id, {
-    agent: "general-purpose",
-    model: "test-model",
-    mode: "background",
-    task: "chat task",
-    slug: "chat",
-    startedAt: 1_000_000,
-    rootSessionId: "root-session",
-    parentRecordId: undefined,
-    depth: 0,
-    chatMode: true,
-    // > 2^31-1：Node setTimeout 溢出域，assertSafeTimerDelay fail-fast
-    idleTimeoutMs: Number.MAX_SAFE_INTEGER,
-  });
-}
-
-describe("[F-R2] stdout 回调链内 fail-fast throw 不逃逸", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    _resetLifecycleState();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    _resetLifecycleState();
-  });
-
-  it("① agent_end keep-alive 分支 resolveSpawnWatchdogMs throw → 降级不 re-arm，run 正常收尾，error 可见", async () => {
-    const record = makeRecord();
-    const promise = runSpawn(record, "Task: keepalive", makeOpts(), makeCtx());
-
-    await waitForSpawn();
-    const child = lastSpawnedChild();
-
-    emitStdoutLine(child, sessionHeader("sess-fr2a"));
-    // 初始 watchdog 解析在 spawn 后同步块内已完成（env 未设 → 不挂）。
-    // 此刻设非法 env：agent_end keep-alive 分支再读 env → assertSafeTimerDelay throw。
-    process.env[SPAWN_WATCHDOG_ENV] = String(Number.MAX_SAFE_INTEGER);
-    try {
-      emitStdoutLine(child, { type: "agent_end", willRetry: false });
-      // 给 stream flush 留一个 tick（对齐 chatmode 测试模式）：throw 若逃逸回调，
-      // vitest 会以 unhandled error 判本测试失败——能走到断言即「未崩宿主」。
-      await new Promise((r) => setTimeout(r, 20));
-
-      // 降级语义：不 re-arm（无 timer 可直接观察的是——子进程未被 kill、run 未被中断）
-      expect(child.killed).toBe(false);
-
-      // 错误可见（fail-fast 语义保留）：bestEffort("error") 经 logger.error 落日志
-      expect(loggerMock.error).toHaveBeenCalledWith(
-        expect.stringContaining("resolveSpawnWatchdogMs"),
-        expect.objectContaining({ detail: expect.stringContaining("exceeds the Node setTimeout limit") }),
-      );
-
-      // 收尾：run 正常完成（未被回调异常打断）
-      child.stdout.end();
-      child.stderr.end();
-      child.emit("close", 0);
-      const result = await promise;
-      expect(result.success).toBe(true);
-    } finally {
-      delete process.env[SPAWN_WATCHDOG_ENV];
-    }
-  });
-
-  it("② chatMode agent_settled armIdleTimer throw → 降级挂 DEFAULT idle timer + warn，onRoundSettled 照常、提前 resolve", async () => {
-    const record = makeChatModeRecord("sa-f2-idle");
-    const onRoundSettled = vi.fn();
-    const ctx: Partial<SessionRunnerContext> = { onRoundSettled };
-    const promise = runSpawn(record, "Task: idle", makeOpts(), makeCtx(ctx as SessionRunnerContext));
-
-    await waitForSpawn();
-    const child = lastSpawnedChild();
-
-    emitStdoutLine(child, sessionHeader("sess-fr2b"));
-    emitStdoutLine(child, { type: "agent_settled" });
-    await new Promise((r) => setTimeout(r, 20));
-
-    // [T4② / PS-4] 降级语义修正：旧「不挂」（丢通知放行门 + 进程回收）改为
-    // 「挂 DEFAULT_IDLE_TIMEOUT_MS + warn」——防御性兜底保住两个不变量且可见
-    expect(hasIdleTimer(record.id)).toBe(true);
-    expect(child.killed).toBe(false);
-
-    // catch 后续语句照常执行：本轮完成通知不因 GC timer 故障丢失
-    expect(onRoundSettled).toHaveBeenCalledTimes(1);
-
-    // 错误可见（原失败留痕）+ 降级动作可见（T4②）
-    expect(loggerMock.error).toHaveBeenCalledWith(
-      expect.stringContaining("armIdleTimer"),
-      expect.objectContaining({ detail: expect.stringContaining("exceeds the Node setTimeout limit") }),
-    );
-    expect(loggerMock.warn).toHaveBeenCalledWith(
-      expect.stringContaining("fell back to DEFAULT_IDLE_TIMEOUT_MS"),
-    );
-
-    // 收尾：chatMode 首轮 agent_settled 已 resolveRun(0)，close 后 runSpawn 正常返回
-    child.stdout.end();
-    child.stderr.end();
-    child.emit("close", 0);
-    const result = await promise;
-    expect(result.success).toBe(true);
-  });
-});

package/src/execution/__tests__/service-kill-escalation.test.ts

@@ -1,91 +0,0 @@
-// src/execution/__tests__/service-kill-escalation.test.ts
-//
-// [u-svc / T2④ / LC-2] killRecordChildWithEscalation 真实现行为（服务侧 kill 收敛入口，
-// 无 SpawnRunState 调用方）：
-//   - child 不在 spawnedChildren / 已 killed → no-op（与旧 `child && !child.killed` 守卫
-//     语义逐字对齐）；
-//   - SIGTERM 后 30s 未见 exit → SIGKILL 升级（SIGTERM 被无视的幽灵进程防线）；
-//   - exit 到达 → 升级 timer 自动清除；
-//   - 同 record 重复调用先清旧升级 timer（防叠加）。
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { ChildProcess } from "node:child_process";
-
-import { FakeChild } from "./helpers/spawn-mock.ts";
-import {
-  _resetServiceKillStateForTest,
-  killRecordChildWithEscalation,
-  spawnedChildren,
-} from "../engine/engines/pi/session-runner.ts";
-
-const SIGKILL_ESCALATION_MS = 30_000;
-
-describe("T2④ killRecordChildWithEscalation", () => {
-  beforeEach(() => {
-    vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
-    _resetServiceKillStateForTest();
-    spawnedChildren.clear();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-    _resetServiceKillStateForTest();
-    spawnedChildren.clear();
-  });
-
-  it("is a no-op when the record has no registered child", () => {
-    expect(() => killRecordChildWithEscalation("sa-missing", "test")).not.toThrow();
-  });
-
-  it("is a no-op when the child already received a kill request (escalation owned by prior path)", () => {
-    const child = new FakeChild();
-    child.killed = true;
-    const killSpy = vi.spyOn(child, "kill");
-    spawnedChildren.set("sa-killed", child as unknown as ChildProcess);
-    killRecordChildWithEscalation("sa-killed", "test");
-    expect(killSpy).not.toHaveBeenCalled();
-  });
-
-  it("sends SIGTERM and escalates to SIGKILL after 30s without exit", async () => {
-    const child = new FakeChild();
-    const killSpy = vi.spyOn(child, "kill");
-    spawnedChildren.set("sa-escalate", child as unknown as ChildProcess);
-
-    killRecordChildWithEscalation("sa-escalate", "closeChatIdle");
-    expect(killSpy).toHaveBeenNthCalledWith(1, "SIGTERM");
-
-    await vi.advanceTimersByTimeAsync(SIGKILL_ESCALATION_MS - 1);
-    expect(killSpy).toHaveBeenCalledTimes(1); // 未到期不升级
-
-    await vi.advanceTimersByTimeAsync(1);
-    expect(killSpy).toHaveBeenNthCalledWith(2, "SIGKILL");
-  });
-
-  it("clears the escalation timer when the child exits in time", async () => {
-    const child = new FakeChild();
-    const killSpy = vi.spyOn(child, "kill");
-    spawnedChildren.set("sa-exit", child as unknown as ChildProcess);
-
-    killRecordChildWithEscalation("sa-exit", "cancelBackground");
-    child.emit("exit", 0, null);
-    await vi.advanceTimersByTimeAsync(SIGKILL_ESCALATION_MS + 1_000);
-    expect(killSpy).toHaveBeenCalledTimes(1); // 只有 SIGTERM，无 SIGKILL
-  });
-
-  it("repeated calls clear the previous escalation timer (no stacking)", async () => {
-    const child = new FakeChild();
-    const killSpy = vi.spyOn(child, "kill");
-    spawnedChildren.set("sa-repeat", child as unknown as ChildProcess);
-
-    killRecordChildWithEscalation("sa-repeat", "first");
-    await vi.advanceTimersByTimeAsync(10_000);
-    // 第二次调用前 child.killed 已为 true（首次 SIGTERM 置位）→ no-op 路径
-    killRecordChildWithEscalation("sa-repeat", "second");
-    expect(killSpy).toHaveBeenCalledTimes(1);
-    await vi.advanceTimersByTimeAsync(SIGKILL_ESCALATION_MS);
-    expect(killSpy).toHaveBeenCalledTimes(2); // 首次 timer 正常触发（未被重复调用清掉）
-    expect(killSpy).toHaveBeenNthCalledWith(2, "SIGKILL");
-  });
-});

package/src/execution/__tests__/session-runner-branch-cache-lru.test.ts

@@ -1,110 +0,0 @@
-// src/execution/__tests__/session-runner-branch-cache-lru.test.ts
-//
-// [LC-8/T6③] branchCache LRU 上界。
-//
-// 背景（设计 §4.3 LC-8）：缓存 key=cwd，worktree 路径每次唯一 → 模块级 Map 永不淘汰，
-// 条目按 path 永久累积（长寿命 orchestrator 内存无界，实锤·轻微）。T6③ 加 LRU 上限
-// BRANCH_CACHE_MAX_ENTRIES=64（常量导出）。
-//
-// 覆盖（验收：65 个路径插入后规模 64，最旧被淘汰）：
-//   - 65 次 miss 插入 → size 封顶 64，execFile 恰 65 次；
-//   - 最旧条目已被淘汰（再查重新 spawn git），次旧条目仍在（LRU 只淘汰最旧）；
-//   - get 命中刷新 LRU 序（touch 后不再是淘汰候选）；
-//   - 常量导出值 = 64。
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-// buildEnvBlock 用 execFile 异步取 git branch：按 opts.cwd 回填可区分的 branch 名。
-const { execFileMock } = vi.hoisted(() => ({ execFileMock: vi.fn() }));
-vi.mock("node:child_process", async () => {
-  const actual = await import("node:child_process");
-  return { ...actual, execFile: execFileMock };
-});
-
-// Mock 共享 logger（buildEnvBlock 的 git 失败 debug 留痕不落真实日志盘）。
-const { loggerMock } = vi.hoisted(() => ({
-  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
-
-import {
-  BRANCH_CACHE_MAX_ENTRIES,
-  _getBranchCacheSizeForTest,
-  _resetBranchCacheForTest,
-  buildEnvBlock,
-} from "../engine/engines/pi/session-runner.ts";
-
-/** execFile mock 回填 br-<cwd>（branch 与 cwd 一一对应，淘汰行为可断言）。 */
-function stubGitBranchSuccess(): void {
-  execFileMock.mockImplementation(
-    (
-      _cmd: string,
-      _args: readonly string[],
-      opts: { cwd?: string },
-      cb: (err: Error | null, stdout?: string, stderr?: string) => void,
-    ) => cb(null, `br-${opts?.cwd ?? "unknown"}`, ""),
-  );
-}
-
-beforeEach(() => {
-  _resetBranchCacheForTest();
-  stubGitBranchSuccess();
-});
-
-afterEach(() => {
-  _resetBranchCacheForTest();
-  execFileMock.mockReset();
-  loggerMock.debug.mockClear();
-});
-
-describe("[LC-8] branchCache LRU 上界", () => {
-  it("常量导出 BRANCH_CACHE_MAX_ENTRIES = 64", () => {
-    expect(BRANCH_CACHE_MAX_ENTRIES).toBe(64);
-  });
-
-  it("65 个路径插入后规模封顶 64，最旧被淘汰（重新 spawn git）", async () => {
-    const cwds = Array.from({ length: BRANCH_CACHE_MAX_ENTRIES + 1 }, (_, i) => `/tmp/lru-cwd-${i}`);
-    for (const cwd of cwds) {
-      const block = await buildEnvBlock(cwd);
-      expect(block).toContain(`Git branch: br-${cwd}`);
-    }
-    // 65 次 miss 插入，第 65 次插入时淘汰最旧（cwd-0）→ execFile 恰 65 次、规模 64
-    expect(execFileMock).toHaveBeenCalledTimes(BRANCH_CACHE_MAX_ENTRIES + 1);
-    expect(_getBranchCacheSizeForTest()).toBe(BRANCH_CACHE_MAX_ENTRIES);
-
-    // 最旧（cwd-0）已被 LRU 淘汰 → 再次查询重新 spawn git（66 次）；重插后淘汰次旧
-    //（cwd-1），更近插入的 cwd-2 不受影响
-    const block0 = await buildEnvBlock("/tmp/lru-cwd-0");
-    expect(block0).toContain("Git branch: br-/tmp/lru-cwd-0");
-    expect(execFileMock).toHaveBeenCalledTimes(BRANCH_CACHE_MAX_ENTRIES + 2);
-
-    // cwd-2（仍近插入序）仍在缓存 → 查询不再 spawn（仍 66 次）
-    await buildEnvBlock("/tmp/lru-cwd-2");
-    expect(execFileMock).toHaveBeenCalledTimes(BRANCH_CACHE_MAX_ENTRIES + 2);
-  });
-
-  it("get 命中刷新 LRU 序：被 touch 的条目不再是最旧淘汰候选", async () => {
-    const cwdA = "/tmp/lru-touch-a";
-    const cwdB = "/tmp/lru-touch-b";
-    await buildEnvBlock(cwdA); // A 先插
-    await buildEnvBlock(cwdB); // B 后插
-    expect(execFileMock).toHaveBeenCalledTimes(2);
-
-    await buildEnvBlock(cwdA); // 命中并 touch → A 变最新，B 变最旧；零 spawn
-    expect(execFileMock).toHaveBeenCalledTimes(2);
-
-    // 再插 63 个新条目挤爆缓存（2 + 63 = 65 → 淘汰恰 1 个最旧）：B（最旧）被淘汰、
-    // A（被 touch 过，次新）存活
-    for (let i = 0; i < BRANCH_CACHE_MAX_ENTRIES - 1; i++) {
-      await buildEnvBlock(`/tmp/lru-flood-${i}`);
-    }
-    expect(_getBranchCacheSizeForTest()).toBe(BRANCH_CACHE_MAX_ENTRIES);
-    const spawnsAfterFlood = execFileMock.mock.calls.length;
-
-    await buildEnvBlock(cwdA); // A 被 touch 过 → 仍在缓存
-    expect(execFileMock).toHaveBeenCalledTimes(spawnsAfterFlood);
-
-    await buildEnvBlock(cwdB); // B 最早未 touch → 已被淘汰，重新 spawn
-    expect(execFileMock).toHaveBeenCalledTimes(spawnsAfterFlood + 1);
-  });
-});

package/src/execution/__tests__/session-runner-close-prune.test.ts

@@ -1,181 +0,0 @@
-// src/execution/__tests__/session-runner-close-prune.test.ts
-//
-// [LC-6/T6②] 进程 close 接线：waitForChildExit close handler 调 prunePendingCursor
-// 剪枝该进程 sessionFile 的 pending 增量游标（session-runner 领地内的单点接线，主
-// agent 裁决授权）。
-//
-// 覆盖：
-//   1. close（resume 锁定 sessionFile）后 cursor 被剪枝——行为观察面：覆写同名文件
-//      （新 register 行落在旧 offset 之内、size ≥ 旧 offset），判定应从头全量读出
-//      新条目；cursor 未剪时会从旧 offset 续读丢掉它。
-//   2. sessionFile 未回填（无 resume、无 header 回填）时 close 跳过剪枝不抛错
-//      （此时也无 cursor：判定从未发生）。
-//
-// mock 拓扑对齐 run-spawn-resume.test.ts（FakeChild / fs 部分 mock / temp-prompt /
-// alive-store）；session-pending 刻意**不 mock**——接线行为的观察面就是真实游标
-// 剪枝语义（statSync/readFileSync 不在 fs mock 名单，走真实 fs）。
-
-import { spawn } from "node:child_process";
-import * as fs from "node:fs";
-import { writeFile } from "node:fs/promises";
-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 }));
-
-vi.mock("node:child_process", async () => {
-  const { FakeChild } = await import("./helpers/spawn-mock.ts");
-  return {
-    spawn: vi.fn(() => new FakeChild()),
-    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")),
-    ),
-  };
-});
-
-// [注意] 工厂内必须 importOriginal 拿真 actual——不带它 `await import("node:fs")` 自引用
-// 返回 mock 面。命名面先 ...actual 展开（session-pending 的 statSync/readFileSync、
-// 测试 fixture 的 mkdtempSync/rmSync 走真实 fs；fixture 写盘走真实透传的
-// node:fs/promises——writeFileSync 本身被 mock 隔离 runSpawn 的生产写入），再覆盖
-// runSpawn 生产写入面的 5 个方法（隔离 ~/.xyz-agent 生产路径写）。
-vi.mock("node:fs", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("node:fs")>();
-  return {
-    default: {
-      ...actual,
-      mkdirSync: vi.fn(),
-      existsSync: vi.fn(() => false),
-      appendFileSync: vi.fn(),
-      writeFileSync: vi.fn(),
-      readdirSync: vi.fn(() => []),
-    },
-    ...actual,
-    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("../engine/engines/pi/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 { runSpawn } from "../engine/engines/pi/session-runner.ts";
-import { clearPendingCursors, listActivePendingFromSessionFile } from "../session-pending.ts";
-import {
-  type FakeChild,
-  lastSpawnedChild as lastSpawnedChildOf,
-  makeCtx,
-  makeOpts,
-  makeRecord,
-  waitForSpawn as waitForSpawnOf,
-} from "./helpers/spawn-mock.ts";
-
-const mockSpawn = vi.mocked(spawn);
-const mockExistsSync = vi.mocked(fs.existsSync);
-
-const lastSpawnedChild = (): FakeChild => lastSpawnedChildOf(mockSpawn);
-const waitForSpawn = (timeoutMs = 1000): Promise<void> => waitForSpawnOf(mockSpawn, timeoutMs);
-
-let sessionDir = "";
-
-function entryLine(customType: string, data: Record<string, unknown>): string {
-  return `${JSON.stringify({
-    type: "custom",
-    customType,
-    data,
-    timestamp: "2026-09-01T00:00:00.000Z",
-    id: `e-${Math.random().toString(36).slice(2)}`,
-  })}\n`;
-}
-
-function registerData(id: string, sessionId: string): Record<string, unknown> {
-  return { id, type: "session", name: `desc-${id}`, status: "active", registeredAt: 1, expiresAt: undefined, sessionId };
-}
-
-/** resume + close 的最短驱动：spawn 后直接 end stdout + close（handshake 经 abandon 放弃）。 */
-async function runToClose(sessionFile: string): Promise<void> {
-  const record = makeRecord();
-  const promise = runSpawn(record, "Task: close prune", makeOpts(), makeCtx(), {
-    sessionFile,
-  });
-  await waitForSpawn();
-  const child = lastSpawnedChild();
-  // resume.sessionFile 真实存在 → existsSync 对它 true（identity 补写路径走通）
-  mockExistsSync.mockImplementation((p: unknown) => String(p) === sessionFile);
-  child.stdin.on("data", () => {}); // 消费 stdin 防背压
-  child.stdout.end();
-  child.emit("close", 0);
-  await promise;
-}
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  clearPendingCursors();
-  mockExistsSync.mockReturnValue(false);
-  sessionDir = fs.mkdtempSync(path.join(os.tmpdir(), "close-prune-"));
-});
-
-afterEach(() => {
-  clearPendingCursors();
-  vi.restoreAllMocks();
-  fs.rmSync(sessionDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-});
-
-describe("[LC-6] 进程 close 剪枝 pending 游标", () => {
-  it("close 后 cursor 被剪枝：覆写同名文件后判定从头全量读（旧 offset 不残留）", async () => {
-    const f = path.join(sessionDir, "closed-proc.jsonl");
-    // gen1：15 字节/行 × 10 行 filler → 预建 cursor offset = 150
-    const gen1 = Array.from({ length: 10 }, (_, i) => `filler-line-${String(i).padStart(2, "0")}\n`).join("");
-    await writeFile(f, gen1); // 真实写盘（同步 writeFileSync 被 mock 隔离生产写入）
-    expect(listActivePendingFromSessionFile(f).items).toHaveLength(0); // cursor 建立
-
-    // 覆写（模拟磁盘状态变化）：register bg-y 落在旧 offset（150）之内、size > 150——
-    // cursor 未剪时会从 byte 150 续读丢掉它。
-    const gen2 =
-      entryLine("pending:register", registerData("bg-y", "sess-y")) +
-      "filler".padEnd(150, ".") +
-      "\n";
-    expect(Buffer.byteLength(gen2, "utf-8")).toBeGreaterThan(150);
-    await writeFile(f, gen2);
-
-    await runToClose(f); // resume 锁定 sessionFile → close handler 剪枝
-
-    const items = listActivePendingFromSessionFile(f).items;
-    expect(items.map((i) => i.id)).toEqual(["bg-y"]); // 剪枝生效：从头全量读
-  });
-
-  it("sessionFile 未回填（无 resume/无 header）时 close 跳过剪枝，流程正常完成", async () => {
-    const record = makeRecord();
-    const promise = runSpawn(record, "Task: no sessionFile", makeOpts(), makeCtx());
-    await waitForSpawn();
-    const child = lastSpawnedChild();
-    child.stdin.on("data", () => {});
-    child.stdout.end();
-    child.emit("close", 0);
-    // sessionFile undefined → guard 跳过（不抛错）；record.sessionFile 保持未回填
-    await expect(promise).resolves.toBeDefined();
-    expect(record.sessionFile).toBeUndefined();
-  });
-});