@zhushanwen/pi-session-manager 0.4.0 → 0.5.0

package/src/watch-coordinator.ts

@@ -12,7 +12,7 @@
 //   3. trailing debounce 50ms 两层攒批（D3 裁决4）：分拣键 (sessionId, reason) 定处理类别，
 //      批身份 settleSeq/deathSeq 定 record 边界——跨 session 不合批由分组键自然排除；
 //      cancelled/orphaned 不入窗（逐笔即时）；
-//   4. session_start 重启收口腿（D7③）：活跃 type 'session' register 重开 watch
+//   4. session_start 重启收尾路径（D7③）：活跃 type 'session' register 重开 watch
 //      （入参 = entry id 即 notifyId，P4 三键零改动），每 entry 独立 handler 禁串行 await。
 //
 // 合批的 record 幂等键 = 批内首个响应的 notifyId（A6 口径：每 notifyId 至多一条、
@@ -32,7 +32,7 @@ import { getLogger } from "@zhushanwen/pi-extension-logger";
 import { toErrorMessage } from "@zhushanwen/pi-ext-guards";
 
 import { buildManagedNotifyContent, type ManagedNotifyDetails } from "./notify-content.ts";
-import { recordManagedNotify } from "./notify-ledger.ts";
+import { recordManagedNotify } from "./notify-delivery.ts";
 
 const logger = getLogger("session-manager");
 
@@ -77,13 +77,15 @@ export interface WatchCoordinatorDeps {
 }
 
 export interface WatchCoordinator {
-	/** 工具结果成功后的 arm：register + 开表（顺序固定——C-5 微窗方向 = 查询面先少计不产幽灵） */
-	armSessionNotify(ctx: ExtensionContext, notifyId: string, name: string): void;
+	/** 工具结果成功后的 arm：register + 开表（顺序固定——C-5 微窗方向 = 查询结果先少计不产幽灵）。
+	 *  kind:"lifetime" = lifetime 死亡债权注册（result-collect 设计 §3.4，emit 申报
+	 *  kind 标记）；缺省 = send 债权。 */
+	armSessionNotify(ctx: ExtensionContext, notifyId: string, name: string, kind?: "lifetime"): void;
 	/** sessionId → label 缓存回填（create 入参 / list 结果；send 的 name 与文案 label 源） */
 	noteLabel(sessionId: string, label: string): void;
 	/** 读 label 缓存（缺席回退 sessionId——label 降级路径，见交付偏差登记） */
 	labelFor(sessionId: string): string;
-	/** session_start 重启收口腿（D7③）：活跃 type 'session' register 逐条重开 watch */
+	/** session_start 重启收尾路径（D7③）：活跃 type 'session' register 逐条重开 watch */
 	recoverStaleRegisters(ctx: ExtensionContext): void;
 }
 
@@ -94,7 +96,7 @@ export function createWatchCoordinator(deps: WatchCoordinatorDeps): WatchCoordin
 	 *  权威源仍是 pi sessionName（登记表主表 #1），本缓存无回写；写方 = noteLabel 单点
 	 *  回填（create 入参 / list 结果），生命周期随 coordinator 实例（pi 进程级）。 */
 	const labels = new Map<string, string>();
-	/** 死亡新闻槽 (sessionId, deathSeq) 去重集合（ADR-0087 关键被否④的槽键消解机制）：
+	/** 死亡新闻槽 (sessionId, deathSeq) 去重集合（ADR-0087 关键不采用④的槽键消解机制）：
 	 *  技术簿记 W24-EX-C（data-source-registry.md §4⑧），非 GUI 数据——键单调不重放、
 	 *  槽位消费一次即终局，无消费点清理（集合容量 = 进程生命周期内死亡事件数），生命周期
 	 *  随 coordinator 实例（pi 进程级）。 */
@@ -110,9 +112,13 @@ export function createWatchCoordinator(deps: WatchCoordinatorDeps): WatchCoordin
 		return labels.get(sessionId) ?? sessionId;
 	}
 
-	function registerPending(id: string, name: string): void {
+	function registerPending(id: string, name: string, kind?: "lifetime"): void {
 		try {
-			pi.events.emit("pending:register", { id, type: "session", name });
+			// kind 债权类别标记（result-collect 设计 §3.4）：lifetime 死亡债权申报
+			// kind:"lifetime"（collect 缺省等待集据此排除），send 债权不带（无 kind
+			// 缺省 = send）——两类注册 emit 此前同形态 {id, type:'session', name}
+			// （type 不可辨），标记经 pending:register 落盘 entry 透传给工具侧。
+			pi.events.emit("pending:register", { id, type: "session", name, ...(kind ? { kind } : {}) });
 		} catch (err) {
 			// emit 失败（stale bus）不阻断 arm——watch 照开，应答侧 unregister 幂等兜底；
 			// warn 留痕（STANDARDS §11.2 静默丢弃必须登记）
@@ -136,13 +142,18 @@ export function createWatchCoordinator(deps: WatchCoordinatorDeps): WatchCoordin
 		}
 	}
 
-	function armSessionNotify(ctx: ExtensionContext, notifyId: string, name: string): void {
-		registerPending(notifyId, name);
+	function armSessionNotify(
+		ctx: ExtensionContext,
+		notifyId: string,
+		name: string,
+		kind?: "lifetime",
+	): void {
+		registerPending(notifyId, name, kind);
 		openWatch(ctx, notifyId, name);
 	}
 
 	/** 开表：fire-and-forget（D2/P1：不传 timeout 长挂不死；被覆盖的悬 promise 已知无害）。
-	 *  每次调用独立 handler——收口腿禁串行 await 链的实现基础（D7③ 编排纪律）。 */
+	 *  每次调用独立 handler——收尾路径禁串行 await 链的实现基础（D7③ 编排纪律）。 */
 	function openWatch(ctx: ExtensionContext, notifyId: string, label: string): void {
 		void deps.callWatch(ctx, notifyId).then(
 			(result) => {
@@ -167,7 +178,7 @@ export function createWatchCoordinator(deps: WatchCoordinatorDeps): WatchCoordin
 	function handleRespond(notifyId: string, label: string, result: MarkerRpcResult): void {
 		if (!result.ok) {
 			// cancelled/timeout = 应答未达（session 销毁等 select 侧折叠）——不动 pending，
-			// 残留由下次 session_start 收口腿清（D7③ / 附录 C-9 的清理通道）。
+			// 残留由下次 session_start 收尾路径清（D7③ / 附录 C-9 的清理通道）。
 			// non-json/channel-error = 应答已到但不可解析 → 折叠 cancelled 清 stale register。
 			if (result.reason === "non-json" || result.reason === "channel-error") {
 				logger.warn("[session-manager] watch respond unusable — folding cancelled", {
@@ -180,8 +191,8 @@ export function createWatchCoordinator(deps: WatchCoordinatorDeps): WatchCoordin
 		}
 		// 读侧不信任外部格式（AGENTS 关键规则 5），null 与畸形/词表外拆开处置：
 		//   ① null（旧 runtime 象限，respond null → JSON "null"）是 D6 兼容矩阵的显式
-		//      静默豁免——折叠 cancelled 收口、不 warn（非漂移信号，不伪造死亡通知）；
-		//   ② 畸形对象 / 词表外 reason / error envelope {error,...}（runtime params 守卫
+	//      静默豁免——折叠 cancelled 收尾、不 warn（非漂移信号，不伪造死亡通知）；
+	//   ② 畸形对象 / 词表外 reason / error envelope {error,...}（runtime params 检查
 		//      拒绝态）= 协议漂移信号 → 必须 warn 留痕（同上方 non-json/channel-error
 		//      分支形态：notifyId + 漂移形态摘要），再折叠 cancelled 清 stale register。
 		let parsed: unknown;
@@ -210,7 +221,7 @@ export function createWatchCoordinator(deps: WatchCoordinatorDeps): WatchCoordin
 		}
 		const reason = parsed.reason;
 		if (reason === "cancelled" || reason === "orphaned") {
-			// 例外1：静默（主 abort 销账 / 归属失效 / fail-closed / orphan 吸收态）——
+			// 例外1：静默（主 abort 处理完毕 / 归属失效 / fail-closed / orphan 吸收态）——
 			// 逐笔即时 unregister，不入攒批窗、不 record、不动死亡槽。
 			unregisterPending(notifyId, reason);
 			return;
@@ -303,8 +314,20 @@ export function createWatchCoordinator(deps: WatchCoordinatorDeps): WatchCoordin
 			fulfills,
 			label: first.label,
 		};
-		// 默认 record（B-ledger ①）；record false（幂等拒收 / 槽空降级）不改 unregister 语义
-		recordManagedNotify(first.notifyId, content, details);
+		// 默认投递（unified-delivery 波 2：port.deliver）；false（port 缺席 / rejected /
+		// 幂等拒收）不改 unregister 语义。collectKeys = 批内全部债权键（result-collect
+		// 设计 §3.4 managed 行）：合批条目载荷幂等键 = 批首债权键，collect 按键集逐键
+		// 展开定位——键集申报经 recordManagedNotify 必传参数构造性防漏。三类「注销
+		// pending 而无投递日志条目」分支不经此申报点——成员键不入任何条目键集，collect
+		// 侧按第四态收取：死亡槽去重跨批与 sessionId 缺失防御在本函数早退（上方两个
+		// return 分支）；例外1 cancelled/orphaned 在上游 handleRespond 应答分流、不入
+		// 攒批窗不进本函数。
+		recordManagedNotify(
+			first.notifyId,
+			content,
+			details,
+			batch.map((item) => item.notifyId),
+		);
 		for (const item of batch) unregisterPending(item.notifyId, reason);
 	}
 

package/src/__tests__/notify-ledger-discipline.test.ts

@@ -1,260 +0,0 @@
-// notify-ledger-discipline.test.ts — ledger 装配纪律（notify-once D3 ①-⑤ / U4）。
-// 包名 import @zhushanwen/subagent-core（D-10 领地补录后的 canonical 形态，相对路径 hack 已删）。
-// 覆盖：
-//   ① ensureLedgerBound 无条件重 bind（唯一装配方形态，与 subagent-workflow
-//      bindLedgerHostAndRecover 同款——槽上不残留捕获旧 ctx 的 host）；
-//   ② 槽空 → bind + recoverFromSession 成对（recover 吸收 session 文件既有条目——用未销账
-//      ledger entry 种子断言 pendingCount，证明 recover 真跑过）；
-//   ③ 双 bind 收敛——「先 bind 方在后 bind 之后 record 仍返回 true」（动态查槽恒取当前实例；
-//      缓存前实例引用则 record 恒 false 零日志——D3⑤ 事故形态反证）；
-//   ④ compactionCheck 直通当前实例、抛错不外抛（接入点降级，STANDARDS §11.1）；
-//   ⑤ 消费点 record 动态查槽 + deliveryCustomType = managed-session-notify；
-//      record 先 appendEntry 落盘后内存更新（时序钉：append 快照 = 该次 record 前计数）；
-//   sendDelivery stale ctx 守卫：stale 抛错静默降级 + warn 归因（条目标 sentAt 不挂回），
-//      非 stale 错误原样上抛走 settleRejected 留账重试；
-//   槽空降级（ensure 未跑/失败时 record → warn + false，用例登记）。
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-// logger mock helper 必须先于任何会加载 pi-extension-logger 的 import
-//（subagent-core barrel / ../notify-ledger.ts），见 logger-mock.ts 文件头
-import { createLoggerModuleMock, getLoggerMock } from "./helpers/logger-mock.ts";
-import {
-	bindNotifyLedgerHost,
-	getBoundNotifyLedger,
-	type NotifyLedgerHost,
-} from "@zhushanwen/subagent-core";
-import { STALE_CTX_MARKER } from "@zhushanwen/pi-ext-guards";
-
-vi.mock("@zhushanwen/pi-extension-logger", () => createLoggerModuleMock());
-
-const loggerMock = getLoggerMock();
-
-import {
-	ensureLedgerBound,
-	recordManagedNotify,
-	runLedgerCompactionCheck,
-} from "../notify-ledger.ts";
-import type { ManagedNotifyDetails } from "../notify-content.ts";
-
-/** recordManagedNotify 的最小合法 details（ManagedNotifyDetails 收紧后的测试桩形状） */
-function makeDetails(notifyId: string): ManagedNotifyDetails {
-	return { notifyId, sessionId: "s-test", reason: "completed", fulfills: 1, label: "test" };
-}
-
-interface HostProbe {
-	host: NotifyLedgerHost;
-	appendLedgerEntries: Array<{ customType: string; data: Record<string, unknown> }>;
-	/** 每次 append 发生时账本 pendingCount 快照——时序钉：恒等于该次 record 前的计数 */
-	pendingCountsAtAppend: number[];
-	attach(pendingCount: () => number): void;
-}
-
-function makeHost(): HostProbe {
-	const appendLedgerEntries: HostProbe["appendLedgerEntries"] = [];
-	const pendingCountsAtAppend: number[] = [];
-	let pendingCount: (() => number) | undefined;
-	const host: NotifyLedgerHost = {
-		appendLedgerEntry(customType, data) {
-			// 时序钉（D3 ③）：record 先 appendEntry 落盘、后内存更新——此刻本条尚未入账
-			if (pendingCount) pendingCountsAtAppend.push(pendingCount());
-			appendLedgerEntries.push({ customType, data: data as Record<string, unknown> });
-		},
-		readSessionEntries: () => [],
-		isIdle: () => false,
-		onAgentSettled: () => {},
-		sendDelivery: () => {},
-	};
-	return {
-		host,
-		appendLedgerEntries,
-		pendingCountsAtAppend,
-		attach: (fn) => {
-			pendingCount = fn;
-		},
-	};
-}
-
-/** ensureLedgerBound 的最小 pi/ctx 桩（appendEntry/on/sendMessage + getEntries/isIdle） */
-function makePiCtx(
-	entries: unknown[],
-	opts?: { isIdle?: boolean; sendMessage?: () => void },
-) {
-	const pi = {
-		appendEntry: vi.fn((customType: string, data: unknown) => {
-			entries.push({ type: "custom", customType, data });
-		}),
-		on: vi.fn(),
-		sendMessage: vi.fn(opts?.sendMessage ?? (() => {})),
-	};
-	const ctx = {
-		sessionManager: { getEntries: vi.fn(() => entries) },
-		isIdle: () => opts?.isIdle ?? false,
-	};
-	return { pi, ctx };
-}
-
-afterEach(() => {
-	// dispose 摘除模块级绑定（bind 路径实例 current===api → setBoundLedger(undefined)）
-	getBoundNotifyLedger()?.dispose();
-});
-
-describe("ledger 装配纪律（D3 ①-⑤，canonical import）", () => {
-	it("槽空 → recordManagedNotify 降级 false（ensure 未跑/失败时的登记降级，warn 留痕）", () => {
-		expect(getBoundNotifyLedger()).toBeUndefined();
-		expect(recordManagedNotify("sm-x", "content", makeDetails("sm-x"))).toBe(false);
-	});
-
-	it("⑤ bind 后 record 经动态查槽入账、deliveryCustomType = managed-session-notify；时序钉：append 先于内存更新", () => {
-		const probe = makeHost();
-		const ledger = bindNotifyLedgerHost(probe.host);
-		probe.attach(() => ledger.pendingCount());
-		expect(getBoundNotifyLedger()).toBe(ledger);
-		expect(recordManagedNotify("sm-a", "hello", makeDetails("sm-a"))).toBe(true);
-		expect(probe.appendLedgerEntries).toHaveLength(1);
-		expect(probe.appendLedgerEntries[0].customType).toBe("subagent-bg-notify-ledger");
-		expect(probe.appendLedgerEntries[0].data.deliveryCustomType).toBe("managed-session-notify");
-		expect(probe.appendLedgerEntries[0].data.content).toBe("hello");
-		expect(probe.pendingCountsAtAppend).toEqual([0]);
-		expect(ledger.pendingCount()).toBe(1);
-	});
-
-	it("③ 先 bind 方在后 bind 之后 record 仍返回 true（后 bind 者收敛单实例；缓存前实例引用则恒 false——D3⑤ 反证）", () => {
-		const probeA = makeHost();
-		const ledgerA = bindNotifyLedgerHost(probeA.host);
-		probeA.attach(() => ledgerA.pendingCount());
-		expect(recordManagedNotify("sm-1", "n1", makeDetails("sm-1"))).toBe(true);
-		expect(probeA.appendLedgerEntries).toHaveLength(1);
-
-		// 后 bind 方（模拟 subagent-workflow session_start 的 re-bind + recover 成对——
-		// bindNotifyLedgerHost 内部先 dispose 旧实例再 set，收敛为单实例全量态）
-		const probeB = makeHost();
-		const ledgerB = bindNotifyLedgerHost(probeB.host);
-		probeB.attach(() => ledgerB.pendingCount());
-
-		// 消费点动态查槽恒取当前实例：先 bind 方的后续 record 落后 bind 实例且返回 true
-		expect(getBoundNotifyLedger()).toBe(ledgerB);
-		expect(recordManagedNotify("sm-2", "n2", makeDetails("sm-2"))).toBe(true);
-		expect(probeB.appendLedgerEntries.map((e) => e.data.notifyId)).toEqual(["sm-2"]);
-		expect(probeA.appendLedgerEntries).toHaveLength(1); // 前实例不再收账
-		// 时序钉跨 bind 仍成立：sm-2 时 B 账面 0（append 快照 = 该次 record 前计数）
-		expect(probeB.pendingCountsAtAppend).toEqual([0]);
-
-		// 反证：若消费点缓存了前实例引用，record 恒 false 且零日志（对半概率丢全部通知的事故形态）
-		expect(ledgerA.record("sm-3", "n3", {})).toBe(false);
-		// 而动态查槽（本包消费面）依旧 true
-		expect(recordManagedNotify("sm-4", "n4", makeDetails("sm-4"))).toBe(true);
-		expect(probeB.appendLedgerEntries).toHaveLength(2);
-		expect(probeB.pendingCountsAtAppend).toEqual([0, 1]);
-	});
-
-	it("② 槽空 + ensureLedgerBound → bind + recoverFromSession 成对（既有未销账 ledger entry 被 recover 吸收）", () => {
-		const entries: unknown[] = [
-			{
-				type: "custom",
-				customType: "subagent-bg-notify-ledger",
-				data: {
-					v: 1,
-					notifyId: "sm-recovered",
-					content: "prior notification",
-					record: { notifyId: "sm-recovered" },
-				},
-			},
-		];
-		const { pi, ctx } = makePiCtx(entries);
-		expect(getBoundNotifyLedger()).toBeUndefined();
-
-		ensureLedgerBound(pi as never, ctx as never);
-		const ledger = getBoundNotifyLedger();
-		expect(ledger).toBeDefined();
-		// recover 真跑过：session 文件的未销账条目被吸收进内存态
-		expect(ctx.sessionManager.getEntries).toHaveBeenCalled();
-		expect(ledger!.pendingCount()).toBe(1);
-		// 装配后消费面就绪
-		expect(recordManagedNotify("sm-new", "n", makeDetails("sm-new"))).toBe(true);
-		expect(pi.appendEntry).toHaveBeenCalledWith(
-			"subagent-bg-notify-ledger",
-			expect.objectContaining({ notifyId: "sm-new", deliveryCustomType: "managed-session-notify" }),
-		);
-	});
-
-	it("① 槽已有实例 + ensureLedgerBound → 无条件重 bind（后 bind 收敛接管 + recover 重跑）", () => {
-		const probe = makeHost();
-		const ledger = bindNotifyLedgerHost(probe.host);
-		probe.attach(() => ledger.pendingCount());
-
-		const { pi, ctx } = makePiCtx([]);
-		ensureLedgerBound(pi as never, ctx as never);
-		// 后 bind 收敛：旧实例被 dispose，槽切到新实例（槽上不残留捕获旧 ctx 的 host）
-		const rebound = getBoundNotifyLedger();
-		expect(rebound).toBeDefined();
-		expect(rebound).not.toBe(ledger);
-		// recover 重跑：新 host 的 readSessionEntries 被消费
-		expect(ctx.sessionManager.getEntries).toHaveBeenCalled();
-		// 消费面动态查槽：record 落新实例（经新 host 的 appendLedgerEntry = pi.appendEntry）
-		expect(recordManagedNotify("sm-1", "n", makeDetails("sm-1"))).toBe(true);
-		expect(pi.appendEntry).toHaveBeenCalled();
-
-		// 重复调用同款：每次 session_start 都重装配（不查槽短路）
-		ensureLedgerBound(pi as never, ctx as never);
-		expect(getBoundNotifyLedger()).not.toBe(rebound);
-	});
-
-	it("sendDelivery stale ctx 守卫：stale 抛错静默降级 + warn 归因（条目标 sentAt，不外抛不挂回）", () => {
-		const { pi, ctx } = makePiCtx([], {
-			isIdle: true,
-			sendMessage: () => {
-				throw new Error(`ctx ${STALE_CTX_MARKER}`);
-			},
-		});
-		ensureLedgerBound(pi as never, ctx as never);
-		const ledger = getBoundNotifyLedger();
-		expect(ledger).toBeDefined();
-		expect(recordManagedNotify("sm-stale", "n", makeDetails("sm-stale"))).toBe(true);
-		expect(() => ledger!.attemptDeliver()).not.toThrow();
-		// stale 降级语义：本条不投递且按已受理标 sentAt（attemptDeliver 摘除，不挂回反复撞）
-		expect(ledger!.pendingCount()).toBe(0);
-		expect(loggerMock.warn).toHaveBeenCalledWith(
-			"[session-manager] notify delivery skipped (stale ctx)",
-			expect.objectContaining({ error: expect.stringContaining("stale") }),
-		);
-	});
-
-	it("sendDelivery 非 stale 错误原样上抛 → settleRejected 留账重试（pending 不摘、无 stale 归因）", () => {
-		// 清上一用例的 warn 记录——断言只认本用例内的调用
-		loggerMock.warn.mockClear();
-		const { pi, ctx } = makePiCtx([], {
-			isIdle: true,
-			sendMessage: () => {
-				throw new Error("boom");
-			},
-		});
-		ensureLedgerBound(pi as never, ctx as never);
-		const ledger = getBoundNotifyLedger();
-		expect(ledger).toBeDefined();
-		expect(recordManagedNotify("sm-err", "n", makeDetails("sm-err"))).toBe(true);
-		expect(() => ledger!.attemptDeliver()).not.toThrow();
-		// 非 stale 走 attemptDeliver 既有 catch：settleRejected 留账等下一边沿重试
-		expect(ledger!.pendingCount()).toBe(1);
-		expect(loggerMock.warn).not.toHaveBeenCalledWith(
-			"[session-manager] notify delivery skipped (stale ctx)",
-			expect.anything(),
-		);
-	});
-
-	it("④ compactionCheck 经动态查槽直通当前实例", () => {
-		const probe = makeHost();
-		const ledger = bindNotifyLedgerHost(probe.host);
-		probe.attach(() => ledger.pendingCount());
-		const spy = vi.spyOn(getBoundNotifyLedger()!, "compactionCheck").mockReturnValue(0);
-		runLedgerCompactionCheck();
-		expect(spy).toHaveBeenCalledTimes(1);
-	});
-
-	it("④ compactionCheck 抛错 → warn 吞掉不外抛（辅助面接入点降级，STANDARDS §11.1）", () => {
-		bindNotifyLedgerHost(makeHost().host);
-		vi.spyOn(getBoundNotifyLedger()!, "compactionCheck").mockImplementation(() => {
-			throw new Error("boom");
-		});
-		expect(() => runLedgerCompactionCheck()).not.toThrow();
-	});
-});

package/src/notify-ledger.ts

@@ -1,121 +0,0 @@
-// src/notify-ledger.ts — notify-ledger（B-ledger）装配与 record 消费（notify-once D3 装配纪律）。
-//
-// canonical 消费面（D-10 领地补录后落地）：@zhushanwen/subagent-core 的
-// getBoundNotifyLedger / bindNotifyLedgerHost——Symbol.for 进程级单例槽跨扩展 bundle
-// 共享同一 ledger 实体（C-ext-06），本包不再持有任何槽镜像。
-//
-// 装配纪律（D3）对照（session_start 无条件重装配方，与 subagent-workflow
-// bindLedgerHostAndRecover 同款；旧「查槽短路」形态已废）：
-//   ① session_start 无条件 bindNotifyLedgerHost(host).recoverFromSession() 成对——host
-//      捕获当次 session 的 pi/ctx，不查槽短路（与 subagent-core 每次 session_start 重
-//      bind 的设计假设对齐：槽上永不残留捕获旧 ctx 的 host）；
-//   ② recover 吸收 session 文件全部既有条目（G3 重启重放即 recoverFromSession 语义）；
-//   ③ 双 bind 收敛：后 bind 者 dispose 前实例 + recover → 单实例全量态，前者的已落盘
-//      条目无损（record 先 appendEntry 落盘后内存更新——notify-ledger-discipline 用例钉住）。
-//      收敛由 subagent-core bindNotifyLedgerHost 的 dispose 旧实例语义保证，装配方无需
-//      自查槽（subagent-core 侧 bind 用模块级单例 handler + boundLedger 引用切换，
-//      重 bind 不累积物理监听）；
-//   ④ compactionCheck 同批接线（session_compact handler，P-B4 降级——
-//      subagent-workflow 同款先例；两侧对同一槽实例重复调用为幂等 no-op）；
-//   ⑤ 消费点恒经 getBoundNotifyLedger() 动态查槽，禁缓存实例引用——后 bind 方 dispose
-//      旧实例后缓存引用的 record() 静默 return false 零日志，对半概率丢全部通知。
-//
-// 唯一装配方形态（拓扑假设）：taiji runtime 每 session 重 spawn pi 进程，进程内无
-// session 替换——session_start 触发时本包是该 session ledger 的唯一装配方（与
-// subagent-workflow 共存时按 ③ 收敛）。stale ctx 面因此收窄，sendDelivery 的
-// guardStaleCtx 为防御性兜底（异常形态留痕归因，非正常路径承重）。
-//
-// 槽空降级（record 时点仍无实例：session_start 未跑 / bind 失败）：warn 留痕 + false
-//（STANDARDS §11.1 通知类接入点降级，非静默吞）。
-
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { bindNotifyLedgerHost, getBoundNotifyLedger } from "@zhushanwen/subagent-core";
-import { getLogger } from "@zhushanwen/pi-extension-logger";
-import { createPiNotifyLedgerHost } from "@zhushanwen/pi-notify-ledger-host";
-import { toErrorMessage } from "@zhushanwen/pi-ext-guards";
-
-import {
-	MANAGED_SESSION_NOTIFY_CUSTOM_TYPE,
-	type ManagedNotifyDetails,
-} from "./notify-content.ts";
-
-const logger = getLogger("session-manager");
-
-/**
- * 装配纪律 ①②（session_start 调用）：无条件 bind + recover 成对。
- * host 五端口的 pi 接线（appendEntry / getEntries / isIdle / agent_settled /
- * sendMessage + 送达 stale 防御）收敛在共享工厂 @zhushanwen/pi-notify-ledger-host
- * ——与 subagent-workflow 同一工厂（同一槽的两处装配方，host 接口一致才能互换
- * 消费），本包以 component/logger/warn 前缀参数化（label = session-manager:*、
- * stale warn 文案带 "[session-manager] " 前缀，归因不串包）。
- * 装配失败不阻断 session_start（record 侧走槽空降级）。
- */
-export function ensureLedgerBound(pi: ExtensionAPI, ctx: ExtensionContext): void {
-	try {
-		// ①② bind + recover 成对（G3 重启重放 = recoverFromSession 既有语义；
-		// 双 bind 收敛 = subagent-core dispose 旧实例语义，见文件头 ③）
-		bindNotifyLedgerHost(
-			createPiNotifyLedgerHost(pi, ctx, {
-				component: "session-manager",
-				logger,
-				staleWarnPrefix: "[session-manager] ",
-			}),
-		).recoverFromSession();
-	} catch (err) {
-		logger.warn("[session-manager] notify ledger bind failed (record degrades until next session_start)", {
-			error: toErrorMessage(err),
-		});
-	}
-}
-
-/**
- * 记账一条通知（B-ledger ① record，deliveryCustomType 走 managed-session-notify 外部通道，
- * 逐条投递不合批——合批已在 watch-coordinator 微窗内重建批身份，D3 裁决4）。
- * 装配纪律⑤：每次调用即到即读查槽，禁存实例引用；槽空 → warn 降级 + false。
- */
-export function recordManagedNotify(
-	notifyId: string,
-	content: string,
-	details: ManagedNotifyDetails,
-): boolean {
-	const ledger = getBoundNotifyLedger();
-	if (!ledger) {
-		logger.warn(
-			"[session-manager] notify ledger not bound — notification dropped (ensureLedgerBound 未跑或 bind 失败；下次 session_start 重试装配)",
-			{ notifyId },
-		);
-		return false;
-	}
-	try {
-		return ledger.record(notifyId, content, details, {
-			deliveryCustomType: MANAGED_SESSION_NOTIFY_CUSTOM_TYPE,
-		});
-	} catch (err) {
-		// 写入异常（stale ctx / appendEntry 失败）按接入点降级：不拖垮 watch 应答编排
-		//（unregister 照常），warn 留痕可归因
-		logger.warn("[session-manager] notify ledger record failed", {
-			notifyId,
-			error: toErrorMessage(err),
-		});
-		return false;
-	}
-}
-
-/**
- * compactionCheck 接线（装配纪律④，P-B4 降级——subagent-workflow session_compact 同款）：
- * 检测 ledger/ack entry 被 compaction 清除时按内存态补写（未清除即 0，幂等 no-op）。
- */
-export function runLedgerCompactionCheck(): void {
-	try {
-		const rewritten = getBoundNotifyLedger()?.compactionCheck() ?? 0;
-		if (rewritten > 0) {
-			logger.warn(
-				`[session-manager] notify ledger entries lost to compaction; rewrote ${rewritten} from memory`,
-			);
-		}
-	} catch (err) {
-		logger.warn("[session-manager] notify ledger compactionCheck failed", {
-			error: toErrorMessage(err),
-		});
-	}
-}