@zhushanwen/subagent-core 0.2.0 → 0.4.0

package/src/execution/__tests__/session-pending.test.ts

@@ -0,0 +1,228 @@
+// src/execution/__tests__/session-pending.test.ts
+//
+// [LC-6/T6②] session-pending 增量游标有界化：register−unregister 差集计数 + 剪枝。
+//
+// 覆盖：
+//   - 差集等值（语义不变）：register/unregister 差集、同 id 重 register 覆盖、
+//     unregister 后同 id 再 register 恢复活跃、count 端口收到的 = 活跃差集、
+//     latestUnregister 60s 唤醒窗口判据不受差集化影响。
+//   - 剪枝：文件删除后 cursor 自动剪枝（重建同名文件从头全量读，不残留旧 offset）；
+//     prunePendingCursor 原语（进程 close 侧回收）；prune 不存在条目 no-op。
+//
+// 真实 fs（临时目录）——增量游标的 offset/差集语义被真实文件形态执行
+//（对齐 descendant-sweep.test.ts 模式；该文件的差集清单/交错用例继续回归）。
+
+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";
+
+import { configureNotifyDomain, resetNotifyDomainForTests } from "../../core/notify-ports.ts";
+import {
+  clearPendingCursors,
+  listActivePendingFromSessionFile,
+  prunePendingCursor,
+  readActivePendingFromSessionFile,
+} from "../session-pending.ts";
+
+let sessionDir = "";
+
+beforeEach(() => {
+  clearPendingCursors();
+  sessionDir = fs.mkdtempSync(path.join(os.tmpdir(), "session-pending-"));
+});
+
+afterEach(() => {
+  clearPendingCursors();
+  resetNotifyDomainForTests();
+  fs.rmSync(sessionDir, { recursive: true, force: true });
+});
+
+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 };
+}
+
+/** 注入直数端口：返回收到的 entry 数（观察 count 口径的消费面）。 */
+function stubCountingPort(): (entries: unknown[]) => number {
+  const counter = vi.fn((entries: unknown[]) => entries.length);
+  configureNotifyDomain({ countActiveFromEntries: counter });
+  return counter;
+}
+
+describe("[LC-6] 差集计数语义等值", () => {
+  it("register−unregister 差集：unregister 后 count/list 归零", () => {
+    const counter = stubCountingPort();
+    const f = path.join(sessionDir, "a.jsonl");
+    fs.writeFileSync(
+      f,
+      entryLine("pending:register", registerData("bg-1", "sess-1")) +
+        entryLine("pending:register", registerData("bg-2", "sess-2")) +
+        entryLine("pending:unregister", { id: "bg-1" }),
+    );
+
+    const r = readActivePendingFromSessionFile(f);
+    expect(r.error).toBeUndefined();
+    expect(r.count).toBe(1); // 2 register − 1 unregister
+    expect(counter.mock.calls[0]?.[0]).toHaveLength(1); // 端口收到差集（非全量 3 行）
+    expect((counter.mock.calls[0]?.[0] as unknown[])[0]).toMatchObject({ customType: "pending:register" });
+
+    const list = listActivePendingFromSessionFile(f);
+    expect(list.items.map((i) => i.id)).toEqual(["bg-2"]);
+  });
+
+  it("同 id 重 register（未 unregister）覆盖 → 仍 1 个活跃", () => {
+    stubCountingPort();
+    const f = path.join(sessionDir, "b.jsonl");
+    fs.writeFileSync(f, entryLine("pending:register", registerData("bg-1", "sess-1")));
+    fs.appendFileSync(f, entryLine("pending:register", registerData("bg-1", "sess-1-moved")));
+
+    const list = listActivePendingFromSessionFile(f);
+    expect(list.items).toHaveLength(1);
+    expect(list.items[0]?.sessionId).toBe("sess-1-moved");
+  });
+
+  it("unregister 后同 id 再 register → 恢复活跃", () => {
+    stubCountingPort();
+    const f = path.join(sessionDir, "c.jsonl");
+    fs.writeFileSync(
+      f,
+      entryLine("pending:register", registerData("bg-1", "sess-1")) +
+        entryLine("pending:unregister", { id: "bg-1" }) +
+        entryLine("pending:register", registerData("bg-1", "sess-2")),
+    );
+
+    const list = listActivePendingFromSessionFile(f);
+    expect(list.items.map((i) => i.id)).toEqual(["bg-1"]);
+    expect(list.items[0]?.sessionId).toBe("sess-2");
+    expect(readActivePendingFromSessionFile(f).count).toBe(1);
+  });
+
+  it("latestUnregister 60s 唤醒窗口判据不受差集化影响", () => {
+    stubCountingPort();
+    const f = path.join(sessionDir, "d.jsonl");
+    const nowIso = new Date().toISOString();
+    fs.writeFileSync(
+      f,
+      entryLine("pending:register", registerData("bg-1", "sess-1")) +
+        JSON.stringify({
+          type: "custom",
+          customType: "pending:unregister",
+          data: { id: "bg-1" },
+          timestamp: nowIso,
+          id: "e-unreg",
+        }) +
+        "\n",
+    );
+
+    const r = readActivePendingFromSessionFile(f);
+    expect(r.count).toBe(0); // 差集归零
+    expect(r.recentUnregister).toBe(true); // unregister 时刻仍被游标记录（唤醒窗口语义保持）
+  });
+
+  it("缺 data.id 的畸形 pending 行丢弃，不影响其余差集", () => {
+    stubCountingPort();
+    const f = path.join(sessionDir, "e.jsonl");
+    fs.writeFileSync(
+      f,
+      entryLine("pending:register", {}) + // 畸形：无 id
+        entryLine("pending:register", registerData("bg-2", "sess-2")),
+    );
+
+    const list = listActivePendingFromSessionFile(f);
+    expect(list.items.map((i) => i.id)).toEqual(["bg-2"]);
+  });
+});
+
+describe("[LC-6] 游标剪枝", () => {
+  it("文件删除后 cursor 自动剪枝：重建同名文件从头全量读（不残留旧 offset）", () => {
+    stubCountingPort();
+    const f = path.join(sessionDir, "reborn.jsonl");
+    // 第一代：15 字节/行 × 10 行 filler → cursor offset = 150
+    const gen1 = Array.from({ length: 10 }, (_, i) => `filler-line-${String(i).padStart(2, "0")}\n`).join("");
+    fs.writeFileSync(f, gen1);
+    expect(readActivePendingFromSessionFile(f).count).toBe(0);
+
+    // 删除后的一次判定触发剪枝（stat ENOENT → cursors.delete，惰性剪枝语义）。
+    fs.unlinkSync(f);
+    const duringAbsent = readActivePendingFromSessionFile(f);
+    expect(duringAbsent.error).toBeDefined();
+
+    // 重建同名文件：新内容 size > 旧 offset（150），bg-x 的 register 行落在旧 offset
+    // 之内——cursor 未剪枝时会从 byte 150 续读漏掉它。
+    const gen2 =
+      entryLine("pending:register", registerData("bg-x", "sess-x")) +
+      "filler".padEnd(200, ".") +
+      "\n";
+    expect(Buffer.byteLength(gen2, "utf-8")).toBeGreaterThan(150);
+    fs.writeFileSync(f, gen2);
+
+    const list = listActivePendingFromSessionFile(f);
+    expect(list.items.map((i) => i.id)).toEqual(["bg-x"]); // 剪枝生效：从头全量读
+  });
+
+  it("prunePendingCursor：回收后重新判定等值（全量重读差集不变）", () => {
+    stubCountingPort();
+    const f = path.join(sessionDir, "pruned.jsonl");
+    fs.writeFileSync(
+      f,
+      entryLine("pending:register", registerData("bg-1", "sess-1")) +
+        entryLine("pending:register", registerData("bg-2", "sess-2")),
+    );
+    expect(readActivePendingFromSessionFile(f).count).toBe(2);
+
+    prunePendingCursor(f); // 进程 close 侧回收
+
+    fs.appendFileSync(f, entryLine("pending:unregister", { id: "bg-1" }));
+    const r = readActivePendingFromSessionFile(f);
+    expect(r.count).toBe(1); // 重建后差集正确（无重复无丢失）
+    expect(listActivePendingFromSessionFile(f).items.map((i) => i.id)).toEqual(["bg-2"]);
+  });
+
+  it("prunePendingCursor：prune 后覆写文件（size ≥ 旧 offset）→ 新内容完整可见", () => {
+    stubCountingPort();
+    const f = path.join(sessionDir, "overwritten.jsonl");
+    const gen1 = Array.from({ length: 10 }, (_, i) => `filler-line-${String(i).padStart(2, "0")}\n`).join("");
+    fs.writeFileSync(f, gen1);
+    readActivePendingFromSessionFile(f); // offset = 160
+
+    const gen2 =
+      entryLine("pending:register", registerData("bg-y", "sess-y")) +
+      "filler".padEnd(200, ".") +
+      "\n";
+    fs.writeFileSync(f, gen2); // 覆写（模拟文件替换），size > 旧 offset
+    prunePendingCursor(f);
+
+    expect(listActivePendingFromSessionFile(f).items.map((i) => i.id)).toEqual(["bg-y"]);
+  });
+
+  it("prunePendingCursor 不存在的条目为 no-op（不抛错）", () => {
+    expect(() => prunePendingCursor(path.join(sessionDir, "never-seen.jsonl"))).not.toThrow();
+  });
+
+  it("读失败（文件不存在）→ error 面返回且 cursor 已剪（后续可全量重建）", () => {
+    stubCountingPort();
+    const f = path.join(sessionDir, "vanish.jsonl");
+    fs.writeFileSync(f, entryLine("pending:register", registerData("bg-1", "sess-1")));
+    expect(readActivePendingFromSessionFile(f).count).toBe(1);
+
+    fs.unlinkSync(f);
+    const r = readActivePendingFromSessionFile(f); // 剪枝触发点（stat ENOENT）
+    expect(r.error).toBeDefined();
+    expect(r.count).toBe(0);
+
+    // 重建后从文件头判定（无 offset 残留），条目完整恢复
+    fs.writeFileSync(f, entryLine("pending:register", registerData("bg-1", "sess-1")));
+    expect(readActivePendingFromSessionFile(f).count).toBe(1);
+  });
+});

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

@@ -0,0 +1,110 @@
+// 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 "../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

@@ -0,0 +1,181 @@
+// 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("../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 "../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();
+  });
+});

package/src/execution/__tests__/session-runner-epipe.test.ts

@@ -54,6 +54,7 @@ vi.mock("../alive-store.ts", () => ({ writeAliveMarker: vi.fn() }));
 
 vi.mock("../session-pending.ts", () => ({
   readActivePendingFromSessionFile: vi.fn(() => ({ count: 0 })),
+  prunePendingCursor: vi.fn(),
 }));
 
 vi.mock("../temp-prompt.ts", () => ({