@zhushanwen/pi-permission 0.0.1

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

@@ -0,0 +1,282 @@
+/**
+ * index-integration.test.ts — W5 tool_call handler 集成测试。
+ *
+ * 测扩展工厂注册的 tool_call handler 行为：
+ *  - yolo 快速路径 → return undefined（放行）
+ *  - strict 模式 → block（headless deny）
+ *  - mode 切换（config 文件变化后 handler 用新 mode）
+ *  - G5 并发串行化（多次 tool_call 顺序处理）
+ *  - fail-closed（异常 → block）
+ *  - session_start 重载 config
+ *
+ * 用 PI_CODING_AGENT_DIR 指向临时目录，写入 controlled permission-config.json，
+ * 让 loadAndWatchConfig 读到指定 mode。mock pi 对象记录 handler 调用。
+ */
+import { existsSync, mkdirSync, rmSync, 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 } from "vitest";
+
+import permissionExtension from "../index.js";
+
+// ──────────────────────── mock pi ────────────────────────
+
+/** tool_call handler 的最小签名（返回 Promise<block 结果 | undefined>）。 */
+type ToolCallHandler = (event: unknown, ctx: unknown) => Promise<ToolCallResult | undefined>;
+/** tool_call handler 的返回值（Pi ToolCallEventResult 子集）。 */
+interface ToolCallResult {
+	block?: boolean;
+	reason?: string;
+}
+
+interface MockPiCalls {
+	registerCommandCalls: Array<{ name: string; options: unknown }>;
+	eventHandlers: Map<string, Array<(event?: unknown, ctx?: unknown) => unknown>>;
+}
+
+/**
+ * 构造 mock pi。返回对象满足 ExtensionAPI 的 on/registerCommand 子集，
+ * 用 `as Pick<ExtensionAPI, "on" | "registerCommand">` 单点断言（taste/no-unsafe-cast 允许 Pick 断言）。
+ */
+function createMockPi(): { pi: Pick<ExtensionAPI, "on" | "registerCommand">; calls: MockPiCalls } {
+	const registerCommandCalls: MockPiCalls["registerCommandCalls"] = [];
+	const eventHandlers: MockPiCalls["eventHandlers"] = new Map();
+	const pi = {
+		registerCommand(name: string, options: unknown): void {
+			registerCommandCalls.push({ name, options });
+		},
+		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: { registerCommandCalls, eventHandlers } };
+}
+
+/** 提取 tool_call handler（已注册的单一 handler）。 */
+function getToolCallHandler(calls: MockPiCalls): ToolCallHandler {
+	const handlers = calls.eventHandlers.get("tool_call");
+	if (!handlers || handlers.length === 0) {
+		throw new Error("tool_call handler not registered");
+	}
+	return handlers[0] as ToolCallHandler;
+}
+
+/** 提取 session_start handler。 */
+function getSessionStartHandler(calls: MockPiCalls): (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];
+}
+
+/** 构造 mock ctx（含 mode/ui/signal）。 */
+function makeCtx(mode: "tui" | "rpc" | "json" | "print" = "json"): unknown {
+	return {
+		mode,
+		cwd: "/tmp",
+		ui: {
+			notify(): void {
+				/* noop */
+			},
+			select(): Promise<string | undefined> {
+				return Promise.resolve(undefined);
+			},
+			custom(): Promise<unknown> {
+				return Promise.resolve(undefined);
+			},
+		},
+		signal: undefined,
+	};
+}
+
+/** bash tool_call event 构造器。 */
+function bashEvent(command: string): { toolName: string; input: { command: string } } {
+	return { toolName: "bash", input: { command } };
+}
+
+// ──────────────────────── 临时 config 目录 ────────────────────────
+
+const TMP_ROOT = join(tmpdir(), "pi-perm-test-" + process.pid);
+const AGENT_DIR = join(TMP_ROOT, "agent");
+const CONFIG_PATH = join(AGENT_DIR, "permission-config.json");
+
+function writeConfig(mode: string, enabled = true): void {
+	mkdirSync(AGENT_DIR, { recursive: true });
+	const config = {
+		mode,
+		enabled,
+		classifier: { enabled: true, model: "auto", timeout: 5, autoApproveLowRisk: true, autoDenyHighRisk: true },
+		userRules: [],
+	};
+	writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
+}
+
+beforeEach(() => {
+	process.env.PI_CODING_AGENT_DIR = AGENT_DIR;
+	mkdirSync(AGENT_DIR, { recursive: true });
+	// 默认 yolo config（大多数测试需要可预测起点）
+	writeConfig("yolo");
+});
+
+afterEach(() => {
+	delete process.env.PI_CODING_AGENT_DIR;
+	if (existsSync(TMP_ROOT)) rmSync(TMP_ROOT, { recursive: true, force: true });
+});
+
+// ──────────────────────── 测试 ────────────────────────
+
+describe("W5 tool_call handler 集成", () => {
+	it("工厂注册 session_start + tool_call + /permission command", () => {
+		const { pi, calls } = createMockPi();
+		expect(() => permissionExtension(pi)).not.toThrow();
+		expect(calls.eventHandlers.has("session_start")).toBe(true);
+		expect(calls.eventHandlers.has("tool_call")).toBe(true);
+		const permCmd = calls.registerCommandCalls.find((c) => c.name === "permission");
+		expect(permCmd).toBeDefined();
+	});
+
+	it("yolo 快速路径 → return undefined（放行，不跑管道）", async () => {
+		writeConfig("yolo");
+		const { pi, calls } = createMockPi();
+		permissionExtension(pi);
+		const handler = getToolCallHandler(calls);
+		const result = await handler(bashEvent("rm -rf /"), makeCtx());
+		expect(result).toBeUndefined();
+	});
+
+	it("enabled=false → 等同 yolo 放行", async () => {
+		writeConfig("strict", false);
+		const { pi, calls } = createMockPi();
+		permissionExtension(pi);
+		const handler = getToolCallHandler(calls);
+		const result = await handler(bashEvent("ls"), makeCtx());
+		expect(result).toBeUndefined();
+	});
+
+	it("strict + headless → block（fail-closed deny）", async () => {
+		writeConfig("strict");
+		const { pi, calls } = createMockPi();
+		permissionExtension(pi);
+		const handler = getToolCallHandler(calls);
+		const result = await handler(bashEvent("ls"), makeCtx("json"));
+		expect(result).toBeDefined();
+		expect(result?.block).toBe(true);
+		expect(result?.reason).toContain("headless");
+	});
+
+	it("approve + 非安全命令 + headless → block", async () => {
+		writeConfig("approve");
+		const { pi, calls } = createMockPi();
+		permissionExtension(pi);
+		const handler = getToolCallHandler(calls);
+		// curl 不在白名单 → ask → approve 模式 → 人工审批 → headless deny
+		const result = await handler(bashEvent("curl http://example.com"), makeCtx("json"));
+		expect(result?.block).toBe(true);
+	});
+
+	it("approve + 安全命令（ls）→ 放行", async () => {
+		writeConfig("approve");
+		const { pi, calls } = createMockPi();
+		permissionExtension(pi);
+		const handler = getToolCallHandler(calls);
+		// ls 在白名单 → allow → 放行
+		const result = await handler(bashEvent("ls"), makeCtx("json"));
+		expect(result).toBeUndefined();
+	});
+
+	it("缺 toolName → fail-closed block", async () => {
+		writeConfig("approve");
+		const { pi, calls } = createMockPi();
+		permissionExtension(pi);
+		const handler = getToolCallHandler(calls);
+		const result = await handler({ input: { command: "ls" } }, makeCtx());
+		expect(result?.block).toBe(true);
+		expect(result?.reason).toContain("missing toolName");
+	});
+
+	it("G5 并发串行：多个 tool_call 顺序处理（不重叠）", async () => {
+		writeConfig("strict");
+		const { pi, calls } = createMockPi();
+		permissionExtension(pi);
+		const handler = getToolCallHandler(calls);
+		// 并发发起 3 个 tool_call（不 await），它们应串行
+		const ctx = makeCtx();
+		const p1 = handler(bashEvent("ls"), ctx);
+		const p2 = handler(bashEvent("pwd"), ctx);
+		const p3 = handler(bashEvent("whoami"), ctx);
+		// Promise.all 这里是故意的：3 个调用是同一串行链上的任务，断言全部 block。
+		// 非独立降级场景才用 allSettled；此处任一 reject 即测试失败（符合预期）。
+		const results = await Promise.all([p1, p2, p3]);
+		expect(results.length).toBe(3);
+		for (const r of results) {
+			expect(r?.block).toBe(true);
+		}
+	});
+
+	it("session_start handler 重载 config（mode 切换生效）", async () => {
+		writeConfig("yolo");
+		const { pi, calls } = createMockPi();
+		permissionExtension(pi);
+		const toolHandler = getToolCallHandler(calls);
+		const sessionHandler = getSessionStartHandler(calls);
+
+		// 初始 yolo → 放行
+		const r1 = await toolHandler(bashEvent("ls"), makeCtx());
+		expect(r1).toBeUndefined();
+
+		// 切换到 strict，触发 session_start 重载
+		writeConfig("strict");
+		getSessionStartHandler(calls);
+		sessionHandler({}, makeCtx());
+
+		// 现在 strict → block
+		const r2 = await toolHandler(bashEvent("ls"), makeCtx());
+		expect(r2?.block).toBe(true);
+	});
+
+	it("异常路径 → fail-closed block（绝不放行）", async () => {
+		writeConfig("approve");
+		const { pi, calls } = createMockPi();
+		permissionExtension(pi);
+		const handler = getToolCallHandler(calls);
+		// input=null → 容错为 {}，bash 无 command → 走管道，approve + 空命令 → 人工审批 → headless deny
+		const result = await handler({ toolName: "bash", input: null }, makeCtx());
+		expect(result).toBeDefined();
+		expect(result?.block).toBe(true);
+	});
+});
+
+// ──────────────────────── W8 /permission rule 命令集成 ────────────────────────
+
+/** 提取 /permission command handler。 */
+function getPermissionHandler(calls: MockPiCalls): (args: string, ctx: unknown) => Promise<void> {
+	const cmd = calls.registerCommandCalls.find((c) => c.name === "permission");
+	if (!cmd) throw new Error("permission command not registered");
+	return (cmd.options as { handler: (args: string, ctx: unknown) => Promise<void> }).handler;
+}
+
+describe("W8 /permission rule 命令集成", () => {
+	it("headless（json）→ notify 降级提示，不改 config", async () => {
+		writeConfig("yolo");
+		const { pi, calls } = createMockPi();
+		permissionExtension(pi);
+		const handler = getPermissionHandler(calls);
+		const ctx = makeCtx("json");
+		// 不应抛错
+		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();
+	});
+});

package/src/__tests__/model-picker.test.ts

@@ -0,0 +1,371 @@
+/**
+ * model-picker.test.ts — W7 T5：model picker 单元测试。
+ *
+ * 覆盖：
+ *  - listAvailableModels（5）：空文件 / 无 apiKey 过滤 / 多 provider 排序 / cost 升序 / 无 model 的 provider 不进 Map
+ *  - pickModelViaOverlay（3）：TUI mock custom / RPC mock select / headless 降级
+ *  - ProviderModelSelectorComponent（5，含 WR1 handleInput 锁定）：
+ *      构造 / 初始 stage / provider onSelect / switchToModelStage / model onSelect
+ *      + 直接调 comp.handleInput('\r') 验证 SelectList.onSelect 触发（WR1）
+ *
+ * 用真实 pi-tui SelectList（不 mock），验证键盘委托集成通路（WR1 critical）。
+ */
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { ResolvedModelEntry } from "../classifier/model-resolver.js";
+import { listAvailableModels } from "../classifier/model-resolver.js";
+import {
+	DEFAULT_SELECT_THEME,
+	type ModelPickerContext,
+	pickModelViaOverlay,
+	ProviderModelSelectorComponent,
+	type SelectionResult,
+} from "../model-picker.js";
+
+// ──────────────────────── 临时文件 fixtures（listAvailableModels） ────────────────────────
+
+let tempDir: string;
+let modelsJsonPath: string;
+
+beforeEach(() => {
+	tempDir = mkdtempSync(join(tmpdir(), "pi-perm-mp-"));
+	modelsJsonPath = join(tempDir, "models.json");
+});
+
+afterEach(() => {
+	rmSync(tempDir, { recursive: true, force: true });
+});
+
+function writeModels(data: unknown): void {
+	writeFileSync(modelsJsonPath, JSON.stringify(data), "utf-8");
+}
+
+/** 构造一条 ResolvedModelEntry（测试 helper）。 */
+function makeEntry(provider: string, id: string, inputCost: number, hasApiKey = true): ResolvedModelEntry {
+	return {
+		provider,
+		id,
+		name: id,
+		api: "openai-completions",
+		cost: { input: inputCost, output: 0, cacheRead: 0, cacheWrite: 0 },
+		hasApiKey,
+	};
+}
+
+/** 构造 models Map（用于 component / pickModelViaOverlay 测试，避免读盘）。 */
+function makeModelsMap(providers: Record<string, ResolvedModelEntry[]>): Map<string, ResolvedModelEntry[]> {
+	return new Map(Object.entries(providers));
+}
+
+// ──────────────────────── listAvailableModels（5 cases） ────────────────────────
+
+describe("MPT1: listAvailableModels", () => {
+	it("文件缺失 → 空 Map（不 throw）", () => {
+		expect(existsSync(modelsJsonPath)).toBe(false);
+		const map = listAvailableModels(undefined, modelsJsonPath);
+		expect(map.size).toBe(0);
+	});
+
+	it("无 apiKey 的 provider 被过滤（不进 Map）", () => {
+		writeModels({
+			providers: {
+				"auth-co": { apiKey: "k1", api: "openai-completions", models: [{ id: "m1", cost: { input: 0.1, output: 0, cacheRead: 0, cacheWrite: 0 } }] },
+				"noauth-co": { api: "openai-completions", models: [{ id: "m2", cost: { input: 0.2, output: 0, cacheRead: 0, cacheWrite: 0 } }] },
+			},
+		});
+		const map = listAvailableModels(undefined, modelsJsonPath);
+		expect(map.has("auth-co")).toBe(true);
+		expect(map.has("noauth-co")).toBe(false); // 无 apiKey 过滤
+	});
+
+	it("多 provider 按 provider 名字母序排序（Map 插入序）", () => {
+		writeModels({
+			providers: {
+				"zebra-co": { apiKey: "k1", api: "openai-completions", models: [{ id: "m1", cost: { input: 0.1, output: 0, cacheRead: 0, cacheWrite: 0 } }] },
+				"alpha-co": { apiKey: "k2", api: "openai-completions", models: [{ id: "m2", cost: { input: 0.2, output: 0, cacheRead: 0, cacheWrite: 0 } }] },
+			},
+		});
+		const map = listAvailableModels(undefined, modelsJsonPath);
+		const providers = [...map.keys()];
+		expect(providers).toEqual(["alpha-co", "zebra-co"]); // 字母序
+	});
+
+	it("provider 内 model 按 cost.input 升序 + id 字母序 tiebreaker", () => {
+		writeModels({
+			providers: {
+				"co": {
+					apiKey: "k1",
+					api: "openai-completions",
+					models: [
+						{ id: "expensive", cost: { input: 1.0, output: 0, cacheRead: 0, cacheWrite: 0 } },
+						{ id: "cheap-b", cost: { input: 0.1, output: 0, cacheRead: 0, cacheWrite: 0 } },
+						{ id: "cheap-a", cost: { input: 0.1, output: 0, cacheRead: 0, cacheWrite: 0 } },
+					],
+				},
+			},
+		});
+		const map = listAvailableModels(undefined, modelsJsonPath);
+		const models = map.get("co")!;
+		expect(models.map((m) => m.id)).toEqual(["cheap-a", "cheap-b", "expensive"]);
+	});
+
+	it("provider 有 apiKey 但无 model → 不进 Map（无 model 项被过滤）", () => {
+		writeModels({
+			providers: {
+				"empty-co": { apiKey: "k1", api: "openai-completions", models: [] },
+				"has-co": { apiKey: "k2", api: "openai-completions", models: [{ id: "m1", cost: { input: 0.1, output: 0, cacheRead: 0, cacheWrite: 0 } }] },
+			},
+		});
+		const map = listAvailableModels(undefined, modelsJsonPath);
+		expect(map.has("empty-co")).toBe(false); // 无 model 不进 Map
+		expect(map.has("has-co")).toBe(true);
+	});
+});
+
+// ──────────────────────── pickModelViaOverlay（3 cases） ────────────────────────
+
+function makePickerCtx(overrides: Partial<ModelPickerContext> = {}): ModelPickerContext {
+	const base: ModelPickerContext = {
+		mode: "tui",
+		ui: {
+			notify: vi.fn(),
+			select: vi.fn(() => Promise.resolve(undefined)),
+			custom: vi.fn(() => Promise.resolve(undefined)),
+		},
+	};
+	return { mode: overrides.mode ?? base.mode, ui: { ...base.ui, ...overrides.ui } };
+}
+
+describe("MPT2: pickModelViaOverlay 分发", () => {
+	it("headless（json）→ 返回 undefined（降级）", async () => {
+		const ctx = makePickerCtx({ mode: "json" });
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const result = await pickModelViaOverlay(ctx, "auto", models);
+		expect(result).toBeUndefined();
+	});
+
+	it("空 models Map → 返回 undefined（降级，无论 mode）", async () => {
+		const ctx = makePickerCtx({ mode: "tui" });
+		const result = await pickModelViaOverlay(ctx, "auto", new Map());
+		expect(result).toBeUndefined();
+	});
+
+	it("RPC 模式：第一次选 Auto → 返回 'auto'", async () => {
+		const ctx = makePickerCtx({
+			mode: "rpc",
+			ui: {
+				notify: vi.fn(),
+				select: vi.fn(() => Promise.resolve("Auto")),
+				custom: vi.fn(),
+			},
+		});
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const result = await pickModelViaOverlay(ctx, "auto", models);
+		expect(result).toBe("auto");
+		expect(ctx.ui.select).toHaveBeenCalledOnce();
+	});
+
+	it("RPC 模式：选 provider 后选 model → 返回 'provider/model'", async () => {
+		const selectMock = vi.fn()
+			.mockResolvedValueOnce("co") // provider
+			.mockResolvedValueOnce("m1"); // model
+		const ctx = makePickerCtx({
+			mode: "rpc",
+			ui: { notify: vi.fn(), select: selectMock, custom: vi.fn() },
+		});
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const result = await pickModelViaOverlay(ctx, "auto", models);
+		expect(result).toBe("co/m1");
+		expect(ctx.ui.select).toHaveBeenCalledTimes(2);
+	});
+
+	it("RPC 模式：第一次 select undefined（cancel）→ 返回 undefined", async () => {
+		const ctx = makePickerCtx({
+			mode: "rpc",
+			ui: {
+				notify: vi.fn(),
+				select: vi.fn(() => Promise.resolve(undefined)),
+				custom: vi.fn(),
+			},
+		});
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const result = await pickModelViaOverlay(ctx, "auto", models);
+		expect(result).toBeUndefined();
+	});
+
+	it("TUI 模式：custom factory 被调用，comp done settle 结果", async () => {
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		// 模拟 ctx.ui.custom：构造 comp 并模拟 done({kind:'auto'})
+		const customMock = vi.fn(
+			<T,>(factory: (tui: unknown, theme: unknown, kb: unknown, done: (r: T) => void) => unknown) =>
+				new Promise<T>((resolve) => {
+					factory({}, {}, {}, (r: T) => resolve(r));
+				}),
+		);
+		const ctx = makePickerCtx({ mode: "tui", ui: { notify: vi.fn(), select: vi.fn(), custom: customMock } });
+		// 在 factory 内拿到 comp，但这里 mock 直接调 done({kind:'auto'})
+		// 改写 mock：构造真实 comp 并用 cancel/settle
+		customMock.mockImplementationOnce(
+			<T,>(factory: (tui: unknown, theme: unknown, kb: unknown, done: (r: T) => void) => unknown) =>
+				new Promise<T>((resolve) => {
+					const comp = factory({}, {}, {}, (r: T) => resolve(r)) as ProviderModelSelectorComponent;
+					// 触发 provider stage 的 'Auto' 选中（index 0）
+					comp.handleInput("\r"); // Enter → onSelect(Auto) → done({kind:'auto'})
+				}),
+		);
+		const result = await pickModelViaOverlay(ctx, "auto", models);
+		expect(result).toBe("auto");
+		expect(customMock).toHaveBeenCalledOnce();
+	});
+});
+
+// ──────────────────────── ProviderModelSelectorComponent（5 cases + WR1） ────────────────────────
+
+describe("MPT3: ProviderModelSelectorComponent 构造 + 初始 stage", () => {
+	it("构造：初始 stage='provider'，render 非空含 'Select Provider'", () => {
+		const done = vi.fn();
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const comp = new ProviderModelSelectorComponent("auto", ["co"], models, done);
+		const lines = comp.render(80);
+		const joined = lines.join("\n");
+		expect(joined).toContain("Select Provider");
+		expect(joined).toContain("Auto");
+		expect(done).not.toHaveBeenCalled();
+	});
+
+	it("currentSpec='auto' → 预选 'Auto'（index 0）", () => {
+		const done = vi.fn();
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const comp = new ProviderModelSelectorComponent("auto", ["co"], models, done);
+		comp.handleInput("\r"); // Enter 选中预选项（Auto）
+		expect(done).toHaveBeenCalledOnce();
+		const result = done.mock.calls[0]![0] as SelectionResult | undefined;
+		expect(result).toEqual({ kind: "auto" });
+	});
+
+	it("currentSpec='provider/modelId' → 预选该 provider（Enter 直接到 model stage）", () => {
+		const done = vi.fn();
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const comp = new ProviderModelSelectorComponent("co/m1", ["co"], models, done);
+		// 预选 'co'（index 1），Enter 触发 switchToModelStage（不 done）
+		comp.handleInput("\r");
+		expect(done).not.toHaveBeenCalled(); // 进入 model stage，未 settle
+		const lines = comp.render(80);
+		expect(lines.join("\n")).toContain("Select Model");
+	});
+});
+
+describe("MPT4: ProviderModelSelectorComponent provider onSelect", () => {
+	it("provider stage 选 Auto → done({kind:'auto'})", () => {
+		const done = vi.fn();
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const comp = new ProviderModelSelectorComponent("auto", ["co"], models, done);
+		comp.handleInput("\r"); // Enter 选中预选 Auto
+		expect(done).toHaveBeenCalledWith({ kind: "auto" });
+	});
+
+	it("provider stage 选具体 provider → switchToModelStage（不 done）", () => {
+		const done = vi.fn();
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const comp = new ProviderModelSelectorComponent("auto", ["co"], models, done);
+		// 下移到 'co'（index 1），Enter 进入 model stage
+		comp.handleInput("\x1b[B"); // Down arrow
+		comp.handleInput("\r"); // Enter
+		expect(done).not.toHaveBeenCalled();
+		expect(comp.render(80).join("\n")).toContain("Select Model");
+	});
+
+	it("provider stage Esc → done(undefined)（cancel）", () => {
+		const done = vi.fn();
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const comp = new ProviderModelSelectorComponent("auto", ["co"], models, done);
+		comp.handleInput("\x1b"); // Esc
+		expect(done).toHaveBeenCalledWith(undefined);
+	});
+});
+
+describe("MPT5: ProviderModelSelectorComponent model onSelect", () => {
+	it("model stage 选 model → done({kind:'specific', provider, modelId})", () => {
+		const done = vi.fn();
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1), makeEntry("co", "m2", 0.2)] });
+		const comp = new ProviderModelSelectorComponent("auto", ["co"], models, done);
+		// 下移到 'co'，Enter 进 model stage
+		comp.handleInput("\x1b[B"); // Down
+		comp.handleInput("\r"); // Enter → model stage
+		// model stage 预选 m1（cost 升序第一个）
+		comp.handleInput("\r"); // Enter 选 m1
+		expect(done).toHaveBeenCalledWith({ kind: "specific", provider: "co", modelId: "m1" });
+	});
+
+	it("model stage Esc → 回退到 provider stage（不 done）", () => {
+		const done = vi.fn();
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const comp = new ProviderModelSelectorComponent("auto", ["co"], models, done);
+		// 进 model stage
+		comp.handleInput("\x1b[B"); // Down
+		comp.handleInput("\r"); // Enter → model stage
+		// Esc 回退
+		comp.handleInput("\x1b"); // Esc
+		expect(done).not.toHaveBeenCalled();
+		expect(comp.render(80).join("\n")).toContain("Select Provider"); // 回到 provider stage
+	});
+
+	it("_resolved 守卫：done 后再 handleInput no-op", () => {
+		const done = vi.fn();
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const comp = new ProviderModelSelectorComponent("auto", ["co"], models, done);
+		comp.handleInput("\r"); // Auto → done
+		expect(done).toHaveBeenCalledOnce();
+		// 二次输入 no-op
+		comp.handleInput("\r");
+		expect(done).toHaveBeenCalledOnce();
+	});
+});
+
+// ──────────────────────── WR1: handleInput 键盘委托锁定（critical） ────────────────────────
+
+describe("MPT6: WR1 handleInput 委托 SelectList.onSelect（critical）", () => {
+	it("handleInput('\\r') 直接触发 SelectList.onSelect（不绕过键盘委托通路）", () => {
+		const done = vi.fn();
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const comp = new ProviderModelSelectorComponent("auto", ["co"], models, done);
+		// 直接调 handleInput('\r')，验证：
+		// 1. Container.handleInput 不存在，组件 override 委托给 SelectList
+		// 2. SelectList.handleInput('\r') 触发 onSelect → comp.settle({kind:'auto'})
+		comp.handleInput("\r");
+		expect(done).toHaveBeenCalledOnce();
+		const result = done.mock.calls[0]![0] as SelectionResult | undefined;
+		expect(result).toEqual({ kind: "auto" });
+	});
+
+	it("handleInput(down + enter) 链式触发 SelectList 导航 + onSelect", () => {
+		const done = vi.fn();
+		const models = makeModelsMap({ "co": [makeEntry("co", "m1", 0.1)] });
+		const comp = new ProviderModelSelectorComponent("auto", ["co"], models, done);
+		// Down 移动到 'co'，Enter 选中 → 进 model stage（done 未调）
+		comp.handleInput("\x1b[B"); // Down
+		comp.handleInput("\r"); // Enter
+		expect(done).not.toHaveBeenCalled(); // 进入 model stage
+		// model stage Enter 选中 m1
+		comp.handleInput("\r");
+		expect(done).toHaveBeenCalledWith({ kind: "specific", provider: "co", modelId: "m1" });
+	});
+});
+
+// ──────────────────────── DEFAULT_SELECT_THEME（G2 修正验证） ────────────────────────
+
+describe("MPT7: DEFAULT_SELECT_THEME（G2/WR2 修正）", () => {
+	it("selectedPrefix 在文本前加 '▶ '", () => {
+		expect(DEFAULT_SELECT_THEME.selectedPrefix("text")).toBe("\u25B6 text");
+	});
+
+	it("selectedPrefix 非 identity（有视觉区分）", () => {
+		const result = DEFAULT_SELECT_THEME.selectedPrefix("foo");
+		expect(result).not.toBe("foo");
+		expect(result.startsWith("\u25B6")).toBe(true);
+	});
+});