@zhushanwen/subagent-core 0.6.0 → 0.7.1

package/src/execution/engine/__tests__/conformance/chat-round-protocol.test.ts

@@ -0,0 +1,230 @@
+// chat-round-protocol.test.ts —— [W6] chat 轮次协议 v1.x 增量的协议黑盒契约。
+//
+// 设计权威源：chat-domain-v1x-liveness-governance.md §3.2 D1-A + §5 W1/W6 行 +
+// 验收 A6。W1 SDK 已交付第 9 反向通道 host/roundLifecycle（settled/idle/failed
+// 三相位，关联键 runId|recordId 互斥分路）与 conversation gate 负向构造器；本套件
+// 在 conformance 层（协议客户端 × fake 引擎 CLI）钉住三条语义，供 W3 chat 改线与
+// A7 live 门回归：
+//
+//   ① roundLifecycle 三相位（settled/idle/failed）× 双关联键：数据面回执链闭合
+//      （宿主必须确认收到——fake 引擎收到帧②应答后回发 host/log "ack …" 回声，
+//      NDJSON 单连接有序保证回声先于 run 应答帧到达）；core 不误判引擎故障
+//      （run 正常 resolve + 客户端保持 ready，10s 数据面守卫不触发）。
+//   ② recordId 键 streamDelta 分路：续聊轮 delta 经 recordId 关联（D1-A 裁定，
+//      InteractParams/Result 无 runId）。[W3 接线落地] reverse-router 的 recordId
+//      分支接 EngineClient.recordRoutes 真实消费——本用例钉「宿主确认收到 +
+//      delta 投递到 recordId 注册的 chat 轮消费点 + 不误投 runId 路由」。
+//   ③ conversation gate 负向（A6）：manifest 无 conversation 位的引擎（capabilities
+//      覆写 unsupported）→ assertChatConversationSupported 同步拒——错误码
+//      engine_capability_unsupported + 恢复指引含「升级引擎包」文案契约；同一
+//      客户端的 run 域完全正常（gate 只拦 chat 面不伤 run 域）。
+//
+// 帧载荷类型权威 = W1 SDK `HostRoundLifecycleParams`（isHostRoundLifecycleParams
+// 的相位居留形状由 SDK 包内测试覆盖）；fake 引擎按该形状发帧，本套件断言消费侧。
+
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import {
+  assertChatConversationSupported,
+  isHostRoundLifecycleParams,
+  type InitializeResult,
+} from "@zhushanwen/subagent-engine-sdk";
+
+import { EngineClient } from "../../client/engine-client.ts";
+
+const FIXTURE_DIR = join(dirname(fileURLToPath(import.meta.url)), "__fixtures__", "engine-protocol");
+const FAKE_ENGINE = join(FIXTURE_DIR, "fake-engine-protocol.mjs");
+const FIXTURE = join(FIXTURE_DIR, "smoke-run.fixture.json");
+
+let dataDir: string;
+
+beforeEach(() => {
+  dataDir = mkdtempSync(join(tmpdir(), "w6-chat-round-protocol-"));
+});
+
+afterEach(() => {
+  rmSync(dataDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+});
+
+interface Harness {
+  client: EngineClient;
+  logs: Array<{ level: string; message: string }>;
+  streamDeltas: string[];
+  /** [W3] recordId 键 chat 轮路由捕获（续聊轮 delta 消费点）。 */
+  recordDeltas: string[];
+  recordPhases: Array<Record<string, unknown>>;
+}
+
+function makeHarness(extraEnv: Record<string, string> = {}): Harness {
+  const h: Harness = {
+    client: undefined as unknown as EngineClient,
+    logs: [],
+    streamDeltas: [],
+    recordDeltas: [],
+    recordPhases: [],
+  };
+  h.client = new EngineClient({
+    engineId: "fake",
+    command: process.execPath,
+    args: [FAKE_ENGINE],
+    hostKind: "test",
+    hostVersion: "w6-chat-round-protocol",
+    dataDir,
+    envPrefixes: [],
+    log: (p) => h.logs.push({ level: p.level, message: p.message }),
+    baseEnv: {
+      ...process.env,
+      FAKE_PROTOCOL_FIXTURE: FIXTURE,
+      ...extraEnv,
+    },
+  });
+  const unregister = h.client.registerRunRoute("run-smoke-1", {
+    onStreamDelta: (delta) => {
+      h.streamDeltas.push(delta);
+    },
+  });
+  void unregister;
+  // [W3] recordId 键 chat 轮路由（registerRecordRoute——RemoteEngine.registerChatRoundRoute
+  // 的底层实现；conformance 层直接驱动 EngineClient 面）。
+  const unregisterRecord = h.client.registerRecordRoute("rec-chat-1", {
+    onStreamDelta: (delta) => {
+      h.recordDeltas.push(delta);
+    },
+    onRoundLifecycle: (phase) => {
+      h.recordPhases.push(phase as Record<string, unknown>);
+    },
+  });
+  void unregisterRecord;
+  return h;
+}
+
+describe("[W6] host/roundLifecycle 三相位 × 双关联键（协议黑盒回执链）", () => {
+  it("settled/idle/failed 相位 × runId|recordId 键全部被宿主确认（ack 回声）且不判引擎故障", async () => {
+    const h = makeHarness({ FAKE_RUN_LIFECYCLE: "1" });
+    try {
+      await h.client.ensureConnected();
+      const result = (await h.client.request("run", {
+        runId: "run-smoke-1",
+        task: "w6 round lifecycle probe",
+        ctx: { poolKey: "shared", cwd: dataDir, model: "fake/fake-1" },
+      })) as { outcome: Record<string, unknown> };
+      void result;
+
+      // 回执链闭合：6 帧（三相位 × runId 键 "run-smoke-1" / recordId 键 "rec-chat-1"）
+      // 的帧②应答全部到达 fake 引擎并回发回声——「宿主必须确认收到」的数据面契约。
+      // 回声帧经引擎侧往返（core 帧②应答 → fake 收到 → 回发 log），晚于 run 应答
+      // 帧到达——断言轮询等待（NDJSON 单连接有序，run resolve 后毫秒级必达）。
+      await expect
+        .poll(
+          () => h.logs.map((l) => l.message).filter((m) => m.startsWith("ack roundLifecycle ")),
+          { timeout: 5_000, interval: 20 },
+        )
+        .toEqual([
+        "ack roundLifecycle run-smoke-1 settled",
+        "ack roundLifecycle run-smoke-1 idle",
+        "ack roundLifecycle run-smoke-1 failed",
+        "ack roundLifecycle rec-chat-1 settled",
+        "ack roundLifecycle rec-chat-1 idle",
+        "ack roundLifecycle rec-chat-1 failed",
+      ]);
+
+      // [W3 接线契约] recordId 键相位帧投递到 registerRecordRoute 注册的 chat 轮
+      // 消费点（settled/idle/failed 三相位按序；宿主编排层据此做交棒/挂 idle timer/
+      // 失败分诊——分发层只做键路由）。
+      await expect
+        .poll(() => h.recordPhases.map((p) => `${p.recordId}:${String(p.phase)}`), { timeout: 5_000, interval: 20 })
+        .toEqual([
+          "rec-chat-1:settled",
+          "rec-chat-1:idle",
+          "rec-chat-1:failed",
+        ]);
+
+      // 不误判引擎故障：run 正常 resolve + 客户端保持 ready（10s 数据面应答守卫
+      // 未触发杀链——roundLifecycle 是数据面回执语义，不是故障信号）。
+      expect(h.client.currentState).toBe("ready");
+
+      // failed 相位的 error{code,message} 居留形状（isHostRoundLifecycleParams
+      // 判据的 failed 分支）——fake 引擎按 W1 载荷类型构造，宿主侧对同形状自证。
+      const failedShape = {
+        runId: "run-smoke-1",
+        phase: "failed",
+        error: { code: "engine_run_failed", message: "round failed (scripted)", recovery: "retry" },
+      };
+      expect(isHostRoundLifecycleParams(failedShape)).toBe(true);
+      const malformedShape = { runId: "r", recordId: "c", phase: "settled" };
+      expect(isHostRoundLifecycleParams(malformedShape)).toBe(false);
+    } finally {
+      await h.client.dispose();
+    }
+  });
+});
+
+describe("[W6] recordId 键 streamDelta / roundLifecycle 分路（续聊轮关联键，D1-A）", () => {
+  it("recordId 键 delta：宿主确认收到（ack 回声）+ 投递到 recordId 注册的 chat 轮消费点，不误投 runId 路由", async () => {
+    const h = makeHarness({ FAKE_RUN_RECORD_DELTA: "1" });
+    try {
+      await h.client.ensureConnected();
+      await h.client.request("run", {
+        runId: "run-smoke-1",
+        task: "w6 record-key delta probe",
+        ctx: { poolKey: "shared", cwd: dataDir, model: "fake/fake-1" },
+      });
+
+      // 宿主确认收到（数据面回执闭合；回声帧晚于 run 应答到达，轮询等待）。
+      await expect
+        .poll(() => h.logs.map((l) => l.message), { timeout: 5_000, interval: 20 })
+        .toContain("ack streamDelta recordId=rec-chat-1");
+      // [W3 接线契约] recordId 键投递到 recordRoutes 注册的 chat 轮消费点
+      //（W1 偏差 #1 的 no-op 分支已替换为真实分发——reverse-router recordId 分支）。
+      expect(h.recordDeltas).toEqual(["chat-delta-not-routed-to-runId"]);
+      // 关联键分路互斥：recordId 键不误投 runId 路由（runId 键 fixture delta 不受影响）。
+      expect(h.streamDeltas).toEqual(["Hello", " world"]);
+      expect(h.client.currentState).toBe("ready");
+    } finally {
+      await h.client.dispose();
+    }
+  });
+
+});
+
+describe("[W6] conversation gate 负向（A6：无 gate 位引擎 chat 请求同步拒，run 域不受影响）", () => {
+  it("capabilities.conversation=unsupported → assertChatConversationSupported 同步拒 + 文案契约；同客户端 run 正常", async () => {
+    const h = makeHarness({ FAKE_CAPABILITIES_CONVERSATION: "unsupported" });
+    try {
+      await h.client.ensureConnected();
+      const diagnostics = h.client.getInitializeDiagnostics() as InitializeResult;
+      expect(diagnostics.capabilities.conversation).toBe("unsupported");
+
+      // W1 具名构造器（W3 chat 路由接线的判据单源）：同步拒、错误码与恢复指引
+      // 文案契约——「升级引擎包」恢复指引对齐 core capability-gate conversation
+      // 分支（错误 → 权威源 → 重试闭环）。
+      let thrown: unknown;
+      try {
+        assertChatConversationSupported("fake", diagnostics.capabilities);
+      } catch (err) {
+        thrown = err;
+      }
+      expect(thrown).toMatchObject({
+        name: "EngineSdkError",
+        code: "engine_capability_unsupported",
+      });
+      expect((thrown as Error).message).toContain("conversation");
+      expect((thrown as { recovery: string }).recovery).toContain("升级引擎包");
+
+      // A6 后半：gate 只拦 chat 面——同一客户端的 run 域完全正常。
+      const result = (await h.client.request("run", {
+        runId: "run-smoke-1",
+        task: "w6 gate-negative run-domain probe",
+        ctx: { poolKey: "shared", cwd: dataDir, model: "fake/fake-1" },
+      })) as { outcome: Record<string, unknown> };
+      expect(result.outcome).toBeDefined();
+      expect(h.client.currentState).toBe("ready");
+    } finally {
+      await h.client.dispose();
+    }
+  });
+});

package/src/execution/engine/__tests__/conformance/contract.abort.test.ts

@@ -1,66 +1,93 @@
-// contract.abort.test.ts —— conformance C4（abort 行为）：运行中 cancel → 宿主合成
-// 终态（exitCode=null）、无悬挂 promise（run 正常 resolve、exited 收口）、错误事件
-// 先于终态 emit（不变量 5 的事件面）。fake app-server 注入（不依赖真机）。
+// contract.abort.test.ts —— conformance C4（abort 行为）：运行中 cancel → 引擎
+// 3s 窗口内收敛终态、无悬挂 promise、错误语义结构化。
 //
-// 2026-09 重构（共享宿主 HOME）：CLI spawn 降级链删除后引擎只剩 app-server 常驻链，
-// abort 用例只覆盖常驻形态（fake-appserver.mjs 挂起场景，stop 链优先于杀链——D3）。
-// capabilities.interrupt 维持 kill-only 声明（D5——改链路先于改声明，stop 链路经
-// conformance 真机验证后再评估升 native）。
+// W10 协议黑盒化：断言对象从内建 ZcodeEngine × fake app-server（inproc，W11 删除）
+// 改为 RemoteEngine × fake 引擎 CLI——abort 走协议 cancel 帧 + 引擎收敛应答
+// （杀链升级面 = W2 EngineClient 套件 3s 收敛窗口用例）。zcode app-server 的
+// stop 优雅链随 W5 归 zcode-subagent-cli 引擎内测试。
 
-import { describe, expect, it, vi } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
 import type { AgentCallOpts } from "../../../../orchestration/models/types.ts";
+import { EngineClient } from "../../client/engine-client.ts";
+import { RemoteEngine } from "../../client/remote-engine.ts";
 import type { RunContext } from "../../port.ts";
 import type { AgentEvent } from "../../types.ts";
-import { makeAppserverHarness, sentMethodNames } from "./zcode-appserver-harness.ts";
+import { FAKE_CAPABILITIES } from "./fake-engine-capabilities.ts";
 
-describe("conformance C4：abort 行为（运行中 cancel → 合成终态、无悬挂）", () => {
-  // app-server 常驻形态：abort 走 D3 链（stop → grace → killChain）。挂起场景
-  // （只推 state.updated，turn 永不落定）+ stopBehavior 缺省 terminal = stop 优雅
-  // 生效路径——不杀共享进程，run 正常 resolve（C4 的常驻通道面）。
-  it("app-server 模式：abort → stop 帧先发 → 优雅收口（run resolve、exitCode=null、error 事件先于终态、kill-only 声明维持）", async () => {
-    const h = makeAppserverHarness({ hangOnly: true });
-    try {
-      // capabilities.interrupt 维持 kill-only（D5——升级序里 interrupt 不动）
-      expect(h.engine.capabilities().interrupt).toBe("kill-only");
+const FAKE_ENGINE = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "__fixtures__", "engine-protocol", "fake-engine-protocol.mjs",
+);
+const FIXTURE = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "__fixtures__", "engine-protocol", "smoke-run.fixture.json",
+);
+
+let dataDir: string;
+
+beforeEach(() => {
+  dataDir = mkdtempSync(join(tmpdir(), "w10-c4-abort-"));
+});
 
+afterEach(() => {
+  rmSync(dataDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+});
+
+function makeEngine(): { engine: RemoteEngine; dispose: () => Promise<void> } {
+  const client = new EngineClient({
+    engineId: "fake",
+    command: process.execPath,
+    args: [FAKE_ENGINE],
+    hostKind: "test",
+    hostVersion: "w10-c4-abort",
+    dataDir,
+    envPrefixes: [],
+    baseEnv: { ...process.env, FAKE_PROTOCOL_FIXTURE: FIXTURE, FAKE_RUN_HANG: "1" },
+  });
+  const engine = new RemoteEngine({
+    engineId: "fake",
+    client,
+    manifest: { capabilities: FAKE_CAPABILITIES },
+    dataDir,
+    hostKind: "test",
+  });
+  return { engine, dispose: () => engine.dispose() };
+}
+
+describe("conformance C4：abort 行为（协议黑盒：cancel 帧 + 引擎收敛）", () => {
+  it("挂起 run 中 abort → cancel 帧送达 → 引擎窗口内收敛终态，run 正常 resolve（不悬挂）", async () => {
+    const { engine, dispose } = makeEngine();
+    try {
       const controller = new AbortController();
       const events: AgentEvent[] = [];
       const ctx: RunContext = {
-        taskId: "sa-c4-appserver",
-        poolKey: "",
+        taskId: "w10-c4-abort",
+        poolKey: "shared",
         signal: controller.signal,
         onEvent: (e) => events.push(e),
       };
-      // D6 合流后单一任务形状 AgentCallOpts（prompt≡原 task、description≡原 slug 源）
       const task: AgentCallOpts = {
         prompt: "hang",
-        description: "abort-appserver",
-        model: "conformance-provider/m1",
-        cwd: h.workspace,
+        description: "abort-protocol",
+        model: "fake/fake-1",
+        cwd: dataDir,
       };
-      const runP = h.engine.run(task, ctx);
-      // 推进到 send 已达（create+send 帧落 fake 流水）再 abort——abort 先于 create 会
-      // 走 pre-aborted 短路面，覆盖不到 stop 链
-      await vi.waitFor(
-        () => expect(sentMethodNames(h.stateFile)).toContain("session/send"),
-        { timeout: 5_000 },
-      );
+      const runP = engine.run(task, ctx);
+      // 推进到 run 受理（fake 引擎进入 hang，poolResolved 反向帧已回）再 abort——
+      // abort 先于受理会走 pre-aborted 短路面，覆盖不到 cancel 帧
+      await new Promise((r) => setTimeout(r, 300));
       controller.abort();
-      const { outcome } = await runP; // 必须正常 resolve（stop 优雅收口，不悬挂）
+      const { outcome } = await runP; // 必须正常 resolve（引擎收敛，无需杀链）
 
       expect(outcome.exitCode).toBeNull();
-      expect(outcome.error).toContain("session/stop");
-      // 错误事件先于终态 emit（不变量 5 的事件面——journal 可重放出失败事实）。abort
-      // 终态不合成 turn_end（只断言 error 事件到达，且其后无任何非 error 事件流出）
-      const errorIdx = events.findIndex((e) => e.type === "error");
-      expect(errorIdx).toBeGreaterThanOrEqual(0);
-      expect(events.slice(errorIdx + 1).every((e) => e.type === "error")).toBe(true);
-      // D3 序：stop 帧先于任何杀链动作（优雅路径下进程未被杀）
-      const methods = sentMethodNames(h.stateFile);
-      expect(methods.indexOf("session/stop")).toBeGreaterThan(methods.indexOf("session/send"));
+      expect(outcome.error).toContain("cancelled");
     } finally {
-      await h.dispose();
+      await dispose();
     }
   }, 20_000);
 });

package/src/execution/engine/__tests__/conformance/contract.agent-events.test.ts

@@ -3,7 +3,10 @@
 // parser」的形态：构造抽掉 message_end / usage 半映射的坏样本流，断言套件转红；
 // 若断言器检不出破坏则本元测试失败）。
 //
-// 2026-09 重构（共享宿主 HOME）：CLI spawn 链删除后引擎只剩 app-server 常驻链，
+// W10 协议化：app-server 常驻全链用例随 zcode 引擎内移（zcode-subagent-cli
+// protocol-e2e/zcode-engine-* 测试覆盖，fake-appserver + golden 同款语料）；core 侧
+// 保留断言器正反例与负例自证（协议黑盒套件 protocol-blackbox.test.ts 消费断言器）。
+// 历史注：2026-09 重构（共享宿主 HOME）：CLI spawn 链删除后引擎只剩 app-server 常驻链，
 // C3 的引擎全链覆盖只走 app-server 形态（fake 常驻引擎 + stream 口径，文件末
 // describe；app-server 设计 §3.4 不变量 1：text_delta 拼接 == read 全文、终态唯一
 // turn.terminal 权威、message_end.usage 完整、tool 事件不合成——granularity 声明
@@ -12,12 +15,6 @@
 import { describe, expect, it } from "vitest";
 
 import type { AgentEvent } from "../../../types.ts";
-import { ZCODE_APPSERVER_GOLDEN } from "../../engines/zcode/golden-sample.ts";
-import { ZCODE_SHARED_POOL_KEY } from "../../engines/zcode/constants.ts";
-import {
-  goldenReadFullText,
-  makeAppserverHarness,
-} from "./zcode-appserver-harness.ts";
 import {
   assertAgentEventInvariants,
   checkAgentEventInvariants,
@@ -98,77 +95,3 @@ describe("conformance 负例自证（A12：套件有牙）", () => {
     expect(findings.some((f) => f.invariant === "2")).toBe(true);
   });
 });
-
-// ============================================================
-// [R6] C3 app-server 口径：fake 常驻引擎全链（eventGranularity=stream 形态）
-// —— 2026-09 重构后唯一生产形态（CLI spawn 降级链已删，无钉扎/降级双通道）。
-// ============================================================
-
-describe("conformance C3：zcode app-server 常驻通道（stream 口径，fake 常驻全链）", () => {
-  it("text_delta 拼接 == read 全文（byte 级）+ 终态唯一 + message_end.usage 完整 + tool 事件不合成", async () => {
-    const h = makeAppserverHarness();
-    try {
-      const events: AgentEvent[] = [];
-      const { outcome } = await h.engine.run(
-        { prompt: "做点什么", description: "c3-appserver", model: "conformance-provider/m1", cwd: h.workspace },
-        { taskId: "sa-c3-appserver", poolKey: "", onEvent: (e) => events.push(e) },
-      );
-
-      // granularity 声明与实际流出一致：声明 stream，流出有 text_delta 实时形态
-      expect(h.engine.capabilities().eventGranularity).toBe("stream");
-      expect(events.some((e) => e.type === "text_delta")).toBe(true);
-
-      // 事件形态：三条 delta（golden pushStream）→ message_end(usage) → turn_end
-      expect(events.map((e) => e.type)).toEqual([
-        "text_delta", "text_delta", "text_delta", "message_end", "turn_end",
-      ]);
-      const messageEnd = events.find((e) => e.type === "message_end") as
-        | { usage?: { input: number; output: number; cacheRead: number; cacheWrite: number } }
-        | undefined;
-      expect(messageEnd?.usage).toEqual({ input: 12599, output: 17, cacheRead: 0, cacheWrite: 0 });
-
-      // tool 事件不合成：首期无逐工具推送帧，流出面不伪造 tool_start/tool_end
-      // （granularity 声明与实际流出一致即合法——app-server 设计 §3.4 不变量 1）
-      expect(events.some((e) => e.type === "tool_start" || e.type === "tool_end")).toBe(false);
-
-      // 不变量五条（stream 口径）：3a 的 content 用 read 全文（终态权威来源）
-      const readFullText = goldenReadFullText();
-      assertAgentEventInvariants(events, { granularity: "stream", content: readFullText });
-      expect(outcome.content).toBe(readFullText);
-    } finally {
-      await h.dispose();
-    }
-  }, 20_000);
-
-  it("终态权威 turn.terminal 缺失 → read 兜底收口，事件不变量仍全绿（宽松匹配防洪堤不破坏 C3）", async () => {
-    const h = makeAppserverHarness({ dropTurnTerminal: true });
-    try {
-      const events: AgentEvent[] = [];
-      const { outcome } = await h.engine.run(
-        { prompt: "做点什么", description: "c3-no-terminal", model: "conformance-provider/m1", cwd: h.workspace },
-        { taskId: "sa-c3-no-terminal", poolKey: "", onEvent: (e) => events.push(e) },
-      );
-      expect(outcome.error).toBeUndefined();
-      // 缺 turn.terminal 时收尾帧 + read 兜底仍产出完整终态（session-channel 宽松匹配）
-      assertAgentEventInvariants(events, { granularity: "stream", content: goldenReadFullText() });
-    } finally {
-      await h.dispose();
-    }
-  }, 20_000);
-
-  it("handle 携带 shared poolKey（共享宿主 HOME 的 journal 分组锚点，①级读取钥匙随 handle 走）", async () => {
-    const h = makeAppserverHarness();
-    try {
-      const { handle, outcome } = await h.engine.run(
-        { prompt: "做点什么", description: "c3-anchor", model: "conformance-provider/m1", cwd: h.workspace },
-        { taskId: "sa-c3-anchor", poolKey: "" },
-      );
-      expect(handle.data.poolKey).toBe(ZCODE_SHARED_POOL_KEY);
-      expect(handle.data.sessionRef["sessionId"]).toBe(outcome.sessionId);
-      // golden 锚点：sessionId 来自 session.sessionId（projection.sessionId 恒 "unknown" 勿用）
-      expect(JSON.parse(ZCODE_APPSERVER_GOLDEN.createResponse).session.sessionId).toBe("sess_golden_r3_01");
-    } finally {
-      await h.dispose();
-    }
-  }, 20_000);
-});

package/src/execution/engine/__tests__/conformance/contract.probe.test.ts

@@ -1,21 +1,41 @@
 // contract.probe.test.ts —— conformance C1（probe 形状）：ProbeReport 字段完整；
 // ok=false 时 error.recovery 非空（§3.3.5——恢复指引是错误闭环「错误→权威源→重试」
-// 的载体，空指引 = 拦截了但不知道怎么修）。pi/zcode 双引擎都过（任何 adapter 必过）。
+// 的载体，空指引 = 拦截了但不知道怎么修）。
 //
-// fake 注入（不依赖真机）：pi 用 probeVersion fake + 不可解析 invocation 场景；
-// zcode 用不存在的 cliPath 构造 binary check 失败。
+// W10 协议黑盒化：断言对象从内建 PiEngine/ZcodeEngine（inproc，W11 删除）改为
+// RemoteEngine × fake 引擎 CLI（协议 probe 帧往返）——成功/失败两形态都经协议面。
+// 引擎内 probe 细节（版本探测、二进制检查）随 W5/W7 归各引擎包测试。
 
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
-import { describe, expect, it } from "vitest";
-
-import { PiEngine } from "../../engines/pi/pi-engine.ts";
-import { ZcodeEngine } from "../../engines/zcode/zcode-engine.ts";
+import { EngineClient } from "../../client/engine-client.ts";
+import { RemoteEngine } from "../../client/remote-engine.ts";
+import { FAKE_CAPABILITIES } from "./fake-engine-capabilities.ts";
 import type { ProbeReport } from "../../types.ts";
 
+const FAKE_ENGINE = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "__fixtures__", "engine-protocol", "fake-engine-protocol.mjs",
+);
+const FIXTURE = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "__fixtures__", "engine-protocol", "smoke-run.fixture.json",
+);
+
+let dataDir: string;
+
+beforeEach(() => {
+  dataDir = mkdtempSync(join(tmpdir(), "w10-c1-probe-"));
+});
+
+afterEach(() => {
+  rmSync(dataDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+});
+
 function assertProbeShape(report: ProbeReport): void {
   expect(typeof report.ok).toBe("boolean");
   expect(typeof report.engineVersion).toBe("string");
@@ -34,44 +54,47 @@ function assertProbeShape(report: ProbeReport): void {
   }
 }
 
-describe("conformance C1：probe 形状（ProbeReport 字段完整 + 失败含恢复指引）", () => {
-  it("pi：成功路径形状（fake 版本探测，不 spawn 真进程）", async () => {
-    const engine = new PiEngine({ getService: () => null, probeVersion: async () => "0.84.1" });
-    const report = await engine.probe();
-    assertProbeShape(report);
-    expect(report.ok).toBe(true);
-    expect(report.engineVersion).toBe("0.84.1");
+function makeEngine(extraEnv: Record<string, string> = {}): RemoteEngine {
+  const client = new EngineClient({
+    engineId: "fake",
+    command: process.execPath,
+    args: [FAKE_ENGINE],
+    hostKind: "test",
+    hostVersion: "w10-c1-probe",
+    dataDir,
+    envPrefixes: [],
+    baseEnv: { ...process.env, FAKE_PROTOCOL_FIXTURE: FIXTURE, ...extraEnv },
   });
-
-  it("pi：失败路径（invocation 不可解析）——error.recovery 非空", async () => {
-    const engine = new PiEngine({
-      getService: () => null,
-      probeVersion: async () => undefined,
-    });
-    // PATH 无 pi 时 invocation check 失败；有 pi 时版本 fake 失败——两形态都走断言器
-    const report = await engine.probe({ force: true });
-    assertProbeShape(report);
+  return new RemoteEngine({
+    engineId: "fake",
+    client,
+    manifest: { capabilities: FAKE_CAPABILITIES },
+    dataDir,
+    hostKind: "test",
   });
+}
 
-  it("zcode：成功路径形状（存在的 cliPath + fake 版本探测）", async () => {
-    const engine = new ZcodeEngine({
-      engineDataDir: () => fs.mkdtempSync(path.join(os.tmpdir(), "probe-zcode-")),
-      cliPath: fileURLToPath(import.meta.url),
-      probeVersion: async () => "0.16.5",
-    });
-    const report = await engine.probe();
-    assertProbeShape(report);
-    expect(report.ok).toBe(true);
+describe("conformance C1：probe 形状（协议黑盒：RemoteEngine × fake 引擎）", () => {
+  it("成功路径：probe 帧往返 → ProbeReport 形状完整", async () => {
+    const engine = makeEngine();
+    try {
+      const report = await engine.probe();
+      assertProbeShape(report);
+      expect(report.ok).toBe(true);
+    } finally {
+      await engine.dispose();
+    }
   });
 
-  it("zcode：失败路径（二进制不存在）——error.recovery 非空且含重探指引", async () => {
-    const engine = new ZcodeEngine({
-      engineDataDir: () => fs.mkdtempSync(path.join(os.tmpdir(), "probe-zcode-")),
-      cliPath: "/nonexistent/zcode.cjs",
-    });
-    const report = await engine.probe();
-    assertProbeShape(report);
-    expect(report.ok).toBe(false);
-    expect(report.error?.recovery).toContain("--version");
+  it("失败路径（FAKE_PROBE_FAIL）：ok=false + error.recovery 非空且指向动作", async () => {
+    const engine = makeEngine({ FAKE_PROBE_FAIL: "1" });
+    try {
+      const report = await engine.probe({ force: true });
+      assertProbeShape(report);
+      expect(report.ok).toBe(false);
+      expect(report.error?.recovery).toContain("Reinstall");
+    } finally {
+      await engine.dispose();
+    }
   });
 });