@zhushanwen/subagent-core 0.4.0 → 0.6.0

package/src/execution/__tests__/output-collector.test.ts

@@ -5,8 +5,17 @@
 // （usage 收口进 getTotalUsage，text 收口进 getFullText，均在 execution-record.test 测）。
 import { describe, expect, it } from "vitest";
 
-import { isStaleContextErrorMsg, DETERMINISTIC_SCHEMA_FAILURE_PREFIX, isDeterministicSchemaFailureMsg, STALE_CONTEXT_PATTERNS } from "../../orchestration/execute-agent-call.ts";
-import { collectResult, describeMissingParsedOutput, extractParsedOutput, neutralizeStalePatterns } from "../output-collector.ts";
+import {
+  classifyFailureKind,
+  collectResult,
+  describeMissingParsedOutput,
+  DETERMINISTIC_SCHEMA_FAILURE_PREFIX,
+  extractParsedOutput,
+  isDeterministicSchemaFailureMsg,
+  isStaleContextErrorMsg,
+  neutralizeStalePatterns,
+  STALE_CONTEXT_PATTERNS,
+} from "../engine/engines/pi/output-collector.ts";
 import type { ExecutionRecord, ToolCall } from "../types.ts";
 
 // ============================================================
@@ -162,9 +171,9 @@ describe("describeMissingParsedOutput", () => {
   // ── [F-R1] 态2（isError 分支）错误摘要拼接段中和 ──
   //
   // 动态错误文本（模型/provider 原始错误）可能携带 "aborted"/"ctx is stale" 等
-  // STALE_CONTEXT_PATTERNS 词；不中和则归因 error 经 collectResult → result.error
-  // 流到 execute-agent-call 的 isStaleContextErrorMsg 分诊，被误诊为 stale-context
-  // 跳过重试。固定前缀静态无命中（上一用例锁定），中和只针对动态段。
+  // STALE_CONTEXT_PATTERNS 词；不中和则归因 error 经 collectResult 的
+  // classifyFailureKind 分诊被误标 stale_context（归因语义被污染）。
+  // 固定前缀静态无命中（上一用例锁定），中和只针对动态段。
   describe("F-R1: 态2 错误摘要 STALE_CONTEXT_PATTERNS 中和", () => {
     function failedSoCallsWith(text: string): ToolCall[] {
       return [
@@ -233,7 +242,7 @@ describe("describeMissingParsedOutput", () => {
 // ============================================================
 
 describe("MF-1: 三态可重试性矩阵（确定性失败标记）", () => {
-  // 矩阵（SSOT 注释在 execute-agent-call DETERMINISTIC_SCHEMA_FAILURE_PREFIX 与
+  // 矩阵（SSOT 注释在本模块 DETERMINISTIC_SCHEMA_FAILURE_PREFIX 与
   // describeMissingParsedOutput JSDoc，本 describe 是执行面锁定）：
   //   态① 从未调用 SO            → 带标记 → 不可重试（环境确定性，C1 安装盲区）
   //   态② SO isError（gate 终止/不可满足 schema）→ 带标记 → 不可重试（同 schema 重试必同结果）
@@ -356,3 +365,105 @@ describe("collectResult — F-1 schemaExpected 失败标注", () => {
     expect(isDeterministicSchemaFailureMsg(result.error)).toBe(true);
   });
 });
+
+// ============================================================
+// D5-③: failureKind 分类（产出侧单点识别）
+// ============================================================
+
+describe("classifyFailureKind（词表 → 结构化标签）", () => {
+  it("pi 真实 stale 文案 → stale_context", () => {
+    const piRealStale =
+      "This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession().";
+    expect(classifyFailureKind(piRealStale)).toBe("stale_context");
+  });
+
+  it("abort 族（context canceled / aborted）→ stale_context", () => {
+    expect(classifyFailureKind("Request context canceled by provider")).toBe("stale_context");
+    expect(classifyFailureKind("Subprocess aborted by runtime shutdown")).toBe("stale_context");
+  });
+
+  it("确定性 schema 失败标记前缀 → schema_deterministic", () => {
+    expect(classifyFailureKind(
+      `${DETERMINISTIC_SCHEMA_FAILURE_PREFIX} Agent finished without producing a structured output`,
+    )).toBe("schema_deterministic");
+  });
+
+  it("未知文案（词表零命中，pi 升级改写文案后的形态）→ unknown（安全默认，可重试）", () => {
+    expect(classifyFailureKind("provider 503 service unavailable")).toBe("unknown");
+    expect(classifyFailureKind("spawn EAGAIN")).toBe("unknown");
+    expect(classifyFailureKind("extension runtime was superseded by a newer orchestration epoch")).toBe("unknown");
+  });
+
+  it("undefined（成功路径）→ undefined（不落失败分诊）", () => {
+    expect(classifyFailureKind(undefined)).toBeUndefined();
+  });
+
+  it("标记词与 stale 词表零交集（分诊优先级无歧义）", () => {
+    expect(classifyFailureKind(DETERMINISTIC_SCHEMA_FAILURE_PREFIX)).toBe("schema_deterministic");
+  });
+});
+
+describe("collectResult — D5-③ failureKind 产出", () => {
+  /** 最小 ExecutionRecord stub（collectResult 只读 turns/toolCalls 派生面）。 */
+  function makeRecordWithCalls(calls: ToolCall[]): ExecutionRecord {
+    return {
+      id: "rec-fk",
+      turns: [{ toolCalls: calls, text: "done", turnCount: 1, closed: true }],
+      turnCount: 1,
+    } as unknown as ExecutionRecord;
+  }
+
+  const baseArgs = {
+    startTime: Date.now(),
+    sessionId: "s-fk",
+    sessionFile: undefined,
+  };
+
+  it("error 命中 stale 词表 → failureKind=stale_context", () => {
+    const record = makeRecordWithCalls([]);
+    const result = collectResult(record, {
+      ...baseArgs,
+      success: false,
+      error: "This extension ctx is stale after session replacement or reload.",
+    });
+    expect(result.failureKind).toBe("stale_context");
+  });
+
+  it("F-1 归因覆写（态①②确定性标记）→ failureKind=schema_deterministic", () => {
+    const record = makeRecordWithCalls([]);
+    const result = collectResult(record, { ...baseArgs, success: true, error: undefined, schemaExpected: true });
+    expect(result.error).toBeDefined();
+    expect(result.failureKind).toBe("schema_deterministic");
+  });
+
+  it("态③归因（调用过但无 details，无标记）→ failureKind=unknown（可重试，矩阵保留）", () => {
+    const record = makeRecordWithCalls([
+      { toolName: "structured-output", result: { content: [] } },
+    ]);
+    const result = collectResult(record, { ...baseArgs, success: true, error: undefined, schemaExpected: true });
+    expect(result.error).toBeDefined();
+    expect(result.failureKind).toBe("unknown");
+  });
+
+  it("普通 provider 错误 → failureKind=unknown", () => {
+    const record = makeRecordWithCalls([]);
+    const result = collectResult(record, { ...baseArgs, success: false, error: "provider boom 5xx" });
+    expect(result.failureKind).toBe("unknown");
+  });
+
+  it("成功路径（error undefined）→ failureKind 不写（缺省 = unknown = 可重试，消费侧语义）", () => {
+    const record = makeRecordWithCalls([]);
+    const result = collectResult(record, { ...baseArgs, success: true, error: undefined });
+    expect(result.failureKind).toBeUndefined();
+  });
+
+  it("词表漂移失效模式：未知文案（未来 pi 形态）→ failureKind=unknown（保守重试，非静默漏诊）", () => {
+    const record = makeRecordWithCalls([]);
+    const result = collectResult(record, {
+      ...baseArgs,
+      success: false,
+      error: "extension runtime was superseded by a newer orchestration epoch",
+    });
+    expect(result.failureKind).toBe("unknown");
+  });
+});

package/src/execution/__tests__/pi-invocation.test.ts

@@ -3,10 +3,42 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
-import { afterEach, describe, expect, it } from "vitest";
-
-import { getPiInvocation } from "../pi-invocation.ts";
-import { RELAY_ENV_NODE, RELAY_ENV_SCRIPT, RELAY_ENV_SOCKET } from "../relay-env.ts";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { getPiInvocation } from "../engine/engines/pi/pi-invocation.ts";
+import {
+  RELAY_ENV_NODE,
+  RELAY_ENV_RECORD_ID,
+  RELAY_ENV_SCRIPT,
+  RELAY_ENV_SESSION_ID,
+  RELAY_ENV_SOCKET,
+} from "../relay-env.ts";
+
+// [验收门修复] getPiInvocation 的 relay 分支优先读宿主 RELAY env——根级 pnpm test
+// 进程若继承宿主（pi 子进程链）的 RELAY 身份，直连分支用例的 execPath/argv 断言
+// 会被改道（非自免疫，依赖 runner 环境）。文件级钩子对全部用例统一消毒：beforeEach
+// 删五键、afterEach 恢复原值——有泄漏无泄漏双向绿；第二组 relay 分支用例自设
+// RELAY_FULL 在清理之后执行，语义不受影响。
+const RELAY_ENV_KEYS = [
+  RELAY_ENV_SOCKET,
+  RELAY_ENV_NODE,
+  RELAY_ENV_SCRIPT,
+  RELAY_ENV_SESSION_ID,
+  RELAY_ENV_RECORD_ID,
+] as const;
+let savedRelayEnv: Record<string, string | undefined>;
+beforeEach(() => {
+  savedRelayEnv = {};
+  for (const key of RELAY_ENV_KEYS) savedRelayEnv[key] = process.env[key];
+  for (const key of RELAY_ENV_KEYS) delete process.env[key];
+});
+afterEach(() => {
+  for (const key of RELAY_ENV_KEYS) {
+    const value = savedRelayEnv[key];
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+});
 
 describe("getPiInvocation", () => {
   const originalArgv = process.argv;

package/src/execution/__tests__/record-entry-collect.test.ts

@@ -0,0 +1,102 @@
+// src/execution/__tests__/record-entry-collect.test.ts
+//
+// subagent-record entry 序列化白名单：collectMode / batchFinalized 两字段
+// （subagent-sync-collect U1 foundation）。
+//
+// 锁三件事（设计 §3.1.3）：
+//   1. 持久化：两字段在 entry data 中如实透传（round-trip 经 JSON 序列化不丢）；
+//   2. 零迁移：无字段（旧 record 形态）的 entry 产物不含新键（JSON.stringify 自然缺省），
+//      与改动前逐字节一致；
+//   3. customType 稳定：SUBAGENT_RECORD_CUSTOM_TYPE 不因扩字段漂移。
+
+import { describe, expect, it } from "vitest";
+
+import {
+  SUBAGENT_RECORD_CUSTOM_TYPE,
+  toSubagentRecordEntry,
+  type SubagentRecordEntryData,
+} from "../record-entry.ts";
+import type { SubagentRecord } from "../types.ts";
+
+/** 最小合法 SubagentRecord（缺省无 collect 两字段 = 旧记录形态）。 */
+function makeRecord(over: Partial<SubagentRecord> = {}): SubagentRecord {
+  return {
+    id: "sa-1",
+    agent: "/home/u/agents/worker.md",
+    task: "t",
+    slug: "worker",
+    status: "running",
+    mode: "background",
+    startedAt: 1000,
+    rootSessionId: "root-A",
+    parentRecordId: undefined,
+    depth: 0,
+    endedAt: undefined,
+    turns: 1,
+    totalTokens: 42,
+    model: "prov/m1",
+    thinkingLevel: undefined,
+    eventLog: [],
+    displayItems: [],
+    sessionFile: "sess-1.jsonl",
+    ...over,
+  } as SubagentRecord;
+}
+
+/** entry data 的 JSONL 形态字符串（appendEntry 落盘即此产物）。 */
+function serialize(entry: SubagentRecordEntryData): string {
+  return JSON.stringify(entry);
+}
+
+describe("record-entry serialization: collect fields (U1 foundation)", () => {
+  it("keeps SUBAGENT_RECORD_CUSTOM_TYPE stable", () => {
+    expect(SUBAGENT_RECORD_CUSTOM_TYPE).toBe("subagent-record");
+  });
+
+  it("passes collectMode through for a sync record", () => {
+    const entry = toSubagentRecordEntry(makeRecord({ collectMode: "sync" }));
+    expect(entry.collectMode).toBe("sync");
+    expect(entry.batchFinalized).toBeUndefined();
+  });
+
+  it("passes batchFinalized through for a member that left the batch", () => {
+    const entry = toSubagentRecordEntry(
+      makeRecord({
+        collectMode: "sync",
+        batchFinalized: true,
+        status: "closed",
+        endedAt: 2000,
+      }),
+    );
+    expect(entry.collectMode).toBe("sync");
+    expect(entry.batchFinalized).toBe(true);
+    expect(entry.status).toBe("closed");
+  });
+
+  it("round-trips both fields through JSON serialization (persisted form)", () => {
+    const entry = toSubagentRecordEntry(
+      makeRecord({ collectMode: "sync", batchFinalized: true }),
+    );
+    const revived = JSON.parse(serialize(entry)) as SubagentRecordEntryData;
+    expect(revived.collectMode).toBe("sync");
+    expect(revived.batchFinalized).toBe(true);
+    expect(revived.v).toBe(1);
+  });
+
+  it("emits no new keys for legacy records (旧记录零迁移)", () => {
+    const json = serialize(toSubagentRecordEntry(makeRecord()));
+    expect(json).not.toContain("collectMode");
+    expect(json).not.toContain("batchFinalized");
+    const revived = JSON.parse(json) as SubagentRecordEntryData;
+    expect(revived.collectMode).toBeUndefined();
+    expect(revived.batchFinalized).toBeUndefined();
+  });
+
+  it("still emits the full legacy whitelist for legacy records (既有字段不受扩字段影响)", () => {
+    const entry = toSubagentRecordEntry(makeRecord());
+    expect(entry.id).toBe("sa-1");
+    expect(entry.status).toBe("running");
+    expect(entry.model).toBe("prov/m1");
+    expect(entry.sessionFile).toBe("sess-1.jsonl");
+  });
+});

package/src/execution/__tests__/record-store.test.ts

@@ -52,8 +52,9 @@ function makeRecord(over: Partial<ExecutionRecord> = {}): ExecutionRecord {
   const base = createRecord("r1", {
     agent: "worker",
     model: "m",
-    mode: "sync",
+    mode: "background",
     task: "t",
+    slug: "test",
     startedAt: 1000,
     rootSessionId: "sess-current",
     // 对齐生产 register 路径（subagent-service createRecord：one-shot 显式 false）
@@ -68,7 +69,7 @@ function makeRecord(over: Partial<ExecutionRecord> = {}): ExecutionRecord {
  */
 function writeSessionJsonl(
   filePath: string,
-  identity: { id: string; agent: string; mode: "sync" | "background"; task: string; startedAt: number; rootSessionId?: string; parentRecordId?: string; depth?: number; lastTs?: number; chatMode?: boolean },
+  identity: { id: string; agent: string; mode: "background"; task: string; startedAt: number; rootSessionId?: string; parentRecordId?: string; depth?: number; lastTs?: number; chatMode?: boolean },
   assistantText = "result text",
 ): void {
   const lastTs = identity.lastTs ?? identity.startedAt + 1000;
@@ -138,7 +139,7 @@ describe("RecordStore", () => {
   describe("archive 立即移除", () => {
     it("archive 后 record 立即从内存移除（不再 linger）", () => {
       const store = new RecordStore(tmpDir);
-      const r = makeRecord({ id: "sync-1", mode: "sync", status: "closed" });
+      const r = makeRecord({ id: "sync-1", mode: "background", status: "closed" });
       store.register(r);
       expect(store.getMutable("sync-1")).toBeDefined();
       store.archive(r);
@@ -1012,7 +1013,7 @@ describe("RecordStore", () => {
       // chatMode 必须显式在场（one-shot=false）——renderer isDone 判据依赖它。
       expect(Object.keys(data).sort()).toEqual([
         "agent", "chatMode", "depth", "displayItems", "eventLog",
-        "id", "mode", "model", "rootSessionId", "round", "startedAt",
+        "id", "mode", "model", "rootSessionId", "round", "slug", "startedAt",
         "status", "task", "totalTokens", "turns", "v", "worktree",
       ]);
       expect(data).toMatchObject({
@@ -1021,7 +1022,7 @@ describe("RecordStore", () => {
         agent: "worker",
         task: "t",
         status: "running",
-        mode: "sync",
+        mode: "background",
         startedAt: 1000,
         rootSessionId: "sess-current",
         chatMode: false,
@@ -1091,13 +1092,13 @@ describe("RecordStore", () => {
       writeSessionJsonl(path.join(tmpDir, "sa-ps14.jsonl"), {
         id: "ps14",
         agent: "worker",
-        mode: "sync",
+        mode: "background",
         task: "t",
         startedAt: 1000,
       });
 
       const store = new RecordStore(tmpDir);
-      const records = store.collectRecords();
+      const records = store.collectRecords(100);
       expect(records).toHaveLength(1); // 扫描本身不受索引写失败影响
 
       // fire-and-forget saveIndex：等 .catch 执行
@@ -1122,13 +1123,13 @@ describe("RecordStore", () => {
       writeSessionJsonl(path.join(tmpDir, "sa-ps14-ok.jsonl"), {
         id: "ps14ok",
         agent: "worker",
-        mode: "sync",
+        mode: "background",
         task: "t",
         startedAt: 1000,
       });
 
       const store = new RecordStore(tmpDir);
-      store.collectRecords();
+      store.collectRecords(100);
       await vi.waitFor(() => expect(saveIndexMock).toHaveBeenCalled());
 
       const warnIndexMsgs = loggerMock.warn.mock.calls.filter((c) =>

package/src/execution/__tests__/records-cwd-isolation.test.ts

@@ -26,7 +26,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
-  fs.rmSync(tmpAgentDir, { recursive: true, force: true });
+  fs.rmSync(tmpAgentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
 });
 
 /** 写一个最小合法的 manifest 到指定 records 目录。 */
@@ -36,7 +36,7 @@ function writeManifest(recordsDir: string, id: string): string {
     id,
     rootSessionId: "sess-1",
     agentName: "worker",
-    status: "completed",
+    status: "closed",
     createdAt: Date.now(),
   };
   const filePath = path.join(recordsDir, `${id}.json`);

package/src/execution/__tests__/recursive-visibility-baseline.test.ts

@@ -16,102 +16,32 @@
 //   4. forkDepth 基线：env PI_SUBAGENT_FORK_DEPTH → fork spawn env 递增
 //
 // mock 策略与 execute-nesting.test.ts 一致（spawn → FakeChild，fs 同步方法 mock，
-// temp-prompt / alive-store / finalized-marker / manifest-store mock）。
-
-import type { PassThrough } from "node:stream";
+// temp-prompt / alive-store / finalized-marker / manifest-store mock；已收敛
+// ./helpers/subagent-service-mocks.ts 四文件共享单源）。
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-// ── mock modules（同 execute-nesting.test.ts）──
-
-vi.mock("node:child_process", async () => {
-  const { EventEmitter } = await import("node:events");
-  const { PassThrough } = await import("node:stream");
-
-  class FakeChild extends EventEmitter {
-    pid = 12345;
-    stdout = new PassThrough();
-    stderr = new PassThrough();
-    killed = false;
-    killSignal: string | undefined;
-    kill(sig?: string): boolean {
-      this.killed = true;
-      this.killSignal = sig;
-      return true;
-    }
-  }
-
-  return {
-    spawn: vi.fn(() => new FakeChild()),
-    // buildEnvBlock 用 execFile 异步取 git branch：默认 err-first 兜底（catch → branch=""）
-    execFile: vi.fn(
-      (
-        _cmd: string,
-        _args: readonly string[],
-        _opts: unknown,
-        cb: (err: Error | null, stdout?: string, stderr?: string) => void,
-      ) => cb(new Error("execFile not configured in this test")),
-    ),
-  };
-});
+import {
+  aliveStoreModule,
+  childProcessModule,
+  finalizedMarkerModule,
+  fsSyncModule,
+  manifestStoreModule,
+  tempPromptModule,
+} from "./helpers/subagent-service-mocks.ts";
 
-vi.mock("node:fs", async () => {
-  const actual = await import("node:fs");
-  return {
-    default: {
-      ...actual,
-      mkdirSync: vi.fn(),
-      existsSync: vi.fn(() => false),
-      appendFileSync: vi.fn(),
-      writeFileSync: vi.fn(),
-      readdirSync: vi.fn(() => []),
-    },
-    mkdirSync: vi.fn(),
-    existsSync: vi.fn(() => false),
-    appendFileSync: vi.fn(),
-    writeFileSync: vi.fn(),
-    readdirSync: vi.fn(() => []),
-    promises: actual.promises,
-  };
-});
-
-vi.mock("../alive-store.ts", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../alive-store.ts")>();
-  return {
-    ...actual,
-    writeAliveMarker: vi.fn(),
-    removeAliveMarker: vi.fn(),
-  };
-});
-
-vi.mock("../finalized-marker.ts", () => ({
-  writeFinalized: vi.fn(),
-  readFinalized: vi.fn(() => false),
-}));
-
-vi.mock("../manifest-store.ts", () => {
-  class FakeManifestStore {
-    writeManifest = vi.fn(async () => {});
-    readManifest = vi.fn(async () => null);
-    listAllSync = vi.fn(() => []);
-    recoverTmpFiles = vi.fn(async () => []);
-  }
-  // vi.fn 包裹：构造参数（recordsDir）可从 mock.calls 断言（[MF-3] 目录统一验证）。
-  // 注意用普通 function（箭头函数不能被 new 调用）。
-  return { ManifestStore: vi.fn(function (_recordsDir: string) { return new FakeManifestStore(); }) };
-});
+// ── mock modules（同 execute-nesting.test.ts）──
 
-vi.mock("../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` };
-  }),
-  cleanupTempPrompt: vi.fn(async () => {}),
-}));
+vi.mock("node:child_process", () => childProcessModule());
+vi.mock("node:fs", async (importOriginal) => fsSyncModule(await importOriginal<typeof import("node:fs")>()));
+vi.mock("../alive-store.ts", async (importOriginal) => aliveStoreModule(await importOriginal<typeof import("../alive-store.ts")>()));
+vi.mock("../finalized-marker.ts", () => finalizedMarkerModule());
+vi.mock("../manifest-store.ts", () => manifestStoreModule());
+vi.mock("../engine/engines/pi/temp-prompt.ts", () => tempPromptModule());
 
 import { spawn } from "node:child_process";
 
-import { waitForSpawn } from "./helpers/spawn-mock.ts";
+import { waitForSpawn, lastSpawnedChild } from "./helpers/spawn-mock.ts";
 import { ModelConfigService } from "../model-config-service.ts";
 import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
 import { ManifestStore } from "../manifest-store.ts";
@@ -128,43 +58,10 @@ const ENV_DEPTH = "PI_SUBAGENT_DEPTH";
 const ENV_ROOT_CWD = "PI_SUBAGENT_ROOT_CWD";
 const ENV_FORK_DEPTH = "PI_SUBAGENT_FORK_DEPTH";
 
-interface FakeChild {
-  pid: number;
-  stdout: PassThrough;
-  stderr: PassThrough;
-  killed: boolean;
-  killSignal: string | undefined;
-  kill(sig?: string): boolean;
-  emit(event: string, ...args: unknown[]): boolean;
-}
-
-function lastSpawnedChild(): FakeChild {
-  const result = mockSpawn.mock.results.at(-1);
-  if (!result) throw new Error("spawn was not called yet");
-  return result.value as FakeChild;
-}
-
 function getLastSpawnEnv(): Record<string, string | undefined> {
   return (mockSpawn.mock.calls.at(-1)?.[2]?.env as Record<string, string | undefined>) ?? {};
 }
 
-function sessionHeader(id = "baseline-session"): Record<string, unknown> {
-  return { type: "session", id, timestamp: "2026-08-11T00-00-00-000Z", cwd: "/tmp/test" };
-}
-
-function emitStdoutLine(child: FakeChild, obj: Record<string, unknown>): void {
-  child.stdout.write(`${JSON.stringify(obj)}\n`);
-}
-
-/** 驱动 FakeChild 完成：header + 可选事件 + close(0)（runSpawn 自然 resolve）。 */
-async function driveChildToCompletion(child: FakeChild, events: Record<string, unknown>[] = []): Promise<void> {
-  emitStdoutLine(child, sessionHeader());
-  for (const e of events) emitStdoutLine(child, e);
-  child.stdout.end();
-  child.stderr.end();
-  child.emit("close", 0);
-}
-
 // ── 辅助：service 构造 ──
 
 function makeEmptyRegistry(): ModelRegistryLike {
@@ -177,7 +74,7 @@ function makePi() {
 
 function setup(env: Record<string, string>): { service: SubagentService; store: RecordStore } {
   const agentDir = "/tmp/baseline-it";
-  const modelService = new ModelConfigService({ agentDir });
+  const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
   modelService.initModel({
     modelRegistry: makeEmptyRegistry(),
     sessionId: "baseline-it",
@@ -227,7 +124,7 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
     const { service, store } = setup({});
 
     // 不在 execCtxAls.run 内调用（模拟 ALS 断裂：事件回调上下文读不到 store）
-    const handle = await service.execute({ task: "child of parent", ctxModel });
+    const handle = await service.execute({ task: "child of parent", slug: "test", ctxModel });
 
     const rec = store.collectRecords(10, "all", "root-main").find((r) => r.id === handle.subagentId);
     expect(rec).toBeDefined();
@@ -239,7 +136,7 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
     // 旧实现传 this.sessionId（子进程自己的 session id ≠ ROOT）→ 子进程内列表恒空。
     // 子进程的本进程 sessionId 是 "baseline-it"（initSession 注入），而 record 归属
     // root-main（env 贯穿的真 ROOT）——能查到即证明过滤用的是 sessionRootId。
-    const viaService = service.collectRecords(10);
+    const viaService = service.queries.collectRecords(10);
     expect(viaService.map((r) => r.id)).toContain(handle.subagentId);
     expect(viaService[0]!.rootSessionId).toBe("root-main");
   });
@@ -247,7 +144,7 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
   it("[顶层] 无 env（根进程）：parentRecordId undefined / depth 0", async () => {
     const { service, store } = setup({});
 
-    const handle = await service.execute({ task: "top level", ctxModel });
+    const handle = await service.execute({ task: "top level", slug: "test", ctxModel });
 
     const rec = store.collectRecords(10, "all", "baseline-it").find((r) => r.id === handle.subagentId);
     expect(rec).toBeDefined();
@@ -261,10 +158,10 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
     process.env[ENV_DEPTH] = "0";
 
     const { service, store } = setup({});
-    const execCtxAls = Reflect.get(service, "execCtxAls") as ExecCtxAls;
+    const execNesting = Reflect.get(service, "execNesting") as ExecCtxAls;
 
-    const handle = await execCtxAls.run({ recordId: "sa-inline-parent", depth: 3 }, () =>
-      service.execute({ task: "inline nested", ctxModel }),
+    const handle = await execNesting.run({ recordId: "sa-inline-parent", depth: 3 }, () =>
+      service.execute({ task: "inline nested", slug: "test", ctxModel }),
     );
 
     const rec = store.collectRecords(10, "all", "root-main").find((r) => r.id === handle.subagentId);
@@ -281,14 +178,14 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
 
     const { service } = setup({});
 
-    const execPromise = service.execute({ task: "fork child", ctxModel, fork: true });
+    const execPromise = service.execute({ task: "fork child", slug: "test", ctxModel, fork: true });
     await waitForSpawn(mockSpawn);
     const childEnv = getLastSpawnEnv();
 
     // 742 行 parentDepth = forkDepthAls.getStore() ?? forkDepthBaseline —— ALS 断裂时基线=1，+1 → 2
     expect(childEnv.PI_SUBAGENT_FORK_DEPTH).toBe("2");
 
-    const child = lastSpawnedChild();
+    const child = lastSpawnedChild(mockSpawn);
     child.emit("close", 0);
     await execPromise;
   });
@@ -303,7 +200,7 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
     // MAX_FORK_DEPTH 至少 > 5 才不会被误拒；这里验证基线参与计数的方式是
     // 用直接深度断言——execute 不抛错说明 nestingDepth=6 未超限，护栏不误伤。
     // （MAX_FORK_DEPTH 具体值由 session-context-resolver 定义，这里不硬编码。）
-    await expect(service.execute({ task: "deep but allowed", ctxModel })).resolves.toBeDefined();
+    await expect(service.execute({ task: "deep but allowed", slug: "test", ctxModel })).resolves.toBeDefined();
   });
 
   it("[MF-3 回归] 有 ENV_ROOT_CWD（worktree 子进程）：sessions 与 records 两套目录统一编码在 ROOT cwd 段", () => {
@@ -314,7 +211,7 @@ describe("进程级基线兜底（ALS 断裂修复，pi 事件回调模型）",
 
     const agentDir = "/tmp/baseline-it";
     const checkoutPath = "/var/folders/worktree/pi-subagents/--root-project--/branch";
-    const modelService = new ModelConfigService({ agentDir });
+    const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
     modelService.initModel({
       modelRegistry: makeEmptyRegistry(),
       sessionId: "baseline-it",