@zhushanwen/pi-subagent-workflow 8.5.0 → 8.7.0

package/src/execution/__tests__/finalize-record.test.ts

@@ -1,368 +0,0 @@
-// doFinalizeRecord — manifest status 透传测试（M3: 4 态方案）。
-//
-// 验证 finalize-record.ts 的 status 映射：done→completed, failed→failed, cancelled→cancelled
-// （cancelled 不再归并 failed）。crashed 不进 finalize 入参（TS 签名锁定 done/failed/cancelled）。
-//
-// 测试策略：record 不带 sessionFile/worktreeHandle,跳过 Step 0 (collectPatch) 和 Step 3
-// (finalized/tombstone/aliveMarker/worktree cleanup) 的文件操作,聚焦 Step 4 writeManifest
-// 的 status 产出。FinalizeDeps 用 stub 注入（manifestStore 为真实实例,指向 tmpDir）。
-
-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";
-
-// Mock 共享 logger，让 logger.error 可被 spy（源码已从 console.error 改为 logger.error）
-const { loggerMock } = vi.hoisted(() => ({
-  loggerMock: {
-    debug: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    info: vi.fn(),
-  },
-}));
-vi.mock("@zhushanwen/pi-extension-logger", () => ({
-  getLogger: () => loggerMock,
-}));
-
-import { doFinalizeRecord, doFinalizeRoundToIdle } from "../finalize-record.ts";
-import { ManifestStore } from "../manifest-store.ts";
-import type { AgentResult, ExecutionRecord } from "../types.ts";
-
-function makeMinimalRecord(overrides: Partial<ExecutionRecord> = {}): ExecutionRecord {
-  return {
-    id: "finalize-test",
-    agent: "worker",
-    model: "test/model",
-    thinkingLevel: undefined,
-    mode: "background",
-    task: "test",
-    slug: "test",
-    startedAt: 1000,
-    rootSessionId: "session-main",
-    parentRecordId: undefined,
-    depth: 0,
-    status: "running",
-    turns: [],
-    turnCount: 0,
-    totalTokens: 0,
-    lastError: undefined,
-    endedAt: undefined,
-    result: undefined,
-    error: undefined,
-    agentResult: undefined,
-    sessionFile: undefined,
-    controller: undefined,
-    ...overrides,
-  } as ExecutionRecord;
-}
-
-function makeMinimalResult(): AgentResult {
-  return {
-    text: "done",
-    turns: 1,
-    durationMs: 100,
-    success: true,
-    sessionId: "sess-1",
-    toolCalls: [],
-  };
-}
-
-describe("doFinalizeRecord — manifest status 透传 (M3 4 态)", () => {
-  let tmpDir: string;
-  let manifestStore: ManifestStore;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "finalize-test-"));
-    manifestStore = new ManifestStore(tmpDir);
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  /** 构造最小 FinalizeDeps：record 无 sessionFile/worktreeHandle,跳过 Step 0/3 文件操作。 */
-  function makeDeps() {
-    return {
-      manifestStore,
-      worktreeManager: {} as never,
-      store: { archive: vi.fn(), reportRecordTransition: vi.fn() } as never,
-      modelService: {} as never,
-      pi: { appendEntry: vi.fn() },
-      emitUnregister: vi.fn(),
-    };
-  }
-
-  it("status=closed + cancelled reason → manifest 写 closed（v4 B-1：cancelled 折入 closed）", async () => {
-    const record = makeMinimalRecord({ id: "rec-cancelled" });
-    await doFinalizeRecord(makeDeps(), record, makeMinimalResult(), "closed", "cancelled");
-
-    const manifest = await manifestStore.readManifest("rec-cancelled");
-    expect(manifest).not.toBeNull();
-    // 关键断言：v4 B-1 manifest status 恒写 closed（cancelled 区分靠 tombstone sidecar）
-    expect(manifest?.status).toBe("closed");
-  });
-
-  it("status=closed + user-close → manifest 写 closed", async () => {
-    const record = makeMinimalRecord({ id: "rec-done" });
-    await doFinalizeRecord(makeDeps(), record, makeMinimalResult(), "closed", "user-close");
-
-    const manifest = await manifestStore.readManifest("rec-done");
-    expect(manifest?.status).toBe("closed");
-  });
-
-  it("status=closed + gc → manifest 写 closed", async () => {
-    const record = makeMinimalRecord({ id: "rec-failed" });
-    await doFinalizeRecord(makeDeps(), record, makeMinimalResult(), "closed", "gc");
-
-    const manifest = await manifestStore.readManifest("rec-failed");
-    expect(manifest?.status).toBe("closed");
-  });
-
-  it("manifest write 抛错时 cleanup-first 顺序仍执行（Step 3 before Step 4 throw）", async () => {
-    // record 带 sessionFile 让 Step 3 finalized/aliveMarker 走真实路径；
-    // 不设 worktreeHandle → Step 0 (collectPatch) 和 Step 3 worktree cleanup 都跳过。
-    const sessionFile = path.join(tmpDir, "session.jsonl");
-    const record = makeMinimalRecord({ id: "rec-cleanup-first", sessionFile });
-
-    // 预写 .alive marker（让 removeAliveMarker 真实生效；不预写因 ENOENT 静默也 OK，
-    // 但预写后用 fs.existsSync 验证更直观）。
-    fs.writeFileSync(
-      `${sessionFile}.alive`,
-      `${JSON.stringify({ pid: 99999, id: "rec-cleanup-first", startedAt: 1000 })}\n`,
-      "utf-8",
-    );
-
-    // mock writeManifest 抛错（模拟 disk full）。在 mock 内捕获「writeManifest 被调用时
-    // finalized marker 是否已存在」——这是 cleanup-first 顺序的关键断言：若有人把
-    // manifest write 前移到 cleanup 之前，本标志会是 false（[Critical #1] 反例）。
-    const finalizedBeforeManifestWrite = { value: false };
-    vi.spyOn(manifestStore, "writeManifest").mockImplementation(async () => {
-      finalizedBeforeManifestWrite.value = fs.existsSync(`${sessionFile}.finalized`);
-      throw new Error("disk full");
-    });
-    loggerMock.error.mockClear();
-
-    const deps = makeDeps();
-
-    // ── 核心 claim 1：不抛错（cleanup-first → manifest write 失败不 throw）──
-    await expect(
-      doFinalizeRecord(deps, record, makeMinimalResult(), "closed"),
-    ).resolves.toBeUndefined();
-
-    // ── 核心 claim 2：Step 3 cleanup 先执行 —— finalized marker 真实写入 ──
-    expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(true);
-
-    // ── 核心 claim 3：Step 3 aliveMarker 被移除（预写的 .alive 不再存在）──
-    expect(fs.existsSync(`${sessionFile}.alive`)).toBe(false);
-
-    // ── 核心 claim 4：pending-notifications 注销仍触发（emitUnregister）──
-    expect(deps.emitUnregister).toHaveBeenCalledWith("rec-cleanup-first", "closed");
-
-    // ── 核心 claim 5：manifest 写失败被 logger.error 记录（含 record id + error）──
-    expect(loggerMock.error).toHaveBeenCalledWith(expect.stringContaining("manifest 写入失败"));
-    const errMsg = loggerMock.error.mock.calls[0]?.[0];
-    expect(errMsg).toContain("rec-cleanup-first");
-    expect(errMsg).toContain("disk full");
-
-    // ── 核心 claim 6：pi.appendEntry 记录 "subagent:manifest-write-failed" 事件 ──
-    expect(deps.pi.appendEntry).toHaveBeenCalledWith(
-      "subagent:manifest-write-failed",
-      expect.objectContaining({ id: "rec-cleanup-first", error: "disk full" }),
-    );
-
-    // ── 核心 claim 7：manifest 实际未写入（writeManifest 抛错被吞咽）──
-    expect(await manifestStore.readManifest("rec-cleanup-first")).toBeNull();
-
-    // ── 核心 claim 8：[Critical #1] cleanup 在 manifest 写之前 —— 顺序锁定 ──
-    // 若有人把 manifest write 前移到 cleanup 之前，本标志会是 false（mock 捕获时刻
-    // .finalized 尚未被 Step 3 写入），保护 Critical #1 时序不变量。
-    expect(finalizedBeforeManifestWrite.value).toBe(true);
-
-    // 清理 mock 调用记录防污染
-    loggerMock.error.mockClear();
-  });
-});
-
-// ============================================================
-// doFinalizeRoundToIdle — chatMode 轮次完成进 idle（M2-A）
-// ============================================================
-
-describe("doFinalizeRoundToIdle — chatMode 轮次完成进 idle (M2-A)", () => {
-  let tmpDir: string;
-  let manifestStore: ManifestStore;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "finalize-idle-test-"));
-    manifestStore = new ManifestStore(tmpDir);
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  /** 构造 FinalizeDeps：worktreeManager.cleanup / store.archive 为 vi.fn 以断言「不调」。 */
-  function makeDeps() {
-    return {
-      manifestStore,
-      worktreeManager: { cleanup: vi.fn(), collectPatch: vi.fn() } as never,
-      store: { archive: vi.fn(), reportRecordTransition: vi.fn() } as never,
-      modelService: {} as never,
-      pi: { appendEntry: vi.fn() } as never,
-      emitUnregister: vi.fn(),
-    };
-  }
-
-  it("record 带 sessionFile → 删 .alive + record.status=running + round 0→1", async () => {
-    const sessionFile = path.join(tmpDir, "session.jsonl");
-    // 预写 .alive marker（验证 doFinalizeRoundToIdle 删除它——进程已回收）
-    fs.writeFileSync(
-      `${sessionFile}.alive`,
-      `${JSON.stringify({ pid: 99999, id: "rec-idle", startedAt: 1000 })}\n`,
-      "utf-8",
-    );
-    const record = makeMinimalRecord({ id: "rec-idle", sessionFile, chatMode: true, round: 0 });
-    // tryTransition 已把 status 设为 done，模拟 runAndFinalize 调用前的状态
-    record.status = "closed";
-
-    await doFinalizeRoundToIdle(makeDeps(), record, makeMinimalResult());
-
-    // 状态机（v4 B-1：旧 idle 折入 running，finalizeRoundToIdle 设 running）
-    expect(record.status).toBe("running");
-    expect(record.round).toBe(1);
-    // .alive marker 被删（进程已 SIGTERM 回收）
-    expect(fs.existsSync(`${sessionFile}.alive`)).toBe(false);
-  });
-
-  it("W16: 轮终上报 reportRecordTransition（record-store 类外恢复写点迁移落 entry）", async () => {
-    const deps = makeDeps();
-    const record = makeMinimalRecord({ id: "rec-report", chatMode: true, round: 2 });
-    record.status = "closed";
-    await doFinalizeRoundToIdle(deps, record, makeMinimalResult());
-    expect(deps.store.reportRecordTransition).toHaveBeenCalledTimes(1);
-    // 上报发生在 round 推进之后（entry 携带新轮计数，重建源不滞后）
-    expect(record.round).toBe(3);
-    expect(record.status).toBe("running");
-  });
-
-  it("record.round 已为 N → round 变 N+1", async () => {
-    const record = makeMinimalRecord({ id: "rec-round", round: 3 });
-    record.status = "closed";
-    await doFinalizeRoundToIdle(makeDeps(), record, makeMinimalResult());
-    expect(record.round).toBe(4);
-    expect(record.status).toBe("running");
-  });
-
-  it("不调 store.archive（record 留内存，getMutable 仍可查）", async () => {
-    const deps = makeDeps();
-    const record = makeMinimalRecord({ id: "rec-noarchive" });
-    record.status = "closed";
-    await doFinalizeRoundToIdle(deps, record, makeMinimalResult());
-    expect(deps.store.archive).not.toHaveBeenCalled();
-  });
-
-  it("不 cleanup worktree（即使 record 带 worktreeHandle——保留对话模式工作目录）", async () => {
-    const deps = makeDeps();
-    const record = makeMinimalRecord({
-      id: "rec-noworktree",
-      worktreeHandle: { path: "/tmp/x", branch: "b", baseCommit: "c", mainCwd: "/tmp" } as never,
-    });
-    record.status = "closed";
-    await doFinalizeRoundToIdle(deps, record, makeMinimalResult());
-    expect(deps.worktreeManager.cleanup).not.toHaveBeenCalled();
-  });
-
-  it("emitUnregister 被调（status=running，进程已死从 pending 活跃差集移除）", async () => {
-    const deps = makeDeps();
-    const record = makeMinimalRecord({ id: "rec-emit" });
-    record.status = "closed";
-    await doFinalizeRoundToIdle(deps, record, makeMinimalResult());
-    expect(deps.emitUnregister).toHaveBeenCalledWith("rec-emit", "running");
-  });
-
-  it("不调 completeRecord：record 不冻结（endedAt / agentResult 仍 undefined）", async () => {
-    const record = makeMinimalRecord({ id: "rec-nofreeze" });
-    record.status = "closed";
-    await doFinalizeRoundToIdle(makeDeps(), record, makeMinimalResult());
-    expect(record.endedAt).toBeUndefined();
-    expect(record.agentResult).toBeUndefined();
-  });
-
-  it("不写 manifest（idle 非终态，manifest 是终态诊断辅助）", async () => {
-    const record = makeMinimalRecord({ id: "rec-nomanifest" });
-    record.status = "closed";
-    await doFinalizeRoundToIdle(makeDeps(), record, makeMinimalResult());
-    const manifest = await manifestStore.readManifest("rec-nomanifest");
-    expect(manifest).toBeNull();
-  });
-
-  it("MF-2: record.result 设为 result.text（否则 notifier idle 回复恒为 (empty)，G1/G2 不成立）", async () => {
-    const record = makeMinimalRecord({ id: "rec-result" });
-    record.status = "closed";
-    const result = makeMinimalResult();
-    result.text = "review done, found 3 issues";
-    await doFinalizeRoundToIdle(makeDeps(), record, result);
-    // MF-2：record.result 被 result.text 填充，notifier idle 分支读取后携带回复正文
-    expect(record.result).toBe("review done, found 3 issues");
-  });
-
-  it("MF-2 兑底：失败轮次 result.text 为空时用 result.error 填 record.result（MF-6 回退 idle 路径）", async () => {
-    const record = makeMinimalRecord({ id: "rec-result-err" });
-    record.status = "closed";
-    const result = makeMinimalResult();
-    result.text = "";
-    result.success = false;
-    result.error = "spawn timeout";
-    await doFinalizeRoundToIdle(makeDeps(), record, result);
-    // 失败轮次的 notify 需可读：result.text 空 → 兑底用 error
-    expect(record.result).toBe("round did not complete: spawn timeout");
-  });
-
-  it("C1TC10: chatMode 空增量轮占位——record.result 固定 (no output this round)，不含上一轮文本（D5）", async () => {
-    const record = makeMinimalRecord({ id: "rec-increment-empty", chatMode: true });
-    record.status = "closed";
-    // 预置上一轮通知文本（模拟增量语义前的 record.result 残留）
-    record.result = "PREV-ROUND-TEXT";
-    const result = makeMinimalResult();
-    result.text = "";
-    result.success = true;
-    result.error = undefined;
-    await doFinalizeRoundToIdle(makeDeps(), record, result);
-    // 空增量轮通知不含上一轮文本：沿用旧值会让父 agent 误读为原样重复回复（D5 判定）
-    expect(record.result).toBe("(no output this round)");
-    expect(record.result).not.toContain("PREV-ROUND-TEXT");
-  });
-
-  it("C1TC11 [R2-1]: one-shot 首轮空文本成功完成 → record.result 补占位「(empty)」（非 undefined）", async () => {
-    const record = makeMinimalRecord({ id: "rec-oneshot-empty", chatMode: false });
-    record.status = "closed";
-    // one-shot 成功空文本完成路径（collectResult getFullText 返回 ""、success=true）：
-    // result 前值 undefined
-    record.result = undefined;
-    const result = makeMinimalResult();
-    result.text = "";
-    result.success = true;
-    result.error = undefined;
-    await doFinalizeRoundToIdle(makeDeps(), record, result);
-    // [R2-1] 轮终信号优先：占位非 undefined 是 renderer hasRunning 排除轮终 running 的
-    // 判据——保持 undefined 会让完成注入后末位 turn 永久「工作中」
-    expect(record.result).toBe("(empty)");
-    // notifier buildLlmContent 的 record.result ?? "(empty)" 兜底同款措辞：
-    // 通知文案逐字节产出 "completed. Result:\n(empty)"（G4 保持）
-    expect(record.result ?? "(empty)").toBe("(empty)");
-  });
-
-  it("C1TC11b [R2-1]: one-shot 续轮空文本 → 沿用前值（one-shot 无增量语义，不覆盖为占位）", async () => {
-    const record = makeMinimalRecord({ id: "rec-oneshot-cont", chatMode: false });
-    record.status = "closed";
-    // 上一轮真实产出（续轮 record.result 前值）
-    record.result = "first round output";
-    const result = makeMinimalResult();
-    result.text = "";
-    result.success = true;
-    result.error = undefined;
-    await doFinalizeRoundToIdle(makeDeps(), record, result);
-    // one-shot record.result = 该 subagent 最终输出：空文本续轮沿用前值，不被 "(empty)" 覆盖
-    expect(record.result).toBe("first round output");
-  });
-});

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

@@ -1,82 +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, 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 });
-  });
-
-  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 内容为空（存在性即信号）", () => {
-      writeFinalized(sessionFile);
-      const content = fs.readFileSync(`${sessionFile}.finalized`, "utf-8");
-      expect(content).toBe("");
-    });
-  });
-
-  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__/format-schema-instruction.test.ts

@@ -1,138 +0,0 @@
-// src/__tests__/format-schema-instruction.test.ts
-//
-// 锁定 formatSchemaInstruction 契约：构造 schema enforcement 的 MANDATORY 指令。
-// 该字符串被拼入 task 末尾（runSpawn 的 fullTask = task + instruction），且 steer
-// reminder 复用同一文本。一旦漏掉 "MUST call structured-output" 关键词或 JSON
-// 序列化漂移，schema 模式会静默失效——agent 可能直接把 JSON 写进文本响应。
-//
-// 纯函数测试：不依赖 Pi 运行时、不 spawn 进程、不 mock。只 import 被测函数。
-import { describe, expect, it } from "vitest";
-
-import { formatSchemaInstruction } from "../session-runner.ts";
-
-describe("formatSchemaInstruction", () => {
-  // ── 指令文本契约 ──────────────────────────────────────────────
-
-  it("contains the structured-output tool keyword", () => {
-    const out = formatSchemaInstruction({ type: "object" });
-    expect(out).toContain("structured-output");
-  });
-
-  it("emits a MANDATORY structured-output directive (not free-form JSON)", () => {
-    const out = formatSchemaInstruction({ type: "object" });
-    expect(out).toContain("MANDATORY");
-    expect(out).toContain("MUST");
-    expect(out).toContain("MUST call the `structured-output` tool");
-    expect(out).toContain("Do NOT output the JSON directly");
-  });
-
-  // ── schema 序列化 ─────────────────────────────────────────────
-
-  it("embeds the schema as pretty-printed JSON (indent=2) inside a fenced block", () => {
-    const schema: Record<string, unknown> = {
-      type: "object",
-      properties: { name: { type: "string" } },
-    };
-    const out = formatSchemaInstruction(schema);
-    // 必须包含 JSON.stringify(schema, null, 2) 的完整结果
-    expect(out).toContain(JSON.stringify(schema, null, 2));
-    expect(out).toContain("```json");
-    expect(out).toContain("```");
-    // indent=2 的可观察证据：属性键前有恰好两个空格（object 第一层缩进）
-    expect(out).toContain('\n  "type": "object"');
-  });
-
-  it("locks the full output structure for a minimal schema", () => {
-    const out = formatSchemaInstruction({ type: "object" });
-    // 完整结构快照——任何指令措辞/顺序/缩进漂移都会被捕获。
-    // 注意第三行末尾的 em-dash（—），防止有人把它替换成普通连字符。
-    // [HISTORICAL] 方案 A 后文案更新：告知 LLM schema 由系统注入，只需传 data。
-    expect(out).toBe(
-      [
-        "MANDATORY: Structured Output Requirement",
-        "You MUST call the `structured-output` tool with your final answer.",
-        "Do NOT output the JSON directly in your text response — you MUST use the structured-output tool.",
-        "The schema is enforced by the system — call structured-output with ONLY the `data` parameter.",
-        "Do NOT pass a `schema` parameter; the system validates `data` against the authoritative schema automatically.",
-        "The schema for your `data` is:",
-        "```json",
-        '{',
-        '  "type": "object"',
-        '}',
-        "```",
-      ].join("\n"),
-    );
-  });
-
-  // ── 特殊字符转义（注入风险路径）──────────────────────────────
-
-  it("escapes double quotes inside schema string values", () => {
-    const schema: Record<string, unknown> = { prompt: 'say "hi"' };
-    const out = formatSchemaInstruction(schema);
-    // JSON.stringify 会把内层 " 转义为 \"
-    expect(out).toContain('say \\"hi\\"');
-    // 原始未转义形式（含成对字面双引号）绝不能回流进 JSON 体内
-    expect(out).not.toContain('say "hi"');
-  });
-
-  it("escapes newlines inside schema string values", () => {
-    const schema: Record<string, unknown> = { text: "line1\nline2" };
-    const out = formatSchemaInstruction(schema);
-    // 换行被序列化为字面反斜杠-n，不能是真实换行符
-    expect(out).toContain("line1\\nline2");
-    expect(out).not.toContain("line1\nline2");
-  });
-
-  it("escapes backslashes inside schema string values", () => {
-    const schema: Record<string, unknown> = { path: "C:\\Users\\x" };
-    const out = formatSchemaInstruction(schema);
-    // 单反斜杠被序列化为 \\，避免后续解析误把转义序列当指令
-    expect(out).toContain("C:\\\\Users\\\\x");
-    expect(out).not.toContain("C:\\Users\\x");
-  });
-
-  // ── 边界值 ────────────────────────────────────────────────────
-
-  it("handles empty schema object", () => {
-    const out = formatSchemaInstruction({});
-    expect(out).toContain("structured-output");
-    expect(out).toContain("{}");
-  });
-
-  it("preserves null values in schema", () => {
-    const schema: Record<string, unknown> = { default: null };
-    const out = formatSchemaInstruction(schema);
-    // JSON.stringify 对 null 保留字面 "null"（不会 omit 键，也不会变字符串）
-    expect(out).toContain('"default": null');
-  });
-
-  it("serializes nested objects and arrays", () => {
-    const schema: Record<string, unknown> = {
-      type: "object",
-      required: ["name", "age"],
-      properties: {
-        name: { type: "string" },
-        age: { type: "integer", minimum: 0 },
-      },
-    };
-    const out = formatSchemaInstruction(schema);
-    expect(out).toContain(JSON.stringify(schema, null, 2));
-    // 嵌套结构 indent 正确（第二层 4 空格）
-    expect(out).toContain('    "name": {');
-    expect(out).toContain('      "type": "string"');
-  });
-
-  // ── 确定性 ────────────────────────────────────────────────────
-
-  it("is deterministic — same schema produces identical output", () => {
-    const schema: Record<string, unknown> = { a: 1, b: [2, 3] };
-    expect(formatSchemaInstruction(schema)).toBe(formatSchemaInstruction(schema));
-  });
-
-  it("is deterministic across different object key insertion (value-equal schemas)", () => {
-    // JSON.stringify 按对象自身属性顺序序列化；同序构造的等价 schema 应产出相同指令
-    const a: Record<string, unknown> = { x: 1, y: 2 };
-    const b: Record<string, unknown> = { x: 1, y: 2 };
-    expect(formatSchemaInstruction(a)).toBe(formatSchemaInstruction(b));
-  });
-});