@zhushanwen/pi-pending-notifications 0.5.2 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-pending-notifications",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Cross-extension async operation registration/query mechanism for Pi.",
   "type": "module",
   "main": "src/index.ts",
@@ -33,7 +33,7 @@
     "typebox": "*"
   },
   "dependencies": {
-    "@zhushanwen/pi-extension-logger": "0.4.0"
+    "@zhushanwen/pi-extension-logger": "0.4.1"
   },
   "scripts": {
     "typecheck": "npx tsc --noEmit",

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

@@ -205,24 +205,31 @@ describe("state pure functions", () => {
 			expect(comp.expiredToFlush).toEqual([]);
 		});
 
-		it("U3: register expired → flush unregister with status=expired", () => {
+		it("[W4 翻档] U3 机器对现存类型不可达：workflow（process 档）超 TTL → 仍 active、无 flush", () => {
+			// 翻档后三类型全 process 档：expiresAt 判定短路（isExpiredEntry 恒 false）。
+			// 旧行为（session 档 1h TTL 过期 → flush expired unregister）已被移除——
+			// 长任务注册不再被 TTL 静默清除（事故环 4 放大器），收口归注销发射点枚举 +
+			// core 注册对账 sweep。
 			const comp = rebuild(
 				[makeRegisterEntry("w-1", { expiresAt: NOW - 1 })],
 				"sess-current",
 				NOW,
 			);
-			expect(comp.activeIds).toEqual([]);
-			expect(comp.expiredToFlush).toEqual([{ id: "w-1", status: "expired" }]);
+			expect(comp.activeIds).toEqual(["w-1"]);
+			expect(comp.expiredToFlush).toEqual([]);
 		});
 
-		it("U4: register with different sessionId → flush unregister with status=expired", () => {
+		it("[W4 读侧过滤③] U4 跨 session 残留 → 不入 registry、不补注销（读侧过滤替代 U4 中性化）", () => {
+			// 翻档后 fork 继承的父级注册残留由 rebuild 读侧过滤兜住（≠ 当前 session →
+			// 跳过），残留 entry 留在 session 文件（差集消费方各自过滤），落盘收口归
+			// core 注册对账 sweep——不再补 expired unregister。
 			const comp = rebuild(
 				[makeRegisterEntry("w-1", { sessionId: "sess-other" })],
 				"sess-current",
 				NOW,
 			);
 			expect(comp.activeIds).toEqual([]);
-			expect(comp.expiredToFlush).toEqual([{ id: "w-1", status: "expired" }]);
+			expect(comp.expiredToFlush).toEqual([]);
 		});
 
 		it("entries 含 null/undefined 元素 → 跳过不抛 TypeError（S-10）", () => {
@@ -238,7 +245,7 @@ describe("state pure functions", () => {
 	});
 
 	describe("normalizeRegisterEntry defaults (via rebuild)", () => {
-		it("entry with only {id} → type=workflow, name=id, sessionId=current, expiresAt=registeredAt+TTL", () => {
+		it("[W4 翻档] entry with only {id} → type=workflow（process 档）, name=id, sessionId=current, expiresAt=undefined", () => {
 			const r = createRegistry();
 			const result = rebuildFromEntries(
 				r,
@@ -252,7 +259,9 @@ describe("state pure functions", () => {
 			expect(entry.name).toBe("w-min");
 			expect(entry.sessionId).toBe("sess-current");
 			expect(entry.status).toBe("active");
-			expect(entry.expiresAt).toBe(entry.registeredAt + 3_600_000);
+			// 翻档后 workflow = process 档：无 TTL（normalizePendingType 默认归 workflow
+			// 的偏好 = 缺失/未知 type 宁挂账不失明，清理通道 = core 对账 sweep）。
+			expect(entry.expiresAt).toBeUndefined();
 		});
 	});
 });
@@ -290,22 +299,22 @@ describe("pendingNotificationsExtension factory", () => {
 			expect(await getCount(setup)).toBe(0);
 		});
 
-		it("U3: expired register → flush pending:unregister entry", async () => {
+		it("[W4 翻档] expired register（process 档）→ 仍 active、不补 unregister entry", async () => {
 			vi.setSystemTime(NOW + 3_700_000);
 			fireSessionStart(setup, createMockCtx([makeRegisterEntry("w-1", { expiresAt: NOW })]));
-			expect(await getCount(setup)).toBe(0);
-			expect(setup.appendEntryMock).toHaveBeenCalledWith(
+			expect(await getCount(setup)).toBe(1);
+			expect(setup.appendEntryMock).not.toHaveBeenCalledWith(
 				"pending:unregister",
-				expect.objectContaining({ id: "w-1", status: "expired" }),
+				expect.objectContaining({ id: "w-1" }),
 			);
 		});
 
-		it("U4: different sessionId → flush pending:unregister entry", async () => {
+		it("[W4 读侧过滤③] different sessionId → 不入 registry（active=0）、不补 unregister entry", async () => {
 			fireSessionStart(setup, createMockCtx([makeRegisterEntry("w-1", { sessionId: "sess-old" })], "sess-current"));
 			expect(await getCount(setup)).toBe(0);
-			expect(setup.appendEntryMock).toHaveBeenCalledWith(
+			expect(setup.appendEntryMock).not.toHaveBeenCalledWith(
 				"pending:unregister",
-				expect.objectContaining({ id: "w-1", status: "expired" }),
+				expect.objectContaining({ id: "w-1" }),
 			);
 		});
 	});
@@ -383,7 +392,10 @@ describe("pendingNotificationsExtension factory", () => {
 	});
 
 	describe("session_shutdown (U11)", () => {
-		it("U11: marks all active as cancelled + flushes unregister entries", () => {
+		it("[W4 翻档] U11 对全部现存类型（process 档）不再发生：shutdown 不标 cancelled、不补 unregister", async () => {
+			// process 档语义跨 shutdown 存活：任务收尾归任务自身/reaper/监督器，不由
+			// session 退出裁定（设计 D4 连带面 3 显式接受）；清理痕迹由 core 注册对账
+			// sweep 兜底。U11 机器留存待未来 session 档类型，勿误认清理仍在工作。
 			fireSessionStart(setup, createMockCtx([]));
 			setup.handlers.pendingRegister!({ id: "w-1", type: "workflow", name: "a" });
 			setup.handlers.pendingRegister!({ id: "s-1", type: "subagent", name: "b" });
@@ -393,12 +405,8 @@ describe("pendingNotificationsExtension factory", () => {
 			void setup.handlers.sessionShutdown({ type: "session_shutdown" }, createMockCtx([]));
 
 			const unregisterCalls = setup.appendEntryMock.mock.calls.filter((c) => c[0] === "pending:unregister");
-			expect(unregisterCalls).toHaveLength(2);
-			const flushedIds = unregisterCalls.map((c) => (c[1] as { id: string }).id).sort();
-			expect(flushedIds).toEqual(["s-1", "w-1"]);
-			for (const c of unregisterCalls) {
-				expect((c[1] as { status: string }).status).toBe("cancelled");
-			}
+			expect(unregisterCalls).toHaveLength(0);
+			expect(await getCount(setup)).toBe(2);
 		});
 	});
 
@@ -512,13 +520,32 @@ describe("countActiveFromEntries（纯差集，供 goal / subagent-workflow 复
 		expect(countActiveFromEntries([bad, good]).ids).toEqual(["bg-1"]);
 	});
 
-	it("跨 session 残留（fork 继承的 register）不校验 sessionId——由 session_start 重建流程补 expired unregister 抵消", () => {
+	it("跨 session 残留（fork 继承的 register）缺省不校验 sessionId——传入 currentSessionId 时按 [W4 读侧过滤①] 跳过", () => {
+		// 差集口向后兼容：不传 currentSessionId = 不过滤（既有调用方零改动）。
 		// 模拟 P fork 主 session：继承来主 session 的 register（sessionId=s-0），已被 rebuild 补 unregister(expired)
 		const inherited = mkRegister("parent-bg", "subagent", { sessionId: "s-0" });
 		const flushed = mkUnregister("parent-bg", "expired");
 		const own = mkRegister("my-bg");
 		expect(countActiveFromEntries([inherited, flushed, own]).ids).toEqual(["my-bg"]);
 	});
+
+	it("[W4 读侧过滤①] currentSessionId 过滤：跨 session entry 跳过、本 session 计入", () => {
+		const inherited = mkRegister("parent-bg", "subagent", { sessionId: "s-0" });
+		const own = mkRegister("my-bg", "subagent", { sessionId: "s-1" });
+		const bashOwn = mkRegister("bt-1", "bash", { sessionId: "s-1" });
+		expect(
+			countActiveFromEntries([inherited, own, bashOwn], { currentSessionId: "s-1" }).ids,
+		).toEqual(["my-bg", "bt-1"]);
+		// 同一输入不传基准 → 全量计入（向后兼容面不变）
+		expect(countActiveFromEntries([inherited, own, bashOwn]).count).toBe(3);
+	});
+
+	it("[W4 读侧过滤①] entry 缺 sessionId 的旧形态条目视为本 session（不过滤，宁放行不误杀）", () => {
+		const legacy = { type: "custom", customType: "pending:register", data: { id: "old-1", type: "subagent", name: "o" } };
+		expect(
+			countActiveFromEntries([legacy], { currentSessionId: "s-1" }).ids,
+		).toEqual(["old-1"]);
+	});
 });
 
 // ────────────────────────────────────────────────────
@@ -541,10 +568,10 @@ function makeBashRegisterEntry(id: string, overrides: Record<string, unknown> =
 }
 
 describe("D16 lifecycle 分档：常量与 type 归一化", () => {
-	it("PENDING_LIFECYCLE：subagent/workflow=session，bash=process", () => {
+	it("[W4 翻档] PENDING_LIFECYCLE：subagent/workflow/bash 全 process 档（session 档机器留存待未来类型）", () => {
 		expect(PENDING_LIFECYCLE).toEqual({
-			subagent: "session",
-			workflow: "session",
+			subagent: "process",
+			workflow: "process",
 			bash: "process",
 		});
 	});
@@ -575,25 +602,29 @@ describe("D16 process 档（type=bash）纯函数行为", () => {
 		expect(comp.expiredToFlush).toEqual([]);
 	});
 
-	it("U4 跨 session 不标 expired：bash entry sessionId 不符当前 session → 仍 active（进程级生命周期跨 session 续存）", () => {
+	it("[W4 读侧过滤③] U4 跨 session 残留（含 bash）→ 不入 registry（读侧过滤一刀对全部类型生效）", () => {
+		// 读侧过滤③不分类型：跨 session 残留在 rebuild 入口即被跳过（W6 的 bash 跨
+		// session 可见性断言钉成的显式选择——子 session goal 不再为父 session bash
+		// 任务 defer）。残留 entry 的落盘收口归 core 注册对账 sweep。
 		const comp = rebuild(
 			[makeBashRegisterEntry("bt-1", { sessionId: "sess-other" })],
 			"sess-current",
 			NOW,
 		);
-		expect(comp.activeIds).toEqual(["bt-1"]);
+		expect(comp.activeIds).toEqual([]);
 		expect(comp.expiredToFlush).toEqual([]);
 	});
 
-	it("session 档对照回归：同形状（无 expiresAt 键）的 workflow entry → 回填 TTL 且过期照旧判 expired", () => {
-		// 保证分档判定没有把 session 档的 TTL 路径一并豁免
+	it("[W4 翻档] 同形状（无 expiresAt 键）的 workflow entry → 不回填 TTL、照常 active（process 档）", () => {
+		// 翻档后 workflow = process 档：读取侧不回填 TTL（normalizeRegisterEntry 对
+		// process 档恒 undefined），注册不再被 1h TTL 静默清除（守卫不失明）。
 		const legacy = {
 			customType: "pending:register",
 			data: { id: "w-1", type: "workflow", name: "w", registeredAt: NOW - 3_700_000, sessionId: "sess-current" },
 		};
 		const comp = rebuild([legacy], "sess-current", NOW);
-		expect(comp.activeIds).toEqual([]);
-		expect(comp.expiredToFlush).toEqual([{ id: "w-1", status: "expired" }]);
+		expect(comp.activeIds).toEqual(["w-1"]);
+		expect(comp.expiredToFlush).toEqual([]);
 	});
 
 	it("差集路径识别 bash entry：register 计入且 type 保留，unregister 抵消", () => {
@@ -646,14 +677,14 @@ describe("D16 process 档（type=bash）工厂行为", () => {
 		expect("expiresAt" in data).toBe(false);
 	});
 
-	it("session 档对照回归：workflow register → 落盘 data.expiresAt = NOW + TTL", async () => {
+	it("[W4 翻档] workflow register → 落盘 data 无 expiresAt 键（process 档写入侧豁免）", async () => {
 		fireSessionStart(setup, createMockCtx([]));
 
 		setup.handlers.pendingRegister!({ id: "w-1", type: "workflow", name: "run" });
 
 		const regCall = setup.appendEntryMock.mock.calls.find((c) => c[0] === "pending:register");
 		const data = regCall![1] as Record<string, unknown>;
-		expect(data.expiresAt).toBe(NOW + 3_600_000);
+		expect("expiresAt" in data).toBe(false);
 	});
 
 	it("U3 工厂级：bash entry 超 1h 后 session_start rebuild → 仍 active、不补 unregister", async () => {
@@ -666,10 +697,9 @@ describe("D16 process 档（type=bash）工厂行为", () => {
 		expect(flushCalls).toHaveLength(0);
 	});
 
-	it("session_shutdown：bash 不标 cancelled、不补 unregister entry、内存仍 active", async () => {
+	it("[W4 翻档] session_shutdown：bash 与 workflow（全 process 档）都不标 cancelled、内存仍 active", async () => {
 		fireSessionStart(setup, createMockCtx([]));
 		setup.handlers.pendingRegister!({ id: "bt-1", type: "bash", name: "run tests" });
-		// 同时注册一个 session 档条目，对照证明分档只豁免 process 档
 		setup.handlers.pendingRegister!({ id: "w-1", type: "workflow", name: "run" });
 		setup.appendEntryMock.mockClear();
 
@@ -677,8 +707,24 @@ describe("D16 process 档（type=bash）工厂行为", () => {
 		void setup.handlers.sessionShutdown({ type: "session_shutdown" }, createMockCtx([]));
 
 		const unregisterCalls = setup.appendEntryMock.mock.calls.filter((c) => c[0] === "pending:unregister");
-		expect(unregisterCalls).toHaveLength(1);
-		expect((unregisterCalls[0][1] as { id: string }).id).toBe("w-1");
+		expect(unregisterCalls).toHaveLength(0);
+		expect(await getCount(setup)).toBe(2);
+	});
+
+	it("[W4 读侧过滤③ 投影] fork 继承残留不入 registry：session 替换后 pending_notifications 工具不虚报跨 session 活跃", async () => {
+		// A9② 场景：父 session（sess-parent）注册 bg-parent → fork 出子 session
+		//（sess-child，继承父 entries）→ 子 session_start rebuild 按 sessionId 过滤
+		// 残留 → 工具 count/list 只见子 session 自己的注册。
+		const parentEntries = [
+			{ customType: "pending:register", data: { id: "bg-parent", type: "subagent", name: "p", registeredAt: NOW, sessionId: "sess-parent" } },
+		];
+		fireSessionStart(setup, createMockCtx(parentEntries, "sess-child"));
+		// 子 session 自己的新注册（listener 写入，sessionId=sess-child）
+		setup.handlers.pendingRegister!({ id: "bg-own", type: "subagent", name: "own" });
+
 		expect(await getCount(setup)).toBe(1);
+		const res = await runTool(setup, { action: "list" });
+		const ids = (res.details as { items: PendingEntry[] }).items.map((i) => i.id);
+		expect(ids).toEqual(["bg-own"]);
 	});
 });

package/src/index.ts

@@ -236,6 +236,13 @@ export default function pendingNotificationsExtension(pi: ExtensionAPI): void {
 	});
 
 	// ── session_shutdown：所有 active → cancelled + 补 entry（U11） ──
+	// [W4 翻档登记] U11（shutdown 标 cancelled）随翻档对全部现存类型（process 档）
+	// 不再发生——process 档语义本就跨 shutdown 存活，任务收尾归任务自身/reaper/
+	// 监督器，不由 session 退出裁定；清理痕迹由 core 注册对账 sweep 兜底（覆盖
+	// subagent/workflow；bash 无 record/store 可查，死亡窗口丢失无补发通道——显式
+	// 边界，impl-plan §5 偏差登记）。已按设计
+	// 接受（设计 D4 连带面 3），非缺陷。本 handler 与 U3/U4 机器同为 session 档
+	// 留存件，待未来 session 档类型。
 	pi.on("session_shutdown", (_event, _ctx: ExtensionContext) => {
 		const active = getActive(registry);
 		for (const op of active) {
@@ -261,7 +268,15 @@ export default function pendingNotificationsExtension(pi: ExtensionAPI): void {
 			"查询当前活跃的异步操作（workflow/subagent/bash 后台任务）。action=count 返回数量；action=list 返回列表。状态由 EventBus + session entries 维护，无需手动注册。",
 		parameters: PendingNotificationsParams,
 		execute: async (_toolCallId: string, params: { action: "count" | "list" }, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: ExtensionContext): Promise<{ content: { type: "text"; text: string }[]; details: PendingToolDetails }> => {
-			const active = getActive(registry);
+			// [W4 读侧过滤③ 工具读侧半口] 防御性按当前 session 过滤（rebuild 入口已按
+			// sessionId 过滤，此处是第二道）：listener 注册路径写入的 entry sessionId =
+			// 注册时的 currentSessionId，session 替换（/new /fork 重建闭包）前残留的
+			// 旧 session entry 若经任何路径进入 registry，投影面会虚报跨 session 活跃。
+			// currentSessionId 为空串（session_start 未到）时不过滤（同 rebuild 的
+			// 旧形态容错方向：宁放行不误逐）。
+			const active = getActive(registry).filter(
+				(op) => currentSessionId === "" || op.sessionId === currentSessionId,
+			);
 
 			debugLog("debug", `tool ${params.action} requested`, { action: params.action, activeCount: active.length });
 

package/src/state.ts

@@ -24,10 +24,22 @@ export type PendingType = "workflow" | "subagent" | "bash";
  *   shutdown 标 cancelled 全套生效。
  * - "process"：随进程存活——无 TTL（不计算/不回填 expiresAt）、跨 session 续存
  *   （fork/switch 后任务仍在跑）、shutdown 不标 cancelled（收尾归任务自身/reaper）。
+ *
+ * [W4 翻档 · 设计 chat-domain-v1x-liveness-governance D4 分档对齐] subagent/workflow
+ * 从 session 档翻 process 档：后台子代理与 workflow run 的真实生命周期跨 session 存活、
+ * 可跑超 1h——session 档的 1h TTL（U3）与跨 session 补注销（U4）会把长任务/重启后的
+ * 注册静默清除，goal 守卫随之失明（2026-09-08 事故环 4 的放大器）。翻档后守卫依赖的
+ * 收口链 = 注销合法发射点枚举（5 处，含 core 注册对账 sweep）+ idle-gc startedAt 锚
+ * 兜底归档（只归档不补注销，注销统一交 sweep）。
+ *
+ * [W4 session 档机器死代码处置] 翻档后三类型全 process 档——PENDING_TTL_MS / U3 / U4 /
+ * U11 全体暂无消费类型。机制本体保留（registry 通用能力，session 档暂无消费类型，
+ * 留存待未来类型），**勿误认清理仍在工作**：本文件不再有任何类型的 TTL 清理或跨
+ * session 注销在运行。
  */
 export const PENDING_LIFECYCLE: Record<PendingType, "session" | "process"> = {
-	subagent: "session",
-	workflow: "session",
+	subagent: "process",
+	workflow: "process",
 	bash: "process",
 };
 
@@ -74,7 +86,13 @@ interface EntryLike {
 	data?: unknown;
 }
 
-/** pending:register entry 的 TTL（1 小时） */
+/**
+ * pending:register entry 的 TTL（1 小时）。
+ *
+ * [W4 死代码登记] 翻档后三类型全 process 档，本常量仅剩 session 档机器的兼容读侧
+ * 回填路径（normalizeRegisterEntry 对 session 档缺失 expiresAt 的旧 entry 回填）——
+ * 现无任何类型声明 session 档，回填分支不可达。留存待未来 session 档类型，勿删。
+ */
 export const PENDING_TTL_MS = 3_600_000;
 
 /** 注册表：内存中的活跃操作（session 隔离，由 index.ts 在闭包内持有） */
@@ -122,6 +140,16 @@ export function getActive(registry: PendingRegistry): PendingEntry[] {
 export interface CountActiveOptions {
 	/** 只统计指定类型的活跃 pending；缺省 = 全部类型（subagent + workflow + bash） */
 	types?: PendingType[];
+	/**
+	 * [W4 读侧过滤①] 当前 session id（跨 session 残留过滤基准）：传入时按
+	 * 「register entry 的 sessionId ≠ 当前 session → 跳过」过滤——fork 继承的
+	 * 父级注册残留（翻 process 档后不再被 U4 补注销中性化，永久留存于子 session
+	 * 文件）不进差集计数，守卫不幻 defer。
+	 * 缺省（undefined）= 不过滤（向后兼容：既有调用方零改动行为不变）。
+	 * entry 缺 sessionId 字段的旧形态条目视为本 session（归一化兜底语义与
+	 * normalizeRegisterEntry 一致），不过滤。
+	 */
+	currentSessionId?: string;
 }
 
 /** countActiveFromEntries 的结果。 */
@@ -136,46 +164,58 @@ export interface CountActiveResult {
  * 从持久化 entries 计算活跃 pending 数（register − unregister 差集）。
  *
  * 与 rebuildFromEntries 的分工：本函数只做「有没有活跃 pending」的只读判断，
- * 不写 registry、不判 sessionId/expiresAt（TTL 刻意不校验——长任务 subagent >1h
+ * 不写 registry、不判 expiresAt（TTL 刻意不校验——长任务 subagent >1h
  * 仍应视为活跃，对齐 goal agent-end 的 continuation 守卫语义）。
  * 调用方：goal（agent_end 时判断是否发 continuation）、subagent-workflow
  * （agent_end 时判断子进程是否有活跃后代，决定是否保持进程等 steer 唤醒）。
  *
- * 注：跨 session 残留（fork 继承的 register）由 index.ts 的 session_start 重建
- * 流程补 unregister(expired) 抵消；本函数只做纯差集，不重复处理。
+ * [W4 读侧过滤①] 跨 session 残留的过滤职责已从「index.ts 的 session_start 重建
+ * 流程补 unregister(expired) 抵消」（session 档 U4 机制，翻档后对 process 档不再
+ * 触发）移交给本函数的 opts.currentSessionId 口——调用方持有当前 session 概念的
+ * 应传入，使 fork 继承的父级注册残留不进差集（守卫不幻 defer）。
  */
 export function countActiveFromEntries(
 	entries: unknown[],
 	opts?: CountActiveOptions,
 ): CountActiveResult {
-	const unregistered = new Set<string>();
-	for (const raw of entries as EntryLike[]) {
-		// S-10：entries 元素可能是 null/undefined（外部调用方/坏数据），
-		// EntryLike 断言前先守卫，避免访问 raw.customType 抛 TypeError 炸掉差集判定。
-		if (!raw || typeof raw !== "object") continue;
-		if (raw.customType !== "pending:unregister") continue;
-		const data = (raw.data ?? {}) as UnregisterEntryData;
-		if (typeof data.id === "string") unregistered.add(data.id);
-	}
+	// 与 rebuildFromEntries 共用单趟扫描（S-10 守卫一致），分流 register/unregister
+	const { registerEntries, unregisteredIds } = scanPendingEntries(entries);
+	const active = filterActiveRegisters(registerEntries, unregisteredIds, opts);
 
+	return {
+		count: active.length,
+		ids: active.map((e) => e.id),
+		entries: active,
+	};
+}
+
+/** 差集过滤：跳过 id 非法 / 已注销 / 重复 register / 跨 session 残留的 entry，按 opts.types 过滤类型。 */
+function filterActiveRegisters(
+	registerEntries: Array<{ data: RegisterEntryData }>,
+	unregisteredIds: Set<string>,
+	opts?: CountActiveOptions,
+): PendingEntry[] {
 	const active: PendingEntry[] = [];
 	const seen = new Set<string>();
-	for (const raw of entries as EntryLike[]) {
-		if (!raw || typeof raw !== "object") continue;
-		if (raw.customType !== "pending:register") continue;
-		const data = (raw.data ?? {}) as RegisterEntryData;
-		if (typeof data.id !== "string" || unregistered.has(data.id) || seen.has(data.id)) continue;
+	for (const { data } of registerEntries) {
+		if (typeof data.id !== "string" || unregisteredIds.has(data.id) || seen.has(data.id)) continue;
 		seen.add(data.id);
 		const entry = normalizeRegisterEntry(data, "");
 		if (opts?.types && !opts.types.includes(entry.type)) continue;
+		// [W4 读侧过滤①] 跨 session 残留跳过（基准 = opts.currentSessionId）。判据读
+		// 原始 data.sessionId 而非归一化值：entry 缺 sessionId 的旧形态条目（归一化
+		// 兜底为 ""）视为本 session——不过滤，与 normalizeRegisterEntry 的容错语义
+		// 对齐（守卫漏计的危害方向是幻 defer，宁放行不误杀活跃计数）。
+		if (
+			opts?.currentSessionId !== undefined &&
+			typeof data.sessionId === "string" &&
+			data.sessionId !== opts.currentSessionId
+		) {
+			continue;
+		}
 		active.push(entry);
 	}
-
-	return {
-		count: active.length,
-		ids: active.map((e) => e.id),
-		entries: active,
-	};
+	return active;
 }
 
 /** rebuildFromEntries 的结果：重建后的活跃列表 + 需要补注销的 entry */
@@ -233,6 +273,16 @@ function scanPendingEntries(entries: unknown[]): PendingEntryScan {
  * - TTL 过期（U3）→ expired
  *
  * process 档两检全跳过（D16：进程级生命周期跨 session 续存且无 TTL）。
+ *
+ * [W4 翻档语义核对登记] 翻档后三类型全 process 档，本函数对现存类型恒 false——
+ * U3/U4 清理对翻档类型不再触发，这是翻档的**预期语义**而非缺陷：process 档的
+ * 生命周期本就跨 shutdown/fork 存活，跨 session 检测（U4）的职能已移交读侧过滤
+ * （countActiveFromEntries 的 currentSessionId 口 + rebuildFromEntries 的
+ * currentSessionId 入 registry 过滤），清理职能移交注销发射点枚举 + core 注册对账
+ * sweep（判据 = record 终态 ∪ 已归档/不存在；覆盖 subagent/workflow——bash 无
+ * record/store 可查，死亡窗口丢失无补发通道，见 normalizePendingType 注的显式
+ * 边界登记）。本函数与 PENDING_TTL_MS 同为
+ * session 档机器留存件，待未来 session 档类型，勿误删。
  */
 function isExpiredEntry(entry: PendingEntry, currentSessionId: string, now: number): boolean {
 	// 跨 session 残留（U4）——process 档跳过（D16：进程级生命周期跨 session 续存，
@@ -264,6 +314,20 @@ export function rebuildFromEntries(
 		if (typeof data.id !== "string") continue;
 		if (unregisteredIds.has(data.id)) continue;
 
+		// [W4 读侧过滤③ rebuild 半口] 跨 session 残留不入 registry（翻 process 档后
+		// U4 补注销对现存类型不再触发，fork 继承的父级注册残留若不过滤会永久虚报
+		// pending_notifications 工具投影）。与 U4 的差异：**跳过不补注销**——残留
+		// entry 留在 session 文件（读侧过滤③①口各自兜住差集消费方），落盘收口归
+		// core 注册对账 sweep（判据含 record 查不到 → 视同终态补注销）。判据读原始
+		// data.sessionId（缺 sessionId 的旧形态条目视为本 session，不过滤——宁放行
+		// 不误逐）。
+		if (
+			typeof data.sessionId === "string" &&
+			data.sessionId !== currentSessionId
+		) {
+			continue;
+		}
+
 		const entry = normalizeRegisterEntry(data, currentSessionId);
 		if (isExpiredEntry(entry, currentSessionId, now)) {
 			expiredToFlush.push({ id: entry.id, status: "expired" });
@@ -280,6 +344,14 @@ export function rebuildFromEntries(
 /**
  * type 归一化：subagent/bash 原样保留，其余（含缺失/未知值）归 workflow。
  * state.ts 与 index.ts 两处归一化共用本函数，防止「写入侧直通、读取侧归并」漂移。
+ *
+ * [W4 偏好显式化] 缺失/未知 type 默认归 workflow = process 档 = 永不 TTL 清理。
+ * 该偏好是刻意选择：畸形条目**宁挂账不失明**——误归 session 档会让未知类型被
+ * 1h TTL / 跨 session 清理静默抹掉（守卫失明方向）。挂账的收口通道按类型分流
+ * [F2 如实口径]：workflow / 畸形条目由 core 注册对账 sweep 收口（查 WorkflowRun
+ * store：终态 ∪ state 文件不存在 → 补注销）；bash 无 record/store 可查——bash
+ * 注册随进程退出注销，进程死亡窗口的丢失无补发通道，属显式边界（impl-plan §5
+ * 偏差登记：每孤儿 bash 注册 1 条静态虚报，无空转驱动源，熔断限损）。
  */
 export function normalizePendingType(raw: unknown): PendingType {
 	if (raw === "subagent") return "subagent";