@zhushanwen/subagent-core 0.6.0 → 0.7.0

package/src/execution/__tests__/spawn-event-adapter.test.ts

@@ -1,167 +0,0 @@
-// src/__tests__/spawn-event-adapter.test.ts
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-import { describe, expect, it } from "vitest";
-
-import {
-  deriveSessionFilePath,
-  findSessionFileByHeaderId,
-  parseSpawnLine,
-} from "../engine/engines/pi/spawn-event-adapter.ts";
-
-describe("parseSpawnLine", () => {
-  describe("空白行", () => {
-    it("空字符串返回 null", () => {
-      expect(parseSpawnLine("")).toBeNull();
-    });
-
-    it("纯空白返回 null", () => {
-      expect(parseSpawnLine("   ")).toBeNull();
-      expect(parseSpawnLine("\t\t")).toBeNull();
-    });
-  });
-
-  describe("header 行", () => {
-    it("type=session + id 识别为 header", () => {
-      const line = JSON.stringify({
-        type: "session",
-        id: "abc-123",
-        timestamp: "2026-07-03T12:00:00.000Z",
-        cwd: "/home/user/project",
-      });
-      const result = parseSpawnLine(line);
-      expect(result?.kind).toBe("header");
-      if (result?.kind === "header") {
-        expect(result.header.id).toBe("abc-123");
-        expect(result.header.cwd).toBe("/home/user/project");
-      }
-    });
-
-    it("header 含 parentSession + version", () => {
-      const line = JSON.stringify({
-        type: "session",
-        id: "child-456",
-        timestamp: "2026-07-03T12:00:00.000Z",
-        cwd: "/home/user/project",
-        parentSession: "parent-789",
-        version: 2,
-      });
-      const result = parseSpawnLine(line);
-      expect(result?.kind).toBe("header");
-      if (result?.kind === "header") {
-        expect(result.header.parentSession).toBe("parent-789");
-        expect(result.header.version).toBe(2);
-      }
-    });
-  });
-
-  describe("事件行", () => {
-    it("tool_execution_start 识别为 event", () => {
-      const line = JSON.stringify({
-        type: "tool_execution_start",
-        toolName: "bash",
-        toolCallId: "call-1",
-        args: { command: "ls" },
-      });
-      const result = parseSpawnLine(line);
-      expect(result?.kind).toBe("event");
-      if (result?.kind === "event") {
-        expect(result.event.type).toBe("tool_execution_start");
-        expect(result.event.toolName).toBe("bash");
-      }
-    });
-
-    it("message_end 识别为 event", () => {
-      const line = JSON.stringify({
-        type: "message_end",
-        message: {
-          role: "assistant",
-          usage: { input: 100, output: 50 },
-        },
-      });
-      const result = parseSpawnLine(line);
-      expect(result?.kind).toBe("event");
-      if (result?.kind === "event") {
-        expect(result.event.type).toBe("message_end");
-      }
-    });
-
-    it("turn_end 识别为 event", () => {
-      const result = parseSpawnLine(JSON.stringify({ type: "turn_end" }));
-      expect(result?.kind).toBe("event");
-    });
-
-    it("未知 type 仍识别为 event（schema 校验由调用方）", () => {
-      const result = parseSpawnLine(JSON.stringify({ type: "some_future_event" }));
-      expect(result?.kind).toBe("event");
-    });
-  });
-
-  describe("invalid 行", () => {
-    it("非 JSON 返回 invalid", () => {
-      const result = parseSpawnLine("not json at all");
-      expect(result?.kind).toBe("invalid");
-      if (result?.kind === "invalid") {
-        expect(result.raw).toBe("not json at all");
-        expect(result.error).toBeTruthy();
-      }
-    });
-
-    it("JSON 但无 type 字段返回 invalid", () => {
-      const result = parseSpawnLine(JSON.stringify({ foo: "bar" }));
-      expect(result?.kind).toBe("invalid");
-      if (result?.kind === "invalid") {
-        expect(result.error).toContain("type");
-      }
-    });
-
-    it("JSON 但 type 非 string 返回 invalid", () => {
-      const result = parseSpawnLine(JSON.stringify({ type: 123 }));
-      expect(result?.kind).toBe("invalid");
-    });
-
-    it("JSON null 返回 invalid", () => {
-      const result = parseSpawnLine("null");
-      expect(result?.kind).toBe("invalid");
-    });
-  });
-});
-
-describe("deriveSessionFilePath", () => {
-  it("拼接 sessionDir + fileTimestamp(冒号点转连字符) + id", () => {
-    const header = {
-      type: "session" as const,
-      id: "abc-123",
-      timestamp: "2026-07-03T12:00:00.000Z",
-      cwd: "/proj",
-    };
-    const path = deriveSessionFilePath(header, "/sessions/dir");
-    // fileTimestamp = timestamp.replace(/[:.]/g, "-") = "2026-07-03T12-00-00-000Z"
-    expect(path).toBe("/sessions/dir/2026-07-03T12-00-00-000Z_abc-123.jsonl");
-  });
-});
-
-describe("findSessionFileByHeaderId", () => {
-  it("sessionId 后缀匹配返回实际文件路径", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "spawn-adapter-test-"));
-    const expectedFile = path.join(tmpDir, "2026-07-03T12-00-00-000Z_sid-456.jsonl");
-    fs.writeFileSync(expectedFile, "{}");
-    const result = findSessionFileByHeaderId(tmpDir, "sid-456");
-    expect(result).toBe(expectedFile);
-    fs.rmSync(tmpDir, { recursive: true, maxRetries: 5, retryDelay: 20 });
-  });
-
-  it("无匹配返回 undefined", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "spawn-adapter-test-"));
-    const result = findSessionFileByHeaderId(tmpDir, "nonexistent");
-    expect(result).toBeUndefined();
-    fs.rmSync(tmpDir, { recursive: true, maxRetries: 5, retryDelay: 20 });
-  });
-
-  it("目录不存在返回 undefined（不抛错）", () => {
-    const result = findSessionFileByHeaderId("/nonexistent/path/xyz", "sid");
-    expect(result).toBeUndefined();
-  });
-});

package/src/execution/__tests__/spawn-worktree-guidance.test.ts

@@ -1,208 +0,0 @@
-// src/execution/__tests__/spawn-worktree-guidance.test.ts
-//
-// worktree 模式认知纠正提示注入测试。
-//
-// 背景：worktree checkout 放 os.tmpdir()（路径形似临时沙箱），子 agent 无 worktree 语义
-// 提示时误判 cwd 为"空隔离目录"，主动 cd 别处放弃隔离（wave-agent 事故 session 019ff64c）。
-// 修复在 runSpawn 的 appendParts 注入 WORKTREE_GUIDANCE_PROMPT。
-//
-// 验证：
-//   - worktree 模式（opts.worktree 传入）→ appendSystemPrompt content 含 WORKTREE_GUIDANCE_PROMPT
-//   - 非 worktree 模式 → content 不含 worktree 提示
-//
-// 测试策略：mock writePromptToTempFile 捕获拼接后的 appendParts content（vi.hoisted 防
-// vi.mock hoisting 引用未初始化变量），断言含/不含 worktree 提示标识。
-
-import type { PassThrough } from "node:stream";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-// 捕获 writePromptToTempFile 的 content 参数（appendParts.join("\n\n")）。
-// vi.hoisted 保证变量在 vi.mock factory hoisting 前已声明可用。
-const captured = vi.hoisted(() => ({ content: "" }));
-
-// ── mock modules（与 session-runner-schema-env.test.ts 同模式）──
-
-vi.mock("node:child_process", async () => {
-  const { EventEmitter } = await import("node:events");
-  const { PassThrough } = await import("node:stream");
-
-  class FakeChild extends EventEmitter {
-    pid = 12345;
-    stdout = new PassThrough();
-    stdin = new PassThrough(); // runSpawn 注册 stdin EPIPE handler（session-runner），FakeChild 必须提供
-    stderr = new PassThrough();
-    killed = false;
-    killSignal: string | undefined;
-    kill(sig?: string): boolean {
-      this.killed = true;
-      this.killSignal = sig;
-      return true;
-    }
-  }
-
-  return {
-    spawn: vi.fn(() => new FakeChild()),
-    execFileSync: vi.fn(() => ""),
-  };
-});
-
-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(),
-}));
-
-vi.mock("../engine/engines/pi/temp-prompt.ts", () => ({
-  writePromptToTempFile: vi.fn(async (agent: string, content: string) => {
-    captured.content = content;
-    const safeName = agent.replace(/[^\w.-]+/g, "_");
-    return { dir: `/tmp/fake-${safeName}`, filePath: `/tmp/fake-${safeName}/prompt.md` };
-  }),
-  cleanupTempPrompt: vi.fn(async () => {}),
-}));
-
-import { spawn } from "node:child_process";
-
-import { createRecord } from "../execution-record.ts";
-import { runSpawn, type RunOptions, type SessionRunnerContext } from "../engine/engines/pi/session-runner.ts";
-
-const mockSpawn = vi.mocked(spawn);
-
-interface FakeChild {
-  pid: number;
-  stdout: PassThrough;
-  stderr: PassThrough;
-  killed: boolean;
-  killSignal: string | undefined;
-  kill(sig?: string): boolean;
-  emit(event: string, ...args: unknown[]): boolean;
-}
-
-function getLastSpawnedChild(): FakeChild {
-  const result = mockSpawn.mock.results.at(-1);
-  if (!result) throw new Error("spawn was not called yet");
-  return result.value as FakeChild;
-}
-
-async function waitForSpawn(timeoutMs = 1000): Promise<void> {
-  const start = Date.now();
-  while (mockSpawn.mock.results.length === 0) {
-    if (Date.now() - start > timeoutMs) {
-      throw new Error(`spawn was not called within ${timeoutMs}ms`);
-    }
-    await new Promise((r) => setTimeout(r, 5));
-  }
-}
-
-function makeRecord() {
-  return createRecord("wt-guidance-1", {
-    agent: "general-purpose",
-    model: "test/model",
-    mode: "background",
-    task: "test task",
-    slug: "test",
-    startedAt: Date.now(),
-    rootSessionId: "s1",
-    parentRecordId: undefined,
-    depth: 0,
-  });
-}
-
-function makeRunOpts(overrides: Partial<RunOptions> = {}): RunOptions {
-  return {
-    resolved: { model: { provider: "test", id: "model", name: "Model", reasoning: false }, thinkingLevel: undefined },
-    agentConfig: undefined,
-    appendSystemPrompt: undefined,
-    skillPath: undefined,
-    schema: undefined,
-    maxTurns: undefined,
-    graceTurns: undefined,
-    signal: undefined,
-    onEvent: undefined,
-    ...overrides,
-  };
-}
-
-function makeCtx(overrides: Partial<SessionRunnerContext> = {}): SessionRunnerContext {
-  return {
-    cwd: "/fake/cwd",
-    agentDir: "/fake/agent",
-    skillDirs: [],
-    mainCwd: "/fake/cwd",
-    sessionRootId: "root-session-test",
-    rootCwd: "/fake/cwd",
-    ...overrides,
-  };
-}
-
-describe("worktree guidance prompt injection", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    captured.content = "";
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("worktree 模式 → appendSystemPrompt content 含 worktree 认知纠正提示", async () => {
-    const record = makeRecord();
-    const opts = makeRunOpts({
-      worktree: {
-        path: "/tmp/pi-subagents/--fake--/pi-sub-sa-wt-guidance-1",
-        branch: "pi-sub-sa-wt-guidance-1",
-        baseCommit: "abc123",
-        mainCwd: "/fake/cwd",
-      },
-    });
-    const ctx = makeCtx();
-
-    const resultPromise = runSpawn(record, "test task", opts, ctx);
-    await waitForSpawn();
-
-    // content 含 WORKTREE_GUIDANCE_PROMPT 的标题
-    expect(captured.content).toContain("Git Worktree");
-    // 含关键纠正信息：cwd 含完整项目代码（非临时沙箱）
-    expect(captured.content).toContain("complete project source code");
-    // 含防 cd 别处的行为指引
-    expect(captured.content).toContain("Do NOT");
-
-    const child = getLastSpawnedChild();
-    child.emit("close", 0);
-    await resultPromise;
-  });
-
-  it("非 worktree 模式 → content 不含 worktree 认知提示", async () => {
-    const record = makeRecord();
-    const opts = makeRunOpts(); // 不传 worktree
-    const ctx = makeCtx();
-
-    const resultPromise = runSpawn(record, "test task", opts, ctx);
-    await waitForSpawn();
-
-    expect(captured.content).not.toContain("Git Worktree");
-
-    const child = getLastSpawnedChild();
-    child.emit("close", 0);
-    await resultPromise;
-  });
-});

package/src/execution/__tests__/spawned-children.test.ts

@@ -1,236 +0,0 @@
-// src/execution/__tests__/spawned-children.test.ts
-//
-// spawnedChildren Map + getChildByRecord + killAllSpawnedChildren 单元测试（M2-B1）。
-//
-// M2-B1 把 spawnedChildren 从 Set<ChildProcess> 改为 Map<recordId, ChildProcess>，
-// 建立 record→child 映射（busy 投递定位活进程用，设计决策 6）。本文件测 Map API 核心行为：
-//   - getChildByRecord：set 后能查到；delete 后查不到；未注册返回 undefined
-//   - killAllSpawnedChildren：遍历 .values() kill + clear；单 child kill 抛错不阻断
-//   - [R1 D6③] killAllSpawnedChildren 编排扩容：先触发 engine registry dispose（触发不等待），
-//     后杀 per-record children——dispose 全部先于任何 kill（D6① 时序）
-//
-// [T2-⑤ / LC-2] 跳过条件变更（原「跳过 child.killed=true」契约已废止）：killed=发过
-// kill 请求 ≠ 已死，只有 exitCode/signalCode 非 null（已确认死亡）才跳过；killed 但
-// 未确认死亡的 child 补 SIGKILL 升级（SIGTERM 可能被无视）。新契约的完整行为矩阵见
-// kill-all-escalation.test.ts（runSpawn 集成面），本文件保留纯 Map 遍历面的正/反例。
-//
-// 直接操作模块级 spawnedChildren（afterEach clear 防泄漏），不依赖 runSpawn/spawn/fs。
-
-import type { ChildProcess } from "node:child_process";
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const { loggerMock } = vi.hoisted(() => ({
-  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-// mock core logger：session-runner 与 engine/registry 共用同一 facade 模块（两处
-// `../../core/logger.ts` 解析到同一文件），本 mock 对二者同时生效。
-vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
-
-import type { EnginePort } from "../engine/port.ts";
-import { clearEngines, getEngine, registerEngine } from "../engine/registry.ts";
-import { getChildByRecord, killAllSpawnedChildren, spawnedChildren } from "../engine/engines/pi/session-runner.ts";
-
-/**
- * 假 child：只关心 killed 标记 + kill 调用（killAllSpawnedChildren 遍历用）。
- * extra 可注入 exitCode/signalCode（模拟已确认死亡的形态）。
- */
-function makeFakeChild(
-  killed = false,
-  extra: Partial<Pick<ChildProcess, "exitCode" | "signalCode">> = {},
-): ChildProcess & { kill: ReturnType<typeof vi.fn> } {
-  return { killed, kill: vi.fn(), ...extra } as unknown as ChildProcess & {
-    kill: ReturnType<typeof vi.fn>;
-  };
-}
-
-/** 带 dispose 的假引擎（编排测试用——dispose 触发顺序记进 events，与 child kill 事件共序）。 */
-function makeDisposingEngine(
-  id: string,
-  events: string[],
-  disposeImpl?: () => Promise<void>,
-): EnginePort {
-  return {
-    id,
-    capabilities: () => ({
-      schemaEnforcement: "native",
-      steer: "unsupported",
-      conversation: "unsupported",
-      personaInjection: "prompt",
-      eventGranularity: "coarse",
-      sandbox: "none",
-      sessionRead: "outcome-only",
-      resume: "unsupported",
-      interrupt: "kill-only",
-      permissionMode: "fixed",
-      maxTurns: false,
-    }),
-    probe: () =>
-      Promise.resolve({ ok: true, engineVersion: "0.0.0-test", checks: [{ name: "stub", ok: true }] }),
-    run: () => Promise.reject(new Error("fake engine: run not implemented")),
-    interact: () => Promise.resolve({ ok: false, code: "engine_capability_unsupported", message: "stub" }),
-    read: () => Promise.resolve({ engineId: id, turns: [], source: "outcome-only" }),
-    dispose: disposeImpl ?? (() => {
-      events.push(`dispose:${id}`);
-      return Promise.resolve();
-    }),
-  };
-}
-
-describe("spawnedChildren Map + getChildByRecord (M2-B1)", () => {
-  afterEach(() => {
-    spawnedChildren.clear();
-  });
-
-  it("set(recordId, child) 后 getChildByRecord 能查到；未注册返回 undefined", () => {
-    const child = makeFakeChild();
-    spawnedChildren.set("rec-1", child);
-    expect(getChildByRecord("rec-1")).toBe(child);
-    expect(getChildByRecord("rec-2")).toBeUndefined();
-  });
-
-  it("delete(recordId) 后 getChildByRecord 返回 undefined（close/error 回调语义）", () => {
-    const child = makeFakeChild();
-    spawnedChildren.set("rec-1", child);
-    spawnedChildren.delete("rec-1");
-    expect(getChildByRecord("rec-1")).toBeUndefined();
-  });
-
-  it("killAllSpawnedChildren 遍历 .values() 对每个未 killed child kill + clear", () => {
-    const c1 = makeFakeChild();
-    const c2 = makeFakeChild();
-    spawnedChildren.set("rec-a", c1);
-    spawnedChildren.set("rec-b", c2);
-
-    const n = killAllSpawnedChildren();
-
-    expect(n).toBe(2);
-    expect(c1.kill).toHaveBeenCalledTimes(1);
-    expect(c2.kill).toHaveBeenCalledTimes(1);
-    expect(spawnedChildren.size).toBe(0);
-  });
-
-  it("[T2-⑤] killed 但未确认死亡 → 不跳过，补 SIGKILL 升级（killed=发过请求≠已死）", () => {
-    const alive = makeFakeChild(false);
-    const killedNotClosed = makeFakeChild(true); // SIGTERM 已发、exit/signal 仍 null
-    spawnedChildren.set("rec-1", alive);
-    spawnedChildren.set("rec-2", killedNotClosed);
-
-    const n = killAllSpawnedChildren();
-
-    expect(n).toBe(2);
-    expect(alive.kill).toHaveBeenCalledWith("SIGTERM");
-    // dispose 是最后兜底，对 killed-not-closed 直接升级 SIGKILL（不再赌 SIGTERM 生效）
-    expect(killedNotClosed.kill).toHaveBeenCalledWith("SIGKILL");
-    expect(spawnedChildren.size).toBe(0);
-  });
-
-  it("[T2-⑤] killed 且已确认死亡（signalCode 非 null）→ 跳过，不重复发信号", () => {
-    const dead = makeFakeChild(true, { signalCode: "SIGTERM" });
-    spawnedChildren.set("rec-1", dead);
-
-    const n = killAllSpawnedChildren();
-
-    expect(n).toBe(0);
-    expect(dead.kill).not.toHaveBeenCalled();
-    expect(spawnedChildren.size).toBe(0);
-  });
-
-  it("killAllSpawnedChildren 对单个 child kill 抛错不阻断其他（best-effort catch）", () => {
-    const ok = makeFakeChild();
-    const throwy = makeFakeChild();
-    throwy.kill.mockImplementation(() => {
-      throw new Error("ESRCH");
-    });
-    spawnedChildren.set("rec-1", ok);
-    spawnedChildren.set("rec-2", throwy);
-
-    const n = killAllSpawnedChildren();
-
-    // throwy 抛错被 catch，不计入 n；ok 正常 kill。两者都调过 kill，Map 已 clear。
-    expect(n).toBe(1);
-    expect(ok.kill).toHaveBeenCalledTimes(1);
-    expect(throwy.kill).toHaveBeenCalledTimes(1);
-    expect(spawnedChildren.size).toBe(0);
-  });
-});
-
-describe("killAllSpawnedChildren 编排扩容（R1 D6③：先引擎 dispose 后 per-record children）", () => {
-  afterEach(() => {
-    spawnedChildren.clear();
-    // registry 是进程级全局状态（Symbol.for 槽），防用例间 fake 引擎泄漏串扰
-    clearEngines();
-  });
-
-  it("先全部触发已实例化引擎 dispose，后遍历杀 children（D6① 时序：dispose 先于 SIGTERM）", () => {
-    const events: string[] = [];
-    registerEngine("e-alpha", () => makeDisposingEngine("e-alpha", events));
-    registerEngine("e-beta", () => makeDisposingEngine("e-beta", events));
-    getEngine("e-alpha"); // disposeEngines 只遍历已实例化单例，须先实例化
-    getEngine("e-beta");
-
-    const c1 = makeFakeChild();
-    const c2 = makeFakeChild();
-    c1.kill.mockImplementation(() => {
-      events.push("kill:rec-a");
-    });
-    c2.kill.mockImplementation(() => {
-      events.push("kill:rec-b");
-    });
-    spawnedChildren.set("rec-a", c1);
-    spawnedChildren.set("rec-b", c2);
-
-    const n = killAllSpawnedChildren();
-
-    expect(n).toBe(2);
-    // 时序断言（不依赖穿插序）：最后一个 dispose 的索引 < 第一个 kill 的索引
-    const disposeIdx = events
-      .map((e, i) => (e.startsWith("dispose:") ? i : -1))
-      .filter((i) => i >= 0);
-    const firstKill = events.findIndex((e) => e.startsWith("kill:"));
-    expect(disposeIdx.length).toBe(2);
-    expect(firstKill).toBeGreaterThan(Math.max(...disposeIdx));
-    expect(spawnedChildren.size).toBe(0);
-  });
-
-  it("引擎 dispose 同步 throw 不阻断 children 清理（best-effort 编排，catch 记日志继续）", () => {
-    const events: string[] = [];
-    registerEngine(
-      "throwy",
-      () =>
-        makeDisposingEngine("throwy", events, () => {
-          throw new Error("dispose boom");
-        }),
-    );
-    getEngine("throwy");
-    const child = makeFakeChild();
-    child.kill.mockImplementation(() => {
-      events.push("kill:rec-1");
-    });
-    spawnedChildren.set("rec-1", child);
-
-    expect(() => killAllSpawnedChildren()).not.toThrow();
-    expect(child.kill).toHaveBeenCalledTimes(1);
-    expect(spawnedChildren.size).toBe(0);
-    expect(loggerMock.warn).toHaveBeenCalledWith(
-      expect.stringContaining("[engine-registry] engine 'throwy' dispose threw synchronously"),
-    );
-  });
-
-  it("引擎仅注册工厂未实例化 → 不触发 dispose 也不实例化（停机路径不反向创建资源）", () => {
-    const events: string[] = [];
-    const engine = makeDisposingEngine("unused", events);
-    registerEngine("unused", () => engine);
-    const child = makeFakeChild();
-    child.kill.mockImplementation(() => {
-      events.push("kill:rec-1");
-    });
-    spawnedChildren.set("rec-1", child);
-
-    const n = killAllSpawnedChildren();
-
-    expect(n).toBe(1);
-    expect(events).toEqual(["kill:rec-1"]); // 无 dispose 事件混入
-    expect(child.kill).toHaveBeenCalledTimes(1);
-  });
-});