@zhushanwen/pi-subagent-workflow 8.5.0 → 8.7.0

package/src/execution/__tests__/tool-action.test.ts

@@ -1,385 +0,0 @@
-// src/__tests__/tool-action.test.ts
-//
-// tool action 路由 + adapter 出参结构测试（AC-2/AC-3/AC-9）。
-// 用 stub SubagentService（不依赖真实 SDK），测 handler + adapter 纯逻辑。
-
-import { describe, expect, it, vi } from "vitest";
-
-import { adapter, cancelHandler, listHandler, startHandler } from "../../interface/subagent-actions.ts";
-import type { SubagentService } from "../subagent-service.ts";
-import type {
-  ExecutionHandle,
-  RecordSnapshot,
-  SubagentRecord,
-  SubagentToolDetails,
-} from "../types.ts";
-
-// ── stub 工厂 ──
-
-function makeDetails(over: Partial<SubagentToolDetails> = {}): SubagentToolDetails {
-  return {
-    status: "closed",
-    mode: "background",
-    agent: "worker",
-    model: "test/model",
-    thinkingLevel: undefined,
-    slug: "test-slug",
-    turns: 1,
-    totalTokens: 10,
-    elapsedSeconds: 1,
-    eventLog: [],
-    result: "ok",
-    ...over,
-  };
-}
-
-function makeSnapshot(over: Partial<RecordSnapshot> = {}): RecordSnapshot {
-  return {
-    id: "run-1",
-    agent: "worker",
-    model: "test/model",
-    thinkingLevel: undefined,
-    mode: "background",
-    task: "t",
-    slug: "test-slug",
-    status: "closed",
-    eventLog: [],
-    turns: 1,
-    totalTokens: 10,
-    startedAt: 1000,
-    endedAt: 2000,
-    result: "ok",
-    error: undefined,
-    sessionFile: undefined,
-    ...over,
-  };
-}
-
-function makeService(over: Partial<SubagentService> = {}): SubagentService {
-  return {
-    execute: vi.fn(),
-    findRecord: vi.fn(() => undefined),
-    cancel: vi.fn(() => false),
-    collectRecords: vi.fn(() => [] as SubagentRecord[]),
-    // [perf] listHandler 逐项 enrich 会调 getFullRecord；mock 回 undefined → 调用方回退 light record
-    getFullRecord: vi.fn(() => undefined as SubagentRecord | undefined),
-    ...over,
-  } as SubagentService;
-}
-
-// ============================================================
-// startHandler
-// ============================================================
-describe("startHandler", () => {
-  it("缺 input → throw + Correct 正例", async () => {
-    const svc = makeService();
-    await expect(startHandler(svc, undefined, undefined)).rejects.toThrow(/task and slug/);
-    // Correct 正例存在（让弱模型撞错后能直接照抄平铺形态）
-    await expect(startHandler(svc, undefined, undefined)).rejects.toThrow(/Correct: \{"action":"start"/);
-  });
-
-  it("task 空白 → throw + Correct 正例", async () => {
-    const svc = makeService();
-    await expect(startHandler(svc, { task: "   ", slug: "x" }, undefined)).rejects.toThrow(/task is required/);
-    await expect(startHandler(svc, { task: "   ", slug: "x" }, undefined)).rejects.toThrow(/Correct: \{"action":"start"/);
-  });
-
-  it("slug 缺失 → throw + Correct 正例", async () => {
-    const svc = makeService();
-    await expect(startHandler(svc, { task: "ok" }, undefined)).rejects.toThrow(/slug is required/);
-    await expect(startHandler(svc, { task: "ok" }, undefined)).rejects.toThrow(/Correct: \{"action":"start"/);
-  });
-
-  it("slug 空白 → throw + Correct 正例", async () => {
-    const svc = makeService();
-    await expect(startHandler(svc, { task: "ok", slug: "   " }, undefined)).rejects.toThrow(/slug is required/);
-    await expect(startHandler(svc, { task: "ok", slug: "   " }, undefined)).rejects.toThrow(/Correct: \{"action":"start"/);
-  });
-
-  it("slug 超 35 字符 → throw", async () => {
-    const svc = makeService();
-    await expect(
-      startHandler(svc, { task: "ok", slug: "a".repeat(36) }, undefined),
-    ).rejects.toThrow(/≤35 chars/);
-  });
-
-  it("background 启动 → kind=bg + bgResponse.message 含 detached", async () => {
-    const svc = makeService({
-      execute: vi.fn(async (): Promise<ExecutionHandle> => ({
-        mode: "background",
-        subagentId: "bg-1-123",
-        sessionFile: undefined,
-        details: makeDetails({ status: "running", mode: "background" }),
-      })),
-    });
-    const r = await startHandler(svc, { task: "long", slug: "long-running" }, undefined);
-    expect(r.kind).toBe("bg");
-    if (r.kind !== "bg") return;
-    expect(r.subagentId).toBe("bg-1-123");
-    expect(r.response.message).toMatch(/detached/);
-  });
-});
-
-// ============================================================
-// listHandler
-// ============================================================
-describe("listHandler", () => {
-  it("空 → running:0, items:[]", () => {
-    const svc = makeService({ collectRecords: vi.fn(() => [] as SubagentRecord[]) });
-    const r = listHandler(svc, undefined);
-    expect(r.response).toEqual({ running: 0, items: [] });
-  });
-
-  it("limit 夹紧 [1,100]——collectRecords 收到夹紧后的值（C1 回归）", () => {
-    const collect = vi.fn(() => [] as SubagentRecord[]);
-    const svc = makeService({ collectRecords: collect });
-    // includeFinished=true 时 filter="all"，验证 limit 夹紧：
-    // 0 → 1
-    listHandler(svc, { includeFinished: true, limit: 0 });
-    expect(collect).toHaveBeenLastCalledWith(1, "all");
-    // 100000 → 100
-    listHandler(svc, { includeFinished: true, limit: 100000 });
-    expect(collect).toHaveBeenLastCalledWith(100, "all");
-    // undefined → 20（默认）
-    listHandler(svc, { includeFinished: true });
-    expect(collect).toHaveBeenLastCalledWith(20, "all");
-    // 负数 → 1
-    listHandler(svc, { includeFinished: true, limit: -5 });
-    expect(collect).toHaveBeenLastCalledWith(1, "all");
-  });
-
-  it("includeFinished=false → collectRecords 收到 filter='running'（C2 回归）", () => {
-    const collect = vi.fn(() => [] as SubagentRecord[]);
-    const svc = makeService({ collectRecords: collect });
-    // includeFinished=false → filter="running"（防截断下沉到 store）
-    listHandler(svc, { includeFinished: false, limit: 5 });
-    expect(collect).toHaveBeenLastCalledWith(5, "running");
-    // includeFinished=true → filter="all"
-    listHandler(svc, { includeFinished: true, limit: 5 });
-    expect(collect).toHaveBeenLastCalledWith(5, "all");
-  });
-
-  it("includeFinished=false → collectRecords 返回 running-only（过滤在 store 层）", () => {
-    // store 层已过滤，listHandler 只做透传——mock 返回的即 running-only。
-    const records: SubagentRecord[] = [
-      { id: "r1", agent: "w", status: "running", mode: "background", startedAt: 1, endedAt: undefined, turns: 0, totalTokens: 0, model: "m", thinkingLevel: undefined, eventLog: [] },
-    ];
-    const svc = makeService({ collectRecords: vi.fn(() => records) });
-    const r = listHandler(svc, { includeFinished: false });
-    expect(r.response.items).toHaveLength(1);
-    expect(r.response.items[0].subagentId).toBe("r1");
-    expect(r.response.running).toBe(1);
-  });
-
-  it("item 8 字段齐全（含 duration 实时计算）", () => {
-    const records: SubagentRecord[] = [
-      { id: "r1", agent: "w", status: "closed", mode: "background", startedAt: 1000, endedAt: 2500, turns: 2, totalTokens: 50, model: "m", thinkingLevel: "high", eventLog: [], sessionFile: "x.jsonl" },
-    ];
-    const svc = makeService({ collectRecords: vi.fn(() => records) });
-    const r = listHandler(svc, { includeFinished: true });
-    const item = r.response.items[0];
-    expect(item).toMatchObject({
-      subagentId: "r1", agent: "w", status: "closed", mode: "background",
-      duration: 1, model: "m", totalTokens: 50, sessionFile: "x.jsonl",
-    });
-  });
-
-  it("items 超过 limit → 截断在 store 层（listHandler 透传 limit）", () => {
-    // 截断责任在 collectRecords（store 层），listHandler 只透传 limit + map。
-    // mock 返回 3 条（模拟 store 未截断），验证 listHandler 不自行截断——全量透传。
-    const records: SubagentRecord[] = [
-      { id: "r1", agent: "w", status: "running", mode: "background", startedAt: 1, endedAt: undefined, turns: 0, totalTokens: 0, model: "m", thinkingLevel: undefined, eventLog: [] },
-      { id: "r2", agent: "w", status: "running", mode: "background", startedAt: 2, endedAt: undefined, turns: 0, totalTokens: 0, model: "m", thinkingLevel: undefined, eventLog: [] },
-      { id: "r3", agent: "w", status: "running", mode: "background", startedAt: 3, endedAt: undefined, turns: 0, totalTokens: 0, model: "m", thinkingLevel: undefined, eventLog: [] },
-    ];
-    const collect = vi.fn(() => records);
-    const svc = makeService({ collectRecords: collect });
-    const r = listHandler(svc, { includeFinished: true, limit: 2 });
-    // listHandler 透传 collectRecords 的结果（截断是 store 的责任）。
-    expect(r.response.items).toHaveLength(3);
-    // 验证 limit 确实透传给了 collectRecords。
-    expect(collect).toHaveBeenCalledWith(2, "all");
-  });
-
-  // TC-2: running 态实时 duration（Date.now()-startedAt）随时间增长，
-  // 区别于终态 endedAt-startedAt。喂给 live TUI，更易出 bug。
-  it("running 态 duration 实时计算：两次 list 间隔 2s，duration 差 = 2（TC-2）", () => {
-    vi.useFakeTimers({ now: 10_000 });
-    try {
-      const records: SubagentRecord[] = [
-        { id: "r1", agent: "w", status: "running", mode: "background", startedAt: 7_000, endedAt: undefined, turns: 0, totalTokens: 0, model: "m", thinkingLevel: undefined, eventLog: [] },
-      ];
-      const svc = makeService({ collectRecords: vi.fn(() => records) });
-      const r1 = listHandler(svc, { includeFinished: true });
-      expect(r1.response.items[0].duration).toBe(3); // (10-7)s
-      vi.advanceTimersByTime(2_000);
-      const r2 = listHandler(svc, { includeFinished: true });
-      expect(r2.response.items[0].duration).toBe(5); // (12-7)s
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  // TC-3: listHandler 保持 collectRecords 返回的顺序（排序责任在 service 层，
-  // listHandler 是顺序透传）。故意传入反序 list 验证 listHandler 不自行排序。
-  it("保持 collectRecords 顺序，不自行重排（TC-3）", () => {
-    // 故意按 startedAt 升序（与 desc 相反）
-    const records: SubagentRecord[] = [
-      { id: "old", agent: "w", status: "running", mode: "background", startedAt: 1, endedAt: undefined, turns: 0, totalTokens: 0, model: "m", thinkingLevel: undefined, eventLog: [] },
-      { id: "new", agent: "w", status: "running", mode: "background", startedAt: 5, endedAt: undefined, turns: 0, totalTokens: 0, model: "m", thinkingLevel: undefined, eventLog: [] },
-    ];
-    const svc = makeService({ collectRecords: vi.fn(() => records) });
-    const r = listHandler(svc, { includeFinished: true });
-    expect(r.response.items.map((i) => i.subagentId)).toEqual(["old", "new"]);
-  });
-});
-
-// ============================================================
-// cancelHandler
-// ============================================================
-describe("cancelHandler", () => {
-  it("缺 subagentId → throw", async () => {
-    const svc = makeService();
-    await expect(cancelHandler(svc, undefined)).rejects.toThrow(/subagentId is required/);
-    await expect(cancelHandler(svc, { subagentId: "  " })).rejects.toThrow(/subagentId is required/);
-  });
-
-  it("id 不存在 → throw No subagent record", async () => {
-    const svc = makeService({ findRecord: vi.fn(() => undefined) });
-    await expect(cancelHandler(svc, { subagentId: "nope" })).rejects.toThrow(/No subagent record with id "nope"/);
-  });
-
-  it("[S-19] id 属树内其他进程的 running record（磁盘可见、本进程内存无）→ throw 跨进程专属消息", async () => {
-    // MF-1 全树可见后：子进程 list 能看到父/兄弟进程的 running record，但 cancel 只作用于
-    // 本进程内存。旧消息「may have finished」误导（该 record 未 finished、正被列出）。
-    const foreign: SubagentRecord = {
-      id: "bg-foreign", agent: "w", status: "running", mode: "background", startedAt: 1,
-      endedAt: undefined, turns: 0, totalTokens: 0, model: "m", thinkingLevel: undefined, eventLog: [],
-    };
-    const svc = makeService({
-      findRecord: vi.fn(() => undefined),
-      collectRecords: vi.fn(() => [foreign] as SubagentRecord[]),
-    });
-    await expect(cancelHandler(svc, { subagentId: "bg-foreign" })).rejects.toThrow(/owned by another process in the tree/);
-  });
-
-  it("[S-19] id 在树内但已终态（磁盘可见 done）→ 仍用 may have finished 消息", async () => {
-    const done: SubagentRecord = {
-      id: "bg-done", agent: "w", status: "closed", mode: "background", startedAt: 1,
-      endedAt: 2, turns: 0, totalTokens: 0, model: "m", thinkingLevel: undefined, eventLog: [],
-    };
-    const svc = makeService({
-      findRecord: vi.fn(() => undefined),
-      collectRecords: vi.fn(() => [done] as SubagentRecord[]),
-    });
-    await expect(cancelHandler(svc, { subagentId: "bg-done" })).rejects.toThrow(/may have finished/);
-  });
-
-  it("已终态（cancel 返回 false）→ throw could not be cancelled", async () => {
-    const svc = makeService({
-      findRecord: vi.fn(() => makeSnapshot({ id: "bg-1", mode: "background", status: "closed" })),
-      cancel: vi.fn(() => false),
-    });
-    await expect(cancelHandler(svc, { subagentId: "bg-1" })).rejects.toThrow(/could not be cancelled.*status: closed/);
-  });
-
-  it("成功 → cancelled:true", async () => {
-    const svc = makeService({
-      findRecord: vi.fn(() => makeSnapshot({ id: "bg-1", mode: "background", status: "running" })),
-      cancel: vi.fn(() => true),
-    });
-    const r = await cancelHandler(svc, { subagentId: "bg-1" });
-    expect(r.subagentId).toBe("bg-1");
-    expect(r.response.cancelled).toBe(true);
-  });
-
-  // TC-1: 并发 CAS 场景——同一 id 两次 cancel，第一次抢锁成功，第二次 CAS 失败后
-  // re-query 到终态。覆盖 cancelHandler 的 re-query 分支（subagent-actions.ts:267-272）。
-  it("并发 CAS：两次 cancel 同一 id，第二次 CAS 失败 re-query 到终态", async () => {
-    const running = makeSnapshot({ id: "bg-cas", mode: "background", status: "running" });
-    const done = makeSnapshot({ id: "bg-cas", mode: "background", status: "closed" });
-
-    let cancelCalls = 0;
-    const svc = makeService({
-      // findRecord 调用序列：
-      //   call 1: 第一次 cancel 初始查询 → running
-      //   call 2: 第二次 cancel 初始查询 → running（快照尚未过期）
-      //   call 3: 第二次 cancel CAS 失败后 re-query → done（状态已变）
-      findRecord: vi.fn()
-        .mockReturnValueOnce(running)
-        .mockReturnValueOnce(running)
-        .mockReturnValueOnce(done),
-      cancel: vi.fn(() => {
-        cancelCalls++;
-        return cancelCalls === 1; // 第一次 true，第二次 false（CAS 失败）
-      }),
-    });
-
-    // 第一次 cancel：抢锁成功
-    const r1 = await cancelHandler(svc, { subagentId: "bg-cas" });
-    expect(r1.response.cancelled).toBe(true);
-
-    // 第二次 cancel：CAS 失败，re-query 返回 closed（不是初始的 running）
-    await expect(cancelHandler(svc, { subagentId: "bg-cas" }))
-      .rejects.toThrow(/could not be cancelled.*status: closed/);
-
-    // 验证 re-query 确实发生（3 次 findRecord：1 初始 + 1 初始 + 1 re-query）
-    expect(svc.findRecord).toHaveBeenCalledTimes(3);
-    expect(svc.cancel).toHaveBeenCalledTimes(2);
-  });
-
-  // BL-3 回归：CAS 失败后 re-query 时 record 已被 archive 移出内存，
-  // 文案诚实报告 "evicted" 而非回落到可能过期的 stale status。
-  it("CAS 失败 + record 被内存淘汰 → 文案诚实报告 evicted（BL-3）", async () => {
-    const svc = makeService({
-      // 第一次 findRecord：初始查询 → running
-      // 第二次 findRecord：CAS 失败后 re-query → undefined（已被淘汰）
-      findRecord: vi.fn()
-        .mockReturnValueOnce(makeSnapshot({ id: "bg-evict", mode: "background", status: "running" }))
-        .mockReturnValueOnce(undefined),
-      cancel: vi.fn(() => false),
-    });
-    await expect(cancelHandler(svc, { subagentId: "bg-evict" }))
-      .rejects.toThrow(/could not be cancelled.*status: unknown \(evicted from memory\)/);
-    expect(svc.findRecord).toHaveBeenCalledTimes(2);
-  });
-});
-
-// ============================================================
-// adapter
-// ============================================================
-describe("adapter", () => {
-  it("start bg → SubagentToolResult.bgResponse + slug 透传 + content 合法 JSON（C3 回归）", () => {
-    const r = adapter({
-      action: "start",
-      domain: {
-        kind: "bg", subagentId: "bg-1", sessionFile: undefined, slug: "extract-urls",
-        response: { status: "running", mode: "background", message: "detached, will notify on completion" },
-      },
-    });
-    expect(r.details.action).toBe("start");
-    expect(r.details.subagentId).toBe("bg-1");
-    expect(r.details.bgResponse).toBeDefined();
-    expect(r.details.sessionFile).toBeNull();
-    // slug 透传到 result（renderResult 的 background 行展示用）
-    expect(r.details.slug).toBe("extract-urls");
-    // content JSON round-trip（bg 序列化回归）
-    const parsed = JSON.parse(r.content[0]!.text);
-    expect(parsed.bgResponse.message).toMatch(/detached/);
-    expect(parsed.slug).toBe("extract-urls");
-  });
-
-  it("list → 最外层 subagentId/sessionFile 为 null", () => {
-    const r = adapter({ action: "list", domain: { response: { running: 0, items: [] } } });
-    expect(r.details.action).toBe("list");
-    expect(r.details.subagentId).toBeNull();
-    expect(r.details.sessionFile).toBeNull();
-    expect(r.details.listResponse).toEqual({ running: 0, items: [] });
-  });
-
-  it("cancel → cancelResponse.cancelled:true 字面量", () => {
-    const r = adapter({ action: "cancel", domain: { subagentId: "bg-1", response: { cancelled: true } } });
-    expect(r.details.cancelResponse).toEqual({ cancelled: true });
-    expect(r.details.subagentId).toBe("bg-1");
-  });
-});

package/src/execution/__tests__/truncline-snapshot.test.ts

@@ -1,81 +0,0 @@
-/**
- * truncLine — indexOf 化（IF12/#18）byte-identical 快照 + 非 SGR ESC 行为锚定。
- *
- * fixture（__fixtures__/truncline.snapshot.json）由**改造前实现**生成落盘
- * （本文件同 commit），断言重构后输出逐字节一致——含 OSC / 裸 \x1b / \x1b[K
- * 非 SGR ESC 用例（等价定义点：非 SGR ESC 不构成文本段边界，按文本计宽进 result）。
- */
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-
-import { describe, expect, it } from "vitest";
-
-import { truncLine } from "../../interface/format.ts";
-
-interface SnapshotCase {
-  label: string;
-  maxWidth: number;
-  text: string;
-  expected: string;
-}
-
-function loadCases(): SnapshotCase[] {
-  const here = dirname(fileURLToPath(import.meta.url));
-  return JSON.parse(
-    readFileSync(join(here, "__fixtures__", "truncline.snapshot.json"), "utf8"),
-  ) as SnapshotCase[];
-}
-
-describe("truncLine — indexOf 化 byte-identical 快照（IF12）", () => {
-  it("全部 fixture 用例（10k ANSI 混合行 / CJK / OSC / 裸 ESC / CSI-K / emoji）与改造前输出逐字节一致", () => {
-    const cases = loadCases();
-    expect(cases.length).toBeGreaterThanOrEqual(10);
-    for (const c of cases) {
-      expect(truncLine(c.text, c.maxWidth)).toBe(c.expected);
-    }
-  });
-
-  it("10k 混合长行在多个截断宽度下均一致（fixture 内 maxWidth 之外再加宽度扫描）", () => {
-    const mixed = loadCases().find((c) => c.label === "sgr-mixed-10k")!;
-    for (const w of [8, 15, 30, 61, 100]) {
-      const expected = mixed.expected; // fixture 锁 maxWidth=60；其他宽度靠 oracle 断言
-      void expected;
-      // 非 fixture 宽度用行为断言：输出含省略号且无裸换行
-      const out = truncLine(mixed.text, w);
-      expect(out).toContain("…");
-      expect(out).not.toContain("\n");
-    }
-  });
-});
-
-describe("truncLine — 非 SGR ESC 行为（等价定义点，显式锚定）", () => {
-  it("OSC 序列（\\x1b]0;title\\x07）按文本计宽进 result（不作为样式捕获/段边界）", () => {
-    // OSC 计入可见宽度（\x1b]0;title\x07 各字符占宽），随后文本继续同段累加
-    const out = truncLine("AB\x1b]0;title\x07CDEFGHIJKLMNOP", 10);
-    expect(out.endsWith("…")).toBe(true);
-    expect(out).not.toContain("\x1b]0;title\x07"); // 截断点在 OSC 之内或之前——
-    // 逐字节形态由 fixture（osc-title / osc-inside-truncation 用例）锚定
-  });
-
-  it("裸 \\x1b 后跟非 [ 字符：不匹配 SGR、并入文本段（不丢字符不死循环）", () => {
-    const out = truncLine("before \x1bZ after bare esc tail", 12);
-    expect(out.endsWith("…")).toBe(true);
-    // 输出是输入前缀（前 11 可见列 + …），未吞字符
-    expect(out.startsWith("before ")).toBe(true);
-  });
-
-  it("非 SGR CSI（\\x1b[K）与 SGR 混排且触发截断：\x1b[K 不进 activeStyles（无错位 reset）", () => {
-    const out = truncLine("\x1b[31mred\x1b[K\x1b[32mgreen tail past width", 10);
-    // SGR（31m/32m）被捕获；\x1b[K 按文本进 result——逐字节形态由 fixture
-    //（csi-k-mixed-sgr 用例）锚定；此处断言 SGR 样式重应用语义未回归
-    expect(out).toMatch(/\x1b\[31m/);
-    expect(out.endsWith("…\x1b[0m")).toBe(true);
-  });
-
-  it("ESC 恰在串尾：无后续字符可判 SGR，按文本并入（end=flat.length）", () => {
-    const out = truncLine("text almost at width limit\x1b", 22);
-    expect(out.endsWith("…")).toBe(true);
-    expect(out).not.toContain("\x1b["); // 末尾裸 ESC 未触发 SGR 捕获
-  });
-});

package/src/execution/__tests__/turn-limiter-semantics.test.ts

@@ -1,194 +0,0 @@
-// src/execution/__tests__/turn-limiter-semantics.test.ts
-//
-// SP-9: turn-limiter chatMode 语义——chatMode 下 maxTurns 每轮 reset（不跨轮累计）。
-// 设计 D9 决策：续聊本质是无限轮，累计上限违背 G1。
-
-import { describe, expect, it, vi } from "vitest";
-
-import { createTurnLimiter } from "../turn-limiter.ts";
-
-describe("SP-9: turn-limiter chatMode semantics (maxTurns reset per round)", () => {
-  describe("TC-1: chatMode 多轮后 maxTurns 每轮 reset（不累计）", () => {
-    it("reset 后 maxTurns 不累计——第二轮从 0 开始，不触发 steer/abort", () => {
-      const steer = vi.fn();
-      const abort = vi.fn();
-      const limiter = createTurnLimiter({ maxTurns: 3, graceTurns: 2, steer, abort });
-
-      // 第一轮：3 turns → steer（达到 maxTurns=3）
-      limiter.onTurnEnd(1);
-      limiter.onTurnEnd(2);
-      limiter.onTurnEnd(3);
-      expect(steer).toHaveBeenCalledTimes(1);
-      expect(abort).not.toHaveBeenCalled();
-
-      // agent_settled → reset（模拟 chatMode 每轮 reset）
-      limiter.reset();
-
-      // 第二轮从 turnCount=0 开始（record.turnCount 由 session-runner 归零）：
-      // 2 turns 不触发 steer（距离 maxTurns=3 还差 1）
-      limiter.onTurnEnd(1);
-      limiter.onTurnEnd(2);
-      // steer 仍然是 1 次（第一轮那次），第二轮未触发
-      expect(steer).toHaveBeenCalledTimes(1);
-      expect(abort).not.toHaveBeenCalled();
-    });
-
-    it("reset 后第二轮同样达到 maxTurns 时仍触发 steer", () => {
-      const steer = vi.fn();
-      const abort = vi.fn();
-      const limiter = createTurnLimiter({ maxTurns: 2, graceTurns: 1, steer, abort });
-
-      // 第一轮：steer + grace + abort
-      limiter.onTurnEnd(1);
-      limiter.onTurnEnd(2); // steer
-      limiter.onTurnEnd(3); // abort
-      expect(steer).toHaveBeenCalledTimes(1);
-      expect(abort).toHaveBeenCalledTimes(1);
-
-      // reset（chatMode 新轮）
-      limiter.reset();
-      expect(limiter.didSteer).toBe(false);
-      expect(limiter.didAbort).toBe(false);
-
-      // 第二轮：同样走完 steer + grace 路径
-      limiter.onTurnEnd(1);
-      limiter.onTurnEnd(2); // steer again
-      expect(steer).toHaveBeenCalledTimes(2);
-      expect(abort).toHaveBeenCalledTimes(1); // 还没到 abort
-
-      limiter.onTurnEnd(3); // abort again
-      expect(abort).toHaveBeenCalledTimes(2);
-    });
-
-    it("多轮连续 reset 后 limiter 始终可用", () => {
-      const steer = vi.fn();
-      const abort = vi.fn();
-      const limiter = createTurnLimiter({ maxTurns: 2, graceTurns: 0, steer, abort });
-
-      for (let round = 1; round <= 5; round++) {
-        limiter.onTurnEnd(1);
-        limiter.onTurnEnd(2); // steer + abort (graceTurns=0)
-        expect(steer).toHaveBeenCalledTimes(round);
-        expect(abort).toHaveBeenCalledTimes(round);
-        limiter.reset();
-      }
-    });
-  });
-
-  describe("TC-2: graceTurns 每轮 reset", () => {
-    it("reset 后 graceTurns 从 0 重新计数", () => {
-      const steer = vi.fn();
-      const abort = vi.fn();
-      const limiter = createTurnLimiter({ maxTurns: 2, graceTurns: 3, steer, abort });
-
-      // 第一轮：steer at turn 2，用掉 1 个 grace turn
-      limiter.onTurnEnd(1);
-      limiter.onTurnEnd(2); // steer
-      limiter.onTurnEnd(3); // grace turn 1
-      expect(abort).not.toHaveBeenCalled();
-
-      // reset（模拟 chatMode agent_settled）
-      limiter.reset();
-
-      // 第二轮：从 turn 1 开始，graceTurns 重新从 0 计数
-      limiter.onTurnEnd(1);
-      limiter.onTurnEnd(2); // steer again
-      limiter.onTurnEnd(3); // grace turn 1（重计）
-      limiter.onTurnEnd(4); // grace turn 2
-      limiter.onTurnEnd(5); // grace turn 3 → abort
-      expect(abort).toHaveBeenCalledTimes(1);
-    });
-
-    it("reset 前未 steer 时 reset 后仍正常工作", () => {
-      const steer = vi.fn();
-      const abort = vi.fn();
-      const limiter = createTurnLimiter({ maxTurns: 5, graceTurns: 2, steer, abort });
-
-      // 第一轮：只走了 2 turns（未达 maxTurns）
-      limiter.onTurnEnd(1);
-      limiter.onTurnEnd(2);
-      expect(steer).not.toHaveBeenCalled();
-
-      limiter.reset();
-
-      // 第二轮：从 turn 1 开始，到 maxTurns=5 触发 steer
-      limiter.onTurnEnd(1);
-      limiter.onTurnEnd(2);
-      limiter.onTurnEnd(3);
-      limiter.onTurnEnd(4);
-      limiter.onTurnEnd(5); // steer
-      expect(steer).toHaveBeenCalledTimes(1);
-      limiter.onTurnEnd(6);
-      limiter.onTurnEnd(7); // abort (5+2)
-      expect(abort).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("TC-3: 非 chatMode 行为不变（全程累计）", () => {
-    it("不调用 reset 时 turn-limiter 行为与原来完全一致", () => {
-      const steer = vi.fn();
-      const abort = vi.fn();
-      const limiter = createTurnLimiter({ maxTurns: 3, graceTurns: 2, steer, abort });
-
-      // 全程累计（非 chatMode，不 reset）：3→steer，5→abort
-      limiter.onTurnEnd(1);
-      limiter.onTurnEnd(2);
-      limiter.onTurnEnd(3); // steer
-      expect(steer).toHaveBeenCalledTimes(1);
-      limiter.onTurnEnd(4); // grace 1
-      limiter.onTurnEnd(5); // grace 2 → abort
-      expect(abort).toHaveBeenCalledTimes(1);
-      expect(limiter.didSteer).toBe(true);
-      expect(limiter.didAbort).toBe(true);
-    });
-
-    it("maxTurns=0（禁用）不因 reset 而误启用", () => {
-      const steer = vi.fn();
-      const abort = vi.fn();
-      const limiter = createTurnLimiter({ maxTurns: 0, graceTurns: 2, steer, abort });
-
-      limiter.onTurnEnd(100);
-      expect(steer).not.toHaveBeenCalled();
-
-      limiter.reset();
-      limiter.onTurnEnd(100);
-      // maxTurns=0（禁用），即使 reset 也不触发
-      expect(steer).not.toHaveBeenCalled();
-      expect(abort).not.toHaveBeenCalled();
-    });
-
-    it("全程累计（不 reset）达到 maxTurns+graceTurns 后不再触发", () => {
-      const steer = vi.fn();
-      const abort = vi.fn();
-      const limiter = createTurnLimiter({ maxTurns: 2, graceTurns: 1, steer, abort });
-
-      limiter.onTurnEnd(1);
-      limiter.onTurnEnd(2); // steer
-      limiter.onTurnEnd(3); // abort
-      expect(steer).toHaveBeenCalledTimes(1);
-      expect(abort).toHaveBeenCalledTimes(1);
-
-      // 已 abort 后继续调用 onTurnEnd（不应再次触发）
-      limiter.onTurnEnd(4);
-      limiter.onTurnEnd(5);
-      expect(steer).toHaveBeenCalledTimes(1);
-      expect(abort).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("TC-4: reset 诊断属性", () => {
-    it("reset 清除 didSteer 和 didAbort 诊断标志", () => {
-      const steer = vi.fn();
-      const abort = vi.fn();
-      const limiter = createTurnLimiter({ maxTurns: 1, graceTurns: 0, steer, abort });
-
-      limiter.onTurnEnd(1); // steer + abort (graceTurns=0)
-      expect(limiter.didSteer).toBe(true);
-      expect(limiter.didAbort).toBe(true);
-
-      limiter.reset();
-      expect(limiter.didSteer).toBe(false);
-      expect(limiter.didAbort).toBe(false);
-    });
-  });
-});