@zhushanwen/pi-subagent-workflow 8.6.0 → 8.8.0

package/src/execution/__tests__/chatmode-round-notify-real-chain.test.ts

@@ -1,215 +0,0 @@
-// src/execution/__tests__/chatmode-round-notify-real-chain.test.ts
-//
-// [N2] chatMode 轮次通知正文——真实 session-runner 链路测试。
-//
-// round2 审查实证的断链：agent_settled → onRoundSettled 先 notifyComplete（此时
-// record.result 从未被写——成功轮次的 MF-2 原写点 doFinalizeRoundToIdle 对
-// runAndFinalize early return 不可达）→ 轮次通知正文恒 "(empty)"，turns[].text 已累积
-// 但 notify 读的是 record.result。修复：onRoundSettled 在 notify 前从本轮 turns 派生
-// 回复文本（对齐 collectResult 的 getFullText）写入 record.result。
-//
-// 与 chatmode-first-round-closure-service.test.ts（mock session-runner）不同，本文件用
-// 真实 session-runner（FakeChild 驱动 text_delta / agent_settled）+ 真实
-// service.execute(conversation:true)，禁止手工预置 record.result——那正是掩盖断链的方式。
-// mock 结构与 run-spawn-chatmode-settled.test.ts 一致（FakeChild + session-pending count=0）。
-
-import { spawn } 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";
-
-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 }));
-
-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(() => []),
-    // tmp 目录创建/清理走真实实现（本文件用例级隔离需要）
-    mkdtempSync: actual.mkdtempSync,
-    rmSync: actual.rmSync,
-    promises: actual.promises,
-  };
-});
-
-// removeAliveMarker 一并 mock（finalize-record 消费；成功轮次 early return 不触达，防御性补全）
-vi.mock("../alive-store.ts", () => ({
-  writeAliveMarker: vi.fn(),
-  removeAliveMarker: vi.fn(),
-}));
-
-// chatMode agent_end 早返回不读后代判定；统一 count=0（对齐 harness）。
-vi.mock("../session-pending.ts", () => ({
-  readActivePendingFromSessionFile: vi.fn(() => ({ count: 0 })),
-}));
-
-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 { _resetLifecycleState } from "../lifecycle-manager.ts";
-import { ModelConfigService } from "../model-config-service.ts";
-import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
-import type { ExecutionRecord } from "../types.ts";
-import { SubagentService } from "../subagent-service.ts";
-import type { PiLike } from "../subagent-service.ts";
-import {
-  emitStdoutLine,
-  lastSpawnedChild,
-  sessionHeader,
-  waitForSpawn,
-} from "./helpers/spawn-mock.ts";
-
-const mockSpawn = vi.mocked(spawn);
-
-const STUB_MODEL: ModelInfo = { id: "test-model", name: "Test", provider: "test", reasoning: false };
-
-/** 最小合法 registry（initModel fail-fast 需要；resolveModel 第三层直接透传 ctxModel）。 */
-function makeEmptyRegistry(): ModelRegistryLike {
-  return { getAvailable: () => [], find: () => undefined, hasConfiguredAuth: () => true };
-}
-
-function makePi(): PiLike & {
-  appendEntry: ReturnType<typeof vi.fn>;
-  events: { emit: ReturnType<typeof vi.fn> };
-  sendMessage: ReturnType<typeof vi.fn>;
-} {
-  return { appendEntry: vi.fn(), events: { emit: vi.fn() }, sendMessage: vi.fn() };
-}
-
-/** 暴露私有 store 的接口（测试专用 cast）。 */
-interface ServiceInternals {
-  store: { getMutable(id: string): ExecutionRecord | undefined };
-}
-
-describe("[N2] chatMode 轮次通知正文：真实 session-runner 链路", () => {
-  let agentDir: string;
-  let service: SubagentService;
-  let pi: ReturnType<typeof makePi>;
-  let internals: ServiceInternals;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // lifecycle-manager 模块级单例（idleTimers Map 跨用例共享），每用例前清空防泄漏。
-    _resetLifecycleState();
-    agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "round-notify-"));
-    const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
-    modelService.initModel({
-      modelRegistry: makeEmptyRegistry(),
-      sessionId: "root-session",
-      ctxModel: STUB_MODEL,
-    });
-    service = new SubagentService({ cwd: agentDir, modelService });
-    pi = makePi();
-    service.initSession({ pi, sessionId: "root-session" });
-    internals = service as unknown as ServiceInternals;
-  });
-
-  afterEach(() => {
-    service.dispose();
-    _resetLifecycleState();
-    vi.restoreAllMocks();
-    fs.rmSync(agentDir, { recursive: true, force: true });
-  });
-
-  it("真实 execute(conversation:true) + FakeChild 驱动 text_delta/agent_settled → 通知正文含本轮真实回复（非 (empty)）", async () => {
-    const ROUND_REPLY = "THE ROUND REPLY";
-
-    // 真实链路：execute → kickOffBackground → runAndFinalize → 真实 runSpawn → FakeChild。
-    // ctx.onRoundSettled 由 buildSessionRunnerContext 注入（真实回调，非 mock）。
-    const handle = await service.execute({
-      task: "tell me something",
-      slug: "round-notify",
-      conversation: true,
-    });
-
-    await waitForSpawn(mockSpawn);
-    const child = lastSpawnedChild(mockSpawn);
-
-    // 真实事件链：header（握手加速）→ text_delta（本轮回复累积进 turns）→ turn_end →
-    // agent_end（chatMode 保活）→ agent_settled（真空闲：armIdleTimer → onRoundSettled）。
-    emitStdoutLine(child, sessionHeader("sess-round-1"));
-    emitStdoutLine(child, {
-      type: "message_update",
-      // type 对齐 pi-ai AssistantMessageEvent 真实协议（text 增量 = "text_delta"，带 contentIndex）。
-      // 曾用 {type:"text"} 假类型——旧实现不查 type 只看 delta 碰巧兼容；现实现按 type 正向
-      // 分流（toolcall_delta 不混入 text 流），假类型事件被正确丢弃，fake 必须对齐真实协议。
-      assistantMessageEvent: { type: "text_delta", contentIndex: 0, delta: ROUND_REPLY },
-    });
-    emitStdoutLine(child, { type: "turn_end" });
-    emitStdoutLine(child, { type: "agent_end", willRetry: false });
-    emitStdoutLine(child, { type: "agent_settled" });
-
-    // agent_settled → onRoundSettled（round+1 + record.result 派生 + notifyComplete）→
-    // 无其他 busy background → 立即 flush → pi.sendMessage。
-    await vi.waitFor(() => {
-      expect(pi.sendMessage).toHaveBeenCalledTimes(1);
-    });
-
-    const sentMsg = pi.sendMessage.mock.calls[0]![0] as { customType: string; content: string };
-    expect(sentMsg.customType).toBe("subagent-bg-notify");
-    expect(sentMsg.content).toContain("finished a round");
-    // [N2] 核心：正文含本轮真实回复文本（修复前此处是 "(empty)"）
-    expect(sentMsg.content).toContain(ROUND_REPLY);
-    expect(sentMsg.content).not.toContain("(empty)");
-
-    // record 侧：turns 已累积 + result 从 turns 真实派生（非手工预置）+ running-resumable
-    const record = internals.store.getMutable(handle.subagentId);
-    expect(record).toBeDefined();
-    expect(record!.turns[0]!.text).toBe(ROUND_REPLY);
-    expect(record!.result).toBe(ROUND_REPLY);
-    expect(record!.status).toBe("running");
-    expect(record!.round).toBe(1);
-
-    // 收尾：close 让 runSpawn resolve → runAndFinalize 续体 early return → .then 的
-    // notifyComplete 被同 id:round dedup 吞——总发送数仍恰为 1。
-    child.stdout.end();
-    child.stderr.end();
-    child.emit("close", 0);
-    await new Promise((r) => setTimeout(r, 30));
-    expect(pi.sendMessage).toHaveBeenCalledTimes(1);
-
-    // [C2] close 现状语义扩展：终态化不再发新通知（总数仍 1），末条轮次通知含
-    // Full transcript 指针行——真实链路 sessionHeader 已回填 record.sessionFile
-    //（session-runner.ts:1039），chatMode:true 经 toNotifyRecord 条件透传到通知正文。
-    const lastMsg = pi.sendMessage.mock.calls[0]![0] as { content: string; details?: { sessionFile?: string } };
-    expect(lastMsg.details?.sessionFile).toBe(record!.sessionFile);
-    expect(lastMsg.content).toContain(`\n\nFull transcript: ${record!.sessionFile}`);
-  });
-});

package/src/execution/__tests__/concurrency-pool.test.ts

@@ -1,250 +0,0 @@
-// src/__tests__/concurrency-pool.test.ts
-import { describe, expect, it } from "vitest";
-
-import { DefaultConcurrencyPool } from "../concurrency-pool.ts";
-
-describe("DefaultConcurrencyPool", () => {
-  it("allows up to maxConcurrent concurrent tasks", async () => {
-    const pool = new DefaultConcurrencyPool(2);
-    await pool.acquire(0);
-    await pool.acquire(0);
-    // 第三个 acquire 应阻塞
-    let thirdAcquired = false;
-    const third = pool.acquire(0).then(() => { thirdAcquired = true; });
-    await new Promise((r) => setTimeout(r, 5));
-    expect(thirdAcquired).toBe(false);
-    expect(pool.active).toBe(2);
-
-    pool.release();
-    await third;
-    expect(thirdAcquired).toBe(true);
-    expect(pool.active).toBe(2);
-
-    pool.release();
-    pool.release();
-    await new Promise((r) => setTimeout(r, 5));
-    expect(pool.active).toBe(0);
-  });
-
-  it("higher priority acquires the pool first", async () => {
-    const pool = new DefaultConcurrencyPool(1);
-    await pool.acquire(0); // 占满
-
-    let lowAcquired = false;
-    let highAcquired = false;
-    const low = pool.acquire(10).then(() => { lowAcquired = true; });
-    const high = pool.acquire(0).then(() => { highAcquired = true; });
-
-    await new Promise((r) => setTimeout(r, 5));
-    pool.release();
-    await Promise.race([low, high, new Promise((r) => setTimeout(r, 20))]);
-
-    expect(highAcquired).toBe(true);
-    expect(lowAcquired).toBe(false);
-    pool.release();
-  });
-
-  it("same-priority tasks wake in FIFO (seq) order", async () => {
-    const pool = new DefaultConcurrencyPool(1);
-    await pool.acquire(0); // fill slot
-
-    const order: number[] = [];
-    // Enqueue 3 tasks with same priority — they should resolve in enqueue order
-    const p1 = pool.acquire(0).then(() => { order.push(1); pool.release(); });
-    const p2 = pool.acquire(0).then(() => { order.push(2); pool.release(); });
-    const p3 = pool.acquire(0).then(() => { order.push(3); pool.release(); });
-
-    pool.release(); // kick off the chain
-    await Promise.allSettled([p1, p2, p3]);
-
-    expect(order).toEqual([1, 2, 3]);
-  });
-
-  it("extra release() does not make active negative", () => {
-    const pool = new DefaultConcurrencyPool(2);
-    pool.release(); // no acquires yet
-    pool.release();
-    pool.release();
-    expect(pool.active).toBe(0);
-  });
-
-  it("active never exceeds maxConcurrent", async () => {
-    const pool = new DefaultConcurrencyPool(2);
-    const acquires: Array<Promise<void>> = [];
-    let peak = 0;
-    for (let i = 0; i < 6; i++) {
-      acquires.push(pool.acquire(0).then(() => {
-        peak = Math.max(peak, pool.active);
-      }));
-    }
-    // Drain: release one at a time so we can observe peak
-    for (let i = 0; i < 6; i++) {
-      pool.release();
-      await new Promise((r) => setTimeout(r, 2));
-    }
-    await Promise.allSettled(acquires);
-    expect(peak).toBeLessThanOrEqual(2);
-  });
-
-  it("clamps maxConcurrent=0 to 1 (no deadlock, C3 fix)", async () => {
-    const pool = new DefaultConcurrencyPool(0);
-    // 不会死锁——clamp 到 1，acquire 立即返回
-    await pool.acquire(0);
-    expect(pool.active).toBe(1);
-    pool.release();
-    expect(pool.active).toBe(0);
-  });
-
-  it("clamps negative maxConcurrent to 1", async () => {
-    const pool = new DefaultConcurrencyPool(-5);
-    await pool.acquire(0);
-    expect(pool.active).toBe(1);
-  });
-
-  it("priority 0 (sync) preempts priority 1000 (background)", async () => {
-    const pool = new DefaultConcurrencyPool(1);
-    await pool.acquire(1000); // background 占满
-
-    let bgAcquired = false;
-    let syncAcquired = false;
-    const bg = pool.acquire(1000).then(() => { bgAcquired = true; });
-    const sync = pool.acquire(0).then(() => { syncAcquired = true; });
-
-    await new Promise((r) => setTimeout(r, 5));
-    pool.release();
-    await Promise.race([bg, sync, new Promise((r) => setTimeout(r, 20))]);
-
-    expect(syncAcquired).toBe(true);
-    expect(bgAcquired).toBe(false);
-    pool.release();
-  });
-
-  // ============================================================
-  // 分层配额：effectiveMaxConcurrent 参数控制放行上限 (T-A1~T-A4)
-  // ============================================================
-  //
-  // [背景] T2 Wave 0 给 acquire 增加可选 effectiveMaxConcurrent 参数，让调用方
-  // 传 max(1, maxConcurrent - depth) 实现分层配额（嵌套越深有效并发越小）。
-  // 该参数覆盖实例级 maxConcurrent 的本次调用上限，不改实例状态。
-  // 这组测试锁定该参数的语义。
-
-  describe("分层配额 effectiveMaxConcurrent (T-A1~T-A4)", () => {
-    it("T-A1: effectiveMaxConcurrent 限制本次调用放行数（小于实例级 maxConcurrent）", async () => {
-      // 实例配额 5，但本次调用 effective=2 → 第 3 个应阻塞
-      const pool = new DefaultConcurrencyPool(5);
-      await pool.acquire(0, 2);
-      await pool.acquire(0, 2);
-      expect(pool.active).toBe(2);
-
-      let thirdAcquired = false;
-      const third = pool.acquire(0, 2).then(() => { thirdAcquired = true; });
-      await new Promise((r) => setTimeout(r, 5));
-
-      expect(thirdAcquired).toBe(false);
-      expect(pool.active).toBe(2);
-
-      pool.release();
-      await third;
-      expect(thirdAcquired).toBe(true);
-      pool.release();
-      pool.release();
-    });
-
-    it("T-A2: 同一 pool 实例不同 effectiveMaxConcurrent 控制不同调用放行数", async () => {
-      // 同一 pool（实例级 maxConcurrent=5）
-      const pool = new DefaultConcurrencyPool(5);
-      // 前 3 个用 effective=3，全放行（active 0→1→2→3，每次 < 3）
-      await pool.acquire(0, 3);
-      await pool.acquire(0, 3);
-      await pool.acquire(0, 3);
-      expect(pool.active).toBe(3);
-
-      // 第 4 个用 effective=3 → 阻塞（active 3 >= 3）
-      let blockedAcquired = false;
-      const blocked = pool.acquire(0, 3).then(() => { blockedAcquired = true; });
-      await new Promise((r) => setTimeout(r, 5));
-      expect(blockedAcquired).toBe(false);
-
-      // 换 effective=5 放行（active 3 < 5）
-      let wideAcquired = false;
-      const wide = pool.acquire(0, 5).then(() => { wideAcquired = true; });
-      await new Promise((r) => setTimeout(r, 5));
-      expect(wideAcquired).toBe(true);
-      expect(pool.active).toBe(4);
-
-      // wide release 后 blocked 仍等（active 3 >= 3 不变直到再 release）
-      pool.release(); // wide 释放
-      await new Promise((r) => setTimeout(r, 5));
-      expect(blockedAcquired).toBe(true);
-
-      // 清理
-      pool.release();
-      pool.release();
-      pool.release();
-      pool.release();
-      await Promise.allSettled([blocked, wide]);
-    });
-
-    it("T-A3: effectiveMaxConcurrent=1 只放行 1 个（保底）", async () => {
-      const pool = new DefaultConcurrencyPool(5);
-      await pool.acquire(0, 1);
-      expect(pool.active).toBe(1);
-
-      let secondAcquired = false;
-      const second = pool.acquire(0, 1).then(() => { secondAcquired = true; });
-      await new Promise((r) => setTimeout(r, 5));
-      expect(secondAcquired).toBe(false);
-      expect(pool.active).toBe(1);
-
-      pool.release();
-      await second;
-      expect(secondAcquired).toBe(true);
-      pool.release();
-    });
-
-    it("T-A4: maxConcurrent readonly 属性可读且等于构造值", () => {
-      const pool = new DefaultConcurrencyPool(4);
-      expect(pool.maxConcurrent).toBe(4);
-
-      // clamp 路径也通过该属性暴露
-      const clamped = new DefaultConcurrencyPool(0);
-      expect(clamped.maxConcurrent).toBe(1);
-
-      const negative = new DefaultConcurrencyPool(-3);
-      expect(negative.maxConcurrent).toBe(1);
-    });
-  });
-
-  // ============================================================
-  // H2: acquire 支持 AbortSignal — abort 时排队条目 reject
-  // ============================================================
-  describe("H2 abort support for acquire", () => {
-    it("abort signal rejects queued acquire with AbortError", async () => {
-      const pool = new DefaultConcurrencyPool(1);
-      await pool.acquire(0); // 占满
-
-      const controller = new AbortController();
-      const queued = pool.acquire(0, undefined, controller.signal);
-
-      await new Promise((r) => setTimeout(r, 5));
-      expect(pool.active).toBe(1); // 仍在排队
-
-      controller.abort();
-
-      await expect(queued).rejects.toThrow("aborted");
-    });
-
-    it("non-aborted acquire still resolves normally after release", async () => {
-      const pool = new DefaultConcurrencyPool(1);
-      await pool.acquire(0); // 占满
-
-      const controller = new AbortController();
-      const queued = pool.acquire(0, undefined, controller.signal);
-
-      pool.release(); // 释放 → queued 应被 resolve
-      await queued;   // 不应 reject
-      expect(pool.active).toBe(1);
-      pool.release();
-    });
-  });
-});

package/src/execution/__tests__/config.test.ts

@@ -1,110 +0,0 @@
-// src/__tests__/config.test.ts
-//
-// loadGlobalConfig 测试。
-// 配置已退化为仅 maxConcurrent（模型解析改为「主 agent model 优先」，
-// 不再有 categories/fallback/yolo/session 级覆盖）。
-
-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 { getGlobalConfigPath, loadGlobalConfig } from "../config.ts";
-
-let tmpDir: string;
-
-beforeEach(() => {
-  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "subagents-config-test-"));
-});
-
-afterEach(() => {
-  fs.rmSync(tmpDir, { recursive: true, force: true });
-});
-
-/** 写入 config.json（自动创建 subagents/ 子目录）。 */
-function writeConfig(agentDir: string, content: string): void {
-  const configPath = getGlobalConfigPath(agentDir);
-  fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  fs.writeFileSync(configPath, content, "utf-8");
-}
-
-// ============================================================
-// loadGlobalConfig
-// ============================================================
-
-describe("loadGlobalConfig", () => {
-  it("returns default config when file does not exist", () => {
-    const cfg = loadGlobalConfig(tmpDir);
-    expect(cfg.version).toBe(1);
-    expect(cfg.maxConcurrent).toBe(6);
-  });
-
-  it("returns default config when JSON is corrupt", () => {
-    writeConfig(tmpDir, "{not valid json");
-    const cfg = loadGlobalConfig(tmpDir);
-    expect(cfg.version).toBe(1);
-    expect(cfg.maxConcurrent).toBe(6);
-  });
-
-  it("deep-merges with defaults: missing fields fall back to defaults", () => {
-    writeConfig(tmpDir, JSON.stringify({ version: 1 }));
-    const cfg = loadGlobalConfig(tmpDir);
-    expect(cfg.version).toBe(1);
-    expect(cfg.maxConcurrent).toBe(6);
-  });
-
-  it("loads valid config with maxConcurrent override", () => {
-    writeConfig(tmpDir, JSON.stringify({ version: 1, maxConcurrent: 8 }));
-    const cfg = loadGlobalConfig(tmpDir);
-    expect(cfg.maxConcurrent).toBe(8);
-  });
-
-  it("ignores legacy categories/fallback/yoloByDefault fields (model resolution deprecated)", () => {
-    // 旧 config.json 仍可能含这些字段——读取时不报错，但 SubagentsGlobalConfig
-    // 类型上已不含它们，loadGlobalConfig 只取 version + maxConcurrent。
-    writeConfig(
-      tmpDir,
-      JSON.stringify({
-        version: 1,
-        maxConcurrent: 6,
-        yoloByDefault: true,
-        categories: { coding: { label: "C", model: "x/y" } },
-        fallback: { model: "anthropic/x" },
-      }),
-    );
-    const cfg = loadGlobalConfig(tmpDir);
-    expect(cfg.maxConcurrent).toBe(6);
-    expect(cfg.version).toBe(1);
-    // 仅两个字段（类型保证）
-    expect(Object.keys(cfg).sort()).toEqual(["maxConcurrent", "version"]);
-  });
-});
-
-// ============================================================
-// sanitizeMaxConcurrent（经 loadGlobalConfig 间接覆盖）
-// ============================================================
-
-describe("sanitizeMaxConcurrent (via loadGlobalConfig)", () => {
-  it("rejects non-number maxConcurrent → default", () => {
-    writeConfig(tmpDir, JSON.stringify({ maxConcurrent: "eight" }));
-    expect(loadGlobalConfig(tmpDir).maxConcurrent).toBe(6);
-  });
-
-  it("rejects non-integer maxConcurrent → default", () => {
-    writeConfig(tmpDir, JSON.stringify({ maxConcurrent: 4.5 }));
-    expect(loadGlobalConfig(tmpDir).maxConcurrent).toBe(6);
-  });
-
-  it("rejects zero/negative maxConcurrent → default", () => {
-    writeConfig(tmpDir, JSON.stringify({ maxConcurrent: 0 }));
-    expect(loadGlobalConfig(tmpDir).maxConcurrent).toBe(6);
-    writeConfig(tmpDir, JSON.stringify({ maxConcurrent: -1 }));
-    expect(loadGlobalConfig(tmpDir).maxConcurrent).toBe(6);
-  });
-
-  it("accepts positive integer", () => {
-    writeConfig(tmpDir, JSON.stringify({ maxConcurrent: 16 }));
-    expect(loadGlobalConfig(tmpDir).maxConcurrent).toBe(16);
-  });
-});