@zhushanwen/pi-permission 1.4.8 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-permission",
-  "version": "1.4.8",
+  "version": "1.5.0",
   "description": "Pi permission extension — four permission modes (yolo/auto/approve/strict) with three-layer pipeline (AST + rules + AI classifier).",
   "type": "module",
   "main": "src/index.ts",
@@ -50,9 +50,9 @@
   "dependencies": {
     "tree-sitter-bash": "^0.25.1",
     "web-tree-sitter": "^0.26.11",
-    "@zhushanwen/pi-ext-guards": "0.4.1",
+    "@zhushanwen/pi-ext-guards": "0.4.2",
     "@zhushanwen/pi-extension-logger": "0.6.1",
-    "@zhushanwen/pi-llm-shared": "0.10.0"
+    "@zhushanwen/pi-llm-shared": "0.11.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.84.4",

package/src/__tests__/index-integration.test.ts

@@ -12,7 +12,7 @@
  * 用 PI_CODING_AGENT_DIR 指向临时目录，写入 controlled permission.json，
  * 让 loadAndWatchConfig 读到指定 mode。mock pi 对象记录 handler 调用。
  */
-import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -22,6 +22,19 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import permissionExtension from "../index.js";
 import { FOOTER_HANDSHAKE_KEY, REQUEST_RENDER_KEY } from "../footer-provider.js";
 
+// migrateLegacyConfig 包 spy 计数（透传真实实现，行为零改变）：迁移接线用例的
+// 操作级去重断言（双派发 spy = 1）经此观测，文件面断言（mtime/内容不变）同源有效。
+const { spyMigrateLegacyConfig } = vi.hoisted(() => ({
+	spyMigrateLegacyConfig: vi.fn(),
+}));
+
+vi.mock("@zhushanwen/pi-llm-shared", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("@zhushanwen/pi-llm-shared")>();
+	spyMigrateLegacyConfig.mockImplementation((agentDir: string, oldRel: string, newRel: string) =>
+		actual.migrateLegacyConfig(agentDir, oldRel, newRel));
+	return { ...actual, migrateLegacyConfig: spyMigrateLegacyConfig };
+});
+
 // ──────────────────────── mock pi ────────────────────────
 
 /** tool_call handler 的最小签名（返回 Promise<block 结果 | undefined>）。 */
@@ -276,24 +289,43 @@ function getPermissionHandler(calls: MockPiCalls): (args: string, ctx: unknown)
 }
 
 describe("W8 /permission rule 命令集成", () => {
-	it("headless（json）→ notify 降级提示，不改 config", async () => {
+	it("headless（json）→ rule 参数走 rule 路径：notify 降级提示，config 字节不变", async () => {
 		writeConfig("yolo");
+		const configBefore = readFileSync(CONFIG_PATH, "utf-8");
 		const { pi, calls } = createMockPi();
 		permissionExtension(pi);
 		const handler = getPermissionHandler(calls);
-		const ctx = makeCtx("json");
+		// notify spy 注入 ctx（commands.test.ts 同款 vi.fn 形态）：headless 降级提示的可观测面
+		const notify = vi.fn();
+		const ctx = {
+			mode: "json",
+			cwd: "/tmp",
+			ui: {
+				notify,
+				select(): Promise<string | undefined> {
+					return Promise.resolve(undefined);
+				},
+				custom(): Promise<unknown> {
+					return Promise.resolve(undefined);
+				},
+			},
+			signal: undefined,
+		};
 		// 不应抛错
-		await handler("rule", ctx);
-	});
-
-	it("permission handler 分流：rule 参数走 rule 路径（headless 降级）", async () => {
-		writeConfig("yolo");
-		const { pi, calls } = createMockPi();
-		permissionExtension(pi);
-		const handler = getPermissionHandler(calls);
-		const ctx = makeCtx("json");
-		// rule 参数应走 headless 降级（notify）
-		await expect(handler("rule", ctx)).resolves.not.toThrow();
+		await expect(handler("rule", ctx)).resolves.toBeUndefined();
+
+		// 分流断言：warning 文案只产自 rule 编辑器的 headless 分支（editRulesViaOverlay），
+		// 同步路径（mode 切换/status）只发 info——命中即证明「rule 参数走了 rule 路径」。
+		// 第二次 notify = 编辑器返回 undefined 后的 no-changes 提示。
+		expect(notify).toHaveBeenCalledTimes(2);
+		expect(notify).toHaveBeenNthCalledWith(
+			1,
+			expect.stringContaining("not available in headless mode"),
+			"warning",
+		);
+		expect(notify).toHaveBeenNthCalledWith(2, "[pi-permission] No changes applied.", "info");
+		// 降级路径不得改 config（编辑器未打开、save 未触发）：字节级不变
+		expect(readFileSync(CONFIG_PATH, "utf-8")).toBe(configBefore);
 	});
 });
 
@@ -377,6 +409,12 @@ describe("footer line 注册", () => {
 // 迁移经 oncePerProcess 守卫（u-audit-fix 收编原内联 once flag），守卫的模块级 Map
 // 跨用例残留：用 vi.resetModules() + 动态 import 取新鲜模块实例，否则前面用例已触发过
 // session_start，迁移分支永不执行（静默不测）。
+// 末两条为守卫双派发实测（u-audit-fix 探针）：
+//   a) 操作级去重：双派发下 spy migrateLegacyConfig 调用 = 1（warn 在 migrateLegacyConfig
+//      调用点内部，调用 = 1 构造性蕴含 warn ≤ 1，不另设断言）；
+//   b) 文件面：第二次派发后重建的旧文件原样保留、新路径 mtime/内容严格不变；
+//   c) 豁免项防误伤：footer 注册为纯内存初始化（registry.register 同 id 覆盖），不在
+//      包装范围——双派发仍每次执行（pending push ×2）。
 describe("session_start 配置路径迁移接线", () => {
 	const LEGACY_PATH = join(AGENT_DIR, "permission-config.json");
 
@@ -459,4 +497,59 @@ describe("session_start 配置路径迁移接线", () => {
 		expect(() => handler({}, makeCtx("json"))).not.toThrow();
 		expect(existsSync(CONFIG_PATH)).toBe(false); // 迁移不凭空造新配置
 	});
+
+	// ── oncePerProcess 守卫双派发实测（u-audit-fix 探针）──
+	it("双派发下 migrateLegacyConfig 仅执行一次：spy = 1，文件面首次迁移到位、第二次 mtime/内容不变", async () => {
+		// spy 是文件级单例（跨 resetModules 保留计数），前面用例已触发过迁移 → 先清零
+		spyMigrateLegacyConfig.mockClear();
+		// 预置旧路径文件（新路径不存在 → 走 renameSync 迁移分支）
+		rmSync(CONFIG_PATH, { force: true });
+		writeLegacyConfig("strict");
+
+		const extension = await freshExtension();
+		const { pi, calls } = createMockPi();
+		extension(pi);
+		const handler = getSessionStartHandler(calls);
+
+		// 第一次派发：迁移发生（旧文件消失 + 新路径出现，内容来自旧文件）
+		handler({}, makeCtx("json"));
+		expect(existsSync(LEGACY_PATH)).toBe(false);
+		expect(existsSync(CONFIG_PATH)).toBe(true);
+		expect(JSON.parse(readFileSync(CONFIG_PATH, "utf-8")).mode).toBe("strict");
+		const mtimeAfterFirst = statSync(CONFIG_PATH).mtimeMs;
+		const contentAfterFirst = readFileSync(CONFIG_PATH, "utf-8");
+
+		// 第二次派发（factory 二调/handler 累积形态：同一 handler 引用再调）：
+		// 重建旧路径文件模拟外部残留——守卫已消费 key，不得再次触碰任何文件。
+		writeLegacyConfig("yolo");
+		handler({}, makeCtx("json"));
+
+		// 探针 a：操作级去重（spy 透传真实实现，文件面与计数同源）
+		expect(spyMigrateLegacyConfig).toHaveBeenCalledTimes(1);
+		// 探针 b：第二次后重建的旧文件原样保留、新路径 mtime/内容严格不变
+		expect(existsSync(LEGACY_PATH)).toBe(true);
+		expect(statSync(CONFIG_PATH).mtimeMs).toBe(mtimeAfterFirst);
+		expect(readFileSync(CONFIG_PATH, "utf-8")).toBe(contentAfterFirst);
+	});
+
+	it("豁免项防误伤：footer 注册不包装，双派发仍每次执行（pending push ×2）", async () => {
+		writeLegacyConfig("strict");
+
+		const extension = await freshExtension();
+		const { pi, calls } = createMockPi();
+		extension(pi);
+		const handler = getSessionStartHandler(calls);
+
+		handler({}, makeCtx("json"));
+		handler({}, makeCtx("json"));
+
+		// 纯内存初始化（registry.register 同 id 覆盖 / pending push）保持每 session_start
+		// 执行——清单「粒度边界」明令不包装，挂进程级 flag 会杀 session 级语义。
+		const slot = Reflect.get(globalThis, FOOTER_HANDSHAKE_KEY) as {
+			pending: Array<{ id: string; renderer: unknown }>;
+		} | undefined;
+		expect(slot).toBeDefined();
+		expect(slot!.pending.length).toBe(2);
+		expect(slot!.pending[0]!.id).toBe("pi-permission");
+	});
 });

package/src/classifier/__tests__/classifier.test.ts

@@ -282,4 +282,27 @@ describe("CT5: callLLM opts 构造（model/messages/timeoutMs/signal）", () =>
 		const opts = getLastOpts();
 		expect(opts?.signal).toBe(ac.signal);
 	});
+
+	it("配置 thinkingLevel 不被模型支持 → warn 留痕 + reasoning 不传（不静默降级）", async () => {
+		// FIXED_MODEL_OBJ reasoning:false → supportedLevels = ["off"]，配置 "high" 判定落空；
+		// changeset pi-permission-thinking-level-datadriven 承诺 warn 留痕（同族 rename-session 对齐）
+		const onLog = vi.fn();
+		const { spy, getLastOpts } = capturingCallLLM(okResult('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":0.9}'));
+		const classifier = createClassifier(makeDeps({ callLLM: spy, onLog }));
+		const r = await classifier.classifyRisk(CTX, { ...CONFIG, thinkingLevel: "high" });
+		expect(r.outcome).toBe("allow");
+		expect(onLog).toHaveBeenCalledWith(
+			expect.stringContaining('configured thinkingLevel "high" is not supported by test-co/test-model; calling without a thinking level'),
+		);
+		expect(getLastOpts()?.reasoning).toBeUndefined();
+	});
+
+	it("配置 thinkingLevel 被模型支持 → 命中透传，无 warn", async () => {
+		const onLog = vi.fn();
+		const { spy, getLastOpts } = capturingCallLLM(okResult('{"outcome":"allow","risk_level":"low","reasoning":"x","confidence":0.9}'));
+		const classifier = createClassifier(makeDeps({ callLLM: spy, onLog }));
+		await classifier.classifyRisk(CTX, { ...CONFIG, thinkingLevel: "off" });
+		expect(onLog).not.toHaveBeenCalledWith(expect.stringContaining("not supported"));
+		expect(getLastOpts()?.reasoning).toBe("off");
+	});
 });

package/src/classifier/classifier.ts

@@ -17,6 +17,7 @@
  *   - fail-closed：timeout / 抛错 / 解析失败 / 无可用模型 → 一律 ask
  */
 
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import type { Api, Message, Model } from "@earendil-works/pi-ai";
 import { toErrorMessage } from "@zhushanwen/pi-ext-guards";
 import type { CallLLMOptions, CallLLMResult } from "@zhushanwen/pi-llm-shared";
@@ -133,15 +134,25 @@ function buildCallOptions(
 	config: ClassifierConfig,
 	timeoutMs: number | undefined,
 	signal: AbortSignal | undefined,
+	onLog?: (msg: string) => void,
 ): CallLLMOptions {
+	// 档位按「该模型自己的 supportedLevels」判定（pi-ai 数据驱动，本层不自持词表）；
+	// 不支持则按「不传档位」处理，不静默换成别的档（clamp），并 warn 留痕
+	// （changeset pi-permission-thinking-level-datadriven 的承诺，与 rename-session 同族对齐）。
+	// llm-shared 会把 "off" 映射为不传。
+	const reasoning = getSupportedThinkingLevels(model).find((l) => l === config.thinkingLevel);
+	if (config.thinkingLevel !== undefined && config.thinkingLevel !== "" && reasoning === undefined) {
+		onLog?.(
+			`[pi-permission] classifier: configured thinkingLevel "${config.thinkingLevel}" is not supported by ${model.provider}/${model.id}; calling without a thinking level`,
+		);
+	}
 	return {
 		model,
 		systemPrompt: CLASSIFIER_SYSTEM_PROMPT,
 		messages: buildMessages(ctx),
 		...(timeoutMs !== undefined ? { timeoutMs } : {}),
 		...(signal !== undefined ? { signal } : {}),
-		// thinkingLevel 直接透传（含 "off"）；llm-shared 内部会把 "off" 映射为不传 reasoning（provider 默认）
-		reasoning: config.thinkingLevel,
+		reasoning,
 	};
 }
 
@@ -223,7 +234,7 @@ export function createClassifier(deps: ClassifierDeps): {
 
 		// 2. 构造 CallLLMOptions
 		const timeoutMs = config.timeout > 0 ? config.timeout * MILLIS_PER_SECOND : undefined;
-		const callPromise = callLLM(buildCallOptions(model, ctx, config, timeoutMs, signal));
+		const callPromise = callLLM(buildCallOptions(model, ctx, config, timeoutMs, signal, onLog));
 
 		// 3. 等待 callLLM + 外层超时/中止兜底（provider 不支持 timeoutMs/signal 时防永挂）
 		let settled: SettledRace;

package/src/config.ts

@@ -22,7 +22,7 @@ import { isRecord, toErrorMessage } from "@zhushanwen/pi-ext-guards";
 import {
 	clearConfigCache,
 	getConfigPath as getLlmConfigPath,
-	isThinkingLevel,
+	normalizeThinkingLevel,
 	loadConfig,
 	saveConfig as saveLlmConfig,
 } from "@zhushanwen/pi-llm-shared";
@@ -59,10 +59,8 @@ function normalizeClassifierConfig(raw: unknown): ClassifierConfig {
 	if (record.model !== undefined && !(typeof record.model === "string" && record.model.length > 0)) {
 		logger.warn("Ignoring invalid classifier.model (expected string 'auto' or 'provider/model-id'), using default auto");
 	}
-	// thinkingLevel 校验：合法值为 'off'|'minimal'|'low'|'medium'|'high'|'xhigh'|'max'
-	const thinkingLevel = isThinkingLevel(record.thinkingLevel)
-		? record.thinkingLevel
-		: DEFAULT_CLASSIFIER_CONFIG.thinkingLevel;
+	// thinkingLevel：非空字符串即采信（合法档位由写入侧 UI 与 pi 判定；本层不再自持词表）
+	const thinkingLevel = normalizeThinkingLevel(record.thinkingLevel) ?? DEFAULT_CLASSIFIER_CONFIG.thinkingLevel;
 	return {
 		enabled: record.enabled !== false,
 		model: typeof record.model === "string" && record.model.length > 0 ? record.model : DEFAULT_CLASSIFIER_CONFIG.model,

package/src/types.ts

@@ -5,7 +5,6 @@
  * 对应 slice plan 的 DM1-DM5 数据模型。
  */
 
-import type { ModelThinkingLevel } from "@earendil-works/pi-ai";
 
 // ──────────────────────── DM1: PermissionMode ────────────────────────
 
@@ -108,11 +107,11 @@ export interface ClassifierConfig {
 	/** 高风险是否强制 deny（不问人：high+allow 时直接拒绝） */
 	autoDenyHighRisk: boolean;
 	/**
-	 * 标题生成 LLM 的 thinking 级别（pi 的 ModelThinkingLevel，THINKING_ORDER SSOT）。
+	 * 标题生成 LLM 的 thinking 级别（字符串透传；合法档位按模型 supportedLevels 在调用点判定）。
 	 * 默认 "off"：不传 pi-ai reasoning（provider 默认行为）；
 	 * "minimal"~"max" 透传给 SimpleStreamOptions.reasoning（provider 不支持时静默忽略）。
 	 */
-	thinkingLevel: ModelThinkingLevel;
+	thinkingLevel: string;
 }
 
 // ──────────────────────── DM5: PermissionConfig ────────────────────────

package/src/__tests__/session-start-once-guard.test.ts

@@ -1,146 +0,0 @@
-/**
- * session-start-once-guard.test.ts — u-audit-fix 探针实测（permission 侧）。
- *
- * 判定「必须接入」：migrateLegacyConfig 写 agentDir 全局配置文件，属跨 session 副作用，
- * 已由 oncePerProcess 守卫收编原内联 once flag。本文件按清单探针验证点双派发实测：
- *   a) 双派发（同一 factory 闭包直接调 handler 两次）下 spy migrateLegacyConfig 调用 = 1；
- *   b) 文件面：tmp agentDir 预置旧路径文件 → 第一次 handler 后旧文件消失 + 新路径出现，
- *      第二次 handler 后新路径 mtime/内容不变（守卫拦截 = 不触碰）；
- *   c) migrated warn 仅一条：构造性蕴含于 a——warn 在 migrateLegacyConfig 调用点内部
- *      （llm-shared migrate.ts "migrated" 分支），调用 = 1 ⟹ warn ≤ 1，不另设断言。
- * 反向断言（豁免项防误伤）：footer 注册为纯内存初始化（registry.register 同 id 覆盖），
- * 不在包装范围——双派发仍每次执行（pending push ×2）。
- */
-import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { FOOTER_HANDSHAKE_KEY } from "../footer-provider.js";
-
-// ── mock：migrateLegacyConfig 包 spy 计数（透传真实实现，文件面断言保留） ──
-
-const { spyMigrateLegacyConfig } = vi.hoisted(() => ({
-	spyMigrateLegacyConfig: vi.fn(),
-}));
-
-vi.mock("@zhushanwen/pi-llm-shared", async (importOriginal) => {
-	const actual = await importOriginal<typeof import("@zhushanwen/pi-llm-shared")>();
-	spyMigrateLegacyConfig.mockImplementation((agentDir: string, oldRel: string, newRel: string) =>
-		actual.migrateLegacyConfig(agentDir, oldRel, newRel));
-	return { ...actual, migrateLegacyConfig: spyMigrateLegacyConfig };
-});
-
-// ── mock pi（对齐 index-integration.test.ts 自包含 helper 形态） ──
-
-function createMockPi(): { pi: Pick<ExtensionAPI, "on" | "registerCommand">; calls: { eventHandlers: Map<string, Array<(event?: unknown, ctx?: unknown) => unknown>> } } {
-	const eventHandlers = new Map<string, Array<(event?: unknown, ctx?: unknown) => unknown>>();
-	const pi = {
-		registerCommand(): void {
-			/* noop */
-		},
-		on(event: string, handler: (event?: unknown, ctx?: unknown) => unknown): void {
-			if (!eventHandlers.has(event)) eventHandlers.set(event, []);
-			eventHandlers.get(event)!.push(handler);
-		},
-	};
-	return { pi: pi as Pick<ExtensionAPI, "on" | "registerCommand">, calls: { eventHandlers } };
-}
-
-function getSessionStartHandler(calls: { eventHandlers: Map<string, Array<(event?: unknown, ctx?: unknown) => unknown>> }): (event: unknown, ctx: unknown) => unknown {
-	const handlers = calls.eventHandlers.get("session_start");
-	if (!handlers || handlers.length === 0) {
-		throw new Error("session_start handler not registered");
-	}
-	return handlers[0]!;
-}
-
-// ── tmp agentDir（getAgentDir 经 PI_CODING_AGENT_DIR 推导，对齐 index-integration.test.ts） ──
-
-const TMP_ROOT = join(tmpdir(), "pi-perm-once-guard-" + process.pid);
-const AGENT_DIR = join(TMP_ROOT, "agent");
-const LEGACY_PATH = join(AGENT_DIR, "permission-config.json");
-const CONFIG_PATH = join(AGENT_DIR, "config", "permission-ext-config.json");
-
-function writeLegacyConfig(mode: string): void {
-	mkdirSync(AGENT_DIR, { recursive: true });
-	writeFileSync(
-		LEGACY_PATH,
-		JSON.stringify({ mode, enabled: true, classifier: { enabled: true }, userRules: [] }, null, 2) + "\n",
-		{ mode: 0o600 },
-	);
-}
-
-/** oncePerProcess 的 Map 是模块级状态：每个用例 resetModules 取新鲜模块实例（对齐迁移接线测试先例）。 */
-async function freshExtension(): Promise<(pi: Pick<ExtensionAPI, "on" | "registerCommand">) => void> {
-	vi.resetModules();
-	const mod = await import("../index.js");
-	return mod.default as (pi: Pick<ExtensionAPI, "on" | "registerCommand">) => void;
-}
-
-beforeEach(() => {
-	Reflect.deleteProperty(globalThis, FOOTER_HANDSHAKE_KEY);
-	process.env.PI_CODING_AGENT_DIR = AGENT_DIR;
-	mkdirSync(AGENT_DIR, { recursive: true });
-});
-
-afterEach(() => {
-	delete process.env.PI_CODING_AGENT_DIR;
-	Reflect.deleteProperty(globalThis, FOOTER_HANDSHAKE_KEY);
-	if (existsSync(TMP_ROOT)) rmSync(TMP_ROOT, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
-});
-
-describe("session_start 双派发幂等守卫（oncePerProcess，u-audit-fix）", () => {
-	it("双派发下 migrateLegacyConfig 仅执行一次：spy = 1，文件面首次迁移到位、第二次 mtime/内容不变", async () => {
-		// 预置旧路径文件（新路径不存在 → 走 renameSync 迁移分支）
-		writeLegacyConfig("strict");
-
-		const extension = await freshExtension();
-		const { pi, calls } = createMockPi();
-		extension(pi);
-		const handler = getSessionStartHandler(calls);
-
-		// 第一次派发：迁移发生（旧文件消失 + 新路径出现，内容来自旧文件）
-		handler({}, { mode: "json", cwd: "/tmp", ui: {}, signal: undefined });
-		expect(existsSync(LEGACY_PATH)).toBe(false);
-		expect(existsSync(CONFIG_PATH)).toBe(true);
-		expect(JSON.parse(readFileSync(CONFIG_PATH, "utf-8")).mode).toBe("strict");
-		const mtimeAfterFirst = statSync(CONFIG_PATH).mtimeMs;
-		const contentAfterFirst = readFileSync(CONFIG_PATH, "utf-8");
-
-		// 第二次派发（factory 二调/handler 累积形态：同一 handler 引用再调）：
-		// 重建旧路径文件模拟外部残留——守卫已消费 key，不得再次触碰任何文件。
-		writeLegacyConfig("yolo");
-		handler({}, { mode: "json", cwd: "/tmp", ui: {}, signal: undefined });
-
-		// 探针 a：操作级去重（spy 透传真实实现，文件面与计数同源）
-		expect(spyMigrateLegacyConfig).toHaveBeenCalledTimes(1);
-		// 探针 b：第二次后重建的旧文件原样保留、新路径 mtime/内容严格不变
-		expect(existsSync(LEGACY_PATH)).toBe(true);
-		expect(statSync(CONFIG_PATH).mtimeMs).toBe(mtimeAfterFirst);
-		expect(readFileSync(CONFIG_PATH, "utf-8")).toBe(contentAfterFirst);
-	});
-
-	it("豁免项防误伤：footer 注册不包装，双派发仍每次执行（pending push ×2）", async () => {
-		writeLegacyConfig("strict");
-
-		const extension = await freshExtension();
-		const { pi, calls } = createMockPi();
-		extension(pi);
-		const handler = getSessionStartHandler(calls);
-
-		handler({}, { mode: "json", cwd: "/tmp", ui: {}, signal: undefined });
-		handler({}, { mode: "json", cwd: "/tmp", ui: {}, signal: undefined });
-
-		// 纯内存初始化（registry.register 同 id 覆盖 / pending push）保持每 session_start
-		// 执行——清单「粒度边界」明令不包装，挂进程级 flag 会杀 session 级语义。
-		const slot = Reflect.get(globalThis, FOOTER_HANDSHAKE_KEY) as {
-			pending: Array<{ id: string; renderer: unknown }>;
-		} | undefined;
-		expect(slot).toBeDefined();
-		expect(slot!.pending.length).toBe(2);
-		expect(slot!.pending[0]!.id).toBe("pi-permission");
-	});
-});