@zhushanwen/pi-base-tool-enhance 0.7.2 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-base-tool-enhance",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "description": "Base tool enhancement - override builtin bash tool: foreground delegates to pi official factory, incremental background mode (design decisions documented in source comments)",
   "type": "module",
   "main": "src/index.ts",
@@ -28,20 +28,20 @@
     "skills/"
   ],
   "dependencies": {
-    "@zhushanwen/extension-protocol": "0.17.0",
-    "@zhushanwen/pi-ext-guards": "0.4.2",
-    "@zhushanwen/pi-extension-logger": "0.6.1",
+    "@zhushanwen/extension-protocol": "0.19.0",
+    "@zhushanwen/pi-ext-guards": "0.4.3",
+    "@zhushanwen/pi-extension-logger": "0.6.2",
     "@zhushanwen/pi-file-lock": "0.4.1",
-    "@zhushanwen/pi-llm-shared": "0.11.0"
+    "@zhushanwen/pi-llm-shared": "0.11.1"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.1.9",
     "vitest": "^4.1.8"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.84.4",
-    "typebox": "*",
-    "@zhushanwen/pi-pending-notifications": "0.8.1"
+    "@earendil-works/pi-coding-agent": "^1.0.0",
+    "typebox": "1.3.27",
+    "@zhushanwen/pi-pending-notifications": "0.8.3"
   },
   "peerDependenciesMeta": {
     "@zhushanwen/pi-pending-notifications": {

package/src/__tests__/background-lifecycle.test.ts

@@ -1,5 +1,5 @@
 // src/__tests__/background-lifecycle.test.ts —— background 核心生命周期集成：
-// 真实 spawn 边沿收尾 / 轮询器自动收尾 / killing intent 双侧 / timeout / 并发上限 /
+// 真实 spawn 边沿收尾 / exit 事件自动收尾 / killing intent 双侧 / timeout / 并发上限 /
 // 收殓 / D15 abort / bash_output / bash_kill（黑盒：经工具 execute 断言使用者可见行为）
 import { existsSync, mkdtempSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -38,7 +38,7 @@ import { isPidAlive } from "@zhushanwen/extension-protocol/background-task";
 import { createBashKillToolDefinition } from "../bash-kill-tool.ts";
 import { createBashOutputToolDefinition } from "../bash-output-tool.ts";
 import { handleTaskExit, refreshPiReference, resetNotifyForTest } from "../background/notify.ts";
-import { pollTickForTest, setOnTaskExit, stopPoller } from "../background/poller.ts";
+import { setOnTaskExit } from "../background/exit-collector.ts";
 import { getRegistryPath, readRegistry, taskToRegistryEntry, writeRegistryEntry } from "../background/registry.ts";
 import type { RegistryEntry } from "../background/types.ts";
 import { DEFAULT_MAX_CONCURRENT_BACKGROUND, spawnBackgroundTask } from "../background/spawn-background.ts";
@@ -74,19 +74,19 @@ function sleep(ms: number): Promise<void> {
 
 /**
  * 真实子进程链（spawn+exec+sleep+exit）满载下延迟不可预估，deadline 放宽到 10s；
- * timeout 路径 / 真实 poller 定时器路径单独放宽到 8s（任务语义内最慢的等待对象）。
+ * timeout 路径单独放宽到 8s（任务语义内最慢的等待对象）。
  */
 const POLL_DEADLINE_MS = 10_000;
 const POLL_DEADLINE_SLOW_MS = 8_000;
 
 /**
- * 轮询直到期望状态出现或超时：每次迭代先 pollTickForTest()（手动 tick 推进状态机）
- * 再检查——固定 sleep 后单次 tick 单次断言是满载 flake 源，等状态而非猜时刻。
+ * 等待直到期望状态出现或超时：状态机由 exit 事件边沿（真实 ChildProcess exit 监听，
+ * ADR-0122 改造后无轮询器）自行推进——固定 sleep 后单次断言是满载 flake 源，等状态
+ * 而非猜时刻。
  */
 async function pollUntilTicked(check: () => boolean, deadlineMs: number, what: string): Promise<void> {
 	const deadline = Date.now() + deadlineMs;
 	for (;;) {
-		pollTickForTest();
 		if (check()) return;
 		if (Date.now() > deadline) {
 			throw new Error(`timed out after ${deadlineMs}ms waiting for ${what}`);
@@ -95,17 +95,6 @@ async function pollUntilTicked(check: () => boolean, deadlineMs: number, what: s
 	}
 }
 
-/** 同 pollUntilTicked 但不手动 tick：语义含「真实定时器/事件自行推进」的用例专用。 */
-async function pollUntil(check: () => boolean, deadlineMs: number, what: string): Promise<void> {
-	const deadline = Date.now() + deadlineMs;
-	while (!check()) {
-		if (Date.now() > deadline) {
-			throw new Error(`timed out after ${deadlineMs}ms waiting for ${what}`);
-		}
-		await sleep(25);
-	}
-}
-
 function spawnBg(command: string, extra: { timeoutSec?: number; maxConcurrent?: number } = {}) {
 	return spawnBackgroundTask({
 		command,
@@ -148,7 +137,6 @@ afterEach(() => {
 		}
 	}
 	clearTaskStoreForTest();
-	stopPoller();
 	setOnTaskExit(undefined);
 	resetProcessExitGuardForTest();
 	// pi 引用（currentPi）统一在 afterEach 复位——用例体内不清：断言先失败时泄漏的
@@ -162,9 +150,9 @@ afterAll(() => {
 	rmSync(DATA_DIR, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
 });
 
-describe("real spawn lifecycle (poll edge finalization)", () => {
+describe("real spawn lifecycle (exit event edge finalization)", () => {
 	it("short task: running → exited with exitCode 0, output file readable, registry terminal", async () => {
-		// 断言只要求「poll 边沿前 state=running」与退出产物，不依赖命令时长（终态化只在 finalizeTask）
+		// 断言只要求「exit 事件边沿前 state=running」与退出产物，不依赖命令时长（终态化只在 finalizeTask）
 		const spawned = spawnBg("sleep 0.1 && echo done");
 		if (!spawned.ok) throw new Error(spawned.error);
 		const { task } = spawned;
@@ -192,28 +180,6 @@ describe("real spawn lifecycle (poll edge finalization)", () => {
 		expect(detail.exitCode).toBe(0);
 	});
 
-	it("poller interval auto-finalizes without manual tick (lazy start/stop)", async () => {
-		// 只 fake setInterval/clearInterval（setTimeout 保持真实：命令退出与 pollUntil
-		// 的等待都真实流逝）——2s 轮询间隔定时器进 fake 队列，advanceTimersByTime 推进
-		// 即触发真实 pollTick 边沿。本用例是「真实间隔边沿自动收尾（lazy start/stop）」
-		// 语义的唯一集成探针：边沿推进逻辑（pollTick 本体）原样执行，仅等待被压缩。
-		vi.useFakeTimers({ toFake: ["setInterval", "clearInterval"] });
-		try {
-			const spawned = spawnBg("sleep 0.1 && echo auto");
-			if (!spawned.ok) throw new Error(spawned.error);
-			const { task } = spawned;
-			// 真实等命令退出（不手动 tick——收尾必须来自轮询器定时器边沿）
-			await pollUntil(() => !isPidAlive(task.pid), 5000, "process to die without poll edge");
-			// fake 队列推进一个完整轮询间隔 → 首个真实边沿收尾
-			vi.advanceTimersByTime(2000);
-			expect(getTask(task.taskId)?.state).toBe("exited");
-			// 无活跃条目后轮询器自停（防空转）
-			expect(getActiveTasks()).toHaveLength(0);
-		} finally {
-			vi.useRealTimers();
-		}
-	});
-
 	it("nonzero exit code is surfaced (exitCode 1)", async () => {
 		// 断言只看 exitCode 透写，不依赖命令时长
 		const spawned = spawnBg("sleep 0.1; exit 3");
@@ -359,7 +325,7 @@ describe("bash_output tool", () => {
 });
 
 describe("bash_kill tool (killing intent, single-point finalization)", () => {
-	it("kill marks BOTH store and registry as killing before the poll edge lands", async () => {
+	it("kill marks BOTH store and registry as killing before the exit event edge lands", async () => {
 		const spawned = spawnBg("sleep 60");
 		if (!spawned.ok) throw new Error(spawned.error);
 		const { task } = spawned;
@@ -367,7 +333,7 @@ describe("bash_kill tool (killing intent, single-point finalization)", () => {
 		const killResult = JSON.parse(await killTool(task.taskId)) as { killed: boolean; reason: string };
 		expect(killResult.killed).toBe(true);
 
-		// 轮询未收尾（sleep 60 才死、kill 后立即断言）：两侧 killing 即可见，无倒挂
+		// exit 边沿未到（sleep 60 才死、kill 后立即断言）：两侧 killing 即可见，无倒挂
 		expect(getTask(task.taskId)?.state).toBe("killing");
 		expect(readRegistry(REGISTRY_PATH).get(task.taskId)?.state).toBe("killing");
 		// kill-tree 确实对该 pid 发过令
@@ -447,22 +413,6 @@ describe("bash_kill tool (killing intent, single-point finalization)", () => {
 		expect(result.reason).toBe("already exited");
 	});
 
-	it("P0-2.2: store entry whose pid already died (poll edge not landed) → already exited style, no kill/intent", async () => {
-		// 死亡等待 ~0.1s 远小于 2s 真实轮询首轮（单例表仍 running 是本用例前提）
-		const spawned = spawnBg("sleep 0.1");
-		if (!spawned.ok) throw new Error(spawned.error);
-		const { task } = spawned;
-		// 轮询进程死透（不 tick——单例表仍 running 是本用例前提）
-		await pollUntil(() => !isPidAlive(task.pid), 5000, "process to die without poll edge");
-		expect(getTask(task.taskId)?.state).toBe("running");
-
-		const result = JSON.parse(await killTool(task.taskId)) as { killed: boolean; reason: string };
-		expect(result.killed).toBe(false);
-		expect(result.reason).toContain("already exited");
-		expect(killTreeCalls).not.toContain(task.pid); // 死 pid 不发 kill
-		expect(getTask(task.taskId)?.state).toBe("running"); // 未标 killing intent（终态归轮询边沿）
-	});
-
 	it("P0-2.2: pidStartTime mismatch (pid reuse suspected) → refuse kill", async () => {
 		const spawned = spawnBg("sleep 30");
 		if (!spawned.ok) throw new Error(spawned.error);
@@ -541,7 +491,7 @@ describe("explicit background timeout (D6)", () => {
 			vi.useRealTimers();
 		}
 
-		// SIGKILL 已真实发出：轮询边沿收尾 → exited(reason:"timeout")，终态由边沿写
+		// SIGKILL 已真实发出：exit 事件边沿收尾 → exited(reason:"timeout")，终态由边沿写
 		//（timeout 路径满载下 SIGKILL 生效延迟不可预估，deadline 放宽到 8s）
 		await pollUntilTicked(
 			() => getTask(taskId)?.state === "exited" && getTask(taskId)?.reason === "timeout",
@@ -568,7 +518,7 @@ describe("explicit background timeout (D6)", () => {
 			expect(killTreeCalls).not.toContain(task.pid);
 			// D6-en/R2-S1 加固：身份校验不过 = 登记原进程已不在（死亡或被复用），intent
 			// 标记一并跳过——无条件改写内存 intent 为 timeout 会冲掉 UI 代杀 / AI bash_kill
-			// 预写的 killed（误报 timed out 唤醒 AI）；终态归轮询边沿按事实收尾
+			// 预写的 killed（误报 timed out 唤醒 AI）；终态归 exit 事件边沿按事实收尾
 			expect(getTask(task.taskId)?.state).toBe("running");
 			expect(getTask(task.taskId)?.intent).toBeUndefined();
 			expect(readRegistry(REGISTRY_PATH).get(task.taskId)?.state).toBe("running");
@@ -632,7 +582,7 @@ describe("explicit background timeout (D6)", () => {
 
 		// 越过 deadline 的时间窗内不得再补杀（终态化必须已清 timer）：轮询真实时钟
 		// 越过 deadline+200ms 余量后断言——这里等待的是时钟流逝本身，非子进程事件
-		await pollUntil(
+		await pollUntilTicked(
 			() => Date.now() >= task.startedAt + 500 + 200,
 			POLL_DEADLINE_SLOW_MS,
 			"real clock to pass the deadline window",
@@ -642,7 +592,7 @@ describe("explicit background timeout (D6)", () => {
 	});
 });
 
-describe("D6-en: poller finalization reads back registry killing (cross-process UI kill)", () => {
+describe("D6-en: exit edge finalization reads back registry killing (cross-process UI kill)", () => {
 	it("memory intent missing + registry killing → reason killed; AI not woken (no sendMessage)", async () => {
 		const pi = { events: { emit: vi.fn() }, sendMessage: vi.fn(), appendEntry: vi.fn() };
 		refreshPiReference(pi as unknown as ExtensionAPI);
@@ -655,8 +605,8 @@ describe("D6-en: poller finalization reads back registry killing (cross-process
 		writeRegistryEntry(REGISTRY_PATH, taskToRegistryEntry({ ...task, state: "killing" }));
 		expect(getTask(task.taskId)?.intent).toBeUndefined(); // 前置：内存无 intent
 		process.kill(task.pid, "SIGKILL");
-		await pollUntil(() => !isPidAlive(task.pid), 5000, "process to die after SIGKILL");
-		pollTickForTest();
+		// exit 事件边沿自动收尾（读回 registry killing → killed）
+		await pollUntilTicked(() => getTask(task.taskId)?.reason === "killed", 5000, "exit edge to read back killing");
 
 		const finalized = getTask(task.taskId);
 		expect(finalized?.state).toBe("exited");
@@ -677,10 +627,11 @@ describe("D6-en: poller finalization reads back registry killing (cross-process
 		// 内存预写 killed intent（AI bash_kill 形态），registry 刻意停留 running
 		//（模拟 intent 落盘失败）——若实现误读回，会按 running 判 natural
 		expect(markKillingIntent(task.taskId, "killed")).toBeDefined();
+		// 前置（SIGKILL 前断言——事件模式下死亡即边沿收尾，registry 停留 running
+		//（模拟 intent 落盘失败，markKillingIntent 不写盘）：若实现误读回会按 running 判 natural
+		expect(readRegistry(REGISTRY_PATH).get(task.taskId)?.state).toBe("running");
 		process.kill(task.pid, "SIGKILL");
-		await pollUntil(() => !isPidAlive(task.pid), 5000, "process to die after SIGKILL");
-		expect(readRegistry(REGISTRY_PATH).get(task.taskId)?.state).toBe("running"); // 前置成立
-		pollTickForTest();
+		await pollUntilTicked(() => getTask(task.taskId)?.reason === "killed", 5000, "exit edge to finalize with intent");
 		expect(getTask(task.taskId)?.reason).toBe("killed"); // intent 优先，非 natural
 	});
 
@@ -690,8 +641,8 @@ describe("D6-en: poller finalization reads back registry killing (cross-process
 		const { task } = spawned;
 		writeFileSync(REGISTRY_PATH, "{corrupted", "utf8"); // 读回路径解析失败
 		process.kill(task.pid, "SIGKILL");
-		await pollUntil(() => !isPidAlive(task.pid), 5000, "process to die after SIGKILL");
-		pollTickForTest();
+		// exit 事件边沿自动收尾（读回失败按无 intent 处理）
+		await pollUntilTicked(() => getTask(task.taskId)?.state === "exited", 5000, "exit edge to finalize");
 		const finalized = getTask(task.taskId);
 		expect(finalized?.state).toBe("exited"); // 终态化未被阻塞
 		expect(finalized?.reason).toBe("natural"); // 读失败按无 intent 处理
@@ -699,7 +650,7 @@ describe("D6-en: poller finalization reads back registry killing (cross-process
 });
 
 describe("D6-en/R2-S1 hardening: armBackgroundTimeout skips kill+mark when recorded pid is gone", () => {
-	it("UI kill × timeout overlap: no timeout mark; poll edge reads back registry killing → killed", async () => {
+	it("UI kill × timeout overlap: no timeout mark; exit edge reads back registry killing → killed", async () => {
 		// 真实时间必须真实流过（R2-S1 前提：到点时 pid 已死才有「跳过补杀」可言），
 		// fake 时钟会让 timeout 回调先于进程死亡触发
 		const spawned = spawnBg("sleep 30", { timeoutSec: 0.5 });
@@ -708,20 +659,18 @@ describe("D6-en/R2-S1 hardening: armBackgroundTimeout skips kill+mark when recor
 		// UI 代杀（跨进程形态）：registry 预写 killing + 直接杀进程，不经内存
 		writeRegistryEntry(REGISTRY_PATH, taskToRegistryEntry({ ...task, state: "killing" }));
 		process.kill(task.pid, "SIGKILL");
-		await pollUntil(() => !isPidAlive(task.pid), 5000, "process to die before the deadline");
+		// exit 事件边沿在 deadline 前收尾（D6-en 读回 registry killing → killed）
+		await pollUntilTicked(() => getTask(task.taskId)?.reason === "killed", 5000, "exit edge to read back killing before deadline");
 		// 越过 deadline（0.5s）+200ms 余量：轮询真实时钟，等待的是时钟流逝本身
-		await pollUntil(
+		await pollUntilTicked(
 			() => Date.now() >= task.startedAt + 500 + 200,
 			POLL_DEADLINE_SLOW_MS,
 			"real clock to pass the deadline window",
 		);
-		// 加固生效：不补杀、不改写内存（无 intent）、不冲掉 registry 侧 killing 预写
+		// 加固生效：到点时任务已终态 → 不补杀、intent 不被改写为 timeout、reason 保持 killed
 		expect(killTreeCalls).not.toContain(task.pid);
-		expect(getTask(task.taskId)?.state).toBe("running");
-		expect(getTask(task.taskId)?.intent).toBeUndefined();
-		expect(readRegistry(REGISTRY_PATH).get(task.taskId)?.state).toBe("killing");
-		pollTickForTest();
 		expect(getTask(task.taskId)?.state).toBe("exited");
+		expect(getTask(task.taskId)?.intent).toBeUndefined();
 		expect(getTask(task.taskId)?.reason).toBe("killed"); // D6-en 读回（非 timeout）
 	});
 
@@ -731,38 +680,37 @@ describe("D6-en/R2-S1 hardening: armBackgroundTimeout skips kill+mark when recor
 		const { task } = spawned;
 		const killed = JSON.parse(await killTool(task.taskId)) as { killed: boolean };
 		expect(killed.killed).toBe(true);
-		await pollUntil(() => !isPidAlive(task.pid), 5000, "process to die before the deadline");
-		// 越过 deadline（0.5s）+200ms 余量：轮询真实时钟——pid 已死 → 跳过 timeout mark
-		await pollUntil(
+		// exit 事件边沿在 deadline 前收尾（intent 优先 → killed）
+		await pollUntilTicked(() => getTask(task.taskId)?.reason === "killed", 5000, "exit edge to finalize killed before deadline");
+		// 越过 deadline（0.5s）+200ms 余量：轮询真实时钟——任务已终态 → 跳过 timeout mark
+		await pollUntilTicked(
 			() => Date.now() >= task.startedAt + 500 + 200,
 			POLL_DEADLINE_SLOW_MS,
 			"real clock to pass the deadline window",
 		);
-		expect(getTask(task.taskId)?.intent?.reason).toBe("killed"); // 未被覆盖为 timeout
+		expect(getTask(task.taskId)?.intent).toBeUndefined(); // 终态化消费 intent，不再存在
 		expect(killTreeCalls.filter((pid) => pid === task.pid)).toHaveLength(1); // 无第二次 kill
-		pollTickForTest();
 		expect(getTask(task.taskId)?.state).toBe("exited");
 		expect(getTask(task.taskId)?.reason).toBe("killed"); // 加固后保持 killed（无通知路径）
 	});
 
-	it("natural death before the deadline: no timeout mark; poll edge finalizes natural (accepted shift)", async () => {
+	it("natural death before the deadline: no timeout mark; exit edge finalizes natural (accepted shift)", async () => {
 		// 命令 0.1s 自然退出 < 0.5s deadline；真实时间必须真实流过（fake 会先于死亡触发回调）
 		const before = killTreeCalls.length;
 		const spawned = spawnBg("sleep 0.1", { timeoutSec: 0.5 });
 		if (!spawned.ok) throw new Error(spawned.error);
 		const { task } = spawned;
-		await pollUntil(() => !isPidAlive(task.pid), 5000, "natural death before the deadline");
-		// 越过 deadline（0.5s）+200ms 余量（仍在 2s 真实轮询 tick 之前，不手动 tick）
-		await pollUntil(
+		// exit 事件边沿在 deadline 前收尾
+		await pollUntilTicked(() => getTask(task.taskId)?.state === "exited", 5000, "natural death before the deadline");
+		// 越过 deadline（0.5s）+200ms 余量：等待的是时钟流逝本身
+		await pollUntilTicked(
 			() => Date.now() >= task.startedAt + 500 + 200,
 			POLL_DEADLINE_SLOW_MS,
 			"real clock to pass the deadline window",
 		);
 		expect(killTreeCalls.length).toBe(before); // 死任务不补杀
-		expect(getTask(task.taskId)?.state).toBe("running"); // 轮询未收尾，未被标 killing
+		expect(getTask(task.taskId)?.state).toBe("exited");
 		expect(getTask(task.taskId)?.intent).toBeUndefined();
-		expect(readRegistry(REGISTRY_PATH).get(task.taskId)?.state).toBe("running");
-		pollTickForTest();
 		expect(getTask(task.taskId)?.reason).toBe("natural"); // 语义微移：natural 非 timeout
 	});
 });
@@ -777,7 +725,7 @@ describe("process-exit reap (D12)", () => {
 
 		reapBackgroundTasksNow();
 		// SIGKILL 发出到进程表移除是异步的：轮询等 pid 判死（满载下延迟不可预估）
-		await pollUntil(() => pids.every((pid) => !isPidAlive(pid)), 5000, "reaped pids to die");
+		await pollUntilTicked(() => pids.every((pid) => !isPidAlive(pid)), 5000, "reaped pids to die");
 
 		for (const pid of pids) {
 			expect(isPidAlive(pid)).toBe(false);

package/src/__tests__/notify.test.ts

@@ -18,7 +18,7 @@ import {
 	refreshPiReference,
 	resetNotifyForTest,
 } from "../background/notify.ts";
-import { pollTickForTest, setOnTaskExit, stopPoller } from "../background/poller.ts";
+import { setOnTaskExit } from "../background/exit-collector.ts";
 import { spawnBackgroundTask } from "../background/spawn-background.ts";
 import {
 	clearTaskStoreForTest,
@@ -63,13 +63,12 @@ function sleep(ms: number): Promise<void> {
 const POLL_DEADLINE_MS = 10_000;
 
 /**
- * 轮询直到期望状态出现或超时：每次迭代先 pollTickForTest()（手动 tick 推进状态机）
- * 再检查——固定 sleep 后单次 tick 单次断言是满载 flake 源，等状态而非猜时刻。
+ * 等待直到期望状态出现或超时：exit 事件边沿（真实 ChildProcess exit 监听）负责
+ * 推进状态机——固定 sleep 后单次断言是满载 flake 源，等状态而非猜时刻。
  */
 async function pollUntilTicked(check: () => boolean, what: string): Promise<void> {
 	const deadline = Date.now() + POLL_DEADLINE_MS;
 	for (;;) {
-		pollTickForTest();
 		if (check()) return;
 		if (Date.now() > deadline) {
 			throw new Error(`timed out after ${POLL_DEADLINE_MS}ms waiting for ${what}`);
@@ -87,7 +86,7 @@ function spawnBg(command: string) {
 	});
 }
 
-/** 构造终态条目直调 handleTaskExit（通知行为单元，不经真实轮询时序）。 */
+/** 构造终态条目直调 handleTaskExit（通知行为单元，不经真实 exit 边沿时序）。 */
 function finalizedTask(overrides: Partial<BackgroundTask> = {}): BackgroundTask {
 	return {
 		taskId: "bt-1700000000-test01",
@@ -125,7 +124,6 @@ function killLeftoverTasks(): void {
 afterEach(() => {
 	killLeftoverTasks();
 	clearTaskStoreForTest();
-	stopPoller();
 	setOnTaskExit(undefined);
 	resetNotifyForTest();
 	vi.restoreAllMocks();
@@ -173,7 +171,7 @@ describe("register emit (data flow ⑤)", () => {
 	});
 });
 
-describe("exit-edge notification (⑧⑨, poll edge wiring)", () => {
+describe("exit-edge notification (⑧⑨, exit-edge wiring)", () => {
 	it("natural exit 0: unregister emit reason 'completed' + sendMessage steer with exact params", async () => {
 		const pi = createMockPi();
 		attach(pi);
@@ -182,7 +180,7 @@ describe("exit-edge notification (⑧⑨, poll edge wiring)", () => {
 		if (!spawned.ok) throw new Error(spawned.error);
 		const { task } = spawned;
 
-		// 轮询到 exit 边沿收尾（handleTaskExit 同步完成 unregister emit + sendMessage）
+		// 等到 exit 边沿收尾（handleTaskExit 同步完成 unregister emit + sendMessage）
 		await pollUntilTicked(
 			() => pi.events.emit.mock.calls.some((c) => c[0] === "pending:unregister"),
 			"pending:unregister (completed)",
@@ -203,7 +201,7 @@ describe("exit-edge notification (⑧⑨, poll edge wiring)", () => {
 		expect(message.content).toContain("exit 0");
 		expect(message.content).toContain("done"); // tail 摘要
 		expect(options).toEqual({ deliverAs: "steer", triggerTurn: true });
-		// U1（D1）：真实轮询边沿投递的 details 与终态条目逐字段一致（非 fixture 常量）
+		// U1（D1）：真实 exit 边沿投递的 details 与终态条目逐字段一致（非 fixture 常量）
 		const finalizedEntry = getTask(task.taskId);
 		expect(message.details).toMatchObject({
 			taskId: task.taskId,
@@ -224,7 +222,7 @@ describe("exit-edge notification (⑧⑨, poll edge wiring)", () => {
 
 		markKillingIntent(task.taskId, "killed");
 		killProcessTree(task.pid);
-		// 轮询到 kill 边沿收尾（SIGKILL 生效 + tick 终态化）
+		// 等到 kill 边沿收尾（SIGKILL 生效 + exit 事件终态化）
 		await pollUntilTicked(() => getTask(task.taskId)?.reason === "killed", "reason=killed finalization");
 
 		expect(getTask(task.taskId)?.reason).toBe("killed");
@@ -259,7 +257,7 @@ describe("exit-edge notification (⑧⑨, poll edge wiring)", () => {
 		if (!spawned.ok) throw new Error(spawned.error);
 		const { task } = spawned;
 
-		// 轮询到 exit 边沿收尾（reason failed）
+		// 等到 exit 边沿收尾（reason failed）
 		await pollUntilTicked(
 			() => pi.events.emit.mock.calls.some((c) => c[0] === "pending:unregister"),
 			"pending:unregister (failed)",
@@ -391,7 +389,7 @@ describe("D17: pi reference refresh (session replacement takeover)", () => {
 		expect(fresh.sendMessage).toHaveBeenCalledTimes(1);
 	});
 
-	it("poller keeps running when notification path throws inside the exit edge", async () => {
+	it("exit edge survives notification path throwing inside the callback", async () => {
 		const stale = createMockPi();
 		stale.sendMessage = vi.fn(() => {
 			throw new Error("stale bus disposed");
@@ -406,15 +404,13 @@ describe("D17: pi reference refresh (session replacement takeover)", () => {
 		const first = spawnBg("sleep 0.1 && echo one");
 		const second = spawnBg("sleep 0.1 && echo two");
 		if (!first.ok || !second.ok) throw new Error("spawn failed");
-		// 边沿回调内部全捕获：轮询到两条任务都完成终态化（每迭代 tick 后查）
+		// 边沿回调内部全捕获：等到两条任务都完成终态化（exit 事件自行推进）
 		await pollUntilTicked(
 			() =>
 				getTask(first.task.taskId)?.state === "exited" &&
 				getTask(second.task.taskId)?.state === "exited",
 			"both tasks to finalize",
 		);
-		// tick 不抛（异常全捕获）
-		expect(() => pollTickForTest()).not.toThrow();
 		expect(getTask(first.task.taskId)?.state).toBe("exited");
 		expect(getTask(second.task.taskId)?.state).toBe("exited");
 	});

package/src/__tests__/pending-reconcile.test.ts

@@ -597,7 +597,7 @@ describe("redelivery: exclusion criteria (decision 2 strict terminal + killed re
 		expect(pi.sendMessage).not.toHaveBeenCalled();
 	});
 
-	it("running leftover with dead pid is NOT redelivered (poller write-failure domain, unregister covers)", async () => {
+	it("running leftover with dead pid is NOT redelivered (exit-edge write-failure domain, unregister covers)", async () => {
 		const entry = makeRegistryEntry({ taskId: "bt-1700000000-rund01", state: "running", pid: deadPid() });
 		writeRegistryEntry(getRegistryPath(DATA_DIR, SESSION_ID), entry);
 		const pi = createMockPi();

package/src/__tests__/task-store.test.ts

@@ -79,7 +79,7 @@ describe("task store state machine", () => {
 		const marked = markKillingIntent(task.taskId, "killed");
 		expect(marked?.state).toBe("killing");
 		expect(marked?.intent).toEqual({ reason: "killed", at: expect.any(Number) });
-		// killing 仍属活跃态（轮询器监护对象）
+		// killing 仍属活跃态（exit 边沿监护对象）
 		expect(getActiveTasks().map((t) => t.taskId)).toEqual([task.taskId]);
 	});
 

package/src/__tests__/tool-error-audit.test.ts

@@ -89,4 +89,38 @@ describe("setupToolErrorAudit", () => {
 
 		expect(pi.appendEntry).not.toHaveBeenCalled();
 	});
+
+	// D13②：嵌套子调用失败不单独记账（父工具的 tool_execution_end 是记账终点）
+
+	it("skips nested sub-call failure (parentToolCallId present) — no audit entry", async () => {
+		const pi = createMockPi();
+		setupToolErrorAudit(pi as unknown as ExtensionAPI);
+		const handler = getRegisteredHandler(pi);
+
+		await handler({
+			isError: true,
+			toolName: "bash",
+			toolCallId: "call-child-1",
+			parentToolCallId: "call-parent-0",
+			result: { content: [{ type: "text", text: "child failed" }] },
+		});
+
+		expect(pi.appendEntry).not.toHaveBeenCalled();
+	});
+
+	it("empty-string parentToolCallId is treated as top-level call — entry still recorded", async () => {
+		const pi = createMockPi();
+		setupToolErrorAudit(pi as unknown as ExtensionAPI);
+		const handler = getRegisteredHandler(pi);
+
+		await handler({
+			isError: true,
+			toolName: "bash",
+			toolCallId: "call-4",
+			parentToolCallId: "",
+			result: { content: [{ type: "text", text: "top-level failed" }] },
+		});
+
+		expect(pi.appendEntry).toHaveBeenCalledTimes(1);
+	});
 });

package/src/background/{poller.ts → exit-collector.ts}

@@ -1,34 +1,31 @@
 /**
- * 模块级轮询器单例（D17：exit 感知靠轮询不靠 ChildProcess 闭包）。
+ * exit 边沿收尾（ADR-0122 改造：原 2s kill(pid,0) 轮询器已删，感知归 ChildProcess
+ * exit 事件——事件驱动，无时间驱动成分）。
  *
- * 为什么轮询：同进程 session 替换（fork/switch/new）会重建 eventBus 并重新 load
- * extension，ChildProcess exit 闭包监听里的 bus/pi 引用全部 stale——完成通知在
- * 新 session 不可达。kill(pid,0) 轮询 + 模块级单例跨替换免疫，2s 延迟对分钟级
- * 任务无感。
+ * 为什么事件可用（原 D17 轮询的根因已消解）：同进程 session 替换（fork/switch/new）
+ * 重建 eventBus 并重新 load extension 实例，但 jiti 模块体只执行一次——本模块与
+ * task-store / notify 均为模块级单例，跨替换存活；exit 监听挂在 ChildProcess 对象
+ * （进程内实体，与 bus 生命周期无关）上，回调链（finalizeExitedTask → task-store
+ * 模块级表 → notify 模块级 currentPi）不含任何实例级 bus/pi 引用。通知可达性由
+ * notify.ts 的 D17 pi 引用刷新承担（新实例 load 时 refreshPiReference 指向新 pi）。
  *
- * 惰性启停：无 running/killing 条目时清定时器（防空转泄漏），新任务登记时重启。
+ * 幂等：exit 事件与 bash_kill / timeout 收尾并发时，finalizeTask 的终态守卫
+ * （isTerminalState）保证单一终态归属，先到者写、后到者 no-op。
  *
  * 已知竞态（设计文档 §3.5 原样登记，不修）：同进程 session 替换 dispose → 新实例
  * load 间毫秒窗口任务恰好完成时通知可能落旧 bus——窗口极窄且后果可恢复（bash_output
- * 可查、对账可补），不加同步握手。
+ * 可查、对账可补），不加同步握手。父进程死亡场景不归本模块（exit 监听随进程消失，
+ * 由 process-exit-guard 收殓 + runtime 孤儿收殓兜底）。
  */
 
-import { isPidAlive } from "@zhushanwen/extension-protocol/background-task";
-
 import { readTailSummary } from "./output-tail.ts";
 import { readRegistry, taskToRegistryEntry, writeRegistryEntry } from "./registry.ts";
-import { finalizeTask, getActiveTasks } from "./task-store.ts";
+import { finalizeTask } from "./task-store.ts";
 import type { BackgroundTask, BackgroundTaskEndReason } from "./types.ts";
 
-/** 轮询间隔（设计文档 §3.5：约 2s）。 */
-export const POLL_INTERVAL_MS = 2000;
-
-let pollTimer: ReturnType<typeof setInterval> | undefined;
-
 /**
  * M3 通知接入点（本单元 no-op 占位）：exit 边沿收尾（单例表 + registry 终态写完）
  * 之后同步回调。M3 在这里接 pending:unregister emit + sendMessage steer。
- * 不在 M2 实现任何通知行为。
  */
 let onTaskExitCallback: ((task: BackgroundTask) => void) | undefined;
 
@@ -36,38 +33,16 @@ export function setOnTaskExit(callback: ((task: BackgroundTask) => void) | undef
 	onTaskExitCallback = callback;
 }
 
-/** 惰性启动：有活跃条目才跑定时器（spawn 登记与 kill/timeout 标记后调用）。 */
-export function ensurePollerRunning(): void {
-	if (pollTimer !== undefined) return;
-	pollTimer = setInterval(pollTick, POLL_INTERVAL_MS);
-	// 不阻止进程退出（收殓路径 stopPoller 统一清理）
-	pollTimer.unref?.();
-}
-
-export function stopPoller(): void {
-	if (pollTimer !== undefined) {
-		clearInterval(pollTimer);
-		pollTimer = undefined;
-	}
-}
-
-function pollTick(): void {
-	const active = getActiveTasks();
-	if (active.length === 0) {
-		stopPoller();
-		return;
-	}
-	for (const task of active) {
-		// libuv 自动 reap 后 kill(pid,0) 报 ESRCH（判死），ChildProcess.exitCode 仍可读
-		if (!isPidAlive(task.pid)) {
-			finalizeExitedTask(task);
-		}
-	}
-}
-
-/** 测试专用：手动跑一轮轮询（不依赖 2s 定时器）。 */
-export function pollTickForTest(): void {
-	pollTick();
+/**
+ * spawn 登记时挂接 exit 监听（唯一调用点 = spawn-background.ts）：
+ * exit 边沿触发收尾（读 exitCode → 组装 tail 摘要 → reason 判定 → 两侧写终态 →
+ * M3 回调）。error 监听仍由 spawn 侧持 no-op（spawn 异步失败只防崩溃，不推进状态
+ * ——spawn 失败即无 pid 无任务）。
+ */
+export function attachExitCollector(task: BackgroundTask): void {
+	task.child?.on("exit", () => {
+		finalizeExitedTask(task);
+	});
 }
 
 /**

package/src/background/notify.ts

@@ -7,14 +7,16 @@
  *  - 完成通知经 pi.sendMessage({customType, content, display:true},
  *    {deliverAs:"steer", triggerTurn:true}) 驱动新 turn
  *
- * D17 pi 引用刷新：轮询器与通知通路持模块级「当前 pi 引用」——同进程 session 替换
+ * D17 pi 引用刷新：通知通路持模块级「当前 pi 引用」——同进程 session 替换
  * （/fork、选择器切换、RPC session.*）会重建 eventBus 并重新 load extension，本
  * 模块引用由新实例 load 时 refreshPiReference 刷新，完成通知投递新 session。
+ * （exit-collector 的收尾回调链同样全模块级，exit 事件边沿由此跨替换可达——
+ * ADR-0122 改造：原 2s 轮询器已删。）
  *
  * 已知竞态（设计 §3.5 原样登记，不修）：dispose → 新实例 load 间毫秒窗口任务恰好
  * 完成时，sendMessage/emit 落旧 bus 丢一条——对账在该 session 重开时补 unregister，
  * 完成内容可由 bash_output 查询；窗口极窄且后果可恢复，不加同步握手。旧引用 throw
- * （旧 bus 已 dispose）时捕获降级为日志，不中断轮询（后续任务仍可通知）。
+ * （旧 bus 已 dispose）时捕获降级为日志，不中断后续任务的通知（边沿收尾不受影响）。
  *
  * kill 路径不 sendMessage（§3.5「bash_kill 终态收尾的单点归属」）：reason:"killed"
  * 只 emit unregister——kill 调用方就在当前 turn 等结果，双发是噪音。
@@ -108,7 +110,7 @@ export function emitPendingRegister(task: BackgroundTask): void {
  * data 形态对齐 pending-notifications parseUnregisterEvent 期望：{id, reason}——
  * status 不在 emit data 里（listener 用 mapReasonToStatus(reason) 自行计算）；
  * appendEntry 侧（对账/收殓）的落盘形态 {id, reason, status} 见 pending-reconcile.ts。
- * 轮询器 exit 边沿与进程退出收殓两条路径共用。
+ * exit 事件边沿与进程退出收殓两条路径共用。
  */
 export function emitPendingUnregister(
 	taskId: string,
@@ -127,7 +129,7 @@ export function emitPendingUnregister(
 }
 
 /**
- * ⑧⑨ 轮询器 exit 边沿的完成通知入口（poller setOnTaskExit 接线，index.ts load 时挂）。
+ * ⑧⑨ exit 事件边沿的完成通知入口（exit-collector setOnTaskExit 接线，index.ts load 时挂）。
  * 入参是 finalizeTask 之后的终态条目（state=exited）。kill 路径不 sendMessage
  * （文件头）；process-exit 不经过这里（收殓路径直接 finalizeTask + 只 emit）。
  */
@@ -152,8 +154,8 @@ function sendTaskFinishedMessage(task: BackgroundTask): void {
 			{ deliverAs: "steer", triggerTurn: true },
 		);
 	} catch (err) {
-		// 旧 bus 已 dispose（session 替换毫秒窗口）——降级日志，不中断轮询（文件头已知竞态）
-		logger.warn("background task notify sendMessage failed; poll continues", {
+		// 旧 bus 已 dispose（session 替换毫秒窗口）——降级日志，不中断后续收尾（文件头已知竞态）
+		logger.warn("background task notify sendMessage failed (stale bus?); notification skipped, later tasks unaffected", {
 			detail: {
 				taskId: task.taskId,
 				err: toErrorMessage(err),

package/src/background/output-tail.ts

@@ -18,7 +18,7 @@ const SUMMARY_TAIL_LINES = 5;
 const SUMMARY_MAX_CHARS = 800;
 
 /**
- * 轮询器 exit 边沿的 tail 摘要（存进条目、M3 通知用）：末尾几行的紧凑文本。
+ * exit 事件边沿收尾的 tail 摘要（存进条目、M3 通知用）：末尾几行的紧凑文本。
  */
 export function readTailSummary(outputFile: string, maxChars: number = SUMMARY_MAX_CHARS): string | undefined {
 	const tail = readOutputTailPrimitive(outputFile, { maxLines: SUMMARY_TAIL_LINES, maxBytes: maxChars });

package/src/background/pending-reconcile.ts

@@ -22,7 +22,7 @@
  * 同步写补投标记 entry 保幂等。覆盖的失效面 = 主路径单次投递丢失（进程死亡收殓、
  * 投递 throw、投递被接受但未落盘即崩溃）。**补投是 registry 全集的独立遍历，不挂
  * pending 差集循环**（决策 2）：差集候选 = pending:register 还挂着的任务，而失效
- * 形态「poller 边沿 unregister 已写、sendMessage 才 throw」下差集为空，挂靠即永久
+ * 形态「exit 边沿 unregister 已写、sendMessage 才 throw」下差集为空，挂靠即永久
  * 漏补。补投**不代写 pending:unregister**——收尾保持差集循环唯一写点（避免绕过
  * listener 的 isPendingActive 幂等门落冗余 entry）。
  *
@@ -33,7 +33,7 @@
  *
  * 补投终态判据（决策 2）：protocol isTerminalState 严格终态（exited/orphaned）——
  * **显式不用下方 isTerminalByRegistry 宽判据**（宽判据含 running/killing 且 pid 判死，
- * 会把 killing 遗留——kill 已发令、poller 终态化前进程死亡，实为被杀任务——误判为
+ * 会把 killing 遗留——kill 已发令、exit 边沿终态化前进程死亡，实为被杀任务——误判为
  * 可补投）；且 state=exited 时 reason≠killed（killed 是 reason 枚举值而非独立
  * state，state 级过滤排不掉，必须 reason 级显式排除——kill 的发起方当次交互已同步
  * 获知结果，补投是重复刺激）。killing/running+判死遗留不补投（保守正确，退化现状）。
@@ -85,9 +85,9 @@ const logger = getLogger("base-tool-enhance");
 /**
  * 对账依赖的最小 pi 面（结构兼容 ExtensionAPI 的子集；测试注入不造完整 pi）。
  *
- * sendMessage 返回类型 `void | Promise<void>` 是 pi 0.84.4 实装的适配登记
- * （bg-task-notify-durability 实装核实）：ExtensionAPI.sendMessage 的类型声明与
- * loader.js:296 / agent-session.js:2004 两级桥接均不返回 promise（bindCore 包装层
+ * sendMessage 返回类型 `void | Promise<void>` 是 pi 实装的适配登记
+ * （bg-task-notify-durability 实装核实，1.0.0 复核同构）：ExtensionAPI.sendMessage 的类型声明与
+ * loader.js / agent-session.js bindCore 两级桥接均不返回 promise（bindCore 包装层
  * 以 .catch 吞 rejection 转 runner emitError），真实 pi 注入时恒返回 undefined——
  * 「await resolve 即已落盘」在实装通道上拿不到。await 两者皆合法：
  *  - 同步 throw（assertActive 失败 / 旧 bus）在调用点抛出，可捕；

package/src/background/process-exit-guard.ts

@@ -32,7 +32,6 @@ import { toErrorMessage } from "@zhushanwen/pi-ext-guards";
 import { getLogger } from "@zhushanwen/pi-extension-logger";
 
 import { emitPendingUnregister } from "./notify.ts";
-import { stopPoller } from "./poller.ts";
 import { taskToRegistryEntry, writeRegistryEntry } from "./registry.ts";
 import { finalizeTask, getActiveTasks } from "./task-store.ts";
 
@@ -67,14 +66,13 @@ export function installProcessExitGuard(): void {
 
 /**
  * 收殓动作（导出供测试直接调用，不真杀 pi 进程）：
- * 轮询器停止 → 遍历**单例表**活跃条目 kill-tree（单例表 = 本进程任务全集，天然
+ * 遍历**单例表**活跃条目 kill-tree（单例表 = 本进程任务全集，天然
  * 不含他进程条目——不遍历 registry，否则 ephemeral 附着进程退出会误杀属主进程的
  * 任务）→ registry 写终态 exited(reason:"process-exit")。
  *
- * 终态与轮询器边沿共用 finalizeTask（单一终态归属）。
+ * 终态与 exit 事件边沿共用 finalizeTask（单一终态归属）。
  */
 export function reapBackgroundTasksNow(): void {
-	stopPoller();
 	for (const task of getActiveTasks()) {
 		try {
 			// 回退路径诊断经 onFallback 注入 logger 适配（ext-simplify-13 D2）

package/src/background/spawn-background.ts

@@ -22,8 +22,8 @@ import { toErrorMessage } from "@zhushanwen/pi-ext-guards";
 import { getLogger } from "@zhushanwen/pi-extension-logger";
 
 import { truncateCommand } from "./command-display.ts";
+import { attachExitCollector } from "./exit-collector.ts";
 import { emitPendingRegister } from "./notify.ts";
-import { ensurePollerRunning } from "./poller.ts";
 import { getRegistryPath, taskToRegistryEntry, writeRegistryEntry } from "./registry.ts";
 import { countActiveTasks, markKillingIntent, oldestActiveTask, registerSpawnedTask } from "./task-store.ts";
 import type { BackgroundTask } from "./types.ts";
@@ -111,7 +111,7 @@ function shellForPlatform(): { shell: string; args: string[] } {
 
 /**
  * 启动后台任务：并发检查 → spawn（输出重定向 .log）→ 单例表登记 + registry 写
- * running 条目 → 显式 timeout 定时器 → 启动轮询器。
+ * running 条目 → 显式 timeout 定时器 → 挂接 exit 事件边沿收尾。
  * 立即返回，不等待命令退出（turn 不被占用，G1）。
  */
 export function spawnBackgroundTask(opts: SpawnBackgroundOptions): SpawnBackgroundResult {
@@ -164,8 +164,9 @@ export function spawnBackgroundTask(opts: SpawnBackgroundOptions): SpawnBackgrou
 			detached: true,
 			stdio: ["ignore", outputFd, outputFd],
 		});
-		// 唯一的事件监听例外：no-op error listener 防 spawn 异步失败 emit error 无监听
-		// 导致进程崩溃（EventEmitter 语义）。不做任何状态推进——exit 感知归轮询器（D17）。
+		// no-op error listener 防 spawn 异步失败 emit error 无监听导致进程崩溃
+		//（EventEmitter 语义），不做任何状态推进——exit 感知归 exit 事件边沿
+		//（attachExitCollector，ADR-0122 改造：原 2s 轮询器已删）。
 		child.on("error", () => {});
 		child.unref();
 	} catch (err) {
@@ -221,25 +222,26 @@ export function spawnBackgroundTask(opts: SpawnBackgroundOptions): SpawnBackgrou
 	registerSpawnedTask(task);
 	writeRegistryEntry(registryPath, taskToRegistryEntry(task));
 	emitPendingRegister(task);
-	ensurePollerRunning();
+	// exit 事件边沿挂接（事件驱动感知，ADR-0122 改造后无轮询器）
+	attachExitCollector(task);
 	return { ok: true, task };
 }
 
 /**
  * 后台显式 timeout（D6：任务寿命可由使用者显式约束）。到点：pid 身份校验通过 →
- * kill-tree + 两侧标 killing intent（reason 候选 timeout）——实际终态由轮询器边沿
- * 收尾写（单一终态归属），此处不写终态。身份校验不过（登记原进程已不在：已死或
+ * kill-tree + 两侧标 killing intent（reason 候选 timeout）——实际终态由 exit 事件
+ * 边沿收尾写（单一终态归属），此处不写终态。身份校验不过（登记原进程已不在：已死或
  * pid 复用嫌疑）→ 跳过 kill **且跳过 intent 标记**（D6-en/R2-S1 加固）：无条件
  * markKillingIntent("timeout") 会把 UI 代杀 / AI bash_kill 刚预写的 killed 改写成
- * timeout → reason=timeout → sendMessage 误报「timed out」唤醒 AI；跳过后由轮询器
+ * timeout → reason=timeout → sendMessage 误报「timed out」唤醒 AI；跳过后由 exit
  * 边沿按事实收尾（自然死亡 → natural；registry 预写 killing → 经 D6-en 读回判
- * killed）。接受语义微移：到期前 ~2s 内自然死亡的任务改标 natural（仅影响 AI
+ * killed）。接受语义微移：到期前极窄窗口内自然死亡的任务改标 natural（仅影响 AI
  * 通知文案）。
  */
 function armBackgroundTimeout(task: BackgroundTask, timeoutSec: number): void {
 	const timer = setTimeout(() => {
 		// pid 复用防御（§3.6，同 bash_kill 范式，宁不杀勿误杀）：
-		// 任务早已退出（exit 边沿未被轮询器收尾或竞态未及）且 pid 在到点前被系统复用
+		// 任务早已退出（exit 边沿未被收尾或竞态未及）且 pid 在到点前被系统复用
 		// 时，直接 killProcessTree 会杀掉复用 pid 上的无辜进程（整进程组 SIGKILL）。
 		if (!isRecordedPidStillOriginal(task)) {
 			logger.warn("background timeout: pid identity unverified (reuse suspected or start time unreadable), skipping kill", {
@@ -252,9 +254,7 @@ function armBackgroundTimeout(task: BackgroundTask, timeoutSec: number): void {
 			});
 			// D6-en/R2-S1 加固：登记原进程已不在时同样跳过 intent 标记——内存 intent
 			// 是本进程权威（task-store.ts 头部不变量），被无条件改写为 timeout 即丢失
-			// killed 语义（D6-en 读回与 AI bash_kill 预写双双失效）。此处提前 return
-			// 时轮询器必在跑（本任务仍是活跃条目，惰性自停条件是活跃数为 0），边沿
-			// 收尾不受影响。
+			// killed 语义（D6-en 读回与 AI bash_kill 预写双双失效）。
 			return;
 		}
 		// 回退路径诊断经 onFallback 注入 logger 适配（ext-simplify-13 D2）
@@ -266,7 +266,6 @@ function armBackgroundTimeout(task: BackgroundTask, timeoutSec: number): void {
 		const marked = markKillingIntent(task.taskId, "timeout");
 		if (marked === undefined) return;
 		writeRegistryEntry(marked.registryPath, taskToRegistryEntry(marked));
-		ensurePollerRunning();
 	}, timeoutSec * MS_PER_SECOND);
 	timer.unref?.();
 	task.timeoutTimer = timer;

package/src/background/task-store.ts

@@ -15,14 +15,14 @@
  *
  * 【不变量登记（D6-en，注释级）】extension 对某条目的**每次 registry 写都先经该
  * 条目的内存状态更新**——registry 侧 killing 状态因此恒为内存态的投影，runtime
- * 跨进程预写的 killing 不会被 stale 内存态冲回，D6-en intent 读回（poller.ts）的
- * 正确性依赖此约束。全部 5 个 writeRegistryEntry 调用点逐一成立：
+ * 跨进程预写的 killing 不会被 stale 内存态冲回，D6-en intent 读回（exit-collector.ts）
+ * 的正确性依赖此约束。全部 5 个 writeRegistryEntry 调用点逐一成立：
  *   ① spawn-background.ts spawnBackgroundTask：registerSpawnedTask（新条目首登记）
  *     先于 registry 写 running；
  *   ② bash-kill-tool.ts：markKillingIntent(taskId,"killed") 先于 registry 写 killing；
  *   ③ spawn-background.ts armBackgroundTimeout：markKillingIntent(taskId,"timeout")
  *     先于 registry 写 killing（pid 已死路径提前 return，不触达写点）；
- *   ④ poller.ts finalizeExitedTask：finalizeTask（内存终态化）先于 registry 写 exited；
+ *   ④ exit-collector.ts finalizeExitedTask：finalizeTask（内存终态化）先于 registry 写 exited；
  *   ⑤ process-exit-guard.ts reapBackgroundTasksNow：finalizeTask 先于 registry 写
  *     exited(process-exit)（设计枚举 4 点时未列本点，实际同序成立，一并登记）。
  * 未来新增写路径（如 maintenance 类）必须保持该顺序，违反即 intent 可丢失。
@@ -61,7 +61,7 @@ export function getAllTasks(): BackgroundTask[] {
 	return [...taskTable.values()];
 }
 
-/** 活跃条目（running | killing），轮询器监护对象。 */
+/** 活跃条目（running | killing），exit 事件边沿的监护对象。 */
 export function getActiveTasks(): BackgroundTask[] {
 	return getAllTasks().filter((t) => isActiveState(t.state));
 }
@@ -99,9 +99,9 @@ export interface FinalizeOutcome {
 }
 
 /**
- * 终态化（exited）：唯一终态写入口。轮询器 exit 边沿、进程退出收殓两条路径收敛
- * 到这里（bash_kill 不直接写终态——单一终态归属，§3.5「bash_kill 终态收尾的
- * 单点归属」）。消费 intent、清 timeout 定时器、算 durationMs、LRU 淘汰溢出终态。
+ * 终态化（exited）：唯一终态写入口。exit 事件边沿（exit-collector）、进程退出收殓
+ * 两条路径收敛到这里（bash_kill 不直接写终态——单一终态归属，§3.5「bash_kill 终态
+ * 收尾的单点归属」）。消费 intent、清 timeout 定时器、算 durationMs、LRU 淘汰溢出终态。
  */
 export function finalizeTask(taskId: string, outcome: FinalizeOutcome): BackgroundTask | undefined {
 	const task = taskTable.get(taskId);

package/src/background/types.ts

@@ -33,9 +33,9 @@ export {
 } from "@zhushanwen/extension-protocol";
 
 /**
- * killing intent：bash_kill / 后台 timeout 已发令、轮询器 exit 边沿未确认的瞬态标记。
+ * killing intent：bash_kill / 后台 timeout 已发令、exit 事件边沿未确认的瞬态标记。
  * 标记写入单例表与 registry 两侧（查询面立即可见，无「已 kill 仍 running」倒挂）；
- * 轮询边沿据此决定终态 reason，消费后清除。
+ * exit 边沿据此决定终态 reason，消费后清除。
  */
 export interface KillingIntent {
 	reason: Extract<ContractEndReason, "killed" | "timeout">;
@@ -45,10 +45,10 @@ export interface KillingIntent {
 /**
  * 单例任务表条目（运行时权威，D17 根基）。
  *
- * child 引用**只用于读 exitCode/signalCode，禁止挂事件监听**——exit 感知统一走
- * 轮询器 kill(pid,0) 边沿；闭包式 exit 监听在同进程 session 替换后指向 stale bus
- * （D17）。child.on("error") 是唯一例外（spawn-background 内的 no-op，防进程崩溃，
- * 不做任何状态推进）。
+ * child 引用**只用于读 exitCode/signalCode 与 exit-collector 的 exit 监听挂接**
+ * （attachExitCollector，ADR-0122 改造：exit 感知归事件边沿——回调链全模块级，
+ * 无实例级 bus/pi 引用，session 替换不产生 stale）。child.on("error") 是另一处
+ * 监听（spawn-background 内的 no-op，防进程崩溃，不做任何状态推进）。
  */
 export interface BackgroundTask {
 	taskId: string;

package/src/bash-kill-tool.ts

@@ -3,7 +3,7 @@
  *
  * 职责边界：只负责杀进程树 + kill 前把单例表与 registry **两侧**标 killing intent
  * （查询面立即可见——kill 返回后 bash_output 即显示 killing，无「已 kill 仍 running」
- * 倒挂窗口）。实际终态（exited, reason:"killed"）由轮询器 exit 边沿收尾写——
+ * 倒挂窗口）。实际终态（exited, reason:"killed"）由 exit 事件边沿收尾写——
  * bash_kill 不直接写终态（单一终态归属），也不 sendMessage（kill 调用方就在当前
  * turn 内等结果，再发 steer 通知是双发噪音——按 notify.ts 的单点归属规则，kill
  * 路径不 sendMessage，reason:"killed" 只 emit unregister，终态由 handleTaskExit 收尾）。
@@ -24,7 +24,6 @@ import { Type } from "typebox";
 import { toErrorMessage } from "@zhushanwen/pi-ext-guards";
 import { getLogger } from "@zhushanwen/pi-extension-logger";
 
-import { ensurePollerRunning } from "./background/poller.ts";
 import { getRegistryPath, readRegistry, taskToRegistryEntry, writeRegistryEntry } from "./background/registry.ts";
 import { getAllTasks, markKillingIntent } from "./background/task-store.ts";
 import { isActiveState, isTerminalState, type RegistryEntry } from "./background/types.ts";
@@ -100,13 +99,13 @@ export function createBashKillToolDefinition() {
 			}
 
 			// pid 复用防御（§3.6 宁不杀勿误杀）：
-			//  - pid 已死 → already exited 风格返回，不发 kill（终态由轮询边沿收尾）
+			//  - pid 已死 → already exited 风格返回，不发 kill（终态由 exit 边沿收尾）
 			//  - 有 pidStartTime 字段 → 校验实际进程 start time 匹配；不匹配/读不到 =
 			//    复用嫌疑，拒绝 kill 并说明
-			//  - 无字段（spawn 时 ps 不可用平台）→ 放行：本进程轮询器 ≤2s 前判过活，
+			//  - 无字段（spawn 时 ps 不可用平台）→ 放行：登记原进程在 spawn 时刻存活，
 			//    复用窗口毫秒级；registry 终态条目不会走到这里（上面 already exited）
 			if (!isPidAlive(fromStore.pid)) {
-				return killedFalse("already exited (process no longer alive; final state pending poll)");
+				return killedFalse("already exited (process no longer alive; final state will be written on task exit)");
 			}
 			if (fromStore.pidStartTime !== undefined) {
 				const actualStartSec = getProcessStartTimeSec(fromStore.pid);
@@ -114,7 +113,7 @@ export function createBashKillToolDefinition() {
 					return killedFalse(
 						"cannot verify process start time; refusing to kill (better safe than sorry)",
 						`pid ${fromStore.pid} is alive but its start time is unreadable, so pid reuse cannot be ruled out; ` +
-							"poll bash_output for the poll edge, or kill the process group manually if certain",
+							"poll bash_output for the final state, or kill the process group manually if certain",
 					);
 				}
 				if (actualStartSec !== fromStore.pidStartTime) {
@@ -141,8 +140,7 @@ export function createBashKillToolDefinition() {
 					detail: { pid: fromStore.pid, err: toErrorMessage(err) },
 				}),
 			);
-			// 轮询器确保在跑：边沿收尾（写终态）依赖它
-			ensurePollerRunning();
+			// 终态由 exit 事件边沿收尾（exit-collector，事件驱动；无轮询器）
 			return textResult(
 				JSON.stringify(
 					{

package/src/bash-tool.ts

@@ -15,7 +15,7 @@
  *     （前台未填 → foregroundTimeoutSeconds，后台未填 → backgroundTimeoutSeconds）
  */
 
-import type { AgentToolUpdateCallback, BashToolDetails, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AgentToolUpdateCallback, BashToolDetails, ExtensionToolContext } from "@earendil-works/pi-coding-agent";
 import { createBashToolDefinition, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
@@ -76,7 +76,7 @@ const ENHANCED_BASH_DESCRIPTION = [
  */
 function startBackgroundAndReply(
 	command: string,
-	ctx: ExtensionContext,
+	ctx: ExtensionToolContext,
 	config: BaseToolEnhanceConfig,
 	timeoutSec: number | undefined,
 	extraNotes: string[] = [],
@@ -162,7 +162,9 @@ export function createBashOverrideToolDefinition() {
 			// 与官方 delegate 同型（展开透传后泛型 TDetails=BashToolDetails|undefined
 			// 随 render 面传入，execute 签名必须对齐，否则 registerTool 赋值检查不过）
 			onUpdate: AgentToolUpdateCallback<BashToolDetails | undefined> | undefined,
-			ctx: ExtensionContext,
+			// pi 1.0.0：ToolDefinition.execute 第 5 参 ctx 收窄为 ExtensionToolContext
+			// （ExtensionContext + tools/executeTool，嵌套工具调用面）
+			ctx: ExtensionToolContext,
 		) {
 			// 配置每次 execute 读时加载（热重载契约：禁止上层缓存，同进程改配置文件
 			// 不重启即生效）。D14：subagent 降级是全量的——白名单与 background 参数

package/src/index.ts

@@ -3,8 +3,8 @@
  *
  * M1：同名 override pi 内置 bash 工具 + 前台委托官方工厂 + 工具报错审计 hook（D11）。
  * M2：background 任务核心生命周期——bash background 分支（spawn 后台 + registry +
- * 轮询器单例任务表）、bash_output / bash_kill 工具、进程退出收殓、subagent 降级。
- * M3：pending-notifications 通知接入——load 时刷新轮询器通知通路的 pi 引用（D17
+ * 模块级单例任务表）、bash_output / bash_kill 工具、进程退出收殓、subagent 降级。
+ * M3：pending-notifications 通知接入——load 时刷新通知通路的 pi 引用（D17
  * session 替换接管）+ 挂 exit 边沿通知回调（unregister emit + sendMessage steer）+
  * session_start 对账（appendEntry 权威路径兜底 pending 收尾）+ 完成通知补投
  * （bg-task-notify-durability：终态无痕迹无标记的任务下次激活合并补投 + 同步幂等标记）。
@@ -33,7 +33,7 @@ import { createBashOverrideToolDefinition } from "./bash-tool.ts";
 import { handleTaskExit, refreshPiReference } from "./background/notify.ts";
 import { installProcessExitGuard } from "./background/process-exit-guard.ts";
 import { reconcilePendingEntries } from "./background/pending-reconcile.ts";
-import { setOnTaskExit } from "./background/poller.ts";
+import { setOnTaskExit } from "./background/exit-collector.ts";
 import { setupToolErrorAudit } from "./tool-error-audit.ts";
 
 const logger = getLogger("base-tool-enhance");
@@ -43,7 +43,7 @@ export default function baseToolEnhanceExtension(pi: ExtensionAPI): void {
 	// ResourceLoader/eventBus + extension 重新 load → 本调用把通知通路（notify.ts
 	// 模块级引用）切到新 pi——任务发起于旧 session 而完成通知投递新 session。
 	refreshPiReference(pi);
-	// ⑧⑨ 轮询器 exit 边沿 → pending:unregister emit + sendMessage steer（kill 路径
+	// ⑧⑨ exit 事件边沿 → pending:unregister emit + sendMessage steer（kill 路径
 	// 不 sendMessage，见 notify.ts 单点归属规则）。重复 load 幂等（覆盖同一回调）
 	setOnTaskExit(handleTaskExit);
 	// 同名 "bash" 覆盖内置工具（pi agent-session _refreshToolRegistry：custom 定义后注册者胜）

package/src/tool-error-audit.ts

@@ -25,6 +25,8 @@ interface ToolExecutionEndLikeEvent {
 	isError: boolean;
 	toolName: string;
 	toolCallId: string;
+	/** 嵌套子调用标记（pi 1.0：另一工具（如 codemode 脚本）发起的调用携带；实装锚点 = dist/core/extensions/types.d.ts ToolExecutionEndEvent :837-838） */
+	parentToolCallId?: string;
 	result?: unknown;
 }
 
@@ -65,6 +67,10 @@ export function setupToolErrorAudit(pi: ExtensionAPI): void {
 	pi.on("tool_execution_end", async (event: unknown) => {
 		const e = event as ToolExecutionEndLikeEvent;
 		if (!e.isError) return;
+		// D13②：嵌套子调用失败不单独记账——父工具的 tool_execution_end 是记账终点，
+		// 子调用（parentToolCallId 非空）再记一条 = session-manager 现役嵌套派发场景下
+		// 审计条目膨胀（一父 N 子记 N+1 条）。
+		if (typeof e.parentToolCallId === "string" && e.parentToolCallId.length > 0) return;
 
 		const errorText = extractErrorText(e.result);