@zhushanwen/pi-subagent-workflow 0.1.0

package/src/execution/__tests__/session-start-reaper.test.ts

@@ -0,0 +1,227 @@
+// src/__tests__/session-start-reaper.test.ts
+//
+// 验证 session_start 的两个新行为：
+//   1. WTM.scan reaper 被调用（best-effort）
+//   2. mainSessionFile 被缓存
+//   3. scan 抛错不阻断启动
+
+import { beforeEach,describe, expect, it, vi } from "vitest";
+
+// ── mock modules（在 import 前声明）──
+
+vi.mock("@mariozechner/pi-coding-agent", () => ({
+  getAgentDir: () => "/home/user/.pi/agent",
+}));
+vi.mock("@earendil-works/pi-coding-agent", () => ({
+  getAgentDir: () => "/home/user/.pi/agent",
+}));
+vi.mock("@mariozechner/pi-ai", () => ({
+  StringEnum: (values: string[]) => ({ type: "string", enum: values }),
+}));
+vi.mock("@earendil-works/pi-ai", () => ({
+  StringEnum: (values: string[]) => ({ type: "string", enum: values }),
+}));
+vi.mock("@sinclair/typebox", () => ({
+  Type: {
+    Object: (props: Record<string, unknown>) => ({ type: "object", properties: props }),
+    Optional: (schema: unknown) => ({ ...schema as object, optional: true }),
+    String: () => ({ type: "string" }),
+    Boolean: () => ({ type: "boolean" }),
+    Number: () => ({ type: "number" }),
+    Array: (items: unknown) => ({ type: "array", items }),
+    Record: (key: unknown, value: unknown) => ({ type: "object", additionalProperties: value, key }),
+    Unknown: () => ({ type: "unknown" }),
+    Union: (members: unknown[]) => ({ type: "union", members }),
+    Literal: (value: unknown) => ({ type: "literal", value }),
+  },
+}));
+
+// hoisted mock 实例
+const { mockScan, mockCleanup } = vi.hoisted(() => ({
+  mockScan: vi.fn(),
+  mockCleanup: vi.fn(),
+}));
+
+vi.mock("../worktree-manager.ts", () => ({
+  WorktreeManager: class {
+    constructor(_agentDir: string) { /* mock */ }
+    scan = mockScan;
+    cleanup = mockCleanup;
+    create = vi.fn();
+    collectPatch = vi.fn();
+    registerPid = vi.fn();
+  },
+}));
+
+vi.mock("../session-file-gc.ts", () => ({
+  maybeCleanupExpiredSessionFiles: vi.fn(),
+}));
+
+// mock subagent-service：避免真正构造 SubagentService（它依赖 ModelConfigService 等）
+const { mockInitModel, mockInitSession, mockSetModelConfigService, mockSetSubagentService, capturedConstructorArg } =
+  vi.hoisted(() => ({
+    mockInitModel: vi.fn(),
+    mockInitSession: vi.fn(),
+    mockSetModelConfigService: vi.fn(),
+    mockSetSubagentService: vi.fn(),
+    capturedConstructorArg: { current: undefined as unknown },
+  }));
+
+vi.mock("../model-config-service.ts", () => ({
+  ModelConfigService: class {
+    initModel = mockInitModel;
+    // F-4/D-003: index.ts 复用 modelService.getAgentRegistry()，stub 返回最小结构
+    getAgentRegistry = () => ({ get: () => undefined, list: () => [] });
+  },
+  getModelConfigService: () => null,
+  setModelConfigService: mockSetModelConfigService,
+}));
+
+vi.mock("../subagent-service.ts", () => ({
+  SubagentService: class {
+    initSession = mockInitSession;
+    constructor(init: unknown) {
+      capturedConstructorArg.current = init;
+    }
+  },
+  getSubagentService: () => null,
+  setSubagentService: mockSetSubagentService,
+}));
+
+// mock commands/tools（避免触发真实注册）
+vi.mock("../commands/subagents.ts", () => ({
+  registerSubagentsCommand: vi.fn(),
+}));
+vi.mock("../tools/subagent-tool.ts", () => ({
+  registerSubagentTool: vi.fn(),
+}));
+vi.mock("../tui/bg-notify-render.ts", () => ({
+  renderBgNotifyMessage: vi.fn(),
+}));
+
+// ── import 被测工厂 ──
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+import subagentsExtension from "../../index.ts";
+
+// ── helpers ──
+
+/** 创建最小 mock ExtensionAPI，捕获 session_start handler。 */
+function createMockPi(overrides: Record<string, unknown> = {}): {
+  pi: ExtensionAPI;
+  getSessionStartHandler: () => ((event: unknown, ctx: unknown) => void) | undefined;
+} {
+  let sessionStartHandler: ((event: unknown, ctx: unknown) => void) | undefined;
+  const noop = (): void => { /* mock */ };
+  const pi = new Proxy<ExtensionAPI>(overrides as ExtensionAPI, {
+    get(target, prop: string | symbol): unknown {
+      if (prop === "on") {
+        return (event: string, handler: (...args: unknown[]) => unknown) => {
+          if (event === "session_start") {
+            sessionStartHandler = handler as (event: unknown, ctx: unknown) => void;
+          }
+        };
+      }
+      if (prop in target) return target[prop as keyof ExtensionAPI];
+      return noop;
+    },
+  });
+  return {
+    pi,
+    getSessionStartHandler: () => sessionStartHandler,
+  };
+}
+
+/** 最小 ExtensionContext mock。 */
+function createMockCtx(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    cwd: "/home/user/project",
+    modelRegistry: { getAvailable: () => [], find: () => undefined, hasConfiguredAuth: () => false },
+    model: undefined,
+    sessionManager: {
+      getSessionId: () => "session-123",
+      getSessionFile: () => "/home/user/.pi/agent/sessions/session-123.jsonl",
+      getSessionDir: () => "/home/user/.pi/agent/sessions",
+      getCwd: () => "/home/user/project",
+      getEntries: () => [],
+      getBranch: () => [],
+      getLeafId: () => null,
+      getLeafEntry: () => undefined,
+      getEntry: () => undefined,
+      getHeader: () => null,
+      getTree: () => [],
+      getSessionName: () => undefined,
+    },
+    ...overrides,
+  };
+}
+
+// ── tests ──
+
+describe("session_start worktree reaper", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("session_start 触发 WTM.scan 调用", () => {
+    const { pi, getSessionStartHandler } = createMockPi();
+    subagentsExtension(pi);
+
+    const handler = getSessionStartHandler();
+    expect(handler).toBeDefined();
+
+    handler!(
+      { type: "session_start", reason: "startup" },
+      createMockCtx(),
+    );
+
+    expect(mockScan).toHaveBeenCalledTimes(1);
+    // scan 无参（全局注册表，不依赖 cwd）
+    expect(mockScan).toHaveBeenCalledWith();
+  });
+
+  it("scan 抛错不阻断 session_start", () => {
+    mockScan.mockImplementation(() => {
+      throw new Error("git not found");
+    });
+
+    const { pi, getSessionStartHandler } = createMockPi();
+    subagentsExtension(pi);
+
+    const handler = getSessionStartHandler();
+    expect(handler).toBeDefined();
+
+    // 不应抛错
+    expect(() => {
+      handler!(
+        { type: "session_start", reason: "startup" },
+        createMockCtx(),
+      );
+    }).not.toThrow();
+
+    // service 仍然被注册（启动未被阻断）
+    expect(mockSetSubagentService).toHaveBeenCalled();
+  });
+
+  it("mainSessionFile 被缓存并传给 SubagentService", () => {
+    const { pi, getSessionStartHandler } = createMockPi();
+    subagentsExtension(pi);
+
+    const handler = getSessionStartHandler();
+    handler!(
+      { type: "session_start", reason: "startup" },
+      createMockCtx(),
+    );
+
+    // SubagentService 构造参数含 getMainSessionFile getter
+    const init = capturedConstructorArg.current as {
+      getMainSessionFile?: () => string | undefined;
+    } | undefined;
+    expect(init).toBeDefined();
+    expect(init?.getMainSessionFile).toBeDefined();
+    // 返回 session_start 时缓存的 sessionFile
+    expect(init?.getMainSessionFile?.()).toBe(
+      "/home/user/.pi/agent/sessions/session-123.jsonl",
+    );
+  });
+});

package/src/execution/__tests__/spawn-args.test.ts

@@ -0,0 +1,244 @@
+// src/__tests__/spawn-args.test.ts
+import { execFileSync } from "node:child_process";
+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 { MAX_FORK_DEPTH } from "../session-context-resolver.ts";
+import { buildEnvBlock, buildSpawnArgs } from "../session-runner.ts";
+
+describe("buildSpawnArgs", () => {
+  const baseParams = {
+    model: undefined as string | undefined,
+    thinkingLevel: undefined as string | undefined,
+    agentTools: undefined as string[] | undefined,
+    appendSystemPromptPath: undefined as string | undefined,
+    sessionDir: "/sessions/dir",
+    forkSource: undefined as string | undefined,
+    skillPaths: undefined as string[] | undefined,
+  };
+
+  it("基础参数：--mode json -p --session-dir + task", () => {
+    const args = buildSpawnArgs(baseParams, "Task: do something");
+    expect(args).toEqual([
+      "--mode", "json", "-p", "--session-dir", "/sessions/dir",
+      "Task: do something",
+    ]);
+  });
+
+  it("有 model → 追加 --model provider/id", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, model: "openai/gpt-4o" },
+      "Task: x",
+    );
+    expect(args).toContain("--model");
+    const idx = args.indexOf("--model");
+    expect(args[idx + 1]).toBe("openai/gpt-4o");
+  });
+
+  it("model + thinkingLevel → model 后缀 :level", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, model: "anthropic/claude", thinkingLevel: "high" },
+      "Task: x",
+    );
+    const idx = args.indexOf("--model");
+    expect(args[idx + 1]).toBe("anthropic/claude:high");
+  });
+
+  it("thinkingLevel 无 model → 不追加（thinking 依赖 model 后缀）", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, model: undefined, thinkingLevel: "high" },
+      "Task: x",
+    );
+    expect(args).not.toContain("--model");
+  });
+
+  it("agentTools → --tools 逗号分隔", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, agentTools: ["read", "bash", "edit"] },
+      "Task: x",
+    );
+    const idx = args.indexOf("--tools");
+    expect(args[idx + 1]).toBe("read,bash,edit");
+  });
+
+  it("appendSystemPromptPath → --append-system-prompt <path>", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, appendSystemPromptPath: "/tmp/prompt.md" },
+      "Task: x",
+    );
+    const idx = args.indexOf("--append-system-prompt");
+    expect(args[idx + 1]).toBe("/tmp/prompt.md");
+  });
+
+  it("forkSource → --fork <path>", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, forkSource: "/sessions/parent.jsonl" },
+      "Task: x",
+    );
+    const idx = args.indexOf("--fork");
+    expect(args[idx + 1]).toBe("/sessions/parent.jsonl");
+  });
+
+  it("skillPaths 多个 → 每个 push --skill <path>", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, skillPaths: ["/skills/a", "/skills/b", "/skills/c"] },
+      "Task: x",
+    );
+    // 三个 --skill token，后跟各自路径，顺序保留
+    const skillIdxs = args
+      .map((a, i) => (a === "--skill" ? i : -1))
+      .filter((i) => i >= 0);
+    expect(skillIdxs).toHaveLength(3);
+    expect(args[skillIdxs[0] + 1]).toBe("/skills/a");
+    expect(args[skillIdxs[1] + 1]).toBe("/skills/b");
+    expect(args[skillIdxs[2] + 1]).toBe("/skills/c");
+  });
+
+  it("skillPaths 空数组 → 不含 --skill", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, skillPaths: [] },
+      "Task: x",
+    );
+    expect(args).not.toContain("--skill");
+  });
+
+  it("skillPaths undefined → 不含 --skill", () => {
+    const args = buildSpawnArgs(baseParams, "Task: x");
+    expect(args).not.toContain("--skill");
+  });
+
+  it("全参数组合顺序正确，task 始终最后", () => {
+    const args = buildSpawnArgs(
+      {
+        model: "openai/gpt-4o",
+        thinkingLevel: "low",
+        agentTools: ["read"],
+        appendSystemPromptPath: "/tmp/p.md",
+        sessionDir: "/s",
+        forkSource: "/parent.jsonl",
+        skillPaths: ["/skills/x"],
+      },
+      "final task",
+    );
+    expect(args[args.length - 1]).toBe("final task");
+    expect(args).toContain("--fork");
+    expect(args).toContain("--tools");
+    expect(args).toContain("--skill");
+  });
+
+  it("空 tools 数组不追加 --tools", () => {
+    const args = buildSpawnArgs(
+      { ...baseParams, agentTools: [] },
+      "Task: x",
+    );
+    expect(args).not.toContain("--tools");
+  });
+});
+
+// ============================================================
+// buildEnvBlock（M1 恢复）
+// ============================================================
+
+describe("buildEnvBlock", () => {
+  // buildEnvBlock 内部按 cwd 缓存 git branch（模块级 Map），用真实 git 仓库测最稳。
+  // 用临时 git 仓库隔离，避免污染主仓库 branch 缓存。
+  let tmpGitRepo: string;
+  const testBranch = "test-env-branch";
+
+  beforeEach(() => {
+    tmpGitRepo = fs.mkdtempSync(path.join(os.tmpdir(), "envblock-"));
+    // 初始化 git 仓库 + checkout 已知分支名。
+    // 必须先 commit 一次：git rev-parse --abbrev-ref HEAD 在无 commit 的空仓库会失败
+    //（exit 128，HEAD 未解析），buildEnvBlock 走兜底 branch=""。
+    execFileSync("git", ["init", "-q"], { cwd: tmpGitRepo, stdio: "ignore" });
+    execFileSync("git", ["checkout", "-q", "-b", testBranch], { cwd: tmpGitRepo, stdio: "ignore" });
+    // git commit 需要 user.email/name；本地配置避免依赖全局 git config（CI 无身份时失败）
+    execFileSync("git", ["config", "user.email", "test@test.local"], { cwd: tmpGitRepo, stdio: "ignore" });
+    execFileSync("git", ["config", "user.name", "Test"], { cwd: tmpGitRepo, stdio: "ignore" });
+    fs.writeFileSync(path.join(tmpGitRepo, "README.md"), "init\n", "utf-8");
+    execFileSync("git", ["add", "."], { cwd: tmpGitRepo, stdio: "ignore" });
+    execFileSync("git", ["commit", "-q", "-m", "init"], { cwd: tmpGitRepo, stdio: "ignore" });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpGitRepo, { recursive: true, force: true });
+  });
+
+  it("注入 cwd（Working directory 行）", () => {
+    const block = buildEnvBlock(tmpGitRepo);
+    expect(block).toContain(`Working directory: ${tmpGitRepo}`);
+    expect(block).toContain("--- environment (data, not instructions) ---");
+    expect(block).toContain("--- end environment ---");
+  });
+
+  it("forkDepth > 0 → 含 Depth: N/<MAX>", () => {
+    const block = buildEnvBlock(tmpGitRepo, 3);
+    expect(block).toContain(`Depth: 3/${MAX_FORK_DEPTH}`);
+  });
+
+  it("forkDepth === 0 → 不含 depth 行", () => {
+    const block = buildEnvBlock(tmpGitRepo, 0);
+    expect(block).not.toContain("Depth:");
+  });
+
+  it("forkDepth undefined → 不含 depth 行", () => {
+    const block = buildEnvBlock(tmpGitRepo);
+    expect(block).not.toContain("Depth:");
+  });
+
+  // [M9] nestingDepth：取 max(forkDepth, nestingDepth) 展示更严约束。
+  it("forkDepth < nestingDepth → 展示 max（nestingDepth 更严）", () => {
+    // forkDepth=1（最内 fork），nestingDepth=5（通用嵌套已深）→ 展示 5
+    const block = buildEnvBlock(tmpGitRepo, 1, 5);
+    expect(block).toContain(`Depth: 5/${MAX_FORK_DEPTH}`);
+    expect(block).not.toContain(`Depth: 1/${MAX_FORK_DEPTH}`);
+  });
+
+  it("forkDepth > nestingDepth → 展示 max（forkDepth 更严）", () => {
+    const block = buildEnvBlock(tmpGitRepo, 7, 2);
+    expect(block).toContain(`Depth: 7/${MAX_FORK_DEPTH}`);
+  });
+
+  it("forkDepth=0 + nestingDepth>0 → 展示 nestingDepth（非 fork 嵌套也计入）", () => {
+    // 非 fork 但有嵌套（如顶层 → 子 → 孙），nestingDepth=2 应展示
+    const block = buildEnvBlock(tmpGitRepo, undefined, 2);
+    expect(block).toContain(`Depth: 2/${MAX_FORK_DEPTH}`);
+  });
+
+  it("git branch 存在 → 含 Git branch 行", () => {
+    const block = buildEnvBlock(tmpGitRepo);
+    expect(block).toContain(`Git branch: ${testBranch}`);
+  });
+
+  it("非 git 目录 → 不含 Git branch 行（git 失败兜底空串）", () => {
+    const nonGitDir = fs.mkdtempSync(path.join(os.tmpdir(), "envblock-nogit-"));
+    try {
+      const block = buildEnvBlock(nonGitDir);
+      expect(block).not.toContain("Git branch:");
+      // 但仍含 working directory（环境块始终输出）
+      expect(block).toContain(`Working directory: ${nonGitDir}`);
+    } finally {
+      fs.rmSync(nonGitDir, { recursive: true, force: true });
+    }
+  });
+
+  it("git 失败（execFileSync throw）→ 不崩，静默省略 branch", () => {
+    const mockExec = vi.spyOn(
+      { execFileSync },
+      "execFileSync",
+    );
+    mockExec.mockImplementation(() => {
+      throw new Error("git not found");
+    });
+    try {
+      const block = buildEnvBlock("/some/cwd");
+      expect(block).not.toContain("Git branch:");
+      expect(block).toContain("Working directory: /some/cwd");
+    } finally {
+      mockExec.mockRestore();
+    }
+  });
+});

package/src/execution/__tests__/spawn-event-adapter.test.ts

@@ -0,0 +1,167 @@
+// src/__tests__/spawn-event-adapter.test.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import {
+  deriveSessionFilePath,
+  findSessionFileByHeaderId,
+  parseSpawnLine,
+} from "../spawn-event-adapter.ts";
+
+describe("parseSpawnLine", () => {
+  describe("空白行", () => {
+    it("空字符串返回 null", () => {
+      expect(parseSpawnLine("")).toBeNull();
+    });
+
+    it("纯空白返回 null", () => {
+      expect(parseSpawnLine("   ")).toBeNull();
+      expect(parseSpawnLine("\t\t")).toBeNull();
+    });
+  });
+
+  describe("header 行", () => {
+    it("type=session + id 识别为 header", () => {
+      const line = JSON.stringify({
+        type: "session",
+        id: "abc-123",
+        timestamp: "2026-07-03T12:00:00.000Z",
+        cwd: "/home/user/project",
+      });
+      const result = parseSpawnLine(line);
+      expect(result?.kind).toBe("header");
+      if (result?.kind === "header") {
+        expect(result.header.id).toBe("abc-123");
+        expect(result.header.cwd).toBe("/home/user/project");
+      }
+    });
+
+    it("header 含 parentSession + version", () => {
+      const line = JSON.stringify({
+        type: "session",
+        id: "child-456",
+        timestamp: "2026-07-03T12:00:00.000Z",
+        cwd: "/home/user/project",
+        parentSession: "parent-789",
+        version: 2,
+      });
+      const result = parseSpawnLine(line);
+      expect(result?.kind).toBe("header");
+      if (result?.kind === "header") {
+        expect(result.header.parentSession).toBe("parent-789");
+        expect(result.header.version).toBe(2);
+      }
+    });
+  });
+
+  describe("事件行", () => {
+    it("tool_execution_start 识别为 event", () => {
+      const line = JSON.stringify({
+        type: "tool_execution_start",
+        toolName: "bash",
+        toolCallId: "call-1",
+        args: { command: "ls" },
+      });
+      const result = parseSpawnLine(line);
+      expect(result?.kind).toBe("event");
+      if (result?.kind === "event") {
+        expect(result.event.type).toBe("tool_execution_start");
+        expect(result.event.toolName).toBe("bash");
+      }
+    });
+
+    it("message_end 识别为 event", () => {
+      const line = JSON.stringify({
+        type: "message_end",
+        message: {
+          role: "assistant",
+          usage: { input: 100, output: 50 },
+        },
+      });
+      const result = parseSpawnLine(line);
+      expect(result?.kind).toBe("event");
+      if (result?.kind === "event") {
+        expect(result.event.type).toBe("message_end");
+      }
+    });
+
+    it("turn_end 识别为 event", () => {
+      const result = parseSpawnLine(JSON.stringify({ type: "turn_end" }));
+      expect(result?.kind).toBe("event");
+    });
+
+    it("未知 type 仍识别为 event（schema 校验由调用方）", () => {
+      const result = parseSpawnLine(JSON.stringify({ type: "some_future_event" }));
+      expect(result?.kind).toBe("event");
+    });
+  });
+
+  describe("invalid 行", () => {
+    it("非 JSON 返回 invalid", () => {
+      const result = parseSpawnLine("not json at all");
+      expect(result?.kind).toBe("invalid");
+      if (result?.kind === "invalid") {
+        expect(result.raw).toBe("not json at all");
+        expect(result.error).toBeTruthy();
+      }
+    });
+
+    it("JSON 但无 type 字段返回 invalid", () => {
+      const result = parseSpawnLine(JSON.stringify({ foo: "bar" }));
+      expect(result?.kind).toBe("invalid");
+      if (result?.kind === "invalid") {
+        expect(result.error).toContain("type");
+      }
+    });
+
+    it("JSON 但 type 非 string 返回 invalid", () => {
+      const result = parseSpawnLine(JSON.stringify({ type: 123 }));
+      expect(result?.kind).toBe("invalid");
+    });
+
+    it("JSON null 返回 invalid", () => {
+      const result = parseSpawnLine("null");
+      expect(result?.kind).toBe("invalid");
+    });
+  });
+});
+
+describe("deriveSessionFilePath", () => {
+  it("拼接 sessionDir + fileTimestamp(冒号点转连字符) + id", () => {
+    const header = {
+      type: "session" as const,
+      id: "abc-123",
+      timestamp: "2026-07-03T12:00:00.000Z",
+      cwd: "/proj",
+    };
+    const path = deriveSessionFilePath(header, "/sessions/dir");
+    // fileTimestamp = timestamp.replace(/[:.]/g, "-") = "2026-07-03T12-00-00-000Z"
+    expect(path).toBe("/sessions/dir/2026-07-03T12-00-00-000Z_abc-123.jsonl");
+  });
+});
+
+describe("findSessionFileByHeaderId", () => {
+  it("sessionId 后缀匹配返回实际文件路径", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "spawn-adapter-test-"));
+    const expectedFile = path.join(tmpDir, "2026-07-03T12-00-00-000Z_sid-456.jsonl");
+    fs.writeFileSync(expectedFile, "{}");
+    const result = findSessionFileByHeaderId(tmpDir, "sid-456");
+    expect(result).toBe(expectedFile);
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it("无匹配返回 undefined", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "spawn-adapter-test-"));
+    const result = findSessionFileByHeaderId(tmpDir, "nonexistent");
+    expect(result).toBeUndefined();
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it("目录不存在返回 undefined（不抛错）", () => {
+    const result = findSessionFileByHeaderId("/nonexistent/path/xyz", "sid");
+    expect(result).toBeUndefined();
+  });
+});