@zhushanwen/pi-subagent-workflow 8.6.0 → 8.8.0

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

@@ -1,267 +0,0 @@
-// 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(), info: vi.fn() },
-}));
-vi.mock("@zhushanwen/pi-extension-logger", () => ({ 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

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