@zhushanwen/subagent-core 0.4.0 → 0.6.0

package/src/execution/engine/engines/zcode/__tests__/appserver-launcher.test.ts

@@ -0,0 +1,321 @@
+// appserver-launcher.test.ts —— wrapper fs 拦截语义 + 落盘幂等/覆盖 + exit 面。
+//
+// 防线背景：wrapper 的失效模式是静默的（曾出过首调走未赋值 __origReadFileSync
+// 导致拦截整体失效的 bug——56a49ad4c），本文件用「落盘产物 + 探针 fake CLI」的
+// 真进程集成形态锚定核心语义：v2 注入优先合并、existsSync 拦截（GUI-only 宿主）、
+// encoding 归一、no-patch 分支、透传不受影响。
+
+import * as childProcess from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import {
+  APPSERVER_LAUNCHER_SOURCE,
+  ZCODE_APPSERVER_LAUNCHER_NAME,
+  ensureAppServerLauncher,
+} from "../appserver-launcher.ts";
+
+// 探针 fake CLI：以 wrapper 注入后的 fs 形态读取 CONFIG_PATH 的各种调用形态并
+// 落盘 state（wrapper 对它 import() 启动——与真实 zcode.cjs 同入口形态）
+const PROBE_SOURCE = `'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const CONFIG = path.join(os.homedir(), '.zcode', 'cli', 'config.json');
+const OTHER = path.join(os.homedir(), '.probe-other.txt');
+const STATE = process.env.ZCODE_PROBE_STATE;
+function grab(v) {
+  if (Buffer.isBuffer(v)) return { kind: 'buffer', text: v.toString('utf8') };
+  return { kind: typeof v, text: String(v) };
+}
+async function main() {
+  const out = {};
+  out.existsConfig = fs.existsSync(CONFIG);
+  out.existsMissing = fs.existsSync(path.join(os.homedir(), '.no-such-file'));
+  out.existsOther = fs.existsSync(OTHER);
+  const tries = (label, fn) => {
+    try { out[label] = grab(fn()); } catch (err) { out[label] = { kind: 'error', code: err && err.code }; }
+  };
+  tries('syncUtf8', () => fs.readFileSync(CONFIG, 'utf8'));
+  tries('syncUtf8Dash', () => fs.readFileSync(CONFIG, 'utf-8'));
+  tries('syncUtf8Obj', () => fs.readFileSync(CONFIG, { encoding: 'utf-8' }));
+  tries('syncNoEnc', () => fs.readFileSync(CONFIG));
+  tries('syncOther', () => fs.readFileSync(OTHER, 'utf8'));
+  out.promiseUtf8Dash = await fs.promises.readFile(CONFIG, 'utf-8').then(
+    (v) => grab(v), (err) => ({ kind: 'error', code: err && err.code }));
+  fs.writeFileSync(STATE, JSON.stringify(out));
+}
+main().then(() => process.exit(0), (err) => {
+  process.stderr.write('probe failed: ' + (err && err.stack || err));
+  process.exit(9);
+});
+`;
+
+interface ProbeState {
+  existsConfig: boolean;
+  existsMissing: boolean;
+  existsOther: boolean;
+  syncUtf8: { kind: string; text?: string; code?: string };
+  syncUtf8Dash: { kind: string; text?: string; code?: string };
+  syncUtf8Obj: { kind: string; text?: string; code?: string };
+  syncNoEnc: { kind: string; text?: string; code?: string };
+  syncOther: { kind: string; text?: string; code?: string };
+  promiseUtf8Dash: { kind: string; text?: string; code?: string };
+  [k: string]: unknown;
+}
+
+let tmpRoot: string;
+
+interface HomeSpec {
+  /** v2 config 原文（与 v2 字段互斥，用于损坏/缺失场景） */
+  v2Raw?: string;
+  /** v2 config 对象形态 */
+  v2?: unknown;
+  /** cli config 原文（与 real 字段互斥） */
+  realRaw?: string;
+  /** cli config 对象形态；undefined = 不布置该文件（GUI-only 宿主） */
+  real?: unknown;
+}
+
+function setupHome(spec: HomeSpec): { run: () => childProcess.SpawnSyncReturns<string>; state: () => ProbeState } {
+  const home = fs.mkdtempSync(path.join(tmpRoot, "home-"));
+  const engineDataDir = fs.mkdtempSync(path.join(tmpRoot, "eng-"));
+  const cliDir = path.join(home, ".zcode", "cli");
+  fs.mkdirSync(cliDir, { recursive: true });
+  fs.writeFileSync(path.join(home, ".probe-other.txt"), "OTHER-CONTENT");
+  const v2Path = path.join(home, ".zcode", "v2", "config.json");
+  fs.mkdirSync(path.dirname(v2Path), { recursive: true });
+  if (spec.v2Raw !== undefined) fs.writeFileSync(v2Path, spec.v2Raw);
+  else if (spec.v2 !== undefined) fs.writeFileSync(v2Path, JSON.stringify(spec.v2, null, 2));
+  const cliConfig = path.join(cliDir, "config.json");
+  if (spec.realRaw !== undefined) fs.writeFileSync(cliConfig, spec.realRaw);
+  else if (spec.real !== undefined) fs.writeFileSync(cliConfig, JSON.stringify(spec.real, null, 2));
+
+  const probePath = path.join(tmpRoot, `probe-${path.basename(home)}.cjs`);
+  fs.writeFileSync(probePath, PROBE_SOURCE);
+  const launcher = ensureAppServerLauncher(engineDataDir);
+  const statePath = path.join(tmpRoot, `state-${path.basename(home)}.json`);
+
+  return {
+    run: () =>
+      childProcess.spawnSync(process.execPath, [launcher], {
+        env: {
+          ...process.env,
+          HOME: home,
+          ZCODE_ENG_CLI_PATH: probePath,
+          ZCODE_ENG_V2_CONFIG: v2Path,
+          ZCODE_PROBE_STATE: statePath,
+        } as NodeJS.ProcessEnv,
+        encoding: "utf8",
+        timeout: 15_000,
+      }),
+    state: () => JSON.parse(fs.readFileSync(statePath, "utf8")) as ProbeState,
+  };
+}
+
+const providerEntry = (apiKey: string) => ({ options: { apiKey, baseURL: "https://example.test/v1" } });
+
+beforeEach(() => {
+  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "zcode-launcher-test-"));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpRoot, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+});
+
+describe("wrapper 合并语义（v2 注入优先）", () => {
+  it("同 id 时 v2 条目整条优先于真实文件（等价复刻 GUI 直传：v2 权威），real 独有条目保留", () => {
+    const h = setupHome({
+      v2: { provider: { shared: providerEntry("v2-new-key") } },
+      real: {
+        provider: { shared: providerEntry("real-stale-key"), realOnly: providerEntry("real-key") },
+        model: { main: "shared/model-a" },
+      },
+    });
+    const res = h.run();
+    expect(res.status).toBe(0);
+    const cfg = JSON.parse(h.state().syncUtf8.text as string);
+    expect(cfg.provider.shared.options.apiKey).toBe("v2-new-key");
+    expect(cfg.provider.realOnly.options.apiKey).toBe("real-key");
+    expect(cfg.model.main).toBe("shared/model-a");
+  });
+
+  it("real 无 model.main 时以 v2.model.main / FALLBACK 兜底注入", () => {
+    const h = setupHome({
+      v2: { provider: { p1: providerEntry("k1") } },
+      real: { provider: { p2: providerEntry("k2") } },
+    });
+    const res = h.run();
+    expect(res.status).toBe(0);
+    const cfg = JSON.parse(h.state().syncUtf8.text as string);
+    expect(cfg.model.main).toBe("builtin:bigmodel-coding-plan/GLM-5.3");
+  });
+
+  it("v2.model.main 存在时优先于 FALLBACK", () => {
+    const h = setupHome({
+      v2: { provider: { p1: providerEntry("k1") }, model: { main: "p1/model-x" } },
+      real: {},
+    });
+    const res = h.run();
+    expect(res.status).toBe(0);
+    const cfg = JSON.parse(h.state().syncUtf8.text as string);
+    expect(cfg.model.main).toBe("p1/model-x");
+  });
+});
+
+describe("existsSync 拦截（GUI-only 宿主：cli config 不存在）", () => {
+  it("真实文件缺失时 existsSync 返回 true 且读取拿到注入配置（短路门不复 exist = 注入不可见）", () => {
+    const h = setupHome({
+      v2: { provider: { p1: providerEntry("k1") } },
+      // real 不布置 → cli/config.json 不存在
+    });
+    const res = h.run();
+    expect(res.status).toBe(0);
+    const st = h.state();
+    expect(st.existsConfig).toBe(true);
+    const cfg = JSON.parse(st.syncUtf8.text as string);
+    expect(cfg.provider.p1.options.apiKey).toBe("k1");
+  });
+});
+
+describe("no-patch 分支（无凭据可注入 → 原生行为透出）", () => {
+  it("v2 无带 apiKey 的 provider：不 patch，读原始内容、existsSync 原生", () => {
+    const h = setupHome({
+      v2: { provider: { p1: { options: { apiKey: "" } } } },
+      realRaw: '{"provider":{"r1":{"options":{"apiKey":"real"}}}}',
+    });
+    const res = h.run();
+    expect(res.status).toBe(0);
+    const st = h.state();
+    expect(st.syncUtf8.text).toBe('{"provider":{"r1":{"options":{"apiKey":"real"}}}}');
+    expect(st.existsConfig).toBe(true);
+  });
+
+  it("v2 文件缺失（ENOENT，未登录）：静默 no-patch，stderr 无 v2 读取失败", () => {
+    const h = setupHome({ realRaw: '{"provider":{}}' });
+    const res = h.run();
+    expect(res.status).toBe(0);
+    expect(res.stderr).not.toContain("v2 config 读取失败");
+    const st = h.state();
+    expect(st.syncUtf8.text).toBe('{"provider":{}}');
+  });
+
+  it("v2 损坏（非 ENOENT）：no-patch 且 stderr 出声（与「未登录」区分）", () => {
+    const h = setupHome({ v2Raw: "{broken-json", realRaw: '{"provider":{}}' });
+    const res = h.run();
+    expect(res.status).toBe(0);
+    expect(res.stderr).toContain("v2 config 读取失败");
+    expect(h.state().syncUtf8.text).toBe('{"provider":{}}');
+  });
+
+  it("no-patch 且真实文件不存在：existsSync 原生 false、读取 ENOENT（原生报错透出）", () => {
+    const h = setupHome({ v2Raw: "{broken" });
+    const res = h.run();
+    expect(res.status).toBe(0);
+    const st = h.state();
+    expect(st.existsConfig).toBe(false);
+    expect(st.syncUtf8.code).toBe("ENOENT");
+  });
+});
+
+describe("调用形态（encoding 归一与透传）", () => {
+  const base = { v2: { provider: { p1: providerEntry("k1") } }, real: {} };
+
+  it("'utf8' / 'utf-8' / {encoding:'utf-8'} 均返回 string；无 encoding 返回 Buffer（内容一致）", () => {
+    const h = setupHome(base);
+    const res = h.run();
+    expect(res.status).toBe(0);
+    const st = h.state();
+    for (const key of ["syncUtf8", "syncUtf8Dash", "syncUtf8Obj", "promiseUtf8Dash"] as const) {
+      expect(st[key].kind, key).toBe("string");
+    }
+    expect(st.syncNoEnc.kind).toBe("buffer");
+    const merged = JSON.parse(st.syncUtf8.text as string);
+    expect(JSON.parse(st.syncNoEnc.text as string)).toEqual(merged);
+  });
+
+  it("非 CONFIG_PATH 读取与 existsSync 穿透不受影响", () => {
+    const h = setupHome(base);
+    const res = h.run();
+    expect(res.status).toBe(0);
+    const st = h.state();
+    expect(st.syncOther.text).toBe("OTHER-CONTENT");
+    expect(st.existsOther).toBe(true);
+    expect(st.existsMissing).toBe(false);
+  });
+});
+
+describe("exit 面", () => {
+  it("ZCODE_ENG_CLI_PATH 缺失：exit 2 + stderr 含恢复指引", () => {
+    const home = fs.mkdtempSync(path.join(tmpRoot, "home-"));
+    const engineDataDir = fs.mkdtempSync(path.join(tmpRoot, "eng-"));
+    const launcher = ensureAppServerLauncher(engineDataDir);
+    // 密封性：本测试自身可能跑在 app-server 宿主链路下（env 带 ZCODE_ENG_CLI_PATH），
+    // 不剥掉则「缺失」前置不成立，launcher 会拿到真 CLI 走正常启动路径（exit 1）而非配置错误 exit 2
+    const { ZCODE_ENG_CLI_PATH: _ambient, ...hermeticEnv } = process.env;
+    const res = childProcess.spawnSync(process.execPath, [launcher], {
+      env: { ...hermeticEnv, HOME: home, ZCODE_ENG_V2_CONFIG: path.join(home, "v2.json") },
+      encoding: "utf8",
+      timeout: 15_000,
+    });
+    expect(res.status).toBe(2);
+    expect(res.stderr).toContain("ZCODE_ENG_CLI_PATH");
+  });
+
+  it("CLI_PATH 指向不存在文件：exit 3 + stderr 加载失败", () => {
+    const home = fs.mkdtempSync(path.join(tmpRoot, "home-"));
+    const engineDataDir = fs.mkdtempSync(path.join(tmpRoot, "eng-"));
+    const launcher = ensureAppServerLauncher(engineDataDir);
+    const res = childProcess.spawnSync(process.execPath, [launcher], {
+      env: {
+        ...process.env,
+        HOME: home,
+        ZCODE_ENG_CLI_PATH: path.join(tmpRoot, "no-such-cli.cjs"),
+        ZCODE_ENG_V2_CONFIG: path.join(home, "v2.json"),
+      },
+      encoding: "utf8",
+      timeout: 15_000,
+    });
+    expect(res.status).toBe(3);
+    expect(res.stderr).toContain("加载失败");
+  });
+});
+
+describe("落盘端（ensureAppServerLauncher）", () => {
+  it("首调落盘产物内容与 APPSERVER_LAUNCHER_SOURCE 一致，路径含 engines/zcode/", () => {
+    const engineDataDir = fs.mkdtempSync(path.join(tmpRoot, "eng-"));
+    const file = ensureAppServerLauncher(engineDataDir);
+    expect(path.basename(file)).toBe(ZCODE_APPSERVER_LAUNCHER_NAME);
+    expect(file).toContain(path.join("engines", "zcode"));
+    expect(fs.readFileSync(file, "utf8")).toBe(APPSERVER_LAUNCHER_SOURCE);
+  });
+
+  it("重复调用幂等：返回同一路径，内容不变", () => {
+    const engineDataDir = fs.mkdtempSync(path.join(tmpRoot, "eng-"));
+    const a = ensureAppServerLauncher(engineDataDir);
+    const b = ensureAppServerLauncher(engineDataDir);
+    expect(b).toBe(a);
+    expect(fs.readFileSync(b, "utf8")).toBe(APPSERVER_LAUNCHER_SOURCE);
+  });
+
+  it("陈旧内容（升级后旧 wrapper）被覆盖刷新", () => {
+    const engineDataDir = fs.mkdtempSync(path.join(tmpRoot, "eng-"));
+    const dir = path.join(engineDataDir, "engines", "zcode");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, ZCODE_APPSERVER_LAUNCHER_NAME), "// stale old wrapper");
+    const file = ensureAppServerLauncher(engineDataDir);
+    expect(fs.readFileSync(file, "utf8")).toBe(APPSERVER_LAUNCHER_SOURCE);
+  });
+
+  it("落盘失败包装为含恢复动作的错误（目录只读）", () => {
+    const engineDataDir = fs.mkdtempSync(path.join(tmpRoot, "eng-"));
+    // 预置同名目录占位目标文件路径，使 renameSync 前的 writeFileSync 落在
+    // 目录形态上失败（EISDIR）——覆盖 recovery 文案分支
+    const dir = path.join(engineDataDir, "engines", "zcode");
+    fs.mkdirSync(path.join(dir, ZCODE_APPSERVER_LAUNCHER_NAME), { recursive: true });
+    expect(() => ensureAppServerLauncher(engineDataDir)).toThrow(/落盘失败[\s\S]*恢复/);
+  });
+});

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

@@ -63,7 +63,6 @@ interface FakeHandle {
   conn: AppServerConnection;
   stateFile: string;
   stderrLog: string;
-  homeDir: string;
   cwd: string;
 }
 
@@ -88,10 +87,10 @@ function makeConnection(opts: FakeOpts = {}): FakeHandle {
   connSeq += 1;
   const stateFile = join(TMP, `state-${connSeq}.jsonl`);
   const stderrLog = join(TMP, `stderr-${connSeq}.log`);
-  const homeDir = join(TMP, `home-${connSeq}`);
   const cwd = join(TMP, `cwd-${connSeq}`);
   const base: NodeJS.ProcessEnv = {
     PATH: process.env.PATH ?? "",
+    HOME: "/fake-host-home",
     FAKE_STATE_FILE: stateFile,
     ...(opts.stderrLines ? { FAKE_STDERR: "1" } : {}),
     ...(opts.extraKeys ? { FAKE_EXTRA_KEYS: "1" } : {}),
@@ -101,12 +100,12 @@ function makeConnection(opts: FakeOpts = {}): FakeHandle {
   const conn = new AppServerConnection({
     cliPath: FAKE_CLI,
     cwd,
-    env: buildAppServerEnv(homeDir, base),
+    env: buildAppServerEnv(base),
     stderrLogPath: stderrLog,
     ...(opts.reverseHandlers ? { reverseHandlers: opts.reverseHandlers } : {}),
   });
   CONNECTIONS.push(conn);
-  return { conn, stateFile, stderrLog, homeDir, cwd };
+  return { conn, stateFile, stderrLog, cwd };
 }
 
 afterEach(async () => {
@@ -171,7 +170,7 @@ describe("四帧型分发（NDJSON，无 jsonrpc 字段）", () => {
     const { conn, stateFile } = makeConnection();
     await conn.request("test/echo", { a: 1 });
     const frames = readState(stateFile)
-      .map((e) => e.frame)
+      .map((e) => (e as Record<string, unknown>).frame)
       .filter((f): f is Record<string, unknown> => isRecord(f) && f.method === "test/echo");
     expect(frames).toHaveLength(1);
     expect(Object.keys(frames[0]).sort()).toEqual(["id", "method", "params"]);
@@ -254,7 +253,7 @@ describe("请求-应答 id 关联", () => {
     expect(b).toEqual({ who: "b", delayMs: 30 });
     expect(c).toEqual({ who: "c" });
     const ids = readState(stateFile)
-      .map((e) => e.frame)
+      .map((e) => (e as Record<string, unknown>).frame)
       .filter((f): f is { id: number } => isRecord(f) && typeof f.method === "string" && typeof f.id === "number")
       .map((f) => f.id);
     expect(ids).toHaveLength(3);
@@ -297,10 +296,10 @@ describe("反向请求应答（D9）", () => {
     ]);
     // 反向应答帧出站精确键集 {id, result}（无 jsonrpc、无未知键）
     const answerFrame = readState(stateFile)
-      .map((e) => e.frame)
+      .map((e) => (e as Record<string, unknown>).frame)
       .find((f): f is Record<string, unknown> => isRecord(f) && typeof f.id === "string");
     expect(answerFrame).toBeDefined();
-    expect(Object.keys(answerFrame).sort()).toEqual(["id", "result"]);
+    expect(Object.keys(answerFrame!).sort()).toEqual(["id", "result"]);
   });
 
   it("未知反向请求 → 回 {id, result:{}}（不答会 15s 超时断连，旧实测 -32022）", async () => {
@@ -385,9 +384,9 @@ describe("stderr tee 落盘", () => {
 
 // ------------------------------------------- env 惯例（构造注入面）
 
-describe("env 惯例（沿用 launcher 惯例的参数化注入）", () => {
-  it("buildAppServerEnv：HOME 隔离 + 遥测关闭 + nesting guard 剥离/注入（fake 侧 env 快照）", async () => {
-    const { conn, stateFile, homeDir } = makeConnection({ polluteNested: true });
+describe("env 惯例（共享宿主 HOME 形态）", () => {
+  it("buildAppServerEnv：HOME 正向透传（共享宿主）+ 遥测关闭 + nesting guard 剥离/注入（fake 侧 env 快照）", async () => {
+    const { conn, stateFile } = makeConnection({ polluteNested: true });
     await conn.request("test/echo", {});
     const envEvents = readState(stateFile).filter((e) => e.ev === "env");
     expect(envEvents).toHaveLength(1);
@@ -397,7 +396,9 @@ describe("env 惯例（沿用 launcher 惯例的参数化注入）", () => {
       nested?: string;
       unifiedNested?: string;
     };
-    expect(snap.home).toBe(homeDir);
+    // 共享宿主 HOME 契约（2026-09 起）：base env 携带的宿主 HOME 值原样透传到子进程
+    // env（不覆写、不剥离——db/plugins/MCP 全继承宿主 HOME）
+    expect(snap.home).toBe("/fake-host-home");
     expect(snap.telemetry).toBe("false");
     expect(snap.nested).toBeUndefined();
     expect(snap.unifiedNested).toBe("1");

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

@@ -1,51 +1,14 @@
-// parser.test.ts —— golden 样本回归（验收 2）+ 损坏 stdout 错误路径 + 缓冲有界性。
-// golden 原文来自 2026-08-25 真机实录（zcode 0.16.5），采集元数据见 fixture _meta。
-
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+// parser.test.ts —— usage 字段映射（事件层 execution 版）+ coarse 事件合成不变量回归。
+// 原 stdout 有界收集/终 JSON 解析/运行失败文案一族（含 golden spawn 样本回归）已随
+// CLI spawn 链删除（2026-09 单一 app-server 形态——终态来自 session-channel 收尾帧，
+// 不经 stdout 解析）；mapZcodeOutcomeUsage（终态层映射）经 zcode-engine-appserver.test.ts
+// 的 outcome.usage 断言覆盖。
 
 import { describe, expect, it } from "vitest";
 
-import {
-  buildRunFailedMessage,
-  createBoundedLineBuffer,
-  mapZcodeUsage,
-  parseZcodeStdoutJson,
-  parseZcodeTerminal,
-  synthesizeCoarseEvents,
-} from "../parser.ts";
-
-interface GoldenFixture {
-  stdoutRaw: string;
-  _meta: { engineVersion: string; exitCode: number; usageMapping: string };
-}
-
-const golden: GoldenFixture = JSON.parse(
-  readFileSync(fileURLToPath(new URL("./__fixtures__/zcode-golden-spawn.json", import.meta.url)), "utf8"),
-);
-
-describe("parseZcodeTerminal：golden 回归", () => {
-  it("实录样本解析出完整终态（sessionId/response/usage/turnCount）", () => {
-    const r = parseZcodeTerminal(golden.stdoutRaw);
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    expect(r.payload.sessionId).toBe("sess_35852a0f-1302-4e20-9e48-87f47527abe3");
-    expect(r.payload.response).toBe("ok");
-    expect(r.payload.usage).toEqual({ input: 12599, output: 17, cacheRead: 512, cacheWrite: 0 });
-    expect(r.payload.turnCount).toBe(1);
-    // 终态层 usage（orchestration 版）：cost 显式 0（zcode 不回传）、contextTokens=
-    // projection.contextUsed、turns=projection.turnCount
-    expect(r.payload.outcomeUsage).toEqual({
-      input: 12599,
-      output: 17,
-      cacheRead: 512,
-      cacheWrite: 0,
-      cost: 0,
-      contextTokens: 12616,
-      turns: 1,
-    });
-  });
+import { mapZcodeUsage, synthesizeCoarseEvents } from "../parser.ts";
 
+describe("mapZcodeUsage：字段名映射", () => {
   it("usage 字段名映射：inputTokens→input 等四项（cost 无来源不出现）", () => {
     const u = mapZcodeUsage({
       inputTokens: 10,
@@ -64,42 +27,6 @@ describe("parseZcodeTerminal：golden 回归", () => {
   });
 });
 
-describe("parseZcodeTerminal：损坏 stdout → ok:false（engine_run_failed 输入）", () => {
-  it("非 JSON 文本", () => {
-    const r = parseZcodeTerminal("Error: something broke\n");
-    expect(r.ok).toBe(false);
-    if (r.ok) return;
-    expect(r.reason).toContain("不是 JSON");
-  });
-
-  it("JSON 但缺 string 型 response（格式漂移形态）", () => {
-    const r = parseZcodeTerminal('{"sessionId": "sess_x", "usage": {}}');
-    expect(r.ok).toBe(false);
-    if (r.ok) return;
-    expect(r.reason).toContain("response");
-  });
-
-  it("数组/标量 JSON 拒收", () => {
-    expect(parseZcodeTerminal("[1,2,3]").ok).toBe(false);
-    expect(parseZcodeTerminal("42").ok).toBe(false);
-  });
-
-  it("混入日志行时首尾大括号容错提取", () => {
-    const mixed = '[info] boot\n{"sessionId":"sess_a","response":"done"}\n[info] exit';
-    const r = parseZcodeTerminal(mixed);
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    expect(r.payload.sessionId).toBe("sess_a");
-    expect(r.payload.response).toBe("done");
-  });
-});
-
-describe("parseZcodeStdoutJson：空对象形态防御", () => {
-  it("无大括号文本返回 null", () => {
-    expect(parseZcodeStdoutJson("plain text")).toBeNull();
-  });
-});
-
 describe("synthesizeCoarseEvents：coarse 不变量", () => {
   it("message_end（含 usage）在前、turn_end 最后", () => {
     const usage = { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 };
@@ -114,133 +41,3 @@ describe("synthesizeCoarseEvents：coarse 不变量", () => {
     expect(evs[evs.length - 1]).toEqual({ type: "turn_end" });
   });
 });
-
-describe("buildRunFailedMessage：错误规格（stdout 尾部 + exit code + 恢复指引）", () => {
-  it("含 exit code、尾部内容与三段恢复动作", () => {
-    const msg = buildRunFailedMessage({
-      exitCode: 3,
-      stdoutTail: "x".repeat(5000),
-      stderrTail: "boom",
-      parseReason: "stdout 不是 JSON 对象",
-    });
-    expect(msg).toContain("engine_run_failed");
-    expect(msg).toContain("exit code: 3");
-    expect(msg).toContain("解析失败");
-    expect(msg).toContain("stderr 尾部: boom");
-    // stdout 尾部截断到 2000 字
-    expect(msg).toContain("x".repeat(2000));
-    expect(msg).not.toContain("x".repeat(2001));
-    expect(msg).toContain("--version");
-    expect(msg).toContain("golden");
-    expect(msg).toContain("engine: pi");
-  });
-
-  it("null exit code 标注被信号杀死", () => {
-    const msg = buildRunFailedMessage({ exitCode: null, stdoutTail: "" });
-    expect(msg).toContain("null（被信号杀死）");
-  });
-
-  it("空 stdout 不产生空 part（防「stdout 尾部: <指引段>」视觉嵌套误读）", () => {
-    const msg = buildRunFailedMessage({ exitCode: 1, stdoutTail: "   " });
-    expect(msg).not.toContain("stdout 尾部");
-  });
-
-  it("LLM API 失败（AI_APICallError）归因到端点/凭据指引，不再给 probe 指引", () => {
-    const msg = buildRunFailedMessage({
-      cliPath: "/fake/zcode.cjs",
-      exitCode: 1,
-      stdoutTail: "",
-      stderrTail: "AI_APICallError: 500 Internal Server Error\nError: Turn execution failed",
-      modelRef: "router/mimo-v2.5-pro",
-      configPath: "/pool/.zcode/cli/config.json",
-    });
-    expect(msg).toContain("模型 API 调用失败");
-    expect(msg).toContain("router/mimo-v2.5-pro");
-    expect(msg).toContain("/pool/.zcode/cli/config.json");
-    expect(msg).toContain("baseURL");
-    expect(msg).toContain("engine: pi");
-    // probe/golden 指引不出现（误导排查方向——2026-08-25 真机教训）
-    expect(msg).not.toContain("--version");
-    expect(msg).not.toContain("golden");
-    expect(msg).not.toContain("stdout 尾部");
-  });
-
-  it("401 有响应形态（无 AI_APICallError 类名）也归因，且带 HTTP 状态与凭据定向", () => {
-    const stderr401 = [
-      "  'x-mife-upstream-status': '401'",
-      "  },",
-      "  responseStatus: 401,",
-      "  statusCode: 401",
-      "}",
-      "Error: Turn execution failed (traceId: a487a9b3)",
-    ].join("\n");
-    const msg = buildRunFailedMessage({
-      cliPath: "/fake/zcode.cjs",
-      exitCode: 1,
-      stdoutTail: "",
-      stderrTail: stderr401,
-      modelRef: "router/mimo-v2.5-pro",
-      configPath: "/pool/.zcode/cli/config.json",
-    });
-    expect(msg).toContain("模型 API 调用失败");
-    expect(msg).toContain("HTTP 401");
-    expect(msg).toContain("凭据无效或过期");
-    expect(msg).toContain("apiKey 大概率无效或过期");
-    expect(msg).not.toContain("--version");
-    expect(msg).not.toContain("golden");
-  });
-
-  it("LLM 归因在缺省 modelRef/configPath 时兜底可读", () => {
-    const msg = buildRunFailedMessage({
-      cliPath: "/fake/zcode.cjs",
-      exitCode: 1,
-      stdoutTail: "ok",
-      stderrTail: "Symbol(vercel.ai.error.AI_APICallError): true",
-    });
-    expect(msg).toContain("模型 API 调用失败");
-    expect(msg).toContain("provider 的 baseURL 可达性");
-    expect(msg).not.toContain("undefined");
-  });
-
-  it("stderr 的 [Object] 噪音行折叠为计数", () => {
-    const noisy = [
-      "AIError: fail",
-      ...Array.from({ length: 12 }, () => "  [Object], [Object],"),
-      "    statusCode: undefined,",
-    ].join("\n");
-    const msg = buildRunFailedMessage({ cliPath: "/c", exitCode: 1, stdoutTail: "", stderrTail: noisy });
-    expect(msg).toContain("[Object]×12");
-    expect(msg).not.toContain("[Object], [Object]");
-  });
-});
-
-describe("createBoundedLineBuffer：有界双缓冲", () => {
-  it("头 4K + 尾 64K 保留，中间丢弃并标记", () => {
-    const buf = createBoundedLineBuffer();
-    const line = "a".repeat(100) + "\n"; // 每行 101 字节
-    for (let i = 0; i < 2000; i++) buf.push(line); // ~202KB，远超 4K+64K
-    const text = buf.text();
-    expect(text.startsWith("a".repeat(100))).toBe(true); // 头部保留
-    expect(text).toContain("已丢弃"); // 中间丢弃标记
-    expect(text.endsWith("\n")).toBe(true);
-    // 尾部窗口 ≈ 64K：总长有界
-    expect(text.length).toBeLessThan(4 * 1024 + 64 * 1024 + 200);
-  });
-
-  it("单行超整个尾部窗口时保留行尾（错误信息在末尾）", () => {
-    const buf = createBoundedLineBuffer({ headLimit: 0, tailLimit: 1000 });
-    buf.push("B".repeat(5000) + "\n");
-    const text = buf.text();
-    // 有效载荷 ≤ 1000（text 里另有「已丢弃 N 字节」标记行）
-    expect(text.match(/B/g)?.length ?? 0).toBeLessThanOrEqual(1000);
-    expect(text.endsWith("\n")).toBe(true);
-    expect(text).toContain("已丢弃");
-  });
-
-  it("未超限时原文完整（golden 646 字节场景）", () => {
-    const buf = createBoundedLineBuffer();
-    buf.push(golden.stdoutRaw);
-    expect(buf.text()).toBe(golden.stdoutRaw);
-    expect(buf.tail(10)).toBe(golden.stdoutRaw.slice(-10));
-  });
-});