@zhushanwen/subagent-core 0.2.0

package/src/execution/__tests__/run-and-finalize-chatmode.test.ts

@@ -0,0 +1,267 @@
+// src/execution/__tests__/run-and-finalize-chatmode.test.ts
+//
+// runAndFinalize 的 chatMode idle 分流测试（M2-A）。
+//
+// mock session-runner.runSpawn（受控返回 success/failed result），走 SubagentService
+// 真实的 runAndFinalize 分流逻辑，验证：
+//   - chatMode + done   → doFinalizeRoundToIdle：record.status=idle、留内存、round+1
+//   - chatMode + failed → MF-6：回退 idle（可恢复），不销毁（agent 可重试 message 或 close）
+//   - 非 chatMode + done → doFinalizeRecord：record.status=done、archived（现有行为不变）
+//
+// 分流效果通过「最终可观察状态」验证（record.status + store.getMutable 是否在内存），
+// 不依赖 spy 私有方法调用，更稳健。
+
+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（doFinalizeRecord 的 manifest 写入降级路径用 logger.error）
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
+
+// mock session-runner：runSpawn 受控返回 result，killAllSpawnedChildren 空实现。
+// 注意：必须在 import SubagentService 之前 mock（vi.mock 提升到顶部）。
+vi.mock("../session-runner.ts", () => ({
+  runSpawn: vi.fn(),
+  killAllSpawnedChildren: vi.fn(),
+}));
+
+import { runSpawn } from "../session-runner.ts";
+import type { SessionRunnerContext } from "../session-runner.ts";
+import { createRecord } from "../execution-record.ts";
+import { ModelConfigService } from "../model-config-service.ts";
+import type { ModelInfo } from "../model-resolver.ts";
+import { RecordStore, type StatusFilter } from "../record-store.ts";
+import { SubagentService } from "../subagent-service.ts";
+import type { PiLike } from "../subagent-service.ts";
+import type {
+  AgentResult,
+  ExecutionRecord,
+  ExecuteOptions,
+} from "../types.ts";
+
+const mockRunSpawn = vi.mocked(runSpawn);
+
+// ── 最小合法 ModelInfo（resolveModel 未注入 registry 会抛错，故 stub；runSpawn 被 mock 不消费）──
+const STUB_MODEL: ModelInfo = {
+  id: "test-model",
+  name: "Test",
+  provider: "test",
+  reasoning: false,
+};
+
+function makeTmpAgentDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "chatmode-test-"));
+}
+
+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() };
+}
+
+function makeResult(success: boolean): AgentResult {
+  return {
+    text: success ? "done" : "err",
+    turns: 1,
+    durationMs: 100,
+    success,
+    error: success ? undefined : "boom",
+    sessionId: "sess-1",
+    toolCalls: [],
+  };
+}
+
+function makeRecord(chatMode: boolean, id = "sa-test"): ExecutionRecord {
+  return createRecord(id, {
+    agent: "general-purpose",
+    model: "test-model",
+    mode: "background",
+    task: "do something",
+    slug: "test",
+    startedAt: 1000,
+    rootSessionId: "root-session",
+    chatMode,
+  });
+}
+
+/** 暴露 runAndFinalize + store 的私有访问接口（测试专用 cast）。 */
+interface ServiceInternals {
+  store: RecordStore;
+  runAndFinalize: (
+    record: ExecutionRecord,
+    opts: ExecuteOptions,
+    ctx: SessionRunnerContext,
+    identity: {
+      agent: string;
+      agentConfig: unknown;
+      resolved: { model: ModelInfo; thinkingLevel: string | undefined };
+    },
+    signal: undefined,
+    priority: number,
+  ) => Promise<AgentResult>;
+}
+
+describe("runAndFinalize chatMode idle 分流 (M2-A)", () => {
+  let agentDir: string;
+  let modelService: ModelConfigService;
+  let service: SubagentService;
+  let internals: ServiceInternals;
+
+  beforeEach(() => {
+    agentDir = makeTmpAgentDir();
+    modelService = new ModelConfigService({ agentDir });
+    service = new SubagentService({ cwd: agentDir, modelService });
+    service.initSession({ pi: makePi(), sessionId: "root-session" });
+    internals = service as unknown as ServiceInternals;
+    mockRunSpawn.mockReset();
+  });
+
+  afterEach(() => {
+    service.dispose();
+    fs.rmSync(agentDir, { recursive: true, force: true });
+  });
+
+  /** 直接调私有 runAndFinalize（mock runSpawn 后走完整分流逻辑）。 */
+  async function callRunAndFinalize(record: ExecutionRecord, success: boolean): Promise<void> {
+    mockRunSpawn.mockResolvedValueOnce(makeResult(success));
+    const opts: ExecuteOptions = { task: "do something", slug: "test" };
+    const ctx: SessionRunnerContext = {
+      cwd: agentDir,
+      agentDir,
+      skillDirs: [],
+      mainCwd: agentDir,
+    };
+    const identity = {
+      agent: "general-purpose",
+      agentConfig: undefined,
+      resolved: { model: STUB_MODEL, thinkingLevel: undefined },
+    };
+    await internals.runAndFinalize(record, opts, ctx, identity, undefined, 0);
+  }
+
+  it("chatMode + done → record running（旧 idle 折入），留内存，round 0→1", async () => {
+    const record = makeRecord(true);
+    internals.store.register(record);
+    await callRunAndFinalize(record, true);
+
+    expect(record.status).toBe("running");
+    expect(record.round).toBe(1);
+    // record 留内存（未 archive）——idle 分流核心断言（v4 B-1：idle 折入 running）
+    expect(internals.store.getMutable(record.id)).toBe(record);
+  });
+
+  it("chatMode + failed → MF-6：回退 running（可恢复），不销毁对话（agent 可重试 message 或 close）", async () => {
+    const record = makeRecord(true);
+    internals.store.register(record);
+    await callRunAndFinalize(record, false);
+
+    // MF-6：chatMode 失败不终态销毁——record 回退 running（留内存），agent 可重试 message 或 close。
+    expect(record.status).toBe("running");
+    expect(internals.store.getMutable(record.id)).toBe(record); // 留内存（未 archive）
+    // record.result 被 finalizeRoundToIdle 设值（MF-2：否则 notifier idle 恒 (empty)）。
+    // makeResult(false) 返回 text:"err" + error:"boom"；text 非空 → record.result="err"。
+    expect(record.result).toBeTruthy();
+  });
+
+  it("非 chatMode + done → record running（SP-5: 一次性完成后保持活跃，等待 message 触发升级）", async () => {
+    const record = makeRecord(false);
+    internals.store.register(record);
+    await callRunAndFinalize(record, true);
+
+    // SP-5: one-shot 完成后 record 保持 running（旧 idle，非终态归档），用户可通过 message 续聊。
+    expect(record.status).toBe("running");
+    expect(internals.store.getMutable(record.id)).toBe(record); // 留内存
+  });
+
+  it("chatMode 第二轮 done → round 累加（1→2，续聊场景）", async () => {
+    // 模拟 resume 续聊：第一轮已完成（round=1，旧 idle 折入 running），第二轮 runAndFinalize 再次 done
+    const record = makeRecord(true);
+    record.status = "running"; // 第一轮已完成（v4 B-1：旧 idle 折入 running）
+    record.round = 1;
+    internals.store.register(record);
+    await callRunAndFinalize(record, true);
+
+    // 续聊第二轮 done：tryTransition(running→closed) 成功 → chatMode 分流 → finalizeRoundToIdle
+    // → status 回到 running、round 1→2（record 保持活跃，等待下一轮续聊）。
+    expect(record.status).toBe("running");
+    expect(record.round).toBe(2);
+    expect(mockRunSpawn).toHaveBeenCalled();
+  });
+
+  it("chatMode + done + closeAfterRound=true → finalizeRecord(done)（不进 idle，M2-B3）", async () => {
+    // close 优雅关闭（force:false）：running 时置 closeAfterRound=true，
+    // runAndFinalize done 分流终态化为 done（而非进 idle）。
+    const record = makeRecord(true);
+    record.status = "running";
+    record.closeAfterRound = true;
+    internals.store.register(record);
+    await callRunAndFinalize(record, true);
+
+    expect(record.status).toBe("closed");
+    expect(record.closeAfterRound).toBeUndefined(); // 清标志
+    // 终态化 → archive → 内存无（与 idle 分流「留内存」对比）
+    expect(internals.store.getMutable(record.id)).toBeUndefined();
+  });
+
+  it("chatMode + done + 无 closeAfterRound → 进 running（旧 idle 折入，M2-A 行为不变）", async () => {
+    const record = makeRecord(true);
+    record.status = "running";
+    internals.store.register(record);
+    await callRunAndFinalize(record, true);
+
+    expect(record.status).toBe("running");
+    expect(record.round).toBe(1);
+    expect(internals.store.getMutable(record.id)).toBe(record);
+  });
+
+  it("[M5] 非 chatMode（one-shot）+ done + closeAfterRound=true → 轮完成时消费标志终态化（不进 running-resumable）", async () => {
+    // one-shot busy 时 close(force:false) 置 closeAfterRound——旧代码非 chatMode 成功分支走
+    // finalizeRoundToIdle 不消费，tool 返回 {closed:true} 谎报：record 永久 running-resumable、
+    // 5min idle timer 杀进程、期间还能继续收 message。修复后在本分支消费终态化。
+    const record = makeRecord(false);
+    record.status = "running";
+    record.closeAfterRound = true;
+    internals.store.register(record);
+    await callRunAndFinalize(record, true);
+
+    expect(record.status).toBe("closed");
+    expect(record.closedReason).toBe("user-close");
+    expect(record.closeAfterRound).toBeUndefined(); // 标志已消费
+    expect(internals.store.getMutable(record.id)).toBeUndefined(); // archived
+  });
+
+  it("[M5] chatMode + failed + closeAfterRound=true → 轮完成时消费标志终态化（不回退 resumable）", async () => {
+    // 失败轮也视为「轮已完成」：close 意图兑现终态化（closedReason=gc），否则标志残留、
+    // record 被 tool 谎报 closed 后仍可继续收 message。
+    const record = makeRecord(true);
+    record.status = "running";
+    record.closeAfterRound = true;
+    internals.store.register(record);
+    await callRunAndFinalize(record, false); // 失败轮
+
+    expect(record.status).toBe("closed");
+    expect(record.closedReason).toBe("gc"); // !success → gc
+    expect(record.closeAfterRound).toBeUndefined();
+    expect(internals.store.getMutable(record.id)).toBeUndefined();
+  });
+
+  it("[S10] chatMode + failed（无 closeAfterRound）→ 回退 running 后 closedReason 不残留", async () => {
+    // tryTransition 先设 closed+gc，finalizeRoundToIdle 回退 running——旧代码 closedReason="gc"
+    // 残留在 running record 上（泄漏进 notify 载荷与 list 投影）。
+    const record = makeRecord(true);
+    record.status = "running";
+    internals.store.register(record);
+    await callRunAndFinalize(record, false);
+
+    expect(record.status).toBe("running"); // MF-6 回退 resumable
+    expect(record.closedReason).toBeUndefined(); // [S10] 不残留
+    expect(internals.store.getMutable(record.id)).toBe(record);
+  });
+});

package/src/execution/__tests__/run-spawn-chatmode-settled.test.ts

@@ -0,0 +1,253 @@
+// src/execution/__tests__/run-spawn-chatmode-settled.test.ts
+//
+// [V2 模块 3] chatMode agent_settled 信号换挂单测（Step 3）。
+//
+// 验证 session-runner 的 V2 改动（5 处）：
+//   ① chatMode record agent_end 不触发 SIGTERM（进程保活，等 agent_settled）
+//   ② chatMode record agent_settled 触发 armIdleTimer（fake timer + 超时后 kill）
+//   ③ chatMode agent_settled 调 ctx.onRoundSettled（挂载点，mock 断言被调）
+//   ④ 非 chatMode agent_settled 不 armIdleTimer、不调 onRoundSettled
+//
+// mock 结构与 run-spawn-edges.test.ts 一致（FakeChild + session-pending 受控 count=0）。
+// lifecycle-manager 用真实模块（hasIdleTimer / _resetLifecycleState 可观测 + 隔离）。
+
+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 测试不依赖后代判定（chatMode agent_end 早返回跳过 readActivePending），统一 count=0。
+// 非 chatMode 用例 ④ 的 agent_end 走正常 kill 分支（count=0 → SIGTERM）。
+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 {
+  DEFAULT_IDLE_TIMEOUT_MS,
+  hasIdleTimer,
+  _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,
+  });
+}
+
+describe("[V2 模块 3] chatMode agent_settled 信号换挂", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // lifecycle-manager 是模块级单例（idleTimers Map 跨用例共享），每用例前清空防泄漏。
+    _resetLifecycleState();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+    _resetLifecycleState();
+  });
+
+  it("① chatMode agent_end → 不触发 SIGTERM（进程保活，等 agent_settled）", async () => {
+    const record = makeChatModeRecord("sa-chat-end");
+    const promise = runSpawn(record, "Task: chatmode-end", makeOpts(), makeCtx());
+
+    await waitForSpawn();
+    const child = lastSpawnedChild();
+
+    emitStdoutLine(child, sessionHeader());
+    emitStdoutLine(child, { type: "agent_end", willRetry: false });
+    // 让事件 pump 处理 agent_end（stream flush 异步）
+    await new Promise((r) => setTimeout(r, 20));
+
+    // [V2 决策 1] chatMode agent_end 不 kill——进程不因轮次死，等 agent_settled。
+    expect(child.killed).toBe(false);
+    // agent_end 不 arm idle timer（arm 点是 agent_settled，不是 agent_end）
+    expect(hasIdleTimer(record.id)).toBe(false);
+
+    // 收尾：手动 close 让 runSpawn resolve（模拟后续 idle timer 超时 kill / 外部终止）
+    child.stdout.end();
+    child.stderr.end();
+    child.emit("close", 143);
+    const result = await promise;
+    expect(result.success).toBe(true);
+  });
+
+  it("② chatMode agent_settled → armIdleTimer，idle 超时后 SIGTERM kill", async () => {
+    const record = makeChatModeRecord("sa-chat-settled");
+    const promise = runSpawn(record, "Task: chatmode-settled", makeOpts(), makeCtx());
+
+    await waitForSpawn();
+    const child = lastSpawnedChild();
+
+    // 必须在 emit agent_settled 前启用 fake timers——armIdleTimer 内 setTimeout 在 agent_settled
+    // 处理器里新建，新建时已是 fake timer 才可 advance。不 fake setImmediate：stream flush 靠
+    // 真实事件循环。对齐 run-spawn-edges MF-3/MF-4 模式。
+    vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "Date"] });
+    try {
+      emitStdoutLine(child, sessionHeader());
+      emitStdoutLine(child, { type: "agent_end", willRetry: false });
+      await new Promise((r) => setImmediate(r));
+      emitStdoutLine(child, { type: "agent_settled" });
+      await new Promise((r) => setImmediate(r));
+
+      // agent_settled → arm idle timer（DEFAULT_IDLE_TIMEOUT_MS = 5min）
+      expect(hasIdleTimer(record.id)).toBe(true);
+      // 进程仍存活（idle timer 未到期）
+      expect(child.killed).toBe(false);
+
+      // 未到 idle timeout（5min - 1ms）：不 kill
+      await vi.advanceTimersByTimeAsync(DEFAULT_IDLE_TIMEOUT_MS - 1);
+      expect(child.killed).toBe(false);
+
+      // idle timeout 到期：onTimeout → child.kill("SIGTERM")（复用现有 kill 路径）
+      await vi.advanceTimersByTimeAsync(1);
+      expect(child.killed).toBe(true);
+      expect(child.killSignal).toBe("SIGTERM");
+      // timer 触发后从 Map 移除（armIdleTimer 内 setTimeout 回调 idleTimers.delete）
+      expect(hasIdleTimer(record.id)).toBe(false);
+    } finally {
+      vi.useRealTimers();
+    }
+
+    // 收尾：close 让 runSpawn resolve
+    child.stdout.end();
+    child.stderr.end();
+    child.emit("close", 143);
+    const result = await promise;
+    expect(result.success).toBe(true);
+  });
+
+  it("③ chatMode agent_settled → 调 ctx.onRoundSettled（Step 3 挂载点，回调被调 1 次）", async () => {
+    const record = makeChatModeRecord("sa-chat-cb");
+    const onRoundSettled = vi.fn();
+    const ctx: SessionRunnerContext = makeCtx({ onRoundSettled });
+    const promise = runSpawn(record, "Task: chatmode-cb", makeOpts(), ctx);
+
+    await waitForSpawn();
+    const child = lastSpawnedChild();
+
+    emitStdoutLine(child, sessionHeader());
+    emitStdoutLine(child, { type: "agent_end", willRetry: false });
+    await new Promise((r) => setTimeout(r, 10));
+    emitStdoutLine(child, { type: "agent_settled" });
+    await new Promise((r) => setTimeout(r, 10));
+
+    // agent_settled → onRoundSettled 被调，入参是当前 record
+    expect(onRoundSettled).toHaveBeenCalledTimes(1);
+    expect(onRoundSettled).toHaveBeenCalledWith(record);
+
+    // 收尾：手动 close（idle timer 仍 armed，由 afterEach _resetLifecycleState 清理）
+    child.stdout.end();
+    child.stderr.end();
+    child.emit("close", 143);
+    const result = await promise;
+    expect(result.success).toBe(true);
+  });
+
+  it("④ 非 chatMode agent_settled → 不 armIdleTimer、不调 onRoundSettled", async () => {
+    // makeRecord 默认非 chatMode（createRecord 未传 chatMode）
+    const record = makeRecord("sa-nonchat-settled");
+    const onRoundSettled = vi.fn();
+    const ctx: SessionRunnerContext = makeCtx({ onRoundSettled });
+    const promise = runSpawn(record, "Task: nonchat-settled", makeOpts(), ctx);
+
+    await waitForSpawn();
+    const child = lastSpawnedChild();
+
+    emitStdoutLine(child, sessionHeader());
+    // 直接 emit agent_settled（非 chatMode：handler 应忽略，不 arm、不调回调）
+    emitStdoutLine(child, { type: "agent_settled" });
+    await new Promise((r) => setTimeout(r, 20));
+
+    expect(hasIdleTimer(record.id)).toBe(false);
+    expect(onRoundSettled).not.toHaveBeenCalled();
+
+    // 收尾：emit agent_end 走正常 kill 分支（count=0 → SIGTERM）→ close resolve
+    emitStdoutLine(child, { type: "agent_end", willRetry: false });
+    await new Promise((r) => setTimeout(r, 10));
+    expect(child.killed).toBe(true); // 非 chatMode agent_end → kill（现有行为，V2 不动）
+
+    child.stdout.end();
+    child.stderr.end();
+    child.emit("close", 143);
+    const result = await promise;
+    expect(result.success).toBe(true);
+  });
+});