@zhushanwen/subagent-core 0.2.0

package/src/execution/__tests__/chatmode-first-round-closure-spawn.test.ts

@@ -0,0 +1,190 @@
+// src/execution/__tests__/chatmode-first-round-closure-spawn.test.ts
+//
+// [V2 决策 2] chatMode 首轮闭环——runSpawn resolve 时机（Step 4a 改动 1）。
+//
+// 改动 1：chatMode agent_settled 时提前 resolve runSpawn 的 exitCode promise（exit code 0），
+// 让 runAndFinalize 拿到首轮 result，进程仍保活（idle timer armed）。非 chatMode 不变
+//（agent_end kill → close resolve）。
+//
+// 本文件验证 resolve 时机（run-spawn-chatmode-settled.test.ts 验证 idle timer + 回调挂载点，
+// 收尾靠 emit close 让 resolve——隐含 agent_settled 不 resolve；本文件显式断言 agent_settled
+// 即 resolve，且进程未 close）。
+//
+// 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 { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+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(() => []),
+    promises: actual.promises,
+  };
+});
+
+vi.mock("../alive-store.ts", () => ({ writeAliveMarker: vi.fn() }));
+
+// chatMode agent_end 早返回（continue），不读 session-pending；统一 count=0 防干扰。
+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 { runSpawn } from "../session-runner.ts";
+import type { SessionRunnerContext } from "../session-runner.ts";
+import { _resetLifecycleState } from "../lifecycle-manager.ts";
+import { createRecord } from "../execution-record.ts";
+import type { ExecutionRecord } from "../types.ts";
+import {
+  emitStdoutLine,
+  type FakeChild,
+  lastSpawnedChild as lastSpawnedChildOf,
+  makeCtx,
+  makeOpts,
+  makeRecord,
+  sessionHeader,
+  waitForSpawn as waitForSpawnOf,
+} from "./helpers/spawn-mock.ts";
+
+const mockSpawn = vi.mocked(spawn);
+
+const lastSpawnedChild = (): FakeChild => lastSpawnedChildOf(mockSpawn);
+const waitForSpawn = (timeoutMs = 1000): Promise<void> => waitForSpawnOf(mockSpawn, timeoutMs);
+
+/** 构造 chatMode record（spawn-mock.makeRecord 默认非 chatMode，此处显式开启）。 */
+function makeChatModeRecord(id = "sa-chat"): ExecutionRecord {
+  return createRecord(id, {
+    agent: "general-purpose",
+    model: "test-model",
+    mode: "sync",
+    task: "chat task",
+    slug: "chat",
+    startedAt: 1_000_000,
+    rootSessionId: "root-session",
+    parentRecordId: undefined,
+    depth: 0,
+    chatMode: true,
+  });
+}
+
+/** 用 race 探测 promise 是否在指定时间内 settle（resolve 或 reject）。 */
+async function settlesWithin(p: Promise<unknown>, ms: number): Promise<boolean> {
+  return Promise.race([
+    p.then(
+      () => true,
+      () => true,
+    ),
+    new Promise<boolean>((r) => setTimeout(() => r(false), ms)),
+  ]);
+}
+
+describe("[V2 决策 2] chatMode 首轮闭环：runSpawn resolve 时机（改动 1）", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    _resetLifecycleState();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+    _resetLifecycleState();
+  });
+
+  it("chatMode agent_settled → runSpawn 提前 resolve（不等 close），进程仍保活", async () => {
+    const record = makeChatModeRecord("sa-first-resolve");
+    const promise = runSpawn(record, "Task: first-round", makeOpts(), makeCtx());
+
+    await waitForSpawn();
+    const child = lastSpawnedChild();
+
+    emitStdoutLine(child, sessionHeader());
+    emitStdoutLine(child, { type: "agent_end", willRetry: false });
+    // 让 stdout flush 处理 agent_end（chatMode 分支 continue，不 kill）
+    await new Promise((r) => setTimeout(r, 10));
+    emitStdoutLine(child, { type: "agent_settled" });
+
+    // [改动 1 核心] agent_settled 后 runSpawn 立即 resolve（resolveRun(0)），不等 close。
+    // 若改动 1 未生效，promise 会 hang 等 close，settlesWithin 返回 false。
+    expect(await settlesWithin(promise, 500)).toBe(true);
+    const result = await promise;
+    expect(result.success).toBe(true);
+    expect(result.sessionId).toBe("sess-abc");
+
+    // 进程仍保活：agent_settled 只 resolve promise，未 kill、未 emit close。
+    // idle timer（5min 真实 setTimeout）armed 但未到期。
+    expect(child.killed).toBe(false);
+
+    // 收尾：手动 close（模拟后续 idle timer 超时 kill / 外部终止）。
+    // close handler 的 cleanup 仍执行（resolve(code) 是 no-op，Promise 已 resolve）。
+    child.stdout.end();
+    child.stderr.end();
+    child.emit("close", 0);
+  });
+
+  it("非 chatMode runSpawn 仍在 close resolve（agent_settled 不触发 resolve）", async () => {
+    // makeRecord 默认非 chatMode
+    const record = makeRecord("sa-nonchat-resolve");
+    const promise = runSpawn(record, "Task: nonchat", makeOpts(), makeCtx());
+
+    await waitForSpawn();
+    const child = lastSpawnedChild();
+
+    emitStdoutLine(child, sessionHeader());
+    emitStdoutLine(child, { type: "agent_end", willRetry: false });
+    // 非 chatMode agent_end → count=0 → SIGTERM kill
+    await new Promise((r) => setTimeout(r, 10));
+    expect(child.killed).toBe(true);
+
+    // agent_settled 在非 chatMode 下被忽略（handler 直接 return，不调 resolveRun）
+    emitStdoutLine(child, { type: "agent_settled" });
+    await new Promise((r) => setTimeout(r, 20));
+
+    // [回归防护] agent_settled 不 resolve 非 chatMode runSpawn——promise 仍 pending（等 close）。
+    expect(await settlesWithin(promise, 200)).toBe(false);
+
+    // emit close 才 resolve（现有行为，改动 1 不影响非 chatMode）
+    child.stdout.end();
+    child.stderr.end();
+    child.emit("close", 143);
+    const result = await promise;
+    expect(result.success).toBe(true); // 信号终止（143 ≥ threshold）视为正常完成
+  });
+});

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

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