@zhushanwen/subagent-core 0.7.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/subagent-core",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Cross-host shared subagent execution layer and workflow orchestration core (dual-form npm package: TS source for workspace, dist ESM+CJS for npm)",
   "type": "module",
   "license": "MIT",
@@ -73,8 +73,8 @@
     "ajv": "^8.20.0",
     "proper-lockfile": "^4.1.2",
     "yaml": "^2.9.0",
-    "@xyz-agent/extension-protocol": "0.8.2",
-    "@zhushanwen/subagent-engine-sdk": "0.2.0"
+    "@xyz-agent/extension-protocol": "0.9.0",
+    "@zhushanwen/subagent-engine-sdk": "0.2.1"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
@@ -82,8 +82,8 @@
     "tsup": "^8.5.1",
     "typescript": "^5.7.0",
     "vitest": "^4.1.8",
-    "@zhushanwen/pi-subagent-cli": "0.1.1",
-    "@zhushanwen/zcode-subagent-cli": "0.1.1"
+    "@zhushanwen/pi-subagent-cli": "0.1.2",
+    "@zhushanwen/zcode-subagent-cli": "0.2.0"
   },
   "scripts": {
     "build": "tsup",

package/src/__tests__/record-store-last-line.test.ts

@@ -21,6 +21,18 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { ManifestStore } from "../execution/manifest-store";
 import { RecordStore } from "../execution/record-store";
 
+// [Gate A teardown 稳定性] no-op 掉索引落盘。根因：recoverOrphanRecords 走的
+// reconstructAll（record-store.ts）扫描尾 fire-and-forget saveIndex（tmp+fsync+rename
+// 异步 fs），满载下该 promise 可能在本文件 teardown 之后才 settle，其失败分支经
+// logger.warn → console.warn 上报 vitest（rpc onUserConsoleLog 在途）——worker 关闭
+// rpc 时在途调用被 reject 为 EnvironmentTeardownError（0 断言失败，纯 teardown 时序）。
+// 本文件用一次性 tmpdir、断言只观察 appendEntry 捕获的判定结果，落盘与否无观察者——
+// no-op 消除在途 IO 链，任何负载下确定；loadIndex 等其余导出保留原实现。
+vi.mock("../execution/sessions-index.ts", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../execution/sessions-index.ts")>()),
+  saveIndex: async () => {},
+}));
+
 interface CapturedEntry {
   type: string;
   data: Record<string, unknown>;

package/src/core/logger.ts

@@ -13,7 +13,7 @@
 
 import { getHostServices } from "./host-services.ts";
 
-/** 日志级别。对齐 @zhushanwen/pi-extension-logger 的 LogLevel（三值，无 info）。 */
+/** 日志级别。级别集合对齐 pi-extension-logger（其 LogLevel 为包内部类型、含 info 四值；实例 API 仅 debug/warn/error 三方法，core facade 据此收窄为三值）。 */
 export type LogLevel = "debug" | "warn" | "error";
 
 /** core logger 接口。与 pi-extension-logger 的 ExtensionLogger 结构兼容——

package/src/execution/__tests__/inflight-production-wiring.test.ts

@@ -0,0 +1,223 @@
+// src/execution/__tests__/inflight-production-wiring.test.ts
+//
+// [u7a 生产补挂] D5 在途推送的生产链路 wiring 测试（crash-forensics impl-plan §7 v6）。
+//
+// 背景：notifyInFlightChanged 此前唯一挂点 = host-bridge arm/disarm 委托，而
+// createHostBridge 全仓无生产调用点——生产迁移点（subagent-service 裸 arm/disarm/
+// 镜像置死、EngineClient 反向通道镜像）全部不推送，extension 监听者恒收不到帧，
+// runtime 侧 inflight 镜像恒 0（Gate B A4 BLOCKED 根因 a）。
+//
+// 三视角：
+//   ①使用者（extension reporter 视角）——注册 setInFlightListener 后，生产迁移点
+//     （idle 相位 arm / 续聊 disarm / 守护击杀 / dispose 批量回收 / 引擎反向通道
+//     childSpawned/childStateChanged）每一处都推来含该 record 贡献的绝对计数快照。
+//   ②构建者——推送携带的是双谓词过滤后的真实计数：活句柄 + 无 armed idle timer
+//     才计在途；镜像置死后计数即刻回落（EngineClient 镜像桥接投影）。
+//   ③观察者——EngineClient 镜像 → core 镜像的单向投影可从镜像面观察（core 镜像
+//     条目随反向通道事件出现/置死），壳层监听者异常不反噬主链（既有出口测试覆盖，
+//     此处不重复）。
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { EventEmitter } from "node:events";
+import type { ChildProcess } from "node:child_process";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
+
+import { clearEngines } from "../engine/registry.ts";
+import { registerFakePiEngine, type FakePiEnginePort } from "./helpers/fake-engine-port.ts";
+import { createRecord } from "../execution-record.ts";
+import { ModelConfigService } from "../model-config-service.ts";
+import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
+import type { RecordStore } from "../record-store.ts";
+import { SubagentService, type PiLike } from "../subagent-service.ts";
+import { _resetLifecycleState, hasIdleTimer } from "../lifecycle-manager.ts";
+import {
+  registerSpawnedChildForRecord,
+  _resetCoreSpawnedChildrenMirrorForTest,
+} from "../engine/host/spawned-children.ts";
+import {
+  getInFlightSnapshot,
+  setInFlightListener,
+  type InFlightSnapshot,
+} from "../engine/inflight-snapshot.ts";
+import { EngineClient } from "../engine/client/engine-client.ts";
+
+const CTX_MODEL: ModelInfo = { id: "m", name: "M", provider: "p", reasoning: false };
+
+function makeEmptyRegistry(): ModelRegistryLike {
+  return { getAvailable: () => [], find: () => undefined, hasConfiguredAuth: () => true };
+}
+
+function makePi(): PiLike {
+  return {
+    appendEntry: vi.fn(),
+    events: { emit: vi.fn() },
+    sendMessage: vi.fn(),
+  } as unknown as PiLike;
+}
+
+/** 最小 fake 子进程（EventEmitter + killed/pid——hasLiveProcessHandle 消费面）。 */
+function makeFakeChild(pid = 4242): ChildProcess & EventEmitter {
+  const child = new EventEmitter() as ChildProcess & EventEmitter;
+  (child as { pid?: number }).pid = pid;
+  (child as { killed: boolean }).killed = false;
+  return child;
+}
+
+interface ServiceInternals {
+  store: RecordStore;
+}
+
+function setup(): {
+  agentDir: string;
+  service: SubagentService;
+  store: RecordStore;
+  fake: FakePiEnginePort;
+} {
+  const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "inflight-wiring-"));
+  clearEngines();
+  const fake = registerFakePiEngine();
+  const modelService = new ModelConfigService({ agentDir, cwd: agentDir });
+  modelService.initModel({ modelRegistry: makeEmptyRegistry(), sessionId: "root-session", ctxModel: CTX_MODEL });
+  const service = new SubagentService({ cwd: agentDir, modelService });
+  service.initSession({ pi: makePi(), sessionId: "root-session" });
+  const store = (service as unknown as ServiceInternals).store;
+  return { agentDir, service, store, fake };
+}
+
+/** chatMode 续聊态 record（首轮已完成等待续聊——v4 B-1 折入 running）。 */
+function makeResumableRecord(id: string): ReturnType<typeof createRecord> {
+  const record = createRecord(id, {
+    agent: "general-purpose",
+    model: "test/model",
+    mode: "background",
+    task: "initial task",
+    slug: "chat",
+    startedAt: 1000,
+    rootSessionId: "root-session",
+    chatMode: true,
+  });
+  record.status = "running";
+  record.round = 1;
+  record.controller = new AbortController();
+  return record;
+}
+
+describe("u7a 生产迁移点 → 在途推送（wiring）", () => {
+  let agentDir: string;
+  let service: SubagentService;
+  let store: RecordStore;
+  let fake: FakePiEnginePort;
+  let seen: InFlightSnapshot[];
+
+  beforeEach(() => {
+    ({ agentDir, service, store, fake } = setup());
+    seen = [];
+    setInFlightListener((s) => seen.push({ ...s }));
+  });
+
+  afterEach(() => {
+    setInFlightListener(null);
+    service.dispose();
+    clearEngines();
+    _resetLifecycleState();
+    _resetCoreSpawnedChildrenMirrorForTest();
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
+  it("idle 相位 arm（生产路径 = handleChatRoundPhase → armChatIdleTimer）：活句柄翻入保活，推送 inFlight=0", async () => {
+    const handle = await service.execute({ task: "first round", slug: "t", ctxModel: CTX_MODEL, conversation: true });
+    const run = fake.runs[0]!;
+    // 引擎侧活句柄（生产经 EngineClient 反向通道桥接投影——此处直接落 core 镜像，
+    // 桥接本体在下方 EngineClient 套件独立验证）
+    registerSpawnedChildForRecord(handle.subagentId, makeFakeChild());
+    expect(getInFlightSnapshot().inFlight).toBe(1); // 前置：在途句柄在场
+
+    seen.length = 0;
+    run.emitLifecycle({ phase: "idle" });
+    expect(hasIdleTimer(handle.subagentId)).toBe(true); // idle 相位 = timer armed
+    expect(seen.at(-1)).toEqual({ inFlight: 0 }); // 保活不算在途（D5 谓词）
+  });
+
+  it("续聊投递 disarm（生产路径 = deliverChatMessage）：翻回正在执行，推送 inFlight=1", async () => {
+    const record = makeResumableRecord("sa-wiring-disarm");
+    store.register(record);
+    registerSpawnedChildForRecord(record.id, makeFakeChild());
+
+    seen.length = 0;
+    await service.chatActions.deliverChatMessage(record, "next round msg", false);
+
+    expect(fake.interacts[0]!.action).toEqual({ kind: "message", payload: "next round msg", interrupt: false });
+    expect(hasIdleTimer(record.id)).toBe(false);
+    expect(seen.at(-1)).toEqual({ inFlight: 1 }); // disarm 后该 record 计在途
+  });
+
+  it("dispose 批量回收：逐 record kill+disarm 后收敛推送终态 inFlight=0", async () => {
+    const record = makeResumableRecord("sa-wiring-dispose");
+    store.register(record);
+    registerSpawnedChildForRecord(record.id, makeFakeChild());
+    expect(getInFlightSnapshot().inFlight).toBe(1);
+
+    seen.length = 0;
+    service.dispose();
+    expect(seen.at(-1)).toEqual({ inFlight: 0 });
+    expect(getInFlightSnapshot().inFlight).toBe(0);
+  });
+});
+
+describe("u7a 数据面桥接：EngineClient 反向通道镜像 → core 镜像 + 推送", () => {
+  let dataDir: string;
+  let client: EngineClient;
+  let seen: InFlightSnapshot[];
+
+  beforeEach(() => {
+    dataDir = fs.mkdtempSync(path.join(os.tmpdir(), "inflight-bridge-"));
+    // 不 connect（构造即被测面：镜像变更经 onChange 同步广播）——零子进程零 fs 写
+    client = new EngineClient({
+      engineId: "fake",
+      command: process.execPath,
+      args: ["-e", "process.exit(0)"],
+      hostKind: "test",
+      hostVersion: "test-host-1.0",
+      dataDir,
+      envPrefixes: [],
+    });
+    seen = [];
+    setInFlightListener((s) => seen.push({ ...s }));
+  });
+
+  afterEach(() => {
+    setInFlightListener(null);
+    client.dispose();
+    _resetCoreSpawnedChildrenMirrorForTest();
+    _resetLifecycleState();
+    fs.rmSync(dataDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
+  it("childSpawned → core 镜像落项 + 推送 inFlight=1；childStateChanged(exited) → 置死 + 推送 inFlight=0", () => {
+    client.mirror.recordSpawned(4242, "sa-bridge");
+    expect(seen.at(-1)).toEqual({ inFlight: 1 });
+    expect(getInFlightSnapshot().inFlight).toBe(1); // core 镜像已投影（计数数据源）
+
+    client.mirror.recordStateChanged({ pid: 4242, recordId: "sa-bridge", state: "exited", killed: true });
+    expect(seen.at(-1)).toEqual({ inFlight: 0 });
+    expect(getInFlightSnapshot().inFlight).toBe(0);
+  });
+
+  it("同 recordId 重 spawn 覆盖 + killedAll 整体置死（引擎回收语义投影）", () => {
+    client.mirror.recordSpawned(111, "sa-bridge-a");
+    client.mirror.recordSpawned(222, "sa-bridge-b");
+    expect(seen.at(-1)).toEqual({ inFlight: 2 });
+
+    client.mirror.killAll(); // 引擎 exit / killAll：逐项 killedAll 事件
+    expect(seen.at(-1)).toEqual({ inFlight: 0 });
+    expect(getInFlightSnapshot().inFlight).toBe(0);
+  });
+});

package/src/execution/__tests__/nested-visibility.test.ts

@@ -13,11 +13,23 @@ 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 { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { createRecord } from "../execution-record.ts";
 import { RecordStore } from "../record-store.ts";
 
+// [Gate A teardown 稳定性] no-op 掉索引落盘。根因：collectRecords 扫描尾的
+// flushIndexAfterScan（record-store.ts）fire-and-forget saveIndex（tmp+fsync+rename
+// 异步 fs），满载下该 promise 可能在本文件 teardown 之后才 settle，其失败分支经
+// logger.warn → console.warn 上报 vitest（rpc onUserConsoleLog 在途）——worker 关闭
+// rpc 时在途调用被 reject 为 EnvironmentTeardownError（0 断言失败，纯 teardown 时序）。
+// 本文件用一次性 tmpdir、断言不观察索引文件，落盘与否无观察者——no-op 消除在途 IO
+// 链，任何负载下确定；loadIndex 等其余导出保留原实现（磁盘重建语义不变）。
+vi.mock("../sessions-index.ts", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../sessions-index.ts")>()),
+  saveIndex: async () => {},
+}));
+
 // ── helpers ──
 
 /**

package/src/execution/engine/__tests__/conformance/registry-fork-filter.test.ts

@@ -2,23 +2,26 @@
 // bash 跨 session 可见性显式断言（R4 一刀语义钉住）+ 偏差 #4 探针（goal 守卫口径）。
 //
 // 设计权威源：chat-domain-v1x-liveness-governance.md §3.2 D4（翻档三连带——读侧
-// 过滤三口 + PENDING_LIFECYCLE 翻 process 档）+ 修订记录 v5-⑤（bash 跨 session
-// 可见性一刀钉成显式选择）+ 验收 A9② + impl-plan §5 偏差 #4（W4 交接：goal 守卫
-// 消费点未传基准，W6 实测裁决是否需 goal 侧两行传参）。
+// 过滤三口；分档常量已随 ext-simplify-12 删除，三类型 process 档成为无条件代码
+// 自然状态）+ 修订记录 v5-⑤（bash 跨 session 可见性一刀钉成显式选择）+ 验收 A9②
+// + impl-plan §5 偏差 #4（W4 交接：goal 守卫消费点未传基准，W6 实测裁决是否需
+// goal 侧两行传参）。
 //
 // 被测函数 = `extensions/universal/pending-notifications/src/state.ts` 的导出纯函数
 // （零依赖、不触 Pi 运行时——文件头注自证；经相对路径源码消费，subagent-core 无该
 // workspace 依赖声明，不加 phantom dep）。分工：
-//   - 过滤函数本体 / rebuild 投影的两口径行为：本套件钉语义（conformance 视角）；
+//   - 过滤函数本体 / pending_notifications 工具投影（entries 现算）的两口径行为：
+//     本套件钉语义（conformance 视角）；
 //   - 过滤①②③的**接线**（goal/subagent-workflow/pending-notifications 三消费点
 //     透传 currentSessionId）：W4 包内测试已承载（pi-pending-notifications
-//     __tests__ :523/:532、subagent-workflow pi-host.test :199-223）；
+//     __tests__、subagent-workflow pi-host.test）；
 //   - 后代判定口（读侧过滤②）的差集口径与①共用同一函数——本套件①的断言即其
 //     语义核心；接线透传由上述 W4 测试守护。
 //
 // 探针结论（偏差 #4，实测证据 = 「goal 守卫口径」describe）：**有虚增**——fork 后
-// 父 session 仍活跃的后台任务残留使 goal 守卫现状口径（无基准）幻 defer；确需的
-// 两行传参改动点列于该 describe 注释，留给主会话裁决（本单元不改 goal——红线）。
+// 父 session 仍活跃的后台任务残留使无基准口径幻 defer。该结论已由 d0b9a6faf
+// （2026-09-09，fix(goal): pass currentSessionId）关闭——goal 两处守卫现传
+// currentSessionId 基准，下方「无基准」形态仅作历史口径对照面保留。
 
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -27,13 +30,9 @@ import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
 // 相对路径源码消费（7 层上溯到仓库根）：state.ts 是零依赖纯函数（不触 Pi 运行时），
 // 无需为探针/契约测试给 subagent-core 添加 workspace 依赖声明。
-import {
-  PENDING_LIFECYCLE,
-  PENDING_TTL_MS,
-  countActiveFromEntries,
-  createRegistry,
-  rebuildFromEntries,
-} from "../../../../../../../extensions/universal/pending-notifications/src/state.ts";
+// [ext-simplify-12] import 面收窄到 countActiveFromEntries——历史的 registry/
+// session 档机器已整体删除，entries 是唯一状态源（跨包语义耦合面收敛到该函数）。
+import { countActiveFromEntries } from "../../../../../../../extensions/universal/pending-notifications/src/state.ts";
 
 import { runReconcileSweep } from "../../../round-supervisor/index.ts";
 
@@ -52,16 +51,13 @@ function registerEntry(
       name: id,
       registeredAt: 1_000,
       sessionId,
-      // bash 真实落盘无 expiresAt 键（写入侧省略，D16）；subagent/workflow 翻
-      // process 档后同理——overrides 仅用于 TTL 对照面。
+      // 真实落盘无 expiresAt 键（写入侧无条件省略）；overrides.expiresAt 模拟历史
+      // session 文件遗留的带 TTL 键 entry——差集读取侧刻意不读该键（对照面）。
       ...(overrides.expiresAt !== undefined ? { expiresAt: overrides.expiresAt } : {}),
     },
   };
 }
 
-/** 语义对照面的基准时刻（远超旧 1h TTL——钉「无 TTL 清理」而非「窗口内未到期」假绿）。 */
-const NOW = 10 * PENDING_TTL_MS + 1;
-
 let tmpDirs: string[] = [];
 
 afterEach(() => {
@@ -69,23 +65,23 @@ afterEach(() => {
   tmpDirs = [];
 });
 
-describe("[W6/D4 翻档] PENDING_LIFECYCLE 三类型全 process 档（跨时长无 TTL 清理的判据锚）", () => {
-  it("subagent/workflow 翻 process 档（bash 原生 process 档）——翻档事实钉住", () => {
-    expect(PENDING_LIFECYCLE).toEqual({ subagent: "process", workflow: "process", bash: "process" });
-  });
-
-  it("翻档后跨时长（远超旧 1h TTL）无 TTL 清理：三类型 register 均不进 expiredToFlush", () => {
-    const registry = createRegistry();
+describe("[W6/D4 翻档余义] 三类型跨时长无 TTL 清理（entries 差集现算）", () => {
+  it("翻档后跨时长（远超旧 1h TTL）无 TTL 清理：三类型 register 均仍 active", () => {
+    // NOW = 10 * 3_600_000 + 1：语义对照面基准时刻（旧 1h TTL = 3_600_000ms 的
+    // 10 倍 + 1ms，远超旧 1h TTL）。entries 差集不接收时间参数——差集语义刻意
+    // 不校验时间，NOW 仅标注对照语义：若旧 session 档 TTL 机器仍在，NOW 时刻
+    // bg-1/wf-1 早已被过期清理。
+    const NOW = 10 * 3_600_000 + 1;
+    // 护栏：钉住对照面确实覆盖「超 TTL」域而非「窗口内未到期」假绿。
+    expect(NOW - 1_000).toBeGreaterThan(3_600_000);
     const entries = [
-      registerEntry("bg-1", "subagent", "sess-root", { expiresAt: 1_000 + 1 }), // 远过去
+      registerEntry("bg-1", "subagent", "sess-root", { expiresAt: 1_000 + 1 }), // 历史遗留 TTL 键（读取侧不读）
       registerEntry("wf-1", "workflow", "sess-root", { expiresAt: 1_000 + 1 }),
       registerEntry("bt-1", "bash", "sess-root"), // 真实落盘形态：无 expiresAt 键
     ];
-    const result = rebuildFromEntries(registry, entries, "sess-root", NOW);
     // 旧 session 档语义（1h TTL + 跨 session 补注销）曾把长任务/跨重启注册静默
-    // 清除 → 守卫失明（事故环 4 放大器）；翻档后三类型全部续存。
-    expect(result.expiredToFlush).toEqual([]);
-    expect(result.activeIds).toEqual(["bg-1", "wf-1", "bt-1"]);
+    // 清除 → 守卫失明（事故环 4 放大器）；三类型全 process 档后差集一律续存。
+    expect(countActiveFromEntries(entries).ids).toEqual(["bg-1", "wf-1", "bt-1"]);
   });
 });
 
@@ -121,41 +117,45 @@ describe("[W6/R4 一刀] bash 跨 session 可见性显式断言（钉成显式
     expect(scoped.count).toBe(1); // 只数本 session 的任务
   });
 
-  it("旧行为显式登记：无基准口径（goal 守卫现状）父 bash 残留仍入计数（= defer 驱动）", () => {
+  it("旧行为显式登记：无基准对照面（历史形态）父 bash 残留仍入计数（= defer 驱动）", () => {
     const childEntries = [registerEntry("parent-bt", "bash", "sess-parent")];
     // 显式钉住「一刀的对照面」：不传基准 = 不过滤 = 子 session goal 仍为父 bash
     // 任务 defer。这是读侧过滤一刀**改变的旧行为**——保留此断言防止有人误以为
-    // 过滤是缺省语义（偏差 #4：goal 消费点现状即此口径，见探针结论）。
+    // 过滤是缺省语义（偏差 #4：goal 消费点历史形态即此口径，已由 d0b9a6faf 修复
+    // 传基准，见探针结论）。
     expect(countActiveFromEntries(childEntries).count).toBe(1);
   });
 });
 
-describe("[W6/D4 读侧过滤③] registry rebuild 投影（pending_notifications 工具读侧）", () => {
-  it("跨 session 残留不入 registry、不补 unregister entry（跳过不补注销——落盘收口归 core sweep）", () => {
-    const registry = createRegistry();
+describe("[W6/D4 读侧过滤③] pending_notifications 工具投影（entries 现算）", () => {
+  it("跨 session 残留不进差集、不产生任何写回（跳过不补注销——落盘收口归 core sweep / bte 对账通道）", () => {
     const entries = [
       registerEntry("parent-bg", "subagent", "sess-parent"),
       registerEntry("own-bg", "subagent", "sess-child"),
     ];
-    const result = rebuildFromEntries(registry, entries, "sess-child", NOW);
-    // 工具投影面（count/list）不虚报继承残留（A9②：count/list 不含继承残留）。
-    expect(result.activeIds).toEqual(["own-bg"]);
-    expect(registry.operations.has("parent-bg")).toBe(false);
+    // 工具投影面（count/list）不虚报继承残留（A9②：count/list 不含继承残留）——
+    // 现算后与读侧过滤①共用同一 countActiveFromEntries 扫描，「落盘了什么」与
+    // 「查询到什么」构造性一致。
+    const result = countActiveFromEntries(entries, { currentSessionId: "sess-child" });
+    expect(result.ids).toEqual(["own-bg"]);
     // 「跳过不补注销」：残留 entry 留在 session 文件（读侧①③口各自兜住差集消费
-    // 方），禁止 rebuild 写侧补发——跨 session 写达域缺口由 core 对账 sweep 收口。
-    expect(result.expiredToFlush).toEqual([]);
+    // 方），countActiveFromEntries 只读不写——跨 session 写达域缺口由 core 对账
+    // sweep 收口（bte 对账同理直接 appendEntry）。只读性实证：输入数组长度不变，
+    // 无补发的 unregister entry。
+    expect(entries).toHaveLength(2);
   });
 });
 
-describe("[W6/偏差 #4 探针] goal 守卫口径（无基准）× fork 残留——实测结论", () => {
+describe("[W6/偏差 #4 探针] goal 守卫口径（无基准）× fork 残留——实测结论（历史口径）", () => {
   // 偏差 #4（impl-plan §5，W4 交接）：W4 读侧过滤①的 currentSessionId 为可选参数，
   // goal 守卫消费点未传基准。本探针在 fork 场景实测该口径是否被父 session 注册
   // 残留虚增，结论二选一回写报告：
   //   (a) 无影响（其他机制覆盖）→ 偏差 #4 关闭，goal 零改动；
   //   (b) 有虚增 → 列出确需的两行传参改动点（不改 goal——红线），留主会话裁决。
   //
-  // **实测结论：(b) 有虚增。**
-  //   证据链：goal 守卫两处消费点现状均无基准调用——
+  // **实测结论：(b) 有虚增。已由 d0b9a6faf（2026-09-09）关闭——goal 现传
+  //   currentSessionId 基准，下方证据链与用例为无基准历史形态的对照面。**
+  //   证据链（历史口径，d0b9a6faf 前的 goal 守卫两处消费点均无基准调用）：
   //     `extensions/universal/goal/src/adapters/event-handlers/agent-end.ts:198`
   //       `const pendingOps = countActiveFromEntries(entries);`（defer 分支判据
   //        = `pendingOps.count > 0`）
@@ -166,21 +166,23 @@ describe("[W6/偏差 #4 探针] goal 守卫口径（无基准）× fork 残留
   //   用例 2 证明仅当父任务 record 已终态（core sweep 补注销落盘）才归零——
   //   「父任务仍活跃」窗口内无任何机制覆盖（W4 翻档后 U4 不再中性化）。
   //
-  //   确需的两行改动点（主会话裁决后由 goal 侧单元执行）：
+  //   已执行的修复（d0b9a6faf，即当时登记的两行传参改动点）：
   //     agent-end.ts:198 → `countActiveFromEntries(entries, { currentSessionId: ctx.sessionManager.getSessionId() })`
   //     agent-end.ts:294 → `countActiveFromEntries(ctx.sessionManager.getEntries(), { currentSessionId: ctx.sessionManager.getSessionId() })`
   //   （getSessionId 是 extension 侧既有取 sessionId 形态——pending-notifications
-  //   index.ts:216、subagent-workflow session-lifecycle.ts 同款先例。）
+  //   index.ts:216、subagent-workflow session-lifecycle.ts 同款先例；现行
+  //   agent-end.ts 守卫注释反向引用本探针作为传基准依据。）
 
-  it("用例 1：父 session 活跃 subagent 残留 → goal 现状口径（无基准）count>0 → defer 分支命中（虚增）", () => {
+  it("用例 1：父 session 活跃 subagent 残留 → 无基准对照面（历史形态）count>0 → defer 分支命中（虚增）", () => {
     // fork 时刻快照：父 session 派了后台子代理（record 仍 running-resumable），
     // 子 session 继承其 register 残留；goal 守卫读到的 entries = 本 session 文件
-    // 全量（含继承残留）。现状口径 = 无基准调用（agent-end.ts:198 逐字形态）。
+    // 全量（含继承残留）。历史形态 = 无基准调用（d0b9a6faf 前 agent-end.ts:198
+    // 逐字形态；现行已传基准，此对照面锁定「不传则虚增」的机制事实）。
     const childEntries = [
       registerEntry("parent-bg", "subagent", "sess-parent"),
       registerEntry("child-bg", "subagent", "sess-child"),
     ];
-    const pendingOps = countActiveFromEntries(childEntries); // ← goal 现状口径
+    const pendingOps = countActiveFromEntries(childEntries); // ← 无基准对照面（历史形态）
     // defer 分支判据（agent-end.ts:199 `if (pendingOps.count > 0)`）命中：
     // 父 session 的任务让子 session 的 goal 停发 continuation 并 notify
     // 「Goal waiting for 2 background task(s)」——计数含非本 session 任务 = 虚增。
@@ -209,9 +211,9 @@ describe("[W6/偏差 #4 探针] goal 守卫口径（无基准）× fork 残留
     });
     expect(result.reconciled).toEqual(["parent-bg"]);
 
-    // 落盘后 goal 守卫（无基准口径）重读 entries：计数归零——sweep 是现状口径的
-    // 唯一收敛通道，且只覆盖「record 可判定终态」的窗口；「父任务仍活跃」窗口
-    // （用例 1）无机制覆盖 → 虚增结论 (b) 成立。
+    // 落盘后 goal 守卫（无基准口径，历史形态）重读 entries：计数归零——sweep 是
+    // 无基准口径的唯一收敛通道，且只覆盖「record 可判定终态」的窗口；「父任务仍
+    // 活跃」窗口（用例 1）无机制覆盖 → 虚增结论 (b) 成立。
     const entriesAfter = readFileSync(sessionFile, "utf8")
       .trim()
       .split("\n")