@zhushanwen/subagent-core 0.2.0 → 0.5.1

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

@@ -2,7 +2,7 @@
 //
 // W1 红灯测试：spawn-event-adapter.ts 协议层重写 — Pi 原生格式 + method 平铺。
 //
-// 测试对象：extensions/universal/subagent-workflow/src/execution/spawn-event-adapter.ts（改造）
+// 测试对象：packages/subagent-core/src/execution/engine/engines/pi/spawn-event-adapter.ts（改造）
 // 契约来源：.fix-plans/00-master-summary.md §二（统一接口契约）+ §一冲突 2/判定顺序
 //
 // 核心改动：
@@ -18,7 +18,7 @@
 
 import { describe, expect, it } from "vitest";
 
-import { parseSpawnLine } from "../spawn-event-adapter.ts";
+import { parseSpawnLine } from "../engine/engines/pi/spawn-event-adapter.ts";
 
 // ── Pi 原生协议样本构造（来源：rpc-types.ts L230-265 真实类型） ──────────
 // 10 种 method，全部 {type:"extension_ui_request", id, method, ...平铺字段}。
@@ -28,6 +28,17 @@ function piLine(methodFields: Record<string, unknown>): string {
   return JSON.stringify({ type: "extension_ui_request", id: "req-001", ...methodFields });
 }
 
+
+/** 判别收窄辅助：string-fallback 变体（method: string）使 !== 收窄失效，
+ *  用 Extract 条件类型（可赋值方向）精确取变体。 */
+function asVariant<M extends string>(
+  req: import("../engine/engines/pi/spawn-event-adapter.ts").ExtensionUiRequest,
+  method: M,
+): Extract<import("../engine/engines/pi/spawn-event-adapter.ts").ExtensionUiRequest, { method: M }> {
+  if (req.method !== method) throw new Error(`request.method 应为 ${method}`);
+  return req as Extract<import("../engine/engines/pi/spawn-event-adapter.ts").ExtensionUiRequest, { method: M }>;
+}
+
 describe("parseSpawnLine — 10 种 method 真实样本分类（Pi 原生格式）", () => {
   describe("dialog 类（select/confirm/input/editor）", () => {
     it("select → kind=extension_ui_request + request.method=select + title/options 平铺", () => {
@@ -37,9 +48,7 @@ describe("parseSpawnLine — 10 种 method 真实样本分类（Pi 原生格式
       expect(result?.kind).toBe("extension_ui_request");
       if (result?.kind !== "extension_ui_request") return;
       expect(result.id).toBe("req-001");
-      expect(result.request.method).toBe("select");
-      expect(result.request.title).toBe("Pick one");
-      expect(result.request.options).toEqual(["a", "b"]);
+      const req = asVariant(result.request, "select");
     });
 
     it("confirm → request.method=confirm + title/message 平铺", () => {
@@ -48,9 +57,7 @@ describe("parseSpawnLine — 10 种 method 真实样本分类（Pi 原生格式
       }));
       expect(result?.kind).toBe("extension_ui_request");
       if (result?.kind !== "extension_ui_request") return;
-      expect(result.request.method).toBe("confirm");
-      expect(result.request.title).toBe("Sure?");
-      expect(result.request.message).toBe("Proceed?");
+      const req = asVariant(result.request, "confirm");
     });
 
     it("input → request.method=input + title + placeholder", () => {
@@ -59,8 +66,7 @@ describe("parseSpawnLine — 10 种 method 真实样本分类（Pi 原生格式
       }));
       expect(result?.kind).toBe("extension_ui_request");
       if (result?.kind !== "extension_ui_request") return;
-      expect(result.request.method).toBe("input");
-      expect(result.request.placeholder).toBe("type here");
+      const req = asVariant(result.request, "input");
     });
 
     it("editor → request.method=editor + title + prefill", () => {
@@ -69,8 +75,7 @@ describe("parseSpawnLine — 10 种 method 真实样本分类（Pi 原生格式
       }));
       expect(result?.kind).toBe("extension_ui_request");
       if (result?.kind !== "extension_ui_request") return;
-      expect(result.request.method).toBe("editor");
-      expect(result.request.prefill).toBe("initial text");
+      const req = asVariant(result.request, "editor");
     });
   });
 
@@ -81,8 +86,7 @@ describe("parseSpawnLine — 10 种 method 真实样本分类（Pi 原生格式
       }));
       expect(result?.kind).toBe("extension_ui_request");
       if (result?.kind !== "extension_ui_request") return;
-      expect(result.request.method).toBe("notify");
-      expect(result.request.message).toBe("hi");
+      const req = asVariant(result.request, "notify");
     });
 
     it("setStatus → request.method=setStatus + statusKey/statusText", () => {
@@ -91,8 +95,8 @@ describe("parseSpawnLine — 10 种 method 真实样本分类（Pi 原生格式
       }));
       expect(result?.kind).toBe("extension_ui_request");
       if (result?.kind !== "extension_ui_request") return;
-      expect(result.request.method).toBe("setStatus");
-      expect(result.request.statusKey).toBe("k");
+      const req = asVariant(result.request, "setStatus");
+      expect(req.statusKey).toBe("k");
     });
 
     it("setWidget → request.method=setWidget + widgetKey/widgetLines/widgetPlacement", () => {
@@ -102,25 +106,24 @@ describe("parseSpawnLine — 10 种 method 真实样本分类（Pi 原生格式
       }));
       expect(result?.kind).toBe("extension_ui_request");
       if (result?.kind !== "extension_ui_request") return;
-      expect(result.request.method).toBe("setWidget");
-      expect(result.request.widgetKey).toBe("w1");
-      expect(result.request.widgetPlacement).toBe("aboveEditor");
+      const req = asVariant(result.request, "setWidget");
+      expect(req.widgetKey).toBe("w1");
+      expect(req.widgetPlacement).toBe("aboveEditor");
     });
 
     it("setTitle → request.method=setTitle + title", () => {
       const result = parseSpawnLine(piLine({ method: "setTitle", title: "My Title" }));
       expect(result?.kind).toBe("extension_ui_request");
       if (result?.kind !== "extension_ui_request") return;
-      expect(result.request.method).toBe("setTitle");
-      expect(result.request.title).toBe("My Title");
+      const req = asVariant(result.request, "setTitle");
+      expect(req.title).toBe("My Title");
     });
 
     it("set_editor_text → request.method=set_editor_text + text", () => {
       const result = parseSpawnLine(piLine({ method: "set_editor_text", text: "body" }));
       expect(result?.kind).toBe("extension_ui_request");
       if (result?.kind !== "extension_ui_request") return;
-      expect(result.request.method).toBe("set_editor_text");
-      expect(result.request.text).toBe("body");
+      const req = asVariant(result.request, "set_editor_text");
     });
   });
 });

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

@@ -9,7 +9,7 @@ import {
   deriveSessionFilePath,
   findSessionFileByHeaderId,
   parseSpawnLine,
-} from "../spawn-event-adapter.ts";
+} from "../engine/engines/pi/spawn-event-adapter.ts";
 
 describe("parseSpawnLine", () => {
   describe("空白行", () => {

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

@@ -71,7 +71,7 @@ vi.mock("../alive-store.ts", () => ({
   writeAliveMarker: vi.fn(),
 }));
 
-vi.mock("../temp-prompt.ts", () => ({
+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, "_");
@@ -83,7 +83,7 @@ vi.mock("../temp-prompt.ts", () => ({
 import { spawn } from "node:child_process";
 
 import { createRecord } from "../execution-record.ts";
-import { runSpawn, type RunOptions, type SessionRunnerContext } from "../session-runner.ts";
+import { runSpawn, type RunOptions, type SessionRunnerContext } from "../engine/engines/pi/session-runner.ts";
 
 const mockSpawn = vi.mocked(spawn);
 
@@ -117,8 +117,9 @@ function makeRecord() {
   return createRecord("wt-guidance-1", {
     agent: "general-purpose",
     model: "test/model",
-    mode: "sync",
+    mode: "background",
     task: "test task",
+    slug: "test",
     startedAt: Date.now(),
     rootSessionId: "s1",
     parentRecordId: undefined,
@@ -128,7 +129,7 @@ function makeRecord() {
 
 function makeRunOpts(overrides: Partial<RunOptions> = {}): RunOptions {
   return {
-    resolved: { model: { provider: "test", id: "model" }, thinkingLevel: undefined },
+    resolved: { model: { provider: "test", id: "model", name: "Model", reasoning: false }, thinkingLevel: undefined },
     agentConfig: undefined,
     appendSystemPrompt: undefined,
     skillPath: undefined,

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

@@ -5,7 +5,14 @@
 // M2-B1 把 spawnedChildren 从 Set<ChildProcess> 改为 Map<recordId, ChildProcess>，
 // 建立 record→child 映射（busy 投递定位活进程用，设计决策 6）。本文件测 Map API 核心行为：
 //   - getChildByRecord：set 后能查到；delete 后查不到；未注册返回 undefined
-//   - killAllSpawnedChildren：遍历 .values() kill + clear；跳过 child.killed=true；单 child kill 抛错不阻断
+//   - 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。
 
@@ -16,13 +23,58 @@ 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 { getChildByRecord, killAllSpawnedChildren, spawnedChildren } from "../session-runner.ts";
+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>;
+  };
+}
 
-/** 假 child：只关心 killed 标记 + kill 调用（killAllSpawnedChildren 遍历用）。 */
-function makeFakeChild(killed = false): ChildProcess & { kill: ReturnType<typeof vi.fn> } {
-  return { killed, kill: vi.fn() } 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)", () => {
@@ -58,17 +110,29 @@ describe("spawnedChildren Map + getChildByRecord (M2-B1)", () => {
     expect(spawnedChildren.size).toBe(0);
   });
 
-  it("killAllSpawnedChildren 跳过 child.killed=true（不重复 kill 已 kill 的）", () => {
+  it("[T2-⑤] killed 但未确认死亡 → 不跳过，补 SIGKILL 升级（killed=发过请求≠已死）", () => {
     const alive = makeFakeChild(false);
-    const alreadyKilled = makeFakeChild(true);
+    const killedNotClosed = makeFakeChild(true); // SIGTERM 已发、exit/signal 仍 null
     spawnedChildren.set("rec-1", alive);
-    spawnedChildren.set("rec-2", alreadyKilled);
+    spawnedChildren.set("rec-2", killedNotClosed);
 
     const n = killAllSpawnedChildren();
 
-    expect(n).toBe(1);
-    expect(alive.kill).toHaveBeenCalledTimes(1);
-    expect(alreadyKilled.kill).not.toHaveBeenCalled();
+    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);
   });
 
@@ -90,3 +154,83 @@ describe("spawnedChildren Map + getChildByRecord (M2-B1)", () => {
     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);
+  });
+});

package/src/execution/__tests__/start-sync-model-guard.test.ts

@@ -30,14 +30,14 @@ vi.mock("node:child_process", async () => {
 });
 
 // buildSpawnArgs 包装为 spy（保留真实实现）——「非全等拒单不触达 spawn 参数组装」的承重断言。
-vi.mock("../session-runner.ts", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../session-runner.ts")>();
+vi.mock("../engine/engines/pi/session-runner.ts", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../engine/engines/pi/session-runner.ts")>();
   return { ...actual, buildSpawnArgs: vi.fn(actual.buildSpawnArgs) };
 });
 
 import { ModelConfigService } from "../model-config-service.ts";
 import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
-import { buildSpawnArgs } from "../session-runner.ts";
+import { buildSpawnArgs } from "../engine/engines/pi/session-runner.ts";
 import type { PiLike } from "../subagent-service.ts";
 import { SubagentService } from "../subagent-service.ts";
 
@@ -128,7 +128,7 @@ describe("start 同步期裁决（U1 验收 3：非全等 → isError 且无 spa
   });
 
   it("全等入参通过裁决（reject 不发生，放行链路触达 spawn 参数组装）——守卫零误伤对照", async () => {
-    // 放行路径会进入 kickOffBackground（detached）；execute resolve 即视为裁决放行。
+    // 放行路径会进入轮次 kick-off（detached）；execute resolve 即视为裁决放行。
     // spawn 本身由 FakeChild 缺失抛错收口——本断言只关心「越过了同步裁决」：
     // execute 不 reject，且 buildSpawnArgs 已被调（或即将被调的 record 已创建）。
     const promise = service.execute({

package/src/execution/__tests__/stdin-writer.test.ts

@@ -33,7 +33,7 @@ vi.mock("../../core/logger.ts", () => ({
   getLogger: () => loggerMock,
 }));
 
-import { respond, sendGetStateCommand, sendPromptCommand } from "../stdin-writer.ts";
+import { respond, sendGetStateCommand, sendPromptCommand } from "../engine/engines/pi/stdin-writer.ts";
 
 // ── helpers ──
 
@@ -362,8 +362,10 @@ describe("sendGetStateCommand", () => {
 describe("writeStdinLine 背压 — write 返回 false 时 warn 不 throw", () => {
   it("child.stdin.write 返回 false → warn 一次，函数正常返回（不 throw）", () => {
     // 构造 write 永远返回 false 的假 stream（模拟内核缓冲满/HWM 到达）
+    // 保留 vi.fn 引用（经 PassThrough 视图后 write 的 mock 面不可达）
+    const fakeWrite = vi.fn((_chunk: unknown) => false);
     const fakeStdin = {
-      write: vi.fn(() => false),
+      write: fakeWrite,
       destroyed: false,
     } as unknown as PassThrough;
     const child = { stdin: fakeStdin } as unknown as ChildProcess;
@@ -371,8 +373,8 @@ describe("writeStdinLine 背压 — write 返回 false 时 warn 不 throw", () =
     expect(() => respond(child, "req-backpressure", { value: "x" })).not.toThrow();
 
     // write 被调一次（写入 command 行）
-    expect(fakeStdin.write).toHaveBeenCalledTimes(1);
-    const writtenArg = fakeStdin.write.mock.calls[0]?.[0] as string;
+    expect(fakeWrite).toHaveBeenCalledTimes(1);
+    const writtenArg = fakeWrite.mock.calls[0]![0] as string;
     expect(writtenArg).toContain("extension_ui_response");
     expect(writtenArg).toContain("req-backpressure");
     expect(writtenArg.endsWith("\n")).toBe(true);

package/src/execution/__tests__/stream-sink-retirement.test.ts

@@ -3,7 +3,7 @@
 // widget 私货通道退役步骤 2（E 方案 §6.3）测试，两层：
 //   判定层：createBackgroundStream 真实函数（vi.importActual 绕过文件级 mock）——
 //   gui+relay 激活不创建；tui / relay 未激活 / headless 原样创建；sink=null 恒降级。
-//   接线层：SubagentService.execute（background → kickOffBackground 同步段）透传
+//   接线层：SubagentService.execute（background → kickOffChatRound 同步段）透传
 //   mode/streamSink 给工厂——mode 传错 = 判定失效，故接线面必须锁定。
 //
 // spawn 层 mock（FakeChild），与 nested-visibility-env-propagation.test.ts 同模式。
@@ -103,7 +103,7 @@ vi.mock("../manifest-store.ts", () => {
   return { ManifestStore: vi.fn(function (_recordsDir: string) { return new FakeManifestStore(); }) };
 });
 
-vi.mock("../temp-prompt.ts", () => ({
+vi.mock("../engine/engines/pi/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` };
@@ -156,7 +156,7 @@ const ctxModel: ModelInfo = { id: "m", name: "M", provider: "p", reasoning: fals
 
 function setupService(mode: ExtensionMode | undefined, sessionId = "retire-it"): SubagentService {
   const agentDir = "/tmp/stream-retire-it";
-  const modelService = new ModelConfigService({ agentDir });
+  const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
   modelService.initModel({
     modelRegistry: makeEmptyRegistry(),
     sessionId,
@@ -176,7 +176,7 @@ function setupService(mode: ExtensionMode | undefined, sessionId = "retire-it"):
   return service;
 }
 
-/** 等 kickOffBackground 的 detached runAndFinalize 走到 spawn（stream 创建先于此）。 */
+/** 等 kickOffChatRound 的 detached 轮次执行走到 spawn（stream 创建先于此）。 */
 async function waitForSpawnCall(): Promise<void> {
   const baseline = mockSpawn.mock.calls.length;
   const deadline = Date.now() + 2000;
@@ -187,7 +187,7 @@ async function waitForSpawnCall(): Promise<void> {
 }
 
 async function executeBackground(service: SubagentService): Promise<void> {
-  await service.execute({ task: "retire test", ctxModel });
+  await service.execute({ task: "retire test", slug: "test", ctxModel });
   await waitForSpawnCall();
   // 推进 detached runSpawn 收尾（FakeChild close），防句柄悬挂干扰后续用例
   lastSpawnedChild().emit("close", 0);
@@ -234,7 +234,7 @@ describe("退役步骤 2 判定层：createBackgroundStream", () => {
 
 // ── 接线层：service → 工厂的参数透传（mode 传错 = 判定失效）──
 
-describe("退役步骤 2 接线层：kickOffBackground 透传 mode/sink 给工厂", () => {
+describe("退役步骤 2 接线层：kickOffChatRound 透传 mode/sink 给工厂", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     for (const key of RELAY_ENV_KEYS) delete process.env[key];