@zhushanwen/subagent-core 0.6.0 → 0.7.0

package/src/execution/engine/engines/zcode/__tests__/reader.test.ts

@@ -1,210 +0,0 @@
-// reader.test.ts —— sqlite 只读 SessionView（验收 4 的 mock 半边：真实 node:sqlite 建库
-// → turns/usage/toolCalls 派生；db 缺失/表漂移 → 结构化错误供降级）。真机半边（实录池
-// 内 db）在 zcode-engine.live.test.ts。
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-import { beforeAll, beforeEach, describe, expect, it } from "vitest";
-
-import { readZcodeSessionView, ZcodeReaderError } from "../reader.ts";
-
-let tmpDir: string;
-let dbPath: string;
-
-// 建出与 zcode 0.16.5 同形的三表最小 schema（列裁剪到 reader 消费面）
-async function createDb(file: string): Promise<void> {
-  const { DatabaseSync } = (await import("node:sqlite")) as { DatabaseSync: new (p: string) => unknown };
-  type Db = {
-    exec: (s: string) => void;
-    prepare: (s: string) => { run: (...a: unknown[]) => void };
-    close: () => void;
-  };
-  const db = new DatabaseSync(file) as unknown as Db;
-  db.exec(
-    "CREATE TABLE session (id TEXT PRIMARY KEY, time_created INTEGER);" +
-      "CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, sequence INTEGER, data TEXT);" +
-      "CREATE TABLE part (id TEXT PRIMARY KEY, message_id TEXT, session_id TEXT, sequence INTEGER, data TEXT);",
-  );
-  const insertMessage = db.prepare("INSERT INTO message (id, session_id, sequence, data) VALUES (?, ?, ?, ?)");
-  const insertPart = db.prepare("INSERT INTO part (id, message_id, session_id, sequence, data) VALUES (?, ?, ?, ?, ?)");
-
-  // session 1（目标）：user prompt + assistant 两轮（text/reasoning/tool/step-finish×2）
-  db.prepare("INSERT INTO session (id, time_created) VALUES (?, ?)").run("sess_target", 2000);
-  insertMessage.run("msg_user", "sess_target", 0, JSON.stringify({ role: "user" }));
-  insertPart.run("part_user_text", "msg_user", "sess_target", 0, JSON.stringify({ type: "text", text: "the task" }));
-
-  insertMessage.run("msg_asst", "sess_target", 1, JSON.stringify({ role: "assistant" }));
-  insertPart.run("p0", "msg_asst", "sess_target", 0, JSON.stringify({ type: "step-start" }));
-  insertPart.run("p1", "msg_asst", "sess_target", 1, JSON.stringify({ type: "reasoning", text: "thinking hard" }));
-  insertPart.run(
-    "p2",
-    "msg_asst",
-    "sess_target",
-    2,
-    JSON.stringify({
-      type: "tool",
-      tool: "Bash",
-      state: JSON.stringify({ status: "completed", input: { command: "ls" }, output: "file-a\nfile-b" }),
-    }),
-  );
-  insertPart.run(
-    "p3",
-    "msg_asst",
-    "sess_target",
-    3,
-    JSON.stringify({
-      type: "step-finish",
-      reason: "stop",
-      cost: 0,
-      tokens: { total: 110, input: 100, output: 10, reasoning: 0, cache: { read: 5, write: 0 } },
-    }),
-  );
-  // 第二轮（同 assistant message 内第二个 step 段）
-  insertPart.run("p4", "msg_asst", "sess_target", 4, JSON.stringify({ type: "text", text: "final answer" }));
-  insertPart.run(
-    "p5",
-    "msg_asst",
-    "sess_target",
-    5,
-    JSON.stringify({
-      type: "step-finish",
-      reason: "stop",
-      cost: 0.5,
-      tokens: { total: 60, input: 50, output: 10, reasoning: 0, cache: { read: 0, write: 0 } },
-    }),
-  );
-
-  // session 2（更早）：验证「缺省取最新」与定向读取互不干扰
-  db.prepare("INSERT INTO session (id, time_created) VALUES (?, ?)").run("sess_older", 1000);
-  insertMessage.run("msg_old", "sess_older", 0, JSON.stringify({ role: "assistant" }));
-  insertPart.run("part_old", "msg_old", "sess_older", 0, JSON.stringify({ type: "text", text: "old turn" }));
-  insertPart.run(
-    "part_old2",
-    "msg_old",
-    "sess_older",
-    1,
-    JSON.stringify({ type: "step-finish", tokens: { input: 1, output: 1, cache: {} } }),
-  );
-  db.close();
-}
-
-beforeAll(async () => {
-  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "zcode-reader-"));
-  dbPath = path.join(tmpDir, "db.sqlite");
-  await createDb(dbPath);
-});
-
-describe("readZcodeSessionView：native 读取", () => {
-  it("turns 派生：两轮闭合、text/thinking/toolCalls/usage 齐备（验收 4）", async () => {
-    const view = await readZcodeSessionView(dbPath, "sess_target");
-    expect(view.engineId).toBe("zcode");
-    expect(view.source).toBe("native");
-    expect(view.sessionId).toBe("sess_target");
-    expect(view.turns).toHaveLength(2);
-
-    const [t1, t2] = view.turns!;
-    expect(t1!.text).toBe("");
-    expect(t1!.thinking).toBe("thinking hard");
-    expect(t1!.toolCalls).toHaveLength(1);
-    expect(t1!.toolCalls[0]!.toolName).toBe("Bash");
-    expect(t1!.toolCalls[0]!.args).toEqual({ command: "ls" });
-    expect(t1!.toolCalls[0]!.result).toEqual({ content: ["file-a\nfile-b"] });
-    expect(t1!.toolCalls[0]!.isError).toBeUndefined(); // status completed
-    expect(t1!.closed).toBe(true);
-
-    expect(t2!.text).toBe("final answer");
-    expect(t2!.closed).toBe(true);
-
-    // usage 聚合 = 两轮 usageDelta 之和（cost 累计第二段的 0.5）
-    expect(view.usage).toEqual({ input: 150, output: 20, cacheRead: 5, cacheWrite: 0, cost: 0.5, total: 175 });
-  });
-
-  it("缺省 sessionId 取池内最新 session（time_created DESC）", async () => {
-    const view = await readZcodeSessionView(dbPath);
-    expect(view.sessionId).toBe("sess_target");
-  });
-
-  it("tool 状态非 completed 标 isError", async () => {
-    // 单独建一个带失败工具调用的 session，避免污染上面的聚合断言
-    const failDb = path.join(tmpDir, "fail.sqlite");
-    await createDb(failDb);
-    const { DatabaseSync } = (await import("node:sqlite")) as { DatabaseSync: new (p: string) => unknown };
-    type Db = { prepare: (s: string) => { run: (...a: unknown[]) => void }; close: () => void };
-    const db = new DatabaseSync(failDb) as unknown as Db;
-    db.prepare("INSERT INTO session (id, time_created) VALUES (?, ?)").run("sess_fail", 3000);
-    db
-      .prepare("INSERT INTO message (id, session_id, sequence, data) VALUES (?, ?, ?, ?)")
-      .run("msg_f", "sess_fail", 0, JSON.stringify({ role: "assistant" }));
-    db
-      .prepare("INSERT INTO part (id, message_id, session_id, sequence, data) VALUES (?, ?, ?, ?, ?)")
-      .run(
-        "pf",
-        "msg_f",
-        "sess_fail",
-        0,
-        JSON.stringify({
-          type: "tool",
-          tool: "Edit",
-          state: JSON.stringify({ status: "error", input: { file: "a" }, output: "conflict" }),
-        }),
-      );
-    db.close();
-    const view = await readZcodeSessionView(failDb, "sess_fail");
-    expect(view.turns[0]!.toolCalls[0]!.isError).toBe(true);
-  });
-});
-
-describe("readZcodeSessionView：结构化错误（供降级②③级，验收 4 负例）", () => {
-  beforeEach(() => {
-    // 无共享状态需重置；保留钩子位置说明负例组意图
-  });
-
-  it("db 文件缺失 → engine_session_read_failed（detail 含路径）", async () => {
-    const missing = path.join(tmpDir, "nope.sqlite");
-    try {
-      await readZcodeSessionView(missing, "sess_x");
-      expect.unreachable("should throw");
-    } catch (err) {
-      expect(err).toBeInstanceOf(ZcodeReaderError);
-      const e = err as ZcodeReaderError;
-      expect(e.code).toBe("engine_session_read_failed");
-      expect(e.detail).toContain(missing);
-      expect(e.message).toContain("降级");
-    }
-  });
-
-  it("表结构漂移（缺 part 表）→ 结构化错误含漂移提示", async () => {
-    const drifted = path.join(tmpDir, "drifted.sqlite");
-    const { DatabaseSync } = (await import("node:sqlite")) as { DatabaseSync: new (p: string) => unknown };
-    type Db = { exec: (s: string) => void; close: () => void };
-    const db = new DatabaseSync(drifted) as unknown as Db;
-    // 只建 session/message（zcode 升级把 part 改名的形态）；塞一行 session 让定位
-    // 通过、失败必然发生在 part 查询（表缺失）
-    db.exec(
-      "CREATE TABLE session (id TEXT PRIMARY KEY, time_created INTEGER);" +
-        "CREATE TABLE message (id TEXT PRIMARY KEY, session_id TEXT, sequence INTEGER, data TEXT);" +
-        "INSERT INTO session (id, time_created) VALUES ('sess_d', 1);",
-    );
-    db.close();
-    try {
-      await readZcodeSessionView(drifted);
-      expect.unreachable("should throw");
-    } catch (err) {
-      const e = err as ZcodeReaderError;
-      expect(e.code).toBe("engine_session_read_failed");
-      expect(e.message).toContain("漂移");
-      expect(e.message).toContain("golden");
-    }
-  });
-
-  it("session 不存在 → 结构化错误（不静默空视图）", async () => {
-    try {
-      await readZcodeSessionView(dbPath, "sess_ghost");
-      expect.unreachable("should throw");
-    } catch (err) {
-      expect((err as ZcodeReaderError).detail).toContain("sess_ghost");
-    }
-  });
-});

package/src/execution/engine/engines/zcode/__tests__/registration.test.ts

@@ -1,71 +0,0 @@
-// registration.test.ts —— 注册表接线（验收 6）：'zcode' 可经 getEngine 获取、幂等
-// 覆盖、engineDataDir 默认走 common/data-dir SSOT。clearEngines 隔离全局注册表状态。
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-// u0-data-discovery 注入化后 data-dir 回退值来自 HostServices.dataRoot() 端口——
-// 用例内 configureCore 假宿主控制端口态，afterEach reset 防跨用例泄漏
-import { configureCore, resetCoreForTests } from "../../../../../core/host-services.ts";
-
-import { clearEngines, getEngine, hasEngine, listEngines } from "../../../registry.ts";
-import { createZcodeEngine, registerZcodeEngine } from "../registration.ts";
-
-const FAKE_DATA_ROOT = "/fake-registration-data-root";
-
-afterEach(() => {
-  clearEngines();
-  resetCoreForTests();
-  vi.restoreAllMocks();
-});
-
-describe("registerZcodeEngine", () => {
-  it("登记后 getEngine('zcode') 可用，id/capabilities 正确", () => {
-    registerZcodeEngine(() => "/tmp/data");
-    expect(hasEngine("zcode")).toBe(true);
-    expect(listEngines()).toContain("zcode");
-    const engine = getEngine("zcode");
-    expect(engine.id).toBe("zcode");
-    expect(engine.capabilities().schemaEnforcement).toBe("emulated");
-  });
-
-  it("幂等：重复注册覆盖不堆积（listEngines 单条）", () => {
-    registerZcodeEngine(() => "/tmp/data");
-    registerZcodeEngine(() => "/tmp/data2");
-    expect(listEngines().filter((id) => id === "zcode")).toHaveLength(1);
-    // 覆盖后单例按新工厂重建（engineDataDir 已换）
-    expect(hasEngine("zcode")).toBe(true);
-  });
-
-  it("createZcodeEngine DI 工厂：deps 直达引擎", () => {
-    const engine = createZcodeEngine({ engineDataDir: () => "/tmp/x" });
-    expect(engine.id).toBe("zcode");
-  });
-});
-
-describe("engineDataDir 默认通道（common/data-dir SSOT）", () => {
-  it("缺省经 getEngineDataDir 解析：env 优先，缺失回落宿主数据根（warn 一次）", async () => {
-    // warn 断言走 getEngineDataDir 自带的 DI warn 参数——缺省 warn 通道是
-    // core logger facade（configureCore 后经 pi-host 桥接落文件，不经
-    // console.warn），spy console 永远收不到且会让 logger 落文件产生测试副作用。
-    const { getEngineDataDir, resetDataDirWarnForTests } = await import("../../../common/data-dir.ts");
-    const warns: string[] = [];
-    const prev = process.env["XYZ_AGENT_DATA_DIR"];
-    delete process.env["XYZ_AGENT_DATA_DIR"];
-    try {
-      resetCoreForTests();
-      configureCore({ dataRoot: () => FAKE_DATA_ROOT, log: () => {} });
-      resetDataDirWarnForTests();
-      // 回退分支：无 env → HostServices.dataRoot()（假宿主值）+ warn 一次
-      expect(getEngineDataDir(process.env, (m) => warns.push(m))).toBe(FAKE_DATA_ROOT);
-      expect(warns).toHaveLength(1);
-      expect(warns[0]).toContain("XYZ_AGENT_DATA_DIR");
-      // env 分支：显式注入即取 env 值（透传链证据见 common/data-dir.ts 文件头）
-      process.env["XYZ_AGENT_DATA_DIR"] = "/from-host";
-      expect(getEngineDataDir(process.env, (m) => warns.push(m))).toBe("/from-host");
-      expect(warns).toHaveLength(1);
-    } finally {
-      if (prev !== undefined) process.env["XYZ_AGENT_DATA_DIR"] = prev;
-      else delete process.env["XYZ_AGENT_DATA_DIR"];
-    }
-  });
-});

package/src/execution/engine/engines/zcode/__tests__/session-channel-dispose-harvest.test.ts

@@ -1,247 +0,0 @@
-// session-channel-dispose-harvest.test.ts —— P0-1 U5 dispose 前收割单测（机制层）。
-//
-// 设计权威源：docs/design/timeout-zcode-turn-and-settled-watchdog.md §3.4（退化路径）、
-// §6 D7（dispose 收割兜底）、§11 P-Z3（close 吞没 → dispose 触发 failAllTurns）。
-// P-Z3 的「close 事件吞没」在真实子进程形态不可确定性注入（Node child 进程退出后
-// stdio 关闭即触发 close 事件）——真实现场归 Gate B；本文件用 mock 连接承载机制层
-// 可判定形态：不触发 onClose（= close 吞没的机制等价物）→ dispose → 在途 turn 收敛
-// 为明确失败。与 zcode-engine-dispose.test.ts（fake-appserver 子进程集成面）互补。
-//
-// 覆盖：
-//   ① close 吞没形态：dispose 触发 failAllTurns——在途 turn 于 dispose 时收割
-//     （P-Z3 核心断言），收割后到达的终态不再改写（settled 守卫）；
-//   ② grace 窗口内全部终态化：并发多会话 turn 全量收割，不留永久 pending；
-//   ③ 正常 close 主路径零回归：onClose 收割先行 → dispose no-op 不改写收割错误；
-//   ④ 终态已落定（成功）后 dispose：settled 守卫不改写已成功结果；
-//   ⑤ dispose 收割后 closeSession 短路：runTurn finally 不再发 session/close
-//     （防写死进程/惰性重建——D7 收割语义的必要闭环）+ 正常完成对照（发 close）；
-//   ⑥ 二次 dispose 幂等。
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import type { AppServerConnection } from "../connection.ts";
-import {
-  SessionChannel,
-  type SessionTurnResult,
-  type SessionTurnOptions,
-} from "../session-channel.ts";
-
-// ============================================================
-// mock 连接 + 驱动器（与 session-channel-turn-timers.test.ts 同形态，
-// 增补 onClose handler 的手动触发面——close 吞没注入的机制等价物）
-// ============================================================
-
-interface MockChannel {
-  ch: SessionChannel;
-  /** 我方发出的请求帧流水（method 序可断言）。 */
-  requests: Array<{ method: string; params: unknown }>;
-  /** 手动触发连接崩溃广播（close 吞没形态 = 不触发；正常形态 = 测试显式触发）。 */
-  emitClose: (reason: string) => void;
-  emit: (method: string, params: unknown) => void;
-  emitTerminal: (sessionId: string | undefined, status: string) => void;
-}
-
-let sidSeq = 0;
-
-function makeMockChannel(): MockChannel {
-  const notifications = new Map<string, (params: unknown) => void>();
-  const requests: Array<{ method: string; params: unknown }> = [];
-  const closeHandlers = new Set<(reason: string) => void>();
-  const conn = {
-    alive: true,
-    onNotification: (method: string, h: (params: unknown) => void) => {
-      notifications.set(method, h);
-      return () => notifications.delete(method);
-    },
-    onClose: (h: (reason: string) => void) => {
-      closeHandlers.add(h);
-      return () => closeHandlers.delete(h);
-    },
-    request: (method: string, params: unknown) => {
-      requests.push({ method, params });
-      if (method === "session/create") {
-        sidSeq += 1;
-        return Promise.resolve({ session: { sessionId: `sess_h${sidSeq}` } });
-      }
-      if (method === "session/send") return Promise.resolve({ accepted: true });
-      if (method === "session/read") return Promise.resolve({ messages: [] });
-      return Promise.resolve({});
-    },
-  } as unknown as AppServerConnection;
-  const ch = new SessionChannel(conn);
-  return {
-    ch,
-    requests,
-    emitClose: (reason) => {
-      for (const fn of [...closeHandlers]) fn(reason);
-    },
-    emit: (method, params) => notifications.get(method)?.(params),
-    emitTerminal: (sessionId, status) =>
-      notifications
-        .get("v4/telemetry/event")
-        ?.({ kind: "turn.terminal", status, sessionId }),
-  };
-}
-
-interface TurnTracker {
-  outcome: "pending" | "fulfilled" | "rejected";
-  result: SessionTurnResult | undefined;
-  error: unknown;
-  promise: Promise<SessionTurnResult>;
-  /** onSessionCreated 回填（getter——回调晚于 tracker 构造，值拷贝会恒空）。 */
-  readonly sessionId: string;
-}
-
-function startTurn(ch: SessionChannel, opts: SessionTurnOptions = {}): TurnTracker {
-  let sessionId = "";
-  const promise = ch.runTurn({ workspacePath: "/tmp/ws-harvest", mode: "yolo" }, "任务", {
-    onSessionCreated: (sid) => {
-      sessionId = sid;
-    },
-    ...opts,
-  });
-  const t: TurnTracker = {
-    outcome: "pending",
-    result: undefined,
-    error: undefined,
-    promise,
-    get sessionId(): string {
-      return sessionId;
-    },
-  };
-  void promise.then(
-    (r) => {
-      t.outcome = "fulfilled";
-      t.result = r;
-    },
-    (e) => {
-      t.outcome = "rejected";
-      t.error = e;
-    },
-  );
-  return t;
-}
-
-/** 排空微任务链（create→subscribe→send 全是已 resolve 的 promise——一拍 setTimeout 足够）。 */
-function flush(): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-async function settle(t: TurnTracker): Promise<void> {
-  await t.promise.then(
-    () => undefined,
-    () => undefined,
-  );
-}
-
-let enginesChannels: SessionChannel[] = [];
-afterEach(() => {
-  for (const ch of enginesChannels.splice(0)) ch.dispose();
-});
-
-// ============================================================
-// dispose 收割（P0-1 U5/D7：close 缺失/被吞没的退化路径闭合）
-// ============================================================
-
-describe("dispose 收割（P-Z3 机制层：close 吞没 → dispose 触发 failAllTurns）", () => {
-  it("close 吞没形态：dispose 时在途 turn 收割为明确失败，迟到终态不再改写", async () => {
-    const m = makeMockChannel();
-    enginesChannels.push(m.ch);
-    const t = startTurn(m.ch);
-    await flush();
-    expect(t.outcome).toBe("pending"); // send 已发、无终态——在途
-
-    m.ch.dispose(); // close 吞没（onClose 未触发）→ dispose 收割兜底
-    await settle(t);
-
-    expect(t.outcome).toBe("rejected");
-    const err = t.error as Error;
-    expect(err).toBeInstanceOf(Error);
-    expect(err.message).toContain("已 dispose");
-    expect(err.message).toContain("收割");
-    expect(err.message).toContain("恢复指引");
-    // 收割后到达的权威终态：settled 守卫——落定结果不改写
-    m.emitTerminal(t.sessionId, "success");
-    expect(t.outcome).toBe("rejected");
-    expect((t.error as Error).message).toBe(err.message);
-  });
-
-  it("grace 窗口内全部终态化：并发双会话 turn 全量收割，不留永久 pending", async () => {
-    const m = makeMockChannel();
-    enginesChannels.push(m.ch);
-    const t1 = startTurn(m.ch);
-    const t2 = startTurn(m.ch);
-    await flush();
-    expect(t1.sessionId).not.toBe(t2.sessionId); // 双会话确实并发
-    expect(t1.outcome).toBe("pending");
-    expect(t2.outcome).toBe("pending");
-
-    m.ch.dispose();
-    await Promise.all([settle(t1), settle(t2)]);
-
-    expect(t1.outcome).toBe("rejected");
-    expect(t2.outcome).toBe("rejected");
-    expect((t1.error as Error).message).toContain("已 dispose");
-    expect((t2.error as Error).message).toContain("已 dispose");
-  });
-
-  it("正常 close 主路径零回归：onClose 收割先行（错误=连接层 reason），dispose no-op 不改写", async () => {
-    const m = makeMockChannel();
-    enginesChannels.push(m.ch);
-    const t = startTurn(m.ch);
-    await flush();
-
-    m.emitClose("进程退出（code=0 signal=SIGTERM）"); // onClose 主路径收割（正常 close 到达）
-    await settle(t);
-    expect(t.outcome).toBe("rejected");
-    const onCloseErr = t.error as Error;
-    expect(onCloseErr.message).toContain("app-server 进程退出");
-
-    m.ch.dispose(); // activeTurns 已空——幂等 no-op，收割错误不被 dispose 文案改写
-    expect(t.outcome).toBe("rejected");
-    expect((t.error as Error).message).toBe(onCloseErr.message);
-  });
-
-  it("终态已落定（成功）后 dispose：settled 守卫不改写已成功结果", async () => {
-    const m = makeMockChannel();
-    enginesChannels.push(m.ch);
-    const t = startTurn(m.ch);
-    await flush();
-    m.emitTerminal(t.sessionId, "success");
-    await settle(t);
-    expect(t.outcome).toBe("fulfilled");
-
-    m.ch.dispose(); // 已成功收尾的 turn 不受 dispose 收割影响
-    expect(t.outcome).toBe("fulfilled");
-    expect(t.result?.terminal).toEqual({ status: "success", source: "turn.terminal" });
-  });
-
-  it("dispose 收割后 closeSession 短路：finally 不发 session/close（防写死进程/惰性重建）；正常完成对照=发 close", async () => {
-    const m1 = makeMockChannel();
-    enginesChannels.push(m1.ch);
-    const t1 = startTurn(m1.ch);
-    await flush();
-    m1.ch.dispose();
-    await settle(t1);
-    await flush(); // runTurn finally 的 closeSession 已过
-    expect(t1.outcome).toBe("rejected");
-    expect(m1.requests.map((r) => r.method)).not.toContain("session/close");
-
-    // 对照：正常完成的 turn，finally 发 session/close（D4 用后即毁——零回归面）
-    const m2 = makeMockChannel();
-    enginesChannels.push(m2.ch);
-    const t2 = startTurn(m2.ch);
-    await flush();
-    m2.emitTerminal(t2.sessionId, "success");
-    await settle(t2);
-    expect(t2.outcome).toBe("fulfilled");
-    expect(m2.requests.map((r) => r.method)).toContain("session/close");
-  });
-
-  it("二次 dispose 幂等：无在途 turn 时 dispose 是 no-op 不抛", async () => {
-    const m = makeMockChannel();
-    enginesChannels.push(m.ch);
-    expect(() => m.ch.dispose()).not.toThrow();
-    expect(() => m.ch.dispose()).not.toThrow();
-  });
-});