@zhushanwen/subagent-core 0.6.0 → 0.7.0

package/src/execution/engine/__tests__/common/session-view-service-zcode-dbpath.test.ts

@@ -1,149 +0,0 @@
-// session-view-service-zcode-dbpath.test.ts —— zcode ①级 dbPath 白名单的分支守护。
-//
-// 三视角：①构建者——白名单三分支（绝对=宿主 db 精确匹配 / 绝对≠宿主 db 拒绝 /
-// 相对池锚定 + 越界拒绝）逐路径断言；②使用者——共享 HOME 形态 record（写侧
-// zcode-engine 恒绝对 dbPath）tier1 不再被误拒静默降②级；③观察者——reader 调用
-// 参数（白名单通过后传入的 dbPath 精确值）与未调用事实（拒绝路径 reader 零触达）。
-//
-// readZcodeSessionView 以 vi.mock 替身：本文件测的是白名单分支（不可触达真实
-// ~/.zcode/cli/db/db.sqlite——那是用户真机数据），reader 本体行为由
-// engines/zcode/__tests__/reader.test.ts 真库覆盖。
-
-import { mkdtempSync, rmSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("../../engines/zcode/reader.ts", () => ({
-  readZcodeSessionView: vi.fn(),
-}));
-
-import { readZcodeSessionView } from "../../engines/zcode/reader.ts";
-import { ZCODE_HOST_DB_SUFFIX } from "../../engines/zcode/constants.ts";
-import { JournalWriter } from "../../common/event-journal.ts";
-import { readSubagentHistoryMessages } from "../../common/session-view-service.ts";
-import { resetNativeSessionReaders } from "../../common/session-view-service.ts";
-import type { SubagentRecordSnapshot } from "../../common/session-view-types.ts";
-import type { AgentEvent } from "../../../types.ts";
-import type { SessionView } from "../../types.ts";
-
-const mockedRead = vi.mocked(readZcodeSessionView);
-
-/** 共享 HOME 形态写侧恒写入的唯一合法绝对 dbPath（与 zcode-engine hostZcodeDbPath 同源推导）。 */
-const HOST_DB = resolve(homedir(), ...ZCODE_HOST_DB_SUFFIX);
-
-let dataDir: string;
-
-beforeEach(() => {
-  dataDir = mkdtempSync(join(tmpdir(), "svs-dbpath-test-"));
-  mockedRead.mockReset();
-});
-
-afterEach(() => {
-  rmSync(dataDir, { recursive: true, force: true });
-  resetNativeSessionReaders();
-});
-
-function makeRecord(overrides: Partial<SubagentRecordSnapshot> = {}): SubagentRecordSnapshot {
-  return {
-    subagentId: "sub-1",
-    task: "do the thing",
-    startedAt: 1_000,
-    engine: "zcode",
-    engineHandle: {
-      sessionRef: { sessionId: "sess-1", dbPath: HOST_DB },
-      poolKey: "shared",
-    },
-    ...overrides,
-  };
-}
-
-async function writeJournal(path: string, events: AgentEvent[]): Promise<void> {
-  const writer = new JournalWriter({ path, taskId: "sub-1", engineId: "zcode" });
-  for (const ev of events) writer.append(ev);
-  await writer.close();
-}
-
-/** record 带②级可达 journal（tier1 被拒后的可观察落点：journal 内容被投影）。 */
-async function journalRecord(dbPath: string): Promise<SubagentRecordSnapshot> {
-  const journalPath = join(dataDir, "engines", "zcode", "shared", "journal-sub-1.jsonl");
-  await writeJournal(journalPath, [{ type: "text_delta", delta: "journal says" }]);
-  return makeRecord({
-    result: "outcome fallback",
-    engineHandle: {
-      sessionRef: { sessionId: "sess-1", dbPath },
-      poolKey: "shared",
-      journalPath,
-    },
-  });
-}
-
-describe("zcode ①级 dbPath 白名单（分支守护）", () => {
-  it("绝对 dbPath = 宿主 db（SSOT 精确匹配）→ 白名单通过，reader 收到原样路径，tier1 命中", async () => {
-    const view: SessionView = {
-      engineId: "zcode",
-      sessionId: "sess-1",
-      turns: [{ text: "from host db", thinking: "", toolCalls: [], closed: true }],
-      source: "native",
-    };
-    mockedRead.mockResolvedValue(view);
-    const messages = await readSubagentHistoryMessages(makeRecord(), dataDir);
-    expect(mockedRead).toHaveBeenCalledTimes(1);
-    expect(mockedRead).toHaveBeenCalledWith(HOST_DB, "sess-1");
-    expect(messages[1]).toMatchObject({ role: "assistant", content: "from host db" });
-  });
-
-  it("绝对 dbPath ≠ 宿主 db → 拒绝 tier1（reader 零触达），降②级 journal", async () => {
-    const record = await journalRecord("/tmp/attacker-chosen/db.sqlite");
-    const messages = await readSubagentHistoryMessages(record, dataDir);
-    expect(mockedRead).not.toHaveBeenCalled();
-    expect(messages[1]).toMatchObject({ role: "assistant", content: "journal says" });
-  });
-
-  it("宿主 db 路径的目录内变体（/../ 注入）≠ 精确匹配 → 同样拒绝", async () => {
-    // 白名单是文本级精确匹配（resolve 不可用于反构造——会把 .. 规约掉变回正身）
-    const sneaky = `${HOST_DB}/../db.sqlite`;
-    const record = await journalRecord(sneaky);
-    const messages = await readSubagentHistoryMessages(record, dataDir);
-    expect(mockedRead).not.toHaveBeenCalled();
-    expect(messages[1]).toMatchObject({ content: "journal says" });
-  });
-
-  it("相对 dbPath 池内（旧池时代 record）→ 锚池目录解析，reader 收到池内绝对路径", async () => {
-    const view: SessionView = {
-      engineId: "zcode",
-      sessionId: "sess-1",
-      turns: [{ text: "legacy pool", thinking: "", toolCalls: [], closed: true }],
-      source: "native",
-    };
-    mockedRead.mockResolvedValue(view);
-    const record = makeRecord({
-      engineHandle: {
-        sessionRef: { sessionId: "sess-1", dbPath: "pool-db/db.sqlite" },
-        poolKey: "shared",
-      },
-    });
-    const messages = await readSubagentHistoryMessages(record, dataDir);
-    expect(mockedRead).toHaveBeenCalledWith(
-      join(dataDir, "engines", "zcode", "shared", "pool-db", "db.sqlite"),
-      "sess-1",
-    );
-    expect(messages[1]).toMatchObject({ content: "legacy pool" });
-  });
-
-  it("相对 dbPath ../ 逃逸池目录 → 拒绝 tier1（reader 零触达），降②级 journal", async () => {
-    const record = await journalRecord("../../escape/db.sqlite");
-    const messages = await readSubagentHistoryMessages(record, dataDir);
-    expect(mockedRead).not.toHaveBeenCalled();
-    expect(messages[1]).toMatchObject({ content: "journal says" });
-  });
-
-  it("白名单通过但 reader 抛错（结构化降级契约）→ 仍降②级不崩", async () => {
-    mockedRead.mockRejectedValue(new Error("engine_session_read_failed: db 文件不存在"));
-    const record = await journalRecord(HOST_DB);
-    const messages = await readSubagentHistoryMessages(record, dataDir);
-    expect(mockedRead).toHaveBeenCalledTimes(1);
-    expect(messages[1]).toMatchObject({ content: "journal says" });
-  });
-});

package/src/execution/engine/__tests__/conformance/__fixtures__/pi-golden-events.json

@@ -1,28 +0,0 @@
-{
-  "_meta": {
-    "engineId": "pi",
-    "description": "pi 引擎 golden 事件序列（统一 AgentEvent 形态——spawn-event-adapter/session-runner 翻译后的 onEvent 出口序列，即 journal 落盘形态）",
-    "source": "从 spawn-event-adapter.test.ts / session-runner 事件形状构造的典型流式序列：bash 工具调用（含 pendingTools 配对）→ 双段 text_delta → message_end（完整 usage）→ turn_end。字段形状与 handleSdkEvent 翻译产物逐一锚定（tool_start.toolName/args、tool_end.result/isError、text_delta.delta、message_end.usage 四项 token、turn_end）",
-    "recordedAt": "2026-08-25",
-    "usageMapping": "message_end.usage = pi SDK message.usage（input/output/cacheRead/cacheWrite 四项 + cost.total 投影为 cost）"
-  },
-  "events": [
-    { "type": "tool_start", "toolName": "bash", "args": { "command": "ls -la /tmp/probe" } },
-    {
-      "type": "tool_end",
-      "toolName": "bash",
-      "args": { "command": "ls -la /tmp/probe" },
-      "result": { "output": "total 0\ndrwxr-xr-x  2 user  staff  64 Aug 25 10:00:00 ." },
-      "isError": false
-    },
-    { "type": "thinking_delta", "delta": "目录为空，无需进一步检查。" },
-    { "type": "text_delta", "delta": "Probe directory is empty. " },
-    { "type": "text_delta", "delta": "Nothing to clean up." },
-    {
-      "type": "message_end",
-      "usage": { "input": 12599, "output": 17, "cacheRead": 512, "cacheWrite": 0, "cost": 0.0001 }
-    },
-    { "type": "turn_end" }
-  ],
-  "content": "Probe directory is empty. Nothing to clean up."
-}

package/src/execution/engine/__tests__/conformance/zcode-appserver-harness.ts

@@ -1,128 +0,0 @@
-// zcode-appserver-harness.ts —— conformance 层的 fake app-server 引擎组装器（R6）。
-//
-// 与 engines/zcode/__tests__/zcode-engine-appserver.test.ts 的 makeEngine 同模式
-// （scenario 文件随 env 固化进 fake 子进程），抽出为 conformance 专用副本而非跨测试
-// 目录 import 测试文件——conformance 套件自包含（A12：套件不依赖被测引擎自己的
-// 单测文件结构）。协议/断言面同源：fake-appserver.mjs + ZCODE_APPSERVER_GOLDEN。
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { ZCODE_APPSERVER_GOLDEN } from "../../engines/zcode/golden-sample.ts";
-import { ZcodeEngine } from "../../engines/zcode/zcode-engine.ts";
-
-const FAKE_CLI = fileURLToPath(
-  new URL("../../engines/zcode/__tests__/__fixtures__/fake-appserver.mjs", import.meta.url),
-);
-const PROVIDER = "conformance-provider";
-
-export interface AppserverHarnessOptions {
-  /** 覆盖 send 推送帧（缺省 = golden pushStream + 终态两帧；dropTurnTerminal 置真时去 turn.terminal）。 */
-  dropTurnTerminal?: boolean;
-  /** 覆盖 read 应答（read 是全文权威来源）。 */
-  readResult?: unknown;
-  /** session/stop 行为（fake scenario.stopBehavior；缺省 'terminal' = stop 优雅生效）。 */
-  stopBehavior?: "terminal" | "none";
-  /** 只保留 state.updated（挂起场景——turn 永不自然落定，abort 用例用）。 */
-  hangOnly?: boolean;
-}
-
-export interface AppserverHarness {
-  engine: ZcodeEngine;
-  /** fake 子进程的事件流水文件（帧序断言数据源）。 */
-  stateFile: string;
-  workspace: string;
-  dataDir: string;
-  dispose(): Promise<void>;
-}
-
-/** 组装连到 fake-appserver 的常驻引擎（单一 app-server 形态——2026-09 起无模式分派）。 */
-export function makeAppserverHarness(opts: AppserverHarnessOptions = {}): AppserverHarness {
-  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "zcode-conformance-appserver-"));
-  const dataDir = path.join(tmpRoot, "data");
-  const stateFile = path.join(tmpRoot, "state.jsonl");
-  const scenarioFile = path.join(tmpRoot, "scenario.json");
-  const workspace = path.join(tmpRoot, "ws");
-  const v2Path = path.join(tmpRoot, "v2.json");
-
-  fs.mkdirSync(path.dirname(v2Path), { recursive: true });
-  fs.writeFileSync(
-    v2Path,
-    JSON.stringify({
-      provider: { [PROVIDER]: { options: { apiKey: "k", baseURL: "https://t.example" }, models: { m1: {} } } },
-    }),
-  );
-
-  const pushes = opts.hangOnly
-    ? [ZCODE_APPSERVER_GOLDEN.pushStream[0]].map((l) => JSON.parse(l) as unknown)
-    : [
-        ...ZCODE_APPSERVER_GOLDEN.pushStream,
-        ...(opts.dropTurnTerminal ? [] : [ZCODE_APPSERVER_GOLDEN.terminal[0]]),
-        ZCODE_APPSERVER_GOLDEN.terminal[1],
-      ].map((l) => JSON.parse(l) as unknown);
-  fs.writeFileSync(
-    scenarioFile,
-    JSON.stringify({
-      createResult: JSON.parse(ZCODE_APPSERVER_GOLDEN.createResponse),
-      readResult: opts.readResult ?? JSON.parse(ZCODE_APPSERVER_GOLDEN.readResponse),
-      sendPushes: pushes,
-      ...(opts.stopBehavior !== undefined ? { stopBehavior: opts.stopBehavior } : {}),
-    }),
-  );
-
-  const engine = new ZcodeEngine({
-    engineDataDir: () => dataDir,
-    cliPath: FAKE_CLI,
-    sources: { v2ConfigPath: v2Path },
-    processEnv: {
-      PATH: process.env.PATH ?? "",
-      FAKE_STATE_FILE: stateFile,
-      FAKE_SESSION_SCENARIO: scenarioFile,
-    },
-  });
-  return {
-    engine,
-    stateFile,
-    workspace,
-    dataDir,
-    dispose: () =>
-      engine.dispose().finally(() => {
-        fs.rmSync(tmpRoot, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-      }),
-  };
-}
-
-/** 读 fake 流水（帧序断言用）。 */
-export function readFakeState(file: string): Array<Record<string, unknown>> {
-  try {
-    return fs
-      .readFileSync(file, "utf8")
-      .trim()
-      .split("\n")
-      .filter(Boolean)
-      .map((l) => JSON.parse(l) as Record<string, unknown>);
-  } catch {
-    return [];
-  }
-}
-
-/** fake 收到的客户端帧方法名序列（abort 链「stop 先于杀链」断言面）。 */
-export function sentMethodNames(stateFile: string): string[] {
-  return readFakeState(stateFile)
-    .map((e) => (e as Record<string, unknown>)["frame"])
-    .filter((f): f is Record<string, unknown> => typeof f === "object" && f !== null && typeof (f as Record<string, unknown>)["method"] === "string")
-    .map((f) => f["method"] as string);
-}
-
-/** golden read 应答里 assistant 消息的 text parts 拼接（read 全文——不变量 3a 的比对基准）。 */
-export function goldenReadFullText(): string {
-  const read = JSON.parse(ZCODE_APPSERVER_GOLDEN.readResponse) as {
-    messages: Array<{ info: { role: string }; parts: Array<{ type: string; text?: string }> }>;
-  };
-  return (read.messages.at(-1)?.parts ?? [])
-    .filter((p) => p.type === "text")
-    .map((p) => p.text ?? "")
-    .join("");
-}

package/src/execution/engine/__tests__/paths.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-  resolveEngineDir,
-  resolveEnginesRoot,
-  resolveJournalPath,
-  resolvePoolDir,
-  sanitizeSeg,
-} from '../paths.js';
-
-describe('engine paths SSOT', () => {
-  it('engines 根锚定 dataDir 顶层', () => {
-    expect(resolveEnginesRoot('/data')).toBe('/data/engines');
-  });
-
-  it('池目录 = engines/<engineId>/<poolKey>', () => {
-    expect(resolvePoolDir('/data', 'zcode', 'home-reviewer')).toBe('/data/engines/zcode/home-reviewer');
-    expect(resolveEngineDir('/data', 'zcode')).toBe('/data/engines/zcode');
-  });
-
-  it('journal 路径带 taskId 文件名', () => {
-    expect(resolveJournalPath('/data', 'zcode', 'pool1', 'sa-123')).toBe(
-      '/data/engines/zcode/pool1/journal-sa-123.jsonl',
-    );
-  });
-
-  it('路径段安全编码：穿越/分隔符/空白折叠为连字符', () => {
-    expect(sanitizeSeg('a/b\\c')).toBe('a-b-c');
-    expect(sanitizeSeg('..')).toBe('default');
-    expect(sanitizeSeg('  ')).toBe('default');
-    expect(sanitizeSeg('home-reviewer')).toBe('home-reviewer');
-    expect(sanitizeSeg('中文名')).toBe('default');
-    expect(sanitizeSeg('x'.repeat(200))).toHaveLength(80);
-  });
-
-  it('engineId 也走安全编码，防注入路径段', () => {
-    expect(resolvePoolDir('/data', '../../etc', 'p')).toBe('/data/engines/etc/p');
-  });
-});

package/src/execution/engine/common/schema-emulation.ts

@@ -1,189 +0,0 @@
-// src/execution/engine/common/schema-emulation.ts
-//
-// schema 仿真降级（P2 公共降级层）。设计权威源：
-// docs/architecture/subagent-engine-abstraction.md D4（native/emulated 硬分流）+ §3.3.3
-// schema_emulation_failed 行 + §5 P2 行。
-//
-// ─── D4 硬分流（违反 = 历史事故形态） ───────────────────────────────
-// 本模块只服务 capabilities.schemaEnforcement === 'emulated' 的引擎
-// （zcode / opencode / kimi-code）。capabilities.schemaEnforcement === 'native' 的引擎
-// （pi 的 PI_WORKFLOW_SCHEMA env 注入链路、claude-code --json-schema、codex
-// --output-schema）**禁止** import 本模块做二次校验或改写其结果——宿主侧再叠一层
-// ajv 会制造第二校验权威，恰是 structured-output 方案 A [HISTORICAL]
-// （2026-08-01「校验自报 schema 致修复静默丢失」事故）的形态。
-// ajv 只允许出现在 emulated 路径（本模块），这是全仓唯一例外。
-//
-// 重试语义：本模块两个函数保持纯——校验失败/提取失败由调用方（宿主编排层）决定
-// 重试，语义与 structured-output 的 workflow-hook 对齐（重试一次、强化 prompt；
-// 仍失败报 schema_emulation_failed，错误含原始输出尾部）。
-//
-// 文案对齐：错误回显风格对齐 structured-output 的 execute.ts（"Schema validation
-// failed: ..."），但不 import 其内部模块（公共层自实现；structured-output 是
-// peer 依赖且可选，import 会造成公共层对 sibling extension 的硬依赖）。
-
-import Ajv, { type ValidateFunction } from "ajv";
-
-/** 原始输出尾部回显长度（结果对象的 tail 字段，供错误展示与重试 prompt 回灌）。 */
-export const SCHEMA_EMULATION_TAIL_CHARS = 500;
-
-// ============================================================
-// prompt 注入段
-// ============================================================
-
-/**
- * 构造 prompt 注入段：schema 声明 + 输出格式约定（emulated 引擎的 launcher 把它拼进
- * 最终 prompt，替代引擎不存在的 schema 强制通道）。
- *
- * 文案风格对齐 structured-output 的 promptGuidelines（"Do not output JSON in text"：emulated 引擎没有工具可调，JSON 必须出现在文本里）。
- */
-export function buildSchemaEmulationSegment(schema: object): string {
-  const schemaJson = JSON.stringify(schema);
-  return [
-    "## Structured Output Requirement",
-    "Your final answer MUST contain exactly one JSON value conforming to this JSON Schema (draft-07):",
-    schemaJson,
-    "Output rules:",
-    "- Output ONLY the JSON value — no prose before or after it.",
-    "- If you wrap it in a markdown code fence, use a single ```json fence.",
-    "- Do not output multiple JSON values; the first complete JSON value is extracted.",
-  ].join("\n");
-}
-
-// ============================================================
-// 三级容错提取 + ajv 校验
-// ============================================================
-
-/** 提取结果联合：ok=true 携带通过校验的 parsed；ok=false 携带 error 简述 + 原始输出尾部。 */
-export type StructuredOutputResult =
-  | { ok: true; parsed: unknown }
-  | { ok: false; error: string; tail: string };
-
-/**
- * 从模型文本输出提取并校验结构化 JSON（三级容错 → ajv）。
- *
- * 三级容错（逐级降级，任一级提取成功即进 ajv）：
- *   1. 直接 JSON.parse（trim 后整体是合法 JSON）；
- *   2. 剥 markdown code fence（```json ... ``` / ``` ... ```）取围栏内内容；
- *   3. 首尾括号扫描（首个 '{'/'[' 到末个 '}'/']' 的子串——容纳前后杂文本）。
- *
- * ajv 校验失败/三级提取失败返回 ok:false（不 throw）——重试与否是宿主编排层的
- * 决策（见文件头重试语义），本函数每次调用独立无状态。
- */
-export function extractAndValidateStructuredOutput(
-  text: string,
-  schema: object,
-): { ok: true; parsed: unknown } | { ok: false; error: string; tail: string } {
-  return extractImpl(text, schema);
-}
-
-/** 实现体（签名拆分只为让导出签名与契约声明逐字一致，见 StructuredOutputResult）。 */
-function extractImpl(text: string, schema: object): StructuredOutputResult {
-  const tail = text.length > SCHEMA_EMULATION_TAIL_CHARS
-    ? text.slice(text.length - SCHEMA_EMULATION_TAIL_CHARS)
-    : text;
-
-  const extracted = extractJsonCandidate(text);
-  if (extracted === undefined) {
-    return {
-      ok: false,
-      error:
-        "could not extract JSON from model output after 3-stage fallback " +
-        "(direct parse -> code-fence strip -> bracket scan)",
-      tail,
-    };
-  }
-
-  const validate = getOrCompileValidator(schema);
-  if (validate === undefined) {
-    return {
-      ok: false,
-      error: "host-side JSON Schema compilation failed (invalid schema object)",
-      tail,
-    };
-  }
-
-  const valid = validate(extracted);
-  if (!valid) {
-    // 错误格式对齐 structured-output："instancePath message" 逐条 join
-    const errors = validate.errors?.map((err) => `${err.instancePath} ${err.message}`).join("; ");
-    return {
-      ok: false,
-      error: `Schema validation failed: ${errors ?? "(no detail)"}`,
-      tail,
-    };
-  }
-  return { ok: true, parsed: extracted };
-}
-
-// ── 内部：三级提取 ──────────────────────────────────────────────
-
-/** 三级容错提取 JSON candidate；全部失败返回 undefined。 */
-function extractJsonCandidate(text: string): unknown {
-  // 第 1 级：整体直接 parse（最常见——严格遵守输出约定的模型）
-  const direct = tryParse(text.trim());
-  if (direct.ok) return direct.value;
-
-  // 第 2 级：markdown code fence 剥离（模型爱用 ```json 包裹）
-  const fenced = extractFirstFencedBlock(text);
-  if (fenced !== undefined) {
-    const parsed = tryParse(fenced.trim());
-    if (parsed.ok) return parsed.value;
-  }
-
-  // 第 3 级：首尾括号扫描（前后杂文本："Here is the result: {...} Hope this helps"）
-  const scanned = extractByBracketScan(text);
-  if (scanned !== undefined) {
-    const parsed = tryParse(scanned.trim());
-    if (parsed.ok) return parsed.value;
-  }
-
-  return undefined;
-}
-
-/** JSON.parse 包装：失败返回 ok:false（malformed 不是异常态，是三级降级的输入）。 */
-function tryParse(raw: string): { ok: true; value: unknown } | { ok: false } {
-  if (raw === "") return { ok: false };
-  try {
-    return { ok: true, value: JSON.parse(raw) };
-  } catch {
-    return { ok: false };
-  }
-}
-
-/** 取第一个 markdown code fence 块内容（```json / ``` 均可）；无 fence 返回 undefined。 */
-function extractFirstFencedBlock(text: string): string | undefined {
-  const match = /```(?:json)?\s*([\s\S]*?)\s*```/.exec(text);
-  return match?.[1];
-}
-
-/** 首尾括号扫描：首个 '{'/'[' 到末个 '}'/']' 的子串；边界不合法返回 undefined。 */
-function extractByBracketScan(text: string): string | undefined {
-  const objOpen = text.indexOf("{");
-  const arrOpen = text.indexOf("[");
-  const open = objOpen === -1 ? arrOpen : arrOpen === -1 ? objOpen : Math.min(objOpen, arrOpen);
-  const objClose = text.lastIndexOf("}");
-  const arrClose = text.lastIndexOf("]");
-  const close = Math.max(objClose, arrClose);
-  if (open === -1 || close === -1 || open >= close) return undefined;
-  return text.slice(open, close + 1);
-}
-
-// ── 内部：ajv 编译缓存 ──────────────────────────────────────────
-
-// WeakMap 缓存（schema 对象引用即 key，GC 友好）——模式对齐 structured-output 的
-// ajv-validator.ts（自实现，不跨包 import；见文件头依赖边界说明）。
-const ajvCache = new WeakMap<object, ValidateFunction>();
-
-/** 编译（或取缓存）validator；schema 非法（ajv 抛错）返回 undefined 由调用方报错。 */
-function getOrCompileValidator(schema: object): ValidateFunction | undefined {
-  const cached = ajvCache.get(schema);
-  if (cached) return cached;
-  try {
-    // strict:false 对齐 structured-output 的宽容度（非标 keyword 不炸编译）
-    const validate = new Ajv({ strict: false }).compile(schema);
-    ajvCache.set(schema, validate);
-    return validate;
-  } catch {
-    return undefined;
-  }
-}

package/src/execution/engine/common/session-view-projection.ts

@@ -1,51 +0,0 @@
-// src/execution/engine/common/session-view-projection.ts
-//
-// Turn → ReplayedTurn 投影 + usage 聚合的单一实现（P5 收敛）。此前三份同构副本：
-// common/journal-replay.ts（journal 重放投影）、engines/pi/pi-engine.ts read()（内联
-// 重写）、engines/pi/reader.ts（native reader）——投影语义唯一（strip 内部态 + closed
-// 恒 true + usageDelta 聚合），实现也必须唯一（防三处漂移）。
-//
-// 纯函数、零运行时依赖（仅类型 import）：reader.ts 的双端复用约束（设计 §3.3.7，
-// xyz-agent runtime 可 import）对本模块同样成立。
-//
-// 设计权威源：docs/architecture/subagent-engine-abstraction.md §3.3.6（重放等价性）。
-
-import type { AgentUsageTotal, InternalToolCall, ToolCall, Turn } from "../../types.ts";
-import type { ReplayedTurn } from "../types.ts";
-
-/** InternalToolCall → ToolCall（导出纯净形状，不泄漏 running/done/failed 内部状态机）。 */
-function toExportedToolCall(tc: InternalToolCall): ToolCall {
-  return {
-    toolName: tc.toolName,
-    ...(tc.args !== undefined ? { args: tc.args } : {}),
-    ...(tc.result !== undefined ? { result: tc.result } : {}),
-    ...(tc.isError !== undefined ? { isError: tc.isError } : {}),
-  };
-}
-
-/** Turn → ReplayedTurn：剥离内部态（closed 恒 true——重放物无进行时语义，§3.3.6）。 */
-export function toReplayedTurn(turn: Turn): ReplayedTurn {
-  return {
-    text: turn.text,
-    thinking: turn.thinking,
-    toolCalls: turn.toolCalls.map(toExportedToolCall),
-    closed: true,
-  };
-}
-
-/** 各 turn usageDelta 聚合为 AgentUsageTotal（无任何 usage 数据时 undefined）。 */
-export function aggregateUsage(turns: readonly Turn[]): AgentUsageTotal | undefined {
-  let acc: AgentUsageTotal | undefined;
-  for (const turn of turns) {
-    const d = turn.usageDelta;
-    if (!d) continue;
-    if (!acc) acc = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, total: 0 };
-    acc.input += d.input;
-    acc.output += d.output;
-    acc.cacheRead += d.cacheRead;
-    acc.cacheWrite += d.cacheWrite;
-    acc.cost += d.cost ?? 0;
-  }
-  if (acc) acc.total = acc.input + acc.output + acc.cacheRead + acc.cacheWrite;
-  return acc;
-}