@zhushanwen/pi-delivery-port 0.2.0 → 0.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zhushanwen/pi-delivery-port",
-  "version": "0.2.0",
-  "description": "In-process delivery port for the pi half of the unified delivery service (design .tmp/tech-design/unified-delivery.md §3.7): binds pi appendEntry / sessionManager.getEntries / isIdle / sendMessage / message_end / session_compact into the @zhushanwen/session-delivery v3 kernel as the sole executor of the custom lane — outbox journal (entry schema v2 + v1 notify-ledger compat read), details-id delivery proof, session_start difference-set replay, submit-side merge window with external-channel isolation, and compaction-wait degradation (shared library, not a Pi extension).",
+  "version": "0.3.0",
+  "description": "In-process delivery port for the pi half of the unified delivery service (design .tmp/tech-design/unified-delivery.md §3.7): binds pi appendEntry / sessionManager.getEntries / isIdle / sendMessage / message_end / session_compact into the @zhushanwen/session-delivery v3 kernel as the sole executor of the custom lane — outbox journal (entry schema v2 + v1 notify-ledger compat read), details-id delivery proof, session_start difference-set replay, edge-immediate dispatch with external-channel isolation (permanent dedup via the delivery journal), and compaction-wait degradation (shared library, not a Pi extension).",
   "type": "module",
   "main": "src/index.ts",
   "keywords": [
@@ -17,18 +17,18 @@
     "src/"
   ],
   "dependencies": {
-    "@zhushanwen/extension-protocol": "0.22.0"
+    "@zhushanwen/extension-protocol": "0.24.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^1.0.0",
-    "@zhushanwen/session-delivery": "2.0.0"
+    "@zhushanwen/session-delivery": "2.1.0"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^1.0.0",
     "@types/node": "^24.0.0",
     "@vitest/coverage-v8": "^4.1.9",
     "vitest": "^4.1.8",
-    "@zhushanwen/session-delivery": "2.0.0"
+    "@zhushanwen/session-delivery": "2.1.0"
   },
   "scripts": {
     "typecheck": "npx tsc --noEmit",

package/src/__tests__/delivery-port.test.ts

@@ -3,7 +3,7 @@
 // ack）/ 幂等（同 id 重提交 swallowed）/ session_start 差集重放 / 外部通道逐条批组
 // 隔离 / compaction 等待降级与事件唤醒 / deliveryId 写入与批展平逐条对位。
 // fake host 全内存（无 fs——测试红线：禁触真实数据目录由构造性满足）；
-// fake timers 驱动 60s 合批窗口。
+// fake timers 驱动「无窗口定时器」负断言与 collect 等待时序（攒批窗已删 §3.3.7③）。
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import {
@@ -31,12 +31,11 @@ type SentMessage = {
 	details?: unknown;
 };
 
-function makeHost(init: { entries?: unknown[]; idle?: boolean; bg?: boolean } = {}) {
+function makeHost(init: { entries?: unknown[]; idle?: boolean } = {}) {
 	const entries: unknown[] = init.entries ?? [];
 	const sent: Array<{ message: SentMessage; options: { deliverAs: string; triggerTurn: boolean } }> = [];
 	const callLog: string[] = [];
 	const idle = { value: init.idle ?? true };
-	const bg = { value: init.bg ?? false };
 	const sendThrows = { value: false };
 	const warn = vi.fn();
 	const debug = vi.fn();
@@ -89,7 +88,6 @@ function makeHost(init: { entries?: unknown[]; idle?: boolean; bg?: boolean } =
 				handlers.session_compact_failed = handlers.session_compact_failed.filter((h) => h !== handler);
 			};
 		},
-		hasRunningBackground: () => bg.value,
 		logger: { warn, debug },
 	};
 	const fireAll = (list: Array<() => void>): void => {
@@ -119,7 +117,6 @@ function makeHost(init: { entries?: unknown[]; idle?: boolean; bg?: boolean } =
 		sent,
 		callLog,
 		idle,
-		bg,
 		sendThrows,
 		warn,
 		debug,
@@ -154,7 +151,7 @@ describe("四步对位（受理前落盘 → 注入 → message_end 命中 → a
 	});
 
 	it("直通路径：outbox 落盘先于 sendMessage；命中后 ack 落盘且重放差集清零", () => {
-		const h = makeHost({ bg: false });
+		const h = makeHost();
 		const port = createDeliveryPort(h.host);
 		const receipt = port.deliver(defaultEnvelope({ id: "n-1" }));
 		expect(receipt).toEqual({ kind: "accepted", id: "n-1" });
@@ -187,14 +184,14 @@ describe("四步对位（受理前落盘 → 注入 → message_end 命中 → a
 	});
 
 	it("followUp 档透传 deliverAs", () => {
-		const h = makeHost({ bg: false });
+		const h = makeHost();
 		const port = createDeliveryPort(h.host);
 		port.deliver(defaultEnvelope({ id: "n-2", timing: "followUp" }));
 		expect(h.sent[0].options.deliverAs).toBe("followUp");
 	});
 
 	it("缺省 id 内部生成且注入 details 携带同一 id", () => {
-		const h = makeHost({ bg: false });
+		const h = makeHost();
 		const port = createDeliveryPort(h.host);
 		const receipt = port.deliver(defaultEnvelope());
 		expect(receipt.kind).toBe("accepted");
@@ -214,7 +211,7 @@ describe("幂等（同 id 重提交 swallowed）", () => {
 	});
 
 	it("缓冲成员同 id 重提交 swallowed", () => {
-		const h = makeHost({ bg: true });
+		const h = makeHost();
 		const port = createDeliveryPort(h.host);
 		expect(port.deliver(defaultEnvelope({ id: "dup-1" })).kind).toBe("accepted");
 		expect(port.deliver(defaultEnvelope({ id: "dup-1" }))).toEqual({ kind: "swallowed", reason: "already-seen" });
@@ -223,7 +220,7 @@ describe("幂等（同 id 重提交 swallowed）", () => {
 	});
 
 	it("直通条目已终局后跨实例同 id 提交不重投（判重三级：持久终局播种）", () => {
-		const h = makeHost({ bg: false });
+		const h = makeHost();
 		const first = createDeliveryPort(h.host);
 		first.deliver(defaultEnvelope({ id: "done-1" }));
 		h.injectAndEmit(h.sent[0].message); // 送达 + ack
@@ -254,9 +251,9 @@ describe("幂等（同 id 重提交 swallowed）", () => {
 	});
 });
 
-// ─── 合批窗口与批组隔离 ─────────────────────────────────────
+// ─── 边沿即投与批组隔离（subagent-observability §3.3.7③ 攒批窗退役后行为锁）──
 
-describe("提交侧合批（60s 滑动窗口）与批组隔离", () => {
+describe("边沿即投与批组隔离（攒批窗已删）", () => {
 	beforeEach(() => {
 		vi.useFakeTimers();
 		vi.setSystemTime(T0);
@@ -265,106 +262,71 @@ describe("提交侧合批（60s 滑动窗口）与批组隔离", () => {
 		vi.useRealTimers();
 	});
 
-	it("默认通道 + 活跃后台 → 进窗口不注入；60s 到期合成一条批消息", () => {
-		const h = makeHost({ bg: true });
+	it("默认通道边沿即投：落盘受理后立即注入（单条无批 wrapper），无窗口等待", () => {
+		const h = makeHost();
 		const port = createDeliveryPort(h.host);
 		port.deliver(defaultEnvelope({ id: "b-1", payload: { kind: "custom", customType: DEFAULT_NOTIFY_CUSTOM_TYPE, content: "first", display: true, details: { k: 1 } } }));
-		port.deliver(defaultEnvelope({ id: "b-2", payload: { kind: "custom", customType: DEFAULT_NOTIFY_CUSTOM_TYPE, content: "second", display: true, details: { k: 2 } } }));
-		expect(h.sent).toHaveLength(0); // 窗口内不注入
-		expect(h.outboxEntries()).toHaveLength(2); // 受理前已逐条落盘
+		// 边沿即投：无 60s 窗口——落盘受理后同步出站
+		expect(h.sent).toHaveLength(1);
+		expect(h.outboxEntries()).toHaveLength(1); // 受理前已落盘
+		expect(h.sent[0].message.customType).toBe(DEFAULT_NOTIFY_CUSTOM_TYPE);
+		expect((h.sent[0].message.details as Record<string, unknown>)["batch"]).toBeUndefined();
 
-		vi.advanceTimersByTime(60_000);
-		expect(h.sent).toHaveLength(1); // 一次 sendMessage
-		const msg = h.sent[0].message;
-		expect(msg.customType).toBe(DEFAULT_NOTIFY_CUSTOM_TYPE);
-		expect(msg.details).toMatchObject({ batch: true });
-		// 批展平逐条对位：items 序 = 成员序，deliveryId 各自携带
-		const items = (msg.details as { items: Array<Record<string, unknown>> }).items;
-		expect(items).toHaveLength(2);
-		expect(items[0]).toMatchObject({ k: 1, deliveryId: "b-1" });
-		expect(items[1]).toMatchObject({ k: 2, deliveryId: "b-2" });
-
-		// message_end 批命中 → 逐条 ack
-		h.injectAndEmit(msg);
-		const ackIds = h.ackEntries().map((a) => (a["data"] as { id: string }).id).sort();
-		expect(ackIds).toEqual(["b-1", "b-2"]);
-	});
-
-	it("滑动窗口：窗口内新到达重置窗口尾", () => {
-		const h = makeHost({ bg: true });
-		const port = createDeliveryPort(h.host);
-		port.deliver(defaultEnvelope({ id: "s-1" }));
-		vi.advanceTimersByTime(59_000);
-		port.deliver(defaultEnvelope({ id: "s-2" }));
-		vi.advanceTimersByTime(59_000);
-		expect(h.sent).toHaveLength(0); // 重置后未到期
-		vi.advanceTimersByTime(1_000);
+		// message_end 命中 → ack
+		h.injectAndEmit(h.sent[0].message);
+		const ackIds = h.ackEntries().map((a) => (a["data"] as { id: string }).id);
+		expect(ackIds).toEqual(["b-1"]);
+		// 无第二批：窗口机制已删，定时器不存在
+		vi.advanceTimersByTime(120_000);
 		expect(h.sent).toHaveLength(1);
 	});
 
-	it("外部通道逐条批组隔离：立即单独注入，不进窗口批", () => {
-		const h = makeHost({ bg: true });
+	it("同组多成员近同时到达 → 分组放行合成一条批消息（保留边界：pumpDirect/commitAsBatch 批形态）", () => {
+		const h = makeHost();
+		const port = createDeliveryPort(h.host);
+		// 同步段连续提交：首条触发的 pump 已取走首条，第二条在新一轮 pump 与首条
+		// 内核注入的 merge-commit hold 窗内聚合——同通道批形态仍合法（保留边界断言）
+		port.deliver(defaultEnvelope({ id: "g-1", payload: { kind: "custom", customType: DEFAULT_NOTIFY_CUSTOM_TYPE, content: "one", display: true, details: { k: 1 } } }));
+		port.deliver(defaultEnvelope({ id: "g-2", payload: { kind: "custom", customType: DEFAULT_NOTIFY_CUSTOM_TYPE, content: "two", display: true, details: { k: 2 } } }));
+		expect(h.sent.length).toBeGreaterThanOrEqual(1);
+		expect(h.sent.length).toBeLessThanOrEqual(2);
+		// 全部条目都出站（不丢）
+		const deliveredIds = h.sent
+			.flatMap((s) => {
+				const details = s.message.details as { batch?: boolean; items?: Array<Record<string, unknown>>; deliveryId?: string };
+				return details.batch === true ? (details.items ?? []).map((i) => i.deliveryId) : [details.deliveryId];
+			})
+			.sort();
+		expect(deliveredIds).toEqual(["g-1", "g-2"]);
+		// 出站消息恒单通道（批组隔离不变量）
+		for (const s of h.sent) expect(s.message.customType).toBe(DEFAULT_NOTIFY_CUSTOM_TYPE);
+	});
+
+	it("外部通道逐条批组隔离：立即单独注入，与默认通道不混批", () => {
+		const h = makeHost();
 		const port = createDeliveryPort(h.host);
 		const wf = { kind: "custom" as const, customType: "workflow-result", content: "workflow done", display: true, details: { runId: "r-1" } };
 		expect(port.deliver({ id: "wf-1", payload: wf })).toEqual({ kind: "accepted", id: "wf-1" });
 		expect(h.sent).toHaveLength(1); // 外部通道立即逐条
 		expect(h.sent[0].message.details).toEqual({ runId: "r-1", deliveryId: "wf-1" }); // 无 batch wrapper
 
-		port.deliver(defaultEnvelope({ id: "bg-1" })); // 默认通道照常进窗口
-		expect(h.sent).toHaveLength(1);
-		vi.advanceTimersByTime(60_000);
+		port.deliver(defaultEnvelope({ id: "bg-1" })); // 默认通道边沿即投
 		expect(h.sent).toHaveLength(2);
-		expect(h.sent[1].message.customType).toBe(DEFAULT_NOTIFY_CUSTOM_TYPE); // 批只含默认通道成员
+		expect(h.sent[1].message.customType).toBe(DEFAULT_NOTIFY_CUSTOM_TYPE); // 各自通道出站
+		expect((h.sent[1].message.details as Record<string, unknown>)["batch"]).toBeUndefined();
+		// 外部通道消息不含默认通道成员（无混批）
+		expect(JSON.stringify(h.sent[0].message.details)).not.toContain("bg-1");
 	});
 
-	it("单成员窗口到期按单条注入（无 batch wrapper）", () => {
-		const h = makeHost({ bg: true });
-		const port = createDeliveryPort(h.host);
-		port.deliver(defaultEnvelope({ id: "solo-1" }));
-		vi.advanceTimersByTime(60_000);
-		expect(h.sent).toHaveLength(1);
-		expect(h.sent[0].message.details).not.toMatchObject({ batch: true });
-		expect(h.sent[0].message.details).toEqual({ outcome: "completed", deliveryId: "solo-1" });
-	});
-
-	it("merge:false 覆写让默认通道跳过窗口立即提交", () => {
-		const h = makeHost({ bg: true });
-		const port = createDeliveryPort(h.host);
-		port.deliver(defaultEnvelope({ id: "nm-1" }), { merge: false });
-		expect(h.sent).toHaveLength(1);
-	});
-
-	it("merge:true 对外部通道不生效（结构性逐条）：立即单条注入无 batch wrapper", () => {
-		const h = makeHost({ bg: true });
-		const port = createDeliveryPort(h.host);
-		const wf = { kind: "custom" as const, customType: "workflow-result", content: "workflow done", display: true, details: { runId: "r-9" } };
-		expect(port.deliver({ id: "wf-m1", payload: wf }, { merge: true })).toEqual({ kind: "accepted", id: "wf-m1" });
-		// 显式 merge:true 不把外部通道条目放进窗口：立即单条注入
-		expect(h.sent).toHaveLength(1);
-		expect(h.sent[0].message.customType).toBe("workflow-result");
-		expect((h.sent[0].message.details as Record<string, unknown>)["batch"]).toBeUndefined();
-		// 窗口到期后无第二批投出（条目从未进 mergeBuffer）
-		vi.advanceTimersByTime(60_000);
-		expect(h.sent).toHaveLength(1);
-	});
-
-	it("flush() 立即放行窗口缓冲", () => {
-		const h = makeHost({ bg: true });
+	it("flush() 幂等放行缓冲条目（空缓冲 no-op 不报错）", () => {
+		const h = makeHost();
 		const port = createDeliveryPort(h.host);
+		port.flush(); // 空缓冲 no-op
+		expect(h.sent).toHaveLength(0);
 		port.deliver(defaultEnvelope({ id: "f-1" }));
-		port.flush();
-		expect(h.sent).toHaveLength(1);
-	});
-
-	it("窗口活跃期到达的外部通道条目单独出站，缓冲成员不随后泄露", () => {
-		const h = makeHost({ bg: true });
-		const port = createDeliveryPort(h.host);
-		port.deliver(defaultEnvelope({ id: "bg-first" })); // 进缓冲
-		port.deliver({ id: "wf-x", payload: { kind: "custom", customType: "managed-session-notify", content: "session died", display: true } });
-		// 外部通道条目独立注入（缓冲成员未入内核——隔离由「缓冲在端口、不在内核」保证）
+		expect(h.sent).toHaveLength(1); // 边沿已投
+		port.flush(); // 已出站，无重复注入
 		expect(h.sent).toHaveLength(1);
-		expect(h.sent[0].message.customType).toBe("managed-session-notify");
-		expect((h.sent[0].message.details as Record<string, unknown>)["batch"]).toBeUndefined();
 	});
 });
 
@@ -380,7 +342,7 @@ describe("compaction 等待降级与事件唤醒", () => {
 	});
 
 	it("before_compact 置标记 → 缓冲挂起不注入（落盘已完成）；session_compact 复位唤醒重投", () => {
-		const h = makeHost({ bg: false, idle: false });
+		const h = makeHost({ idle: false });
 		const port = createDeliveryPort(h.host);
 		h.fireBeforeCompact(); // compaction 开始边沿（事件标记置位，非 isIdle 判定）
 		const receipt = port.deliver(defaultEnvelope({ id: "c-1" }));
@@ -397,7 +359,7 @@ describe("compaction 等待降级与事件唤醒", () => {
 	});
 
 	it("session_compact_failed 边沿同样复位唤醒", () => {
-		const h = makeHost({ bg: false, idle: false });
+		const h = makeHost({ idle: false });
 		const port = createDeliveryPort(h.host);
 		h.fireBeforeCompact();
 		port.deliver(defaultEnvelope({ id: "c-2" }));
@@ -407,7 +369,7 @@ describe("compaction 等待降级与事件唤醒", () => {
 	});
 
 	it("run 活跃（isIdle=false）未 compaction → 照常注入（steer 入 pi 队列不拒）", () => {
-		const h = makeHost({ bg: false, idle: false }); // run 活跃：无 before_compact，标记 false
+		const h = makeHost({ idle: false }); // run 活跃：无 before_compact，标记 false
 		const port = createDeliveryPort(h.host);
 		const receipt = port.deliver(defaultEnvelope({ id: "run-1" }));
 		expect(receipt).toEqual({ kind: "accepted", id: "run-1" });
@@ -416,7 +378,7 @@ describe("compaction 等待降级与事件唤醒", () => {
 	});
 
 	it("持有期内 settled 边沿只做无谓尝试，仍挂起（无双重注入）", () => {
-		const h = makeHost({ bg: false, idle: false });
+		const h = makeHost({ idle: false });
 		const port = createDeliveryPort(h.host);
 		h.fireBeforeCompact();
 		port.deliver(defaultEnvelope({ id: "c-3" }));
@@ -427,7 +389,7 @@ describe("compaction 等待降级与事件唤醒", () => {
 	});
 
 	it("注入 throw → 内核 retain 留账 + settleRejected 计数；恢复后 settled 边沿重投", () => {
-		const h = makeHost({ bg: false, idle: true });
+		const h = makeHost({ idle: true });
 		h.sendThrows.value = true;
 		const port = createDeliveryPort(h.host);
 		expect(port.deliver(defaultEnvelope({ id: "t-1" })).kind).toBe("accepted");
@@ -455,12 +417,12 @@ describe("失败保留策略（onFailure 覆写）", () => {
 	});
 
 	it("显式 forget 首败即弃（真注入 throw）：discard 终局列落盘、settled 边沿不重投、重放不复活", () => {
-		const h = makeHost({ bg: false });
+		const h = makeHost();
 		h.sendThrows.value = true; // 注入通道全程 throw
 		const port = createDeliveryPort(h.host);
 		expect(port.deliver(defaultEnvelope({ id: "fg-1" }), { onFailure: "forget" }).kind).toBe("accepted");
 		// 提交链两段：首投被 commitAsBatch 注入门禁 hold（设计内等待，不计首败、无终局落盘）
-		// → 窗口结束 kernel.flush() 重提 → 真注入 throw（首败语义生效）：forget → discard。
+		// → kernel.flush() 重提 → 真注入 throw（首败语义生效）：forget → discard。
 		// settleRejected=1 锚定 discard 由真注入失败触发（hold 路径不计数）。
 		expect(h.sent).toHaveLength(0);
 		expect(port.metrics().settleRejected).toBe(1);
@@ -479,12 +441,12 @@ describe("失败保留策略（onFailure 覆写）", () => {
 		expect(h.sent).toHaveLength(0);
 	});
 
-	it("提交窗 hold 拒不计首败：forget 条目不被 discard、留册，窗口结束重提送达成功", () => {
-		const h = makeHost({ bg: false });
+	it("提交窗 hold 拒不计首败：forget 条目不被 discard、留册，重提送达成功", () => {
+		const h = makeHost();
 		const port = createDeliveryPort(h.host);
-		// 默认通道 bg=false → 直通 → commitAsBatch 提交窗：首投被注入门禁 hold（设计内等待）
+		// 边沿即投仍经 commitAsBatch 提交窗：首投被注入门禁 hold（设计内等待）
 		expect(port.deliver(defaultEnvelope({ id: "hd-1" }), { onFailure: "forget" }).kind).toBe("accepted");
-		// 窗口结束 kernel.flush() 重提 → 送达成功（旧实现此处 hold 被误计首败 → discard 永久丢弃）
+		// kernel.flush() 重提 → 送达成功（旧实现此处 hold 被误计首败 → discard 永久丢弃）
 		expect(h.sent).toHaveLength(1);
 		expect(h.sent[0].message.details).toMatchObject({ deliveryId: "hd-1" });
 		expect(h.ackEntries()).toHaveLength(0); // 无 discard 终局（条目全程未失败）
@@ -497,11 +459,9 @@ describe("失败保留策略（onFailure 覆写）", () => {
 	});
 
 	it("提交窗 hold 拒对 retain 条目同样不计首败：留守不重复计数，重提送达正常终局", () => {
-		const h = makeHost({ bg: true });
+		const h = makeHost();
 		const port = createDeliveryPort(h.host);
-		port.deliver(defaultEnvelope({ id: "hd-r" })); // 缺省 retain
-		expect(h.sent).toHaveLength(0); // 窗口缓冲期不注入
-		vi.advanceTimersByTime(60_000); // 窗口到期 → commitAsBatch 提交（首投 hold 留守）→ kernel.flush 重提
+		port.deliver(defaultEnvelope({ id: "hd-r" })); // 缺省 retain——边沿即投经 commitAsBatch（首投 hold 留守）→ kernel.flush 重提
 		expect(h.sent).toHaveLength(1);
 		expect(port.metrics().settleRejected).toBe(0); // hold 不重复计入失败
 		const firstFailWarns = h.warn.mock.calls.filter((c) => String(c[0]).includes("first-failure"));
@@ -510,8 +470,8 @@ describe("失败保留策略（onFailure 覆写）", () => {
 		expect(h.ackEntries()[0]!["data"]).toEqual({ v: 2, id: "hd-r" }); // ack（无 outcome = 非 discard）
 	});
 
-	it("缺省（不传 onFailure）：首投经提交窗 hold 留守（设计内等待）；窗口外重投遇真注入 throw → retain 留账，恢复后边沿重投", () => {
-		const h = makeHost({ bg: false, idle: true });
+	it("缺省（不传 onFailure）：首投经提交窗 hold 留守（设计内等待）；重投遇真注入 throw → retain 留账，恢复后边沿重投", () => {
+		const h = makeHost({ idle: true });
 		h.sendThrows.value = true;
 		const port = createDeliveryPort(h.host);
 		expect(port.deliver(defaultEnvelope({ id: "rt-1" })).kind).toBe("accepted");
@@ -534,19 +494,21 @@ describe("session_start 差集重放", () => {
 		vi.useRealTimers();
 	});
 
-	it("崩溃在注入前：新实例 recover 重投（默认通道合批形态）且 replayReplays 计数", () => {
-		const h = makeHost({ bg: true });
+	it("崩溃在注入前：新实例 recover 重投（同组重放批形态）且 replayReplays 计数", () => {
+		const h = makeHost();
 		const first = createDeliveryPort(h.host);
 		first.deliver(defaultEnvelope({ id: "r-1", payload: { kind: "custom", customType: DEFAULT_NOTIFY_CUSTOM_TYPE, content: "one", display: true } }));
 		first.deliver(defaultEnvelope({ id: "r-2", payload: { kind: "custom", customType: DEFAULT_NOTIFY_CUSTOM_TYPE, content: "two", display: true } }));
-		first.dispose(); // 崩溃：进程消亡，outbox entry 留在 session 文件
+		first.dispose(); // 崩溃：进程消亡，outbox entry 留在 session 文件（首实例边即投的 sent 不算送达——无 message_end）
 
 		const second = createDeliveryPort(h.host); // respawn 后 session_start 重新装配
+		const sentBefore = h.sent.length;
 		expect(second.recover()).toBe(2);
 		expect(second.metrics().recoveryReplays).toBe(2);
-		// 重放合并投出（账本 recover→attemptDeliver 形态）：一条批消息
-		expect(h.sent).toHaveLength(1);
-		const items = (h.sent[0].message.details as { items: Array<Record<string, unknown>> }).items;
+		// 重放同组两条一起放行 → 分组放行批形态（保留边界断言）：一条批消息
+		expect(h.sent.length).toBe(sentBefore + 1);
+		const replayMsg = h.sent[h.sent.length - 1].message;
+		const items = (replayMsg.details as { items: Array<Record<string, unknown>> }).items;
 		expect(items.map((i) => i.deliveryId).sort()).toEqual(["r-1", "r-2"]);
 	});
 
@@ -580,7 +542,7 @@ describe("session_start 差集重放", () => {
 	});
 
 	it("重放幂等：recover 二次调用零动作（在途条目不重复入账）", () => {
-		const h = makeHost({ bg: false });
+		const h = makeHost();
 		const first = createDeliveryPort(h.host);
 		first.deliver(defaultEnvelope({ id: "ri-1" }));
 		first.dispose();
@@ -596,7 +558,7 @@ describe("session_start 差集重放", () => {
 
 describe("受理前落盘（耐久承诺）", () => {
 	it("appendEntry 抛错 → rejected(persist-failed)，不注入、id 不登记（可重试）", () => {
-		const h = makeHost({ bg: false });
+		const h = makeHost();
 		let fail = false;
 		const host = h.host;
 		const orig = host.appendEntry;
@@ -646,11 +608,12 @@ const pendingRegister = (id: string, type = "bash") => ({
 	data: { id, type, name: `task ${id}`, registeredAt: T0, sessionId: "s-1" },
 });
 
-/** pending unregister entry fixture（status = 写侧 mapReasonToStatus 已映射落盘值）。 */
-const pendingUnregister = (id: string, status: string) => ({
+/** pending unregister entry fixture（reason = 写侧真实原因词，status = mapReasonToStatus
+ *  映射落盘的 legacy 副档——生产 listener 双字段同写，结清解析以 reason 为权威）。 */
+const pendingUnregister = (id: string, reason: string, status: string) => ({
 	type: "custom",
 	customType: "pending:unregister",
-	data: { id, reason: "fixture", status },
+	data: { id, reason, status },
 });
 
 const managedEnvelope = (id: string, overrides: Partial<Envelope> = {}): Envelope => ({
@@ -727,7 +690,7 @@ describe("collect 挂起分流与收取（合批多键）", () => {
 		expect(collected.map((c) => c.id).sort()).toEqual(["k-a", "k-b"]);
 	});
 
-	it("collectRelease 解散等待集 + 未收挂起条目直通内核（跳过 60s 窗口，恢复 push）", () => {
+	it("collectRelease 解散等待集 + 未收挂起条目直通内核（边沿即投无窗口，恢复 push）", () => {
 		const h = makeHost({ entries: [pendingRegister("k-a")] });
 		const port = createDeliveryPort(h.host);
 		port.collectArm(["k-a"]);
@@ -803,23 +766,25 @@ describe("collectArm 五态快照", () => {
 		expect(h.sent).toHaveLength(1);
 	});
 
-	it("unregistered-no-entry：曾注册已注销且无日志条目 → 按 unregister status 定 outcome（三形态：死亡跨批 / 例外1 / 防御分支的 status 值变体）", () => {
-		// 写侧 mapReasonToStatus 落盘值：exited/orphaned → cancelled（死亡跨批・例外1）、
-		// stopped → aborted（例外1 掐断）、reopened → completed（防御分支收尾）
-		const cases: Array<{ id: string; status: string }> = [
-			{ id: "k-death", status: "cancelled" },
-			{ id: "k-orph", status: "cancelled" },
-			{ id: "k-stop", status: "aborted" },
-			{ id: "k-defn", status: "completed" },
+	it("unregistered-no-entry：曾注册已注销且无日志条目 → 按 unregister reason 结清解析定 outcome（三形态：死亡跨批 / 例外1 / 防御分支收尾）", () => {
+		// 写侧 listener 双字段同写：reason = 真实原因词（结清权威通道）、status = legacy
+		// 副档。exited/orphaned → cancelled（死亡跨批・例外1）、stopped → cancelled
+		// （中止族——legacy status 副档为 aborted，结清视图以五值为准）、reopened →
+		// completed（防御分支收尾）
+		const cases: Array<{ id: string; reason: string; status: string }> = [
+			{ id: "k-death", reason: "exited", status: "cancelled" },
+			{ id: "k-orph", reason: "orphaned", status: "cancelled" },
+			{ id: "k-stop", reason: "stopped", status: "aborted" },
+			{ id: "k-defn", reason: "reopened", status: "completed" },
 		];
 		const h = makeHost({
-			entries: [...cases.map((c) => pendingRegister(c.id)), ...cases.map((c) => pendingUnregister(c.id, c.status))],
+			entries: [...cases.map((c) => pendingRegister(c.id)), ...cases.map((c) => pendingUnregister(c.id, c.reason, c.status))],
 		});
 		const port = createDeliveryPort(h.host);
 		const snap = port.collectArm(cases.map((c) => c.id));
 		expect(snap.map((s) => s.state)).toEqual(["unregistered-no-entry", "unregistered-no-entry", "unregistered-no-entry", "unregistered-no-entry"]);
 		expect(snap[0]!.entry).toMatchObject({ outcome: "cancelled", note: expect.any(String) });
-		expect(snap[2]!.entry).toMatchObject({ outcome: "aborted" });
+		expect(snap[2]!.entry).toMatchObject({ outcome: "cancelled" });
 		expect(snap[3]!.entry).toMatchObject({ outcome: "completed" });
 		// 无处可写终局（该键不属任何日志条目）：零 ack entry
 		expect(h.ackEntries()).toHaveLength(0);

package/src/__tests__/pi-host.test.ts

@@ -38,22 +38,22 @@ function makeCtx(entries: unknown[], idle: boolean) {
 	};
 }
 
-function makeOptions(bg = false) {
+function makeOptions() {
 	const logger = {
 		warn: () => {},
 		debug: () => {},
 	};
-	return { component: "test", logger, hasRunningBackground: () => bg };
+	return { component: "test", logger };
 }
 
-describe("createPiDeliveryPortHost 接线（八端口逐成员）", () => {
-	it("appendEntry / readSessionEntries / isIdle / hasRunningBackground 透传", () => {
+describe("createPiDeliveryPortHost 接线（七端口逐成员）", () => {
+	it("appendEntry / readSessionEntries / isIdle 透传", () => {
 		const { pi, appended } = makePi();
 		const entries = [{ type: "message" }];
 		const host = createPiDeliveryPortHost(
 			pi as never,
 			makeCtx(entries, false) as never,
-			makeOptions(true),
+			makeOptions(),
 		);
 
 		host.appendEntry("custom_x", { a: 1 });
@@ -61,7 +61,9 @@ describe("createPiDeliveryPortHost 接线（八端口逐成员）", () => {
 
 		expect(host.readSessionEntries()).toBe(entries);
 		expect(host.isIdle()).toBe(false);
-		expect(host.hasRunningBackground()).toBe(true);
+		// [subagent-observability §3.3.7③] hasRunningBackground 已随攒批窗退役删除，
+		// 接线面不再含该成员（结构断言：host 对象无此键）。
+		expect("hasRunningBackground" in host).toBe(false);
 	});
 
 	it("sendMessage 注入恒携带 triggerTurn: true，deliverAs 透传", () => {
@@ -122,7 +124,7 @@ describe("createPiDeliveryPortHost 接线（八端口逐成员）", () => {
 		const host = createPiDeliveryPortHost(
 			pi as never,
 			makeCtx([], true) as never,
-			{ component: "probe", logger, hasRunningBackground: () => false },
+			{ component: "probe", logger },
 		);
 		expect(host.logger).toBe(logger);
 	});

package/src/delivery-port.ts

@@ -2,7 +2,7 @@
 //
 // pi 半区投递端口主体（设计 .tmp/tech-design/unified-delivery.md §3.7 组件表）：
 // 把 pi 扩展运行时端口接线成 @zhushanwen/session-delivery v3 内核的 port 半区
-// 装配——custom 车道唯一执行者。与账本（notify-ledger）的四步生命周期逐条对位：
+// 装配——custom 投递路径唯一执行者。与账本（notify-ledger）的四步生命周期逐条对位：
 //   ① record（受理前落盘）→ deliver 入口 appendEntry（outbox，plain entry）；
 //   ② deliver（投递）→ 内核 on-accept 受理即出站 → pi.sendMessage 直达唯一队列
 //     （两档出队由 pi 原生 steer/followUp 队列承载，本端口零注入时机代码——提交
@@ -14,19 +14,24 @@
 // 装配形态（§3.7）：每 session 一份（session_start 重绑 = 旧实例 dispose + 新实例
 // recover）；消费方经 Symbol.for 进程级槽 getDeliveryPort 获取（C-ext-06 惯例）。
 //
-// ── 提交侧双缓冲与按通道分组放行（§3.7 合批行 + 批组隔离行）───────────────
-// 全部提交先落盘再进提交缓冲（攒批成员 mergeBuffer / 直通成员 directBuffer），由
-// 放行泵按通道分组交给内核：
-//   - 默认通道组（subagent-bg-notify）：60s 滑动窗口攒批（攒批条件 = 有活跃后台
-//     任务），到期/flush 时经 merge-commit hold 逐条提交内核（注入门禁 hold →
-//     内核 retain → 条目 queued 聚合）→ kernel.flush() → 内核 buildBatchPayload
-//     合成一条 {batch:true, items} 消息一次 sendMessage 入队；
+// ── 提交侧缓冲与按通道分组放行（§3.7 批组隔离行；攒批窗已退役）─────────────
+// 全部提交先落盘再进提交缓冲（directBuffer），由放行泵按通道分组交给内核：
+//   - 默认通道组（subagent-bg-notify）：边沿即投——落盘受理后立即经 merge-commit
+//     hold 逐条提交内核（注入门禁 hold → 内核 retain → 条目 queued 聚合）→
+//     kernel.flush() → 内核 buildBatchPayload 合成一条 {batch:true, items} 消息
+//     一次 sendMessage 入队（同组多成员近同时到达时仍是合法批形态——分组放行
+//     语义保留，窗口等待已删）；
 //   - 外部通道组（workflow-result / managed-session-notify 等）：逐条提交、逐条
 //     消息（账本 [u9] 分组规则——batch 合并形态对外部通道无消费契约）。
+// [subagent-observability §3.3.7③] 攒批窗（60s 滑动窗口 + mergeBuffer +
+// wantMerge 判定 + MERGE_WINDOW_MS 定时器）整机制退役删除——所有通知边沿即投；
+// 省 token 价值由 collect_results 批量收取能力取代。保留边界（防误删）：内核
+// buildBatchPayload 与 pumpDirect/commitAsBatch/merge-commit hold（recover 重放、
+// collectRelease 直通、compaction 唤醒仍产合法批形态）、消费方批兼容读分支、
+// collect 挂起子系统、journal 差集重放——全部保留。
 // 分组放行的不变量：内核 queued 集恒来自单次单组放行 → 内核 doSend 的合批产物恒
 // 单通道——批组隔离不依赖时序巧合（混批窗口结构性消除；残余边界见 pumpDirect
-// 注释）。双缓冲（攒批/直通分离）的原因：直通放行不得携带窗口攒批成员（窗口语义
-// = 攒到到期/flush）。账目/幂等/回执/ack 全程逐条（成员各自独立内核条目，
+// 注释）。账目/幂等/回执/ack 全程逐条（成员各自独立内核条目，
 // items[].deliveryId 逐项对位），合批只发生在注入形态。
 //
 // ── compaction 防御（§3.8 提交侧等待）────────────────────────
@@ -46,8 +51,8 @@
 // 不进投递内核）+ onCollectArrival 唤醒等待器；未命中 → push 现状零变化。挂起不独立
 // 持久化，投递日志即耐久层：崩溃后差集重放按未投递重投（push），收取过的条目写
 // collected 终局（ack outcome 扩值）构造性退出差集。等待器三 API（collectArm 五态
-// 快照 / consume 全键展开收取 / collectRelease 解散等待集 + 未收条目直通内核跳过
-// 合批窗口）。session 替换路径 abort 先于 dispose 归并中断语义；extension 重载在
+// 快照 / consume 全键展开收取 / collectRelease 解散等待集 + 未收条目直通内核
+// flush——边沿即投，攒批窗已删 §3.3.7③）。session 替换路径 abort 先于 dispose 归并中断语义；extension 重载在
 // collect 阻塞期不可达（设计 §3.1 [重绑] 登记），dispose 只做在途等待器 warn 留痕
 // 不变量检查，不定义唤醒与返回语义。
 //
@@ -74,11 +79,11 @@ import type {
 import {
   scanPendingEntries,
   type MappedPendingStatus,
+  type ResolvedSettlementReason,
 } from "@zhushanwen/extension-protocol";
 
 import {
   ACK_CUSTOM_TYPE,
-  DEFAULT_NOTIFY_CUSTOM_TYPE,
   OUTBOX_CUSTOM_TYPE,
   extractDeliveryIds,
   isPlainObject,
@@ -98,9 +103,6 @@ import type {
   DeliveryTiming,
 } from "./types.ts";
 
-/** 提交侧合批窗口（账本 MERGE_WINDOW_MS=60s 现状保持，设计 §3.7 合批行）。 */
-const MERGE_WINDOW_MS = 60_000;
-
 /** genId 时间戳段进制（base36：紧凑且小写字母数字安全，dp-<ts>-<seq> 的 ts 段）。 */
 const ID_TIMESTAMP_RADIX = 36;
 
@@ -212,9 +214,8 @@ function createKernelAssembly(deps: KernelAssemblyDeps): { kernel: ReturnType<ty
    */
   const kernelPort: KernelPort = {
     supportedPayloads: ["custom"],
-    // 内核接口必填成员；on-accept 模式内核 busy gate 短路旁路（delivery.ts flush/
-    // scheduleFlush 均先判 on-accept），恒不被消费。提交侧挂起判定 = compacting
-    // 事件标记（见 send 第二道防线与放行泵预检），不走本探测。
+    // 内核接口必填成员；内核受理即出站不读忙闲探测，恒不被消费。提交侧挂起判定 =
+    // compacting 事件标记（见 send 第二道防线与放行泵预检），不走本探测。
     isIdle: () => host.isIdle(),
     subscribeSettled: (cb) => host.onAgentSettled(cb),
     send(msg: DeliveryMessage, intent: DeliveryIntent) {
@@ -257,7 +258,6 @@ function createKernelAssembly(deps: KernelAssemblyDeps): { kernel: ReturnType<ty
 
   const kernelConfig: DeliveryConfigWithWarn = {
     intent: "interrupt-at-turn-boundary",
-    dispatchMode: "on-accept",
     store,
     // details-id 凭据判定：state.deliveredIds 由 message_end 边沿增量维护（事件与
     // entry 写入同栈——收到事件 = entry 已持久），O(1) 且锚定磁盘事实。
@@ -275,7 +275,7 @@ interface CollectFaceDeps {
   /** 挂起条目收取时摘除失败策略项（deliver 登记的提交时选项不残留）。 */
   failurePolicies: Map<string, DeliveryFailurePolicy>;
   warn(msg: string, err?: unknown): void;
-  /** 解散等待集后未收条目的直通放行（进 pumpDirect 分组放行管线，跳过合批窗口）。 */
+  /** 解散等待集后未收条目的直通放行（进 pumpDirect 分组放行管线——边沿即投，攒批窗已删 §3.3.7③）。 */
   routeDirect(records: readonly JournalRecord[]): void;
 }
 
@@ -328,7 +328,7 @@ function createCollectFace(deps: CollectFaceDeps): CollectFace {
   ): Omit<CollectedEntry, "id"> {
     return {
       type: pending.registerTypes.get(key),
-      outcome: pending.unregisterStatus.get(key),
+      outcome: unregisterOutcomeOf(pending, key),
       content: rec.payload.content,
       details: rec.payload.details,
     };
@@ -343,15 +343,21 @@ function createCollectFace(deps: CollectFaceDeps): CollectFace {
    *   收取（不写新终局——已注入条目再写 collected 会让日志宣称「未注入过」）；
    * - in-push-pipeline：键 ∈ 日志条目键集、条目无终局（已过分流点，在 push 管线
    *   排队待注入）→ 不收取不等待（等它会自锁，设计 §3.3 push 管线态决策）；
-   * - unregistered-no-entry：键曾注册已注销、不属任何日志条目键集 → 按 unregister
-   *   entry 的 status 定 outcome 进 collected（无载荷快照形态）；
+   * - unregistered-no-entry：键曾注册已注销、不属任何日志条目键集 → outcome 按
+   *   unregister entry 的结清视图优先 + legacy status 兜底定值进 collected（无载荷
+   *   快照形态；畸形 data 缺省语义见 types.ts CollectedEntry 注释）；
    * - waiting：活跃（register 在册无注销）且无日志条目 → 登记等待集，后续 deliver
    *   命中被挂起；
    * - unknown（MF-1-5 第五态）：键未注册且无条目——判定源 = 活跃集 ∪ 投递日志 ∪
    *   曾注册集的补集。不登记等待集（防空等到 timeout 挂死）、不虚构终态；工具侧
    *   读本态组装 errors（不再伪装 waiting——端口是唯一未知判定点，词表诚实表达）。
    */
-  function collectArm(keys: string[]): CollectSnapshot {
+  /** 注销 key 的 outcome（结清视图优先——权威通道 resolveSettlementReason；legacy status 兜底）。 */
+function unregisterOutcomeOf(pending: PendingBaseline, key: string) {
+  return pending.unregisterSettlements.get(key) ?? pending.unregisterStatus.get(key);
+}
+
+function collectArm(keys: string[]): CollectSnapshot {
     if (deps.isDisposed()) throw new Error("collectArm on disposed delivery port");
     const pending = scanPendingBaseline(host.readSessionEntries());
     const snapshot: CollectSnapshot = [];
@@ -370,7 +376,7 @@ function createCollectFace(deps: CollectFaceDeps): CollectFace {
           state: "unregistered-no-entry",
           entry: {
             type: pending.registerTypes.get(key),
-            outcome: pending.unregisterStatus.get(key),
+            outcome: unregisterOutcomeOf(pending, key),
             note: UNREGISTERED_NO_ENTRY_NOTE,
           },
         });
@@ -424,10 +430,9 @@ function createCollectFace(deps: CollectFaceDeps): CollectFace {
   }
 
   /**
-   * 解散等待集；未收挂起条目直通内核 flush（跳过 60s 合批窗口——等待期
-   * hasRunningBackground 恒真，复用 wantMerge 判定会把恢复 push 推迟一个窗口）。
-   * 直通走 routeDirect（pumpDirect 按通道分组放行：外部通道逐条 / 默认通道组合批
-   * 消息，批形态语义合法——跳过的是窗口不是分组）。
+   * 解散等待集；未收挂起条目直通内核 flush（边沿即投——攒批窗已删，恢复 push
+   * 不再有任何窗口延迟）。直通走 routeDirect（pumpDirect 按通道分组放行：外部
+   * 通道逐条 / 默认通道组合批消息，批形态语义合法——分组放行保留，窗口已删）。
    */
   function collectRelease(): void {
     if (deps.isDisposed()) return;
@@ -492,20 +497,14 @@ export function createDeliveryPort(host: DeliveryPortHost): DeliveryPortHandle {
   const buckets: DeliveryPortMetrics = { settleRejected: 0, recoveryReplays: 0 };
   let disposed = false;
   /**
-   * 提交双缓冲（落盘已完成，等待放行；仅在缓冲期持有，放行即摘）：
-   * - mergeBuffer = 默认通道攒批成员（60s 窗口，到期聚合批放行）；
-   * - directBuffer = 直通成员（外部通道 / 无后台任务 / merge:false；按通道分组
-   *   立即放行）。
-   * 分两缓冲的原因：直通放行不得携带窗口攒批成员（窗口语义 = 攒到到期/flush），
-   * 统一单缓冲时「直通触发的 pump」会把窗口成员提前冲出——正是内核 v1 clearMergeTimer
-   * 注释登记过的「孤儿 timer 冲出窗口成员」同构缺陷，结构性规避。
+   * 提交缓冲（落盘已完成，等待放行；仅在缓冲期持有，放行即摘）。窗口攒批缓冲
+   * （mergeBuffer）已随攒批窗退役删除（§3.3.7③）——全部受理条目统一进本缓冲
+   * 边沿即投；同组多成员近同时到达经 pumpDirect 分组放行仍产合法批形态。
    */
-  const mergeBuffer = new Map<string, JournalRecord>();
   const directBuffer = new Map<string, JournalRecord>();
   /** 已受理 id 索引（deliver 幂等预检的全窗口快路径；内核三级判重对已入内核条目
    *  兜底）。仅增量添加，无淘汰——量级 = 每 session 通知总量（数十~数百）。 */
   const seenIds = new Set<string>();
-  let mergeTimer: ReturnType<typeof setTimeout> | undefined;
   /** merge-commit 期标志：默认通道组逐条提交内核期间 hold 注入，使成员聚合为内核
    *  queued 集，最后 kernel.flush() 一次合批出站（见文件头分组放行段）。 */
   let mergeCommitting = false;
@@ -521,7 +520,7 @@ export function createDeliveryPort(host: DeliveryPortHost): DeliveryPortHandle {
   let idSeq = 0;
   /**
    * 显式覆写的失败保留策略（deliver opts.onFailure → submitToKernel 的单次传递）：
-   * 条目在提交缓冲期（合批窗口 / compaction 挂起）暂存 id → policy，提交内核时
+   * 条目在提交缓冲期（compaction 挂起等提交期悬置；攒批窗已删 §3.3.7③）暂存 id → policy，提交内核时
    * 消费并摘除。不进 JournalRecord / outbox schema（§3.7 耐久面行 schema 定形，
    * 策略是提交时选项非账目字段）。重放重建的条目不在册（缺省 retain）：forget
    * 条目首败即 discard 落终局列、不在重放差集；「首败前崩溃」的残留条目重放按
@@ -546,7 +545,7 @@ export function createDeliveryPort(host: DeliveryPortHost): DeliveryPortHandle {
 
   // ─── collect 挂起面（result-collect 设计 §3.1②；子系统实现见 createCollectFace）───
   // routeDirect = 解散等待集后未收条目的直通放行（进 pumpDirect 分组放行管线——
-  // 跳过 60s 合批窗口，不逐条唤醒泵）。
+  // 边沿即投，攒批窗已删 §3.3.7③，不逐条唤醒泵）。
   const collectFace = createCollectFace({
     host,
     state,
@@ -585,7 +584,6 @@ export function createDeliveryPort(host: DeliveryPortHost): DeliveryPortHandle {
     if (disposed) return;
     compacting = false;
     try {
-      flushMergeBuffer("compaction-edge");
       pumpDirect();
       kernel.flush();
     } catch (err) {
@@ -665,7 +663,7 @@ export function createDeliveryPort(host: DeliveryPortHost): DeliveryPortHandle {
     // 显式失败策略随条目登记（submitToKernel 单次消费；缺省 retain 不占位）。
     // 登记在落盘成功后——persist-failed rejected 的条目不残留策略项。
     if (opts?.onFailure) failurePolicies.set(id, opts.onFailure);
-    routeAcceptedDelivery(id, record, collectKeys, channel, opts);
+    routeAcceptedDelivery(id, record, collectKeys);
     return { kind: "accepted", id };
   }
 
@@ -687,16 +685,14 @@ export function createDeliveryPort(host: DeliveryPortHost): DeliveryPortHandle {
     return true;
   }
 
-  /** 受理后路由（collect 挂起分流 → 攒批判定）：挂起条目已落盘（persistOutboxRecord
+  /** 受理后路由（collect 挂起分流 → 边沿即投放行）：挂起条目已落盘（persistOutboxRecord
    * 成功在前）——崩溃后差集重放按未投递重投。 */
   function routeAcceptedDelivery(
     id: string,
     record: JournalRecord,
     collectKeys: readonly string[] | undefined,
-    channel: string,
-    opts: DeliveryDeliverOptions | undefined,
   ): void {
-    // collect 挂起分流（result-collect 设计 §3.1②，先于合批判定）：键集 ∩ 在途
+    // collect 挂起分流（result-collect 设计 §3.1②，先于放行）：键集 ∩ 在途
     // 等待集 ≠ ∅ → 挂起缓冲（不进内核，push 管线零感知）+ 唤醒等待器；否则 push
     // 现状零变化。
     if (collectKeys !== undefined && collectKeys.length > 0 && collectFace.hasWaiterFor(collectKeys)) {
@@ -704,56 +700,16 @@ export function createDeliveryPort(host: DeliveryPortHost): DeliveryPortHandle {
       seenIds.add(id);
       return;
     }
-    // 攒批判定（§3.4 缺省值表）：默认通道 + 有活跃后台任务 → 60s 窗口攒批；其余
-    // → 立即放行（泵按通道分组）：外部通道结构性逐条——merge:true 亦不得覆盖
-    // （批组隔离 [u9]，窗口合批形态 {batch,items} 对外部通道无消费契约，任务书
-    // 目标 6）；默认通道的无后台任务 / merge:false 覆写同样立即放行。
-    const wantMerge =
-      channel === DEFAULT_NOTIFY_CUSTOM_TYPE &&
-      (opts?.merge ?? host.hasRunningBackground());
-    if (wantMerge) {
-      mergeBuffer.set(id, record);
-      seenIds.add(id);
-      armMergeTimer();
-    } else {
-      directBuffer.set(id, record);
-      seenIds.add(id);
-      pumpDirect();
-    }
-  }
-
-  // ─── 合批窗口（60s 滑动；攒批路径专用）─────────────────────
-
-  function clearMergeTimer(): void {
-    if (mergeTimer !== undefined) {
-      clearTimeout(mergeTimer);
-      mergeTimer = undefined;
-    }
-  }
-
-  /** 滑动窗口：每次新攒批成员到达重置窗口尾（账本内核 mergeWindowMs 滑动语义同源）。 */
-  function armMergeTimer(): void {
-    clearMergeTimer();
-    mergeTimer = setTimeout(() => {
-      mergeTimer = undefined;
-      flushMergeBuffer("merge-window");
-    }, MERGE_WINDOW_MS);
+    // 边沿即投（§3.3.7③ 攒批窗退役后唯一路由）：落盘受理的条目直接进放行缓冲，
+    // 泵按通道分组交给内核——默认通道组经 merge-commit hold 聚合出合法批形态，
+    // 外部通道组结构性逐条（批组隔离 [u9] 不依赖时序）。
+    directBuffer.set(id, record);
+    seenIds.add(id);
+    pumpDirect();
   }
 
   // ─── 放行泵（按通道分组交给内核）───────────────────────────
 
-  /**
-   * 窗口攒批成员聚合放行（mergeBuffer → 一次批消息）。compaction 挂起标记置位时
-   * 整缓冲挂起（compaction 终态边沿唤醒）。
-   */
-  function flushMergeBuffer(_reason: string): void {
-    if (disposed || mergeBuffer.size === 0) return;
-    if (compacting) return; // compaction 等待：整缓冲挂起（终态边沿复位 + 唤醒）
-    const group = [...mergeBuffer.values()];
-    mergeBuffer.clear();
-    commitAsBatch(group);
-  }
-
   /**
    * 直通成员分组放行（directBuffer）。不变量：内核 queued 集恒来自单次单组放行
    * → 内核 doSend 的合批产物恒单通道——批组隔离不依赖时序巧合。
@@ -835,8 +791,6 @@ export function createDeliveryPort(host: DeliveryPortHost): DeliveryPortHandle {
 
   function flush(): void {
     if (disposed) return;
-    clearMergeTimer();
-    flushMergeBuffer("flush");
     pumpDirect();
     kernel.flush();
   }
@@ -853,18 +807,14 @@ export function createDeliveryPort(host: DeliveryPortHost): DeliveryPortHandle {
       if (seenIds.has(rec.id)) continue;
       if (state.ackedIds.has(rec.id) || state.deliveredIds.has(rec.id)) continue;
       seenIds.add(rec.id);
-      if (rec.payload.customType === DEFAULT_NOTIFY_CUSTOM_TYPE) {
-        mergeBuffer.set(rec.id, rec);
-      } else {
-        directBuffer.set(rec.id, rec);
-      }
+      directBuffer.set(rec.id, rec);
       replayed += 1;
     }
     if (replayed > 0) {
       buckets.recoveryReplays += replayed;
       emitBucketLog(host, "recoveryReplays", buckets.recoveryReplays);
-      // 立即尝试投递（重放合并形态：攒批成员合并批、直通成员分组放行）。
-      flushMergeBuffer("replay");
+      // 立即尝试投递（重放合并形态：直通成员分组放行——同组多成员仍产合法批
+      // 形态，保留边界 pumpDirect/commitAsBatch 未删）。
       pumpDirect();
     }
     return replayed;
@@ -888,8 +838,6 @@ export function createDeliveryPort(host: DeliveryPortHost): DeliveryPortHandle {
           `(waiting=${inFlight.waiting}, suspended=${inFlight.suspended})`,
       );
     }
-    clearMergeTimer();
-    mergeBuffer.clear();
     directBuffer.clear();
     unsubMessageEnd();
     unsubBeforeCompact();
@@ -942,6 +890,10 @@ interface PendingBaseline {
   unregisteredIds: Set<string>;
   /** 注销条目 id → status（写侧经 mapReasonToStatus 已映射落盘；畸形不收）。 */
   unregisterStatus: Map<string, MappedPendingStatus>;
+  /** 注销条目 id → 结清五值（§3.3.6 权威通道 resolveSettlementReason——快照收取与
+   *  工具侧回填两通道同规则，结清视图优先取值；legacy status 视图承担对账副档与
+   *  本视图缺位（畸形 data：reason 非 string）时的兜底）。 */
+  unregisterSettlements: Map<string, ResolvedSettlementReason>;
 }
 
 function scanPendingBaseline(entries: readonly unknown[]): PendingBaseline {
@@ -955,6 +907,7 @@ function scanPendingBaseline(entries: readonly unknown[]): PendingBaseline {
     registerTypes: scan.registerTypes,
     unregisteredIds: scan.unregisteredIds,
     unregisterStatus: scan.unregisterStatuses,
+    unregisterSettlements: scan.unregisterSettlements,
   };
 }
 

package/src/index.ts

@@ -1,7 +1,7 @@
 // src/index.ts
 //
 // @zhushanwen/pi-delivery-port 公共出口：统一消息投递服务的 pi 半区投递端口
-// （custom 车道唯一执行者；设计 .tmp/tech-design/unified-delivery.md §3.7）。
+// （custom 投递路径唯一执行者；设计 .tmp/tech-design/unified-delivery.md §3.7）。
 //
 // 装配形态（§3.7）：共享库（非 pi extension）+ 装配点 = @zhushanwen/pi-base-tool-
 // enhance 的 session_start（infrastructure 档必载）。消费方（notifier / session-

package/src/pi-host.ts

@@ -23,8 +23,6 @@ export interface CreatePiDeliveryPortHostOptions { // oe-exempt:20261017:framewo
   component: string;
   /** 降级与诊断出口（@zhushanwen/pi-extension-logger 的 ExtensionLogger）。 */
   logger: DeliveryPortHost["logger"];
-  /** 攒批条件谓词（有活跃后台任务；base-tool-enhance 注入 task-store 计数）。 */
-  hasRunningBackground(): boolean;
 }
 
 /** 接线 pi 扩展运行时端口为 DeliveryPortHost（纯端口面，无业务状态）。 */
@@ -62,7 +60,6 @@ export function createPiDeliveryPortHost(
 			pi.on("session_compact_failed", () => {
 				handler();
 			}),
-		hasRunningBackground: () => options.hasRunningBackground(),
 		logger: options.logger,
 	};
 }

package/src/types.ts

@@ -4,7 +4,7 @@
 // §3.7 pi 半区组件表 / §3.4 提交选项缺省值表）。
 //
 // 本包是「知 pi 又知内核」的适配层：把 pi 扩展运行时
-// 端口接线成 @zhushanwen/session-delivery v3 内核的 port 半区——custom 车道唯一
+// 端口接线成 @zhushanwen/session-delivery v3 内核的 port 半区——custom 投递路径唯一
 // 执行者（outbox 投递日志 / details-id 送达凭据 / session_start 差集重放 / 提交侧
 // 合批与批组隔离 / compaction 等待）。消费方（notifier / session-manager / bash）
 // 经 Symbol.for 进程级槽 getDeliveryPort() 获取实例（C-ext-06 惯例）。包依赖分层：
@@ -16,7 +16,7 @@
 // 的 extensions 侧同位形态）；内核包零 pi 词汇的纪律由 session-delivery 自守。
 
 import type { CustomPayload, DeliveryFailurePolicy } from "@zhushanwen/session-delivery";
-import type { MappedPendingStatus } from "@zhushanwen/extension-protocol";
+import type { MappedPendingStatus, SettlementReason } from "@zhushanwen/extension-protocol";
 
 // ─── envelope ───────────────────────────────────────────────
 
@@ -29,7 +29,7 @@ import type { MappedPendingStatus } from "@zhushanwen/extension-protocol";
 export type DeliveryTiming = "steer" | "followUp";
 
 /**
- * 投递信封（进程内 custom 车道）：text 载荷属 runtime 半区端点，不出现在本端口面。
+ * 投递信封（进程内 custom 投递路径）：text 载荷属 runtime 半区端点，不出现在本端口面。
  *
  * to 字段刻意缺席：port 每 session 装配一份（session_start 重绑），投递目标恒为
  * 当前 session——进程内端口无跨 session 寻址语义（跨会话互投是设计 §9 非目标）。
@@ -43,15 +43,8 @@ export interface DeliveryEnvelope { // oe-exempt:20261017:framework:统一投递
   id?: string;
 }
 
-/** deliver 提交选项（缺省值表 §3.4：通知域 = steer + retain + 合批 + details-id）。 */
+/** deliver 提交选项（§3.4：通知域 = steer + retain + details-id；攒批窗已删，无合批选项）。 */
 export interface DeliveryDeliverOptions { // oe-exempt:20261017:framework:统一投递对外 API 契约（deliver 提交选项面）
-  /**
-   * 合批窗口判定覆盖。缺省 = 「默认通道（subagent-bg-notify）且宿主有活跃后台任务」
-   * 时进 60s 滑动窗口攒批；外部通道（workflow-result / managed-session-notify 等）
-   * 恒逐条（批组隔离 [u9] 规则，merge:true 不得覆盖——窗口合批形态 {batch,items}
-   * 对外部通道无消费契约）。显式 merge:false 可让默认通道条目跳过窗口立即提交。
-   */
-  merge?: boolean;
   /**
    * 失败保留策略（内核首败处置）。缺省 "retain"（留账：下一边沿 / compaction 唤醒 /
    * session_start 重放重投——通知域无人值守语义）；显式 "forget" = 首败即弃（discard
@@ -84,17 +77,21 @@ export type DeliveryDeliverResult =
 /**
  * 收取条目（collect 面返回给等待器的单条结果；字段来源设计 §3.1③ 字段来源表）：
  * id = 收取展开键（单债权条目 = 生产方申报的操作 id；managed 合批条目逐键展开，
- * 每键一条、载荷共享）；type 与 outcome 与 pending 词表对齐（protocol
- * mapReasonToStatus 单一权威点，不建第三套终态词表）——两字段的两条填充路径：
- * collectArm 快照收取（ready / unregistered-no-entry，端口按日志基线填）与消费方
- * 终局回填（consume 条目，等待结束后按 session entries 现算填，见 consume 时序
- * 契约）；content/details = 通知载荷原样；note 标记特殊态说明（如 managed 域「注销
+ * 每键一条、载荷共享）；type 与 pending 词表对齐；outcome 是不透明终态标注值
+ * （消费方按原文呈现，不做词表分支判断）。快照与回填两通道统一填充规则：
+ * 注销结清视图（SettlementReason ∪ 'unknown'——reason 事实经 resolveSettlementReason
+ * 结清解析，subagent-observability §3.3.6 权威通道）优先取值；结清视图缺位时
+ * legacy status 副档（expired / time_limited / aborted 等历史终态，
+ * mapReasonToStatus 映射产物）兜底。缺位仅发生于畸形 data（status 合法但 reason
+ * 非 string——注销 entry 不入结清视图），此时两通道同取 status 值保持一致；
+ * 两视图皆缺位保持 undefined（诚实缺省，不虚构终态）。
+ * content/details = 通知载荷原样；note 标记特殊态说明（如 managed 域「注销
  * 无条目分支完结，无独立载荷快照」）。
  */
 export interface CollectedEntry { // oe-exempt:20261017:framework:collect 批量收取对外契约（收取条目形态）
   id: string;
   type?: string;
-  outcome?: MappedPendingStatus;
+  outcome?: MappedPendingStatus | SettlementReason;
   content?: string;
   details?: unknown;
   note?: string;
@@ -106,8 +103,9 @@ export interface CollectedEntry { // oe-exempt:20261017:framework:collect 批量
  *   discarded）→ 可快照收取；
  * - in-push-pipeline：键 ∈ 某日志条目键集、条目无终局（已过分流点，在 push 管线
  *   排队待注入）→ 不收取不等待；
- * - unregistered-no-entry：键曾注册且已注销、不属任何日志条目键集 → 按 unregister
- *   的 status 定 outcome 进 collected（无载荷快照形态）；
+ * - unregistered-no-entry：键曾注册且已注销、不属任何日志条目键集 → outcome 按
+ *   unregister 的结清视图优先 + legacy status 兜底定值进 collected（无载荷快照
+ *   形态，畸形 data 缺省语义见 CollectedEntry 注释）；
  * - waiting：活跃且无日志条目 → 登记等待，后续 deliver 命中等待集被挂起；
  * - unknown：键未注册且无条目（活跃集 ∪ 投递日志键集 ∪ 曾注册集的补集）→ 不登记
  *   等待集、不虚构终态——工具侧读本态组装 errors（未知判定单点在端口）。
@@ -158,8 +156,8 @@ export interface DeliveryPortHost { // oe-exempt:20261017:framework:pi 能力注
   readSessionEntries(): readonly unknown[];
   /**
    * 主 agent 是否空闲（ctx.isIdle()——含 run 活跃与 compaction 两态）。仅作内核
-   * port.isIdle 供给（内核接口必填成员；on-accept 模式内核 busy gate 旁路，恒不
-   * 消费）。提交侧挂起判定不用本端口——compaction 等待由 compaction 事件标记承载
+   * port.isIdle 供给（内核接口必填成员；内核受理即出站不读忙闲探测，恒不消费）。
+   * 提交侧挂起判定不用本端口——compaction 等待由 compaction 事件标记承载
    * （见 onSessionBeforeCompact），run 活跃必须放行（sendMessage 入 pi steer 队列
    * 不拒），isIdle 的复合语义不能承载该区分。
    */
@@ -186,8 +184,6 @@ export interface DeliveryPortHost { // oe-exempt:20261017:framework:pi 能力注
   onSessionCompact(handler: () => void): () => void;
   /** compaction 失败/中止边沿（标记同样复位 + 唤醒——失败也要重投尝试，失败可见性归日志）。 */
   onSessionCompactFailed(handler: () => void): () => void;
-  /** 攒批条件谓词（有活跃后台任务；账本 mergeHoldActive = hasRunningBackground 同源）。 */
-  hasRunningBackground(): boolean;
   /** 分桶诊断与降级 warn 出口（extensionLogger——落 session JSONL 不进 LLM +
    *  TAIJI_AGENT_DEBUG 落日志盘）。 */
   logger: DeliveryPortLogger;
@@ -196,30 +192,29 @@ export interface DeliveryPortHost { // oe-exempt:20261017:framework:pi 能力注
 // ─── handle（进程级槽暴露面）────────────────────────────────
 
 /**
- * 投递端口句柄（custom 车道唯一执行者的对外形态）。
+ * 投递端口句柄（custom 投递路径唯一执行者的对外形态）。
  * 同 session 必须单例（session_start 重绑 = 旧实例 dispose + 新实例 recover）。
  */
 export interface DeliveryPortHandle { // oe-exempt:20261017:framework:进程级槽交付的端口句柄契约（消费方读槽面）
   /**
-   * 唯一提交入口（§3.4 端点形态）：受理前 appendEntry 落投递日志 → 缓冲（攒批路径）
-   * 或内核 send（直通路径）→ 受理结果同步返回。fire-and-forget 语义：调用方忽略
-   * 返回值不受影响；rejected 条目由调用方裁决重试（幂等键未登记，重提合法）。
+   * 唯一提交入口（§3.4 端点形态）：受理前 appendEntry 落投递日志 → 提交缓冲 →
+   * 边沿即投放行（攒批窗已删 §3.3.7③）→ 受理结果同步返回。fire-and-forget 语义：
+   * 调用方忽略返回值不受影响；rejected 条目由调用方裁决重试（幂等键未登记，重提合法）。
    */
   deliver(envelope: DeliveryEnvelope, opts?: DeliveryDeliverOptions): DeliveryDeliverResult;
   /**
    * session_start 差集重放：扫投递日志 −
-   * （对话记录已送达 ∪ ack）差集 → 重入队 → 立即尝试投递。重放条目若满足攒批
-   * 条件经窗口合并投出（合并形态与直通路径一致）。幂等：可
-   * 重复调用，差集为空零动作。
+   * （对话记录已送达 ∪ ack）差集 → 重入队 → 边沿即投。重放同组多成员经分组放行
+   * 仍产合法批形态（保留边界）。幂等：可重复调用，差集为空零动作。
    *
    * @returns 重放条数。
    */
   recover(): number;
   /** 分桶计数快照（副本）。 */
   metrics(): DeliveryPortMetrics;
-  /** 强制投递尝试（窗口缓冲提前出站 + 内核 flush——外部重触发口）。 */
+  /** 强制投递尝试（缓冲条目出站 + 内核 flush——外部重触发口）。 */
   flush(): void;
-  /** 销毁：清窗口 timer + 内核 dispose + 退订全部事件订阅 + 摘进程级槽绑定。 */
+  /** 销毁：内核 dispose + 退订全部事件订阅 + 摘进程级槽绑定。 */
   dispose(): void;
   /**
    * collect 面（result-collect 设计 §3.1② 端口挂起面，方法语义以该节为准）。
@@ -239,7 +234,7 @@ export interface DeliveryPortHandle { // oe-exempt:20261017:framework:进程级
    * 以等待结束后的最终回填为准（诚实缺省，不虚构终态）。
    */
   consume(): CollectedEntry[];
-  /** 解散等待集；未收挂起条目直通内核 flush（跳过 60s 合批窗口，恢复 push）。 */
+  /** 解散等待集；未收挂起条目直通内核 flush（边沿即投，恢复 push）。 */
   collectRelease(): void;
   /** 挂起条目到达回调订阅（事件驱动唤醒等待器，无轮询）；返回退订函数。 */
   onCollectArrival(cb: () => void): () => void;