@zhushanwen/subagent-core 0.2.0

package/src/__tests__/robustness-low-batch1.test.ts

@@ -0,0 +1,286 @@
+// Low batch 1 robustness fix verification
+//
+// L9: run.state.errorLogs 追加而非覆盖——保留重试历史的诊断日志
+//
+// 一个 run 经历多次 error → rebuild → 最终 return 的场景，中间 worker 实例的
+// console 日志对排查「为什么重试了 3 次」很关键。旧代码三处赋值都是覆盖式
+//（run.state.errorLogs = ...），每次重试的诊断日志都被最后一次覆盖丢失。
+// 修复：改为 push + 截断（MAX_ERROR_LOGS=500 防无界增长）。
+//
+// 测试搭建方式参照 error-recovery-handlers.test.ts（mock LifecycleDeps + WorkflowRun）。
+// - handleScriptError 是 export 的 async function，直接 import 调用
+// - handleReturn 不是 export 的——通过 handleWorkerMessage 发 { type: "return", ... } 触发
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { handleScriptError, handleWorkerMessage } from "../orchestration/error-recovery.ts";
+import type { LifecycleDeps, WorkerHandlers } from "../orchestration/models/ports.ts";
+import type { WorkflowRun } from "../orchestration/models/workflow-run.ts";
+
+// ── helpers ──────────────────────────────────────────────────
+
+/**
+ * 构造一个 status="running" 的 mock WorkflowRun。
+ *
+ * 关键：errorLogs 必须是真实数组（push/slice 会操作它），不能用 vi.fn 占位。
+ * transition 把 status 切到 done——调用方可通过 resetRunning() 重置回 running
+ * 以便多次触发 handleReturn（每条 return 消息都会 transition done）。
+ */
+function makeRunningRun(): WorkflowRun & { resetRunning(): void } {
+  const run = {
+    runId: "run-test",
+    state: {
+      status: "running" as const,
+      reason: undefined as string | undefined,
+      budget: { usedTokens: 0, usedCost: 0 },
+      // 真实数组——push/slice 直接作用于它
+      errorLogs: [] as Array<{ level: string; message: string }>,
+      scriptResult: undefined as unknown,
+      // rebuildRuntime 内 discardInFlightCalls 遍历 calls + 移除 trace 节点——
+      // 必须是真实 Map（空 = 无在飞 call，discard 为 no-op）
+      calls: new Map(),
+      trace: { removeByStepIndex: vi.fn() },
+    },
+    meta: {
+      startedAt: new Date().toISOString(),
+    },
+    spec: {
+      scriptName: "test-wf",
+      scriptSource: "execute() {}",
+      args: {},
+    },
+    runtime: {
+      worker: { postMessage: vi.fn() },
+    },
+    transition(target: string, reason?: string): void {
+      this.state.status = target;
+      if (target === "done") this.state.reason = reason;
+    },
+    replaceRuntime(rt: unknown): void {
+      this.runtime = rt;
+    },
+    // 多次触发 handleReturn 时把状态从 done 重置回 running
+    resetRunning(): void {
+      this.state.status = "running";
+      this.state.reason = undefined;
+    },
+  } as unknown as WorkflowRun & { resetRunning(): void };
+  return run;
+}
+
+/** LifecycleDeps mock：store.save 是异步 no-op，其余可观察。 */
+function makeDeps(): LifecycleDeps & {
+  store: { save: ReturnType<typeof vi.fn> };
+  workerHost: { start: ReturnType<typeof vi.fn> };
+  eventBus: { emit: ReturnType<typeof vi.fn> };
+  onRunDone: ReturnType<typeof vi.fn>;
+  log: ReturnType<typeof vi.fn>;
+} {
+  return {
+    store: { save: vi.fn(async () => {}) },
+    workerHost: { start: vi.fn(() => ({ postMessage: vi.fn() })) },
+    runner: { run: vi.fn(async () => ({})) },
+    runs: new Map(),
+    eventBus: { emit: vi.fn() },
+    onRunDone: vi.fn(),
+    log: vi.fn(),
+  } as unknown as ReturnType<typeof makeDeps>;
+}
+
+/** WorkerHandlers 占位（重试路径递归回调，但测试场景不触发）。 */
+function makeHandlers(): WorkerHandlers {
+  return {
+    onMessage: vi.fn(async () => {}),
+    onError: vi.fn(async () => {}),
+    onExit: vi.fn(async () => {}),
+  } as unknown as WorkerHandlers;
+}
+
+beforeEach(() => {
+  // handleScriptError 重试路径走 scheduleRebuild（指数退避 1s/2s/4s）。
+  // 测试中 workerLogs 已在退避前 push，但为了让 promise resolve（rebuildRuntime 后），
+  // 用 fake timers 推进退避。超 MAX 的终态路径不进退避，直接 resolve。
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+// ── handleScriptError: errorLogs 追加 ─────────────────────────
+
+describe("L9: handleScriptError 追加 errorLogs（非覆盖）", () => {
+  it("第一次 scriptError：errorLogs 长度为 1", async () => {
+    const run = makeRunningRun();
+    const deps = makeDeps();
+
+    // count=1 <= MAX → 进退避重试路径。advance timer 让 promise resolve。
+    const p = handleScriptError(
+      run,
+      "boom-1",
+      [{ level: "error", message: "console error from worker #1" }],
+      deps,
+      makeHandlers(),
+    );
+    await vi.advanceTimersByTimeAsync(1000);
+    await p;
+
+    expect(run.state.errorLogs).toHaveLength(1);
+    expect(run.state.errorLogs[0]).toEqual({
+      level: "error",
+      message: "console error from worker #1",
+    });
+  });
+
+  it("第二次 scriptError：errorLogs 长度为 2（追加而非覆盖）", async () => {
+    const run = makeRunningRun();
+    const deps = makeDeps();
+
+    // 第一次：count=1 <= MAX → 退避 1s
+    const p1 = handleScriptError(
+      run,
+      "boom-1",
+      [{ level: "error", message: "console error from worker #1" }],
+      deps,
+      makeHandlers(),
+    );
+    await vi.advanceTimersByTimeAsync(1000);
+    await p1;
+
+    // 第二次：count=2 <= MAX → 退避 2s
+    const p2 = handleScriptError(
+      run,
+      "boom-2",
+      [{ level: "warn", message: "console warn from worker #2" }],
+      deps,
+      makeHandlers(),
+    );
+    await vi.advanceTimersByTimeAsync(2000);
+    await p2;
+
+    expect(run.state.errorLogs).toHaveLength(2);
+    expect(run.state.errorLogs[0]).toEqual({
+      level: "error",
+      message: "console error from worker #1",
+    });
+    expect(run.state.errorLogs[1]).toEqual({
+      level: "warn",
+      message: "console warn from worker #2",
+    });
+  });
+});
+
+// ── handleReturn: errorLogs 追加（经 handleWorkerMessage 触发） ──
+
+describe("L9: handleReturn 追加 errorLogs（非覆盖）", () => {
+  it("已有 2 条 errorLogs 后 handleReturn 再追加 1 条 → 长度 3", async () => {
+    const run = makeRunningRun();
+    const deps = makeDeps();
+
+    // 先用 scriptError 累积 2 条诊断日志
+    const p1 = handleScriptError(
+      run,
+      "boom-1",
+      [{ level: "error", message: "diag-1" }],
+      deps,
+      makeHandlers(),
+    );
+    await vi.advanceTimersByTimeAsync(1000);
+    await p1;
+
+    const p2 = handleScriptError(
+      run,
+      "boom-2",
+      [{ level: "error", message: "diag-2" }],
+      deps,
+      makeHandlers(),
+    );
+    await vi.advanceTimersByTimeAsync(2000);
+    await p2;
+
+    expect(run.state.errorLogs).toHaveLength(2);
+
+    // handleReturn 经 handleWorkerMessage 触发——它内部会 transition("done","completed")
+    run.resetRunning();
+    await handleWorkerMessage(
+      run,
+      { type: "return", result: "final-result", workerLogs: [{ level: "log", message: "final-return-log" }] },
+      deps,
+      makeHandlers(),
+    );
+
+    expect(run.state.errorLogs).toHaveLength(3);
+    expect(run.state.errorLogs[2]).toEqual({
+      level: "log",
+      message: "final-return-log",
+    });
+    // scriptResult 也被正确写入（验证未破坏其他字段）
+    expect(run.state.scriptResult).toBe("final-result");
+    expect(run.state.status).toBe("done");
+    expect(run.state.reason).toBe("completed");
+  });
+});
+
+// ── 截断：超过 MAX_ERROR_LOGS 只保留最后 500 条 ────────────────
+
+describe("L9: errorLogs 截断到 MAX_ERROR_LOGS（500）", () => {
+  it("handleScriptError 追加超过 MAX 后只保留最后 MAX 条", async () => {
+    const run = makeRunningRun();
+    const deps = makeDeps();
+
+    // 注入 499 条已有日志，再追加 3 条 → 502 > 500，应截断到 500
+    for (let i = 0; i < 499; i++) {
+      run.state.errorLogs.push({ level: "log", message: `pre-${i}` });
+    }
+    expect(run.state.errorLogs).toHaveLength(499);
+
+    // handleScriptError 内部 push 3 条 + 截断。走终态路径（count > MAX）避免退避计时。
+    // scriptErrorCount=3 → count=4 > 3 → transition done,failed，不进 scheduleRebuild。
+    run.meta.scriptErrorCount = 3;
+    await handleScriptError(
+      run,
+      "boom",
+      [
+        { level: "error", message: "new-1" },
+        { level: "error", message: "new-2" },
+        { level: "error", message: "new-3" },
+      ],
+      deps,
+      makeHandlers(),
+    );
+
+    expect(run.state.errorLogs).toHaveLength(500);
+    // 截断保留最后 500 条：499 + 3 = 502，丢弃最前 2 条（pre-0, pre-1）
+    expect(run.state.errorLogs[0]).toEqual({ level: "log", message: "pre-2" });
+    expect(run.state.errorLogs[499]).toEqual({ level: "error", message: "new-3" });
+  });
+
+  it("handleReturn 追加超过 MAX 后只保留最后 MAX 条", async () => {
+    const run = makeRunningRun();
+    const deps = makeDeps();
+
+    // 注入 500 条已有日志，再追加 2 条 → 502 > 500
+    for (let i = 0; i < 500; i++) {
+      run.state.errorLogs.push({ level: "log", message: `pre-${i}` });
+    }
+
+    await handleWorkerMessage(
+      run,
+      {
+        type: "return",
+        result: "done",
+        workerLogs: [
+          { level: "log", message: "ret-1" },
+          { level: "log", message: "ret-2" },
+        ],
+      },
+      deps,
+      makeHandlers(),
+    );
+
+    expect(run.state.errorLogs).toHaveLength(500);
+    // 截断保留最后 500 条：丢弃最前 2 条（pre-0, pre-1）
+    expect(run.state.errorLogs[0]).toEqual({ level: "log", message: "pre-2" });
+    expect(run.state.errorLogs[499]).toEqual({ level: "log", message: "ret-2" });
+  });
+});

package/src/__tests__/robustness-medium-batch1.test.ts

@@ -0,0 +1,69 @@
+// Medium batch 1 robustness fixes verification
+//
+// M4: dispatchAgentCall .then() clears node.live BEFORE stale guard (not after)
+// M7: handleWorkerMessage validates msg shape before dereferencing msg.opts
+// M8: session-reconstructor guards Array.isArray(msg.content) before for...of
+
+import { readFileSync } from "node:fs";
+import { dirname,join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { describe, expect, it } from "vitest";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = join(__dirname, "..", "..");
+
+function readSrc(relPath: string): string {
+  return readFileSync(join(PKG_ROOT, relPath), "utf-8");
+}
+
+// ── M4: node.live cleared before stale guard ─────────────────
+
+describe("M4: dispatchAgentCall .then() clears node.live before stale guard", () => {
+  const src = readSrc(join("src", "orchestration", "error-recovery.ts"));
+
+  it("node.live = undefined appears before the stale guard return", () => {
+    // 找到 .then 回调中的 stale guard 和 node.live 清理的相对顺序
+    const thenMatch = src.match(/\.then\(\(\)\s*=>\s*\{[\s\S]*?\}\)/);
+    expect(thenMatch).toBeTruthy();
+    const thenBlock = thenMatch![0];
+
+    const liveIdx = thenBlock.indexOf("node.live = undefined");
+    const guardIdx = thenBlock.indexOf('run.state.status !== "running"');
+
+    expect(liveIdx).toBeGreaterThan(-1);
+    expect(guardIdx).toBeGreaterThan(-1);
+    // node.live 清理必须在 stale guard 之前（代码行号更小）
+    expect(liveIdx).toBeLessThan(guardIdx);
+  });
+});
+
+// ── M7: handleWorkerMessage shape validation ─────────────────
+
+describe("M7: handleWorkerMessage validates msg before dereferencing", () => {
+  const src = readSrc(join("src", "orchestration", "error-recovery.ts"));
+
+  it("handleWorkerMessage has shape guard for msg before dereferencing opts", () => {
+    // handleWorkerMessage 中 `raw as WorkerMsg` 后应有 typeof/形状校验
+    // 防止畸形 IPC 消息（msg.opts undefined）导致 TypeError
+    const handlerMatch = src.match(/export async function handleWorkerMessage[\s\S]*?switch/);
+    expect(handlerMatch).toBeTruthy();
+    const handlerBlock = handlerMatch![0];
+    // 在 switch 前应有 msg 形状校验（typeof msg === 'object' 或 msg?.type 检查）
+    expect(handlerBlock).toMatch(/typeof\s+(msg|raw)|!\s*(msg|raw)|(msg|raw)\s*&&/);
+  });
+});
+
+// ── M8: reconstructor Array.isArray guard ────────────────────
+
+describe("M8: session-reconstructor guards msg.content with Array.isArray", () => {
+  const src = readSrc(join("src", "execution", "session-reconstructor.ts"));
+
+  it("for...of msg.content is guarded by Array.isArray", () => {
+    // 验证 for (const block of msg.content) 前有 Array.isArray 守卫
+    expect(src).toContain("Array.isArray");
+    // 确保守卫与 msg.content 相关
+    const contentGuardMatch = src.match(/Array\.isArray\([^)]*content[^)]*\)/);
+    expect(contentGuardMatch).toBeTruthy();
+  });
+});

package/src/__tests__/robustness-medium-batch2.test.ts

@@ -0,0 +1,65 @@
+// Medium batch 2 robustness fixes verification
+//
+// M6: worktree cleanup not gated by patchOk (decoupled)
+// M9: store.save not fire-and-forget (has .catch)
+// M12: budget-done transition and onRunDone in separate try blocks
+// [u1-move] M10（notifyDone 序列化守卫，读壳侧 interface/helpers.ts 源文本）随壳件
+// 留守 pi extension 包：src/__tests__/robustness-medium-batch2-interface.test.ts。
+
+import { readFileSync } from "node:fs";
+import { dirname,join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { describe, expect, it } from "vitest";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = join(__dirname, "..", "..");
+
+function readSrc(relPath: string): string {
+  return readFileSync(join(PKG_ROOT, relPath), "utf-8");
+}
+
+// ── M6: worktree cleanup decoupled from patchOk ──────────────
+
+describe("M6: worktree cleanup not gated by patchOk", () => {
+  const src = readSrc(join("src", "execution", "subagent-service.ts"));
+
+  it("worktree cleanup condition does not reference patchOk", () => {
+    // 找到 worktree cleanup 调用前的条件判断
+    const cleanupMatch = src.match(/if\s*\([^)]*worktreeHandle[^)]*\)\s*\{[\s\S]*?worktreeManager\.cleanup/);
+    expect(cleanupMatch).toBeTruthy();
+    const condition = cleanupMatch![0];
+    // 条件中不应包含 patchOk（解耦后 worktree cleanup 只依赖 worktreeHandle 存在）
+    expect(condition).not.toContain("patchOk");
+  });
+});
+
+// ── M9: store.save has .catch (not fire-and-forget) ──────────
+
+describe("M9: store.save not fire-and-forget in dispatchAgentCall", () => {
+  const src = readSrc(join("src", "orchestration", "error-recovery.ts"));
+
+  it("no bare `void deps.store.save` without .catch", () => {
+    // 查找所有 void deps.store.save(run) 的出现
+    const bareSave = /void\s+deps\.store\.save\(run\)\s*;(?!\s*\.catch)/g;
+    const matches = [...src.matchAll(bareSave)];
+    // 修复后不应有裸 void store.save（应有 .catch 或 await）
+    expect(matches.length).toBe(0);
+  });
+});
+
+// ── M12: budget-done has separate try blocks ─────────────────
+
+describe("M12: budget-done separates transition and onRunDone error handling", () => {
+  const src = readSrc(join("src", "orchestration", "error-recovery.ts"));
+
+  it("budget-done block has more than one catch (transition vs onRunDone separated)", () => {
+    // 找到 budget isExceeded 块
+    const budgetMatch = src.match(/budget\.isExceeded\(\)[\s\S]*?\}\s*\}\s*\)/);
+    expect(budgetMatch).toBeTruthy();
+    const budgetBlock = budgetMatch![0];
+    // 修复后应有多个 catch（至少 2 个：一个给 transition，一个给 onRunDone/emit）
+    const catchCount = (budgetBlock.match(/\bcatch\b/g) || []).length;
+    expect(catchCount).toBeGreaterThanOrEqual(2);
+  });
+});

package/src/__tests__/robustness-medium-batch3.test.ts

@@ -0,0 +1,30 @@
+// Medium batch 3: thinkingLevel 字段声明检查
+//
+// M2（保留）: AgentCallOpts 声明 thinkingLevel 字段（仍有效）
+// M2 propagation / M3 model fallback: resolveAgentOpts 删除 agent 处理块后废弃，相关测试已移除
+
+import { readFileSync } from "node:fs";
+import { dirname,join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { describe, expect, it } from "vitest";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = join(__dirname, "..", "..");
+
+function readSrc(relPath: string): string {
+  return readFileSync(join(PKG_ROOT, relPath), "utf-8");
+}
+
+// ── M2: AgentCallOpts has thinkingLevel ───────────────────────
+
+describe("M2: AgentCallOpts has thinkingLevel field", () => {
+  const src = readSrc(join("src", "orchestration", "models", "types.ts"));
+
+  it("AgentCallOpts interface declares thinkingLevel", () => {
+    // 找到 AgentCallOpts interface 块，断言含 thinkingLevel 字段
+    const ifaceMatch = src.match(/export interface AgentCallOpts \{[\s\S]*?\}/);
+    expect(ifaceMatch).toBeTruthy();
+    expect(ifaceMatch![0]).toContain("thinkingLevel");
+  });
+});