@andares/pi-toolkits 0.4.1 → 0.4.2

package/README.md

@@ -163,8 +163,8 @@ pi -e ./src/index.ts
 
 **评审模型选择**(每次 `/third-review` 都会弹出选择界面):
 
-- `/third-review` → 弹出模型列表(与 `/model` 同源):**第一项 = 当前配置的模型**(默认高亮),直接**回车**即用它开始评审;也可移动到其他模型
-- **换选其他模型** → 立即写回配置(**落盘 + 内存**),**下次默认使用该模型**;标题实时显示当前配置
+- `/third-review` → 弹出 **`/model` 同款选择器**(限高滚动 + 模糊搜索):**默认选中当前配置的模型**(✓ 标记),直接**回车**即用它开始评审
+- **换选其他模型** → 立即写回配置(**落盘 + 内存**),**下次默认使用该模型**
 - **取消**(Esc)→ 不执行评审,配置不变
 - 配置持久化于 `<agent-dir>/pi-toolkits-review.json`(默认 `~/.pi/agent/`):
 
@@ -206,7 +206,7 @@ pi 的 `/compact` 与 auto-compact 默认**用当前会话模型**做上下文
 { "model": "google/gemini-2.5-flash" }
 ```
 
-- `/compact-model` —— 查看/更换/清除:弹出可用模型列表(标题显示当前配置,首项「✕ 清除配置」),选中即写入;取消则不修改
+- `/compact-model` —— 查看/更换:`/model` 同款选择器(限高滚动 + 模糊搜索),**默认选中当前配置的模型**,回车即确认;换选即写入;取消则不变(清除配置:编辑 `pi-toolkits-compact.json` 把 `model` 置为 `null`)
 - 未配置 = 功能未启用,全部走 pi 默认,零开销;footer 出现灰色 `compact` 状态 = 已配置
 
 **无损回落**(本功能永远不会把压缩「做挂」):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andares/pi-toolkits",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Integrated toolkit extension for pi — ask mode (read-only Q&A), model favorites, prompt stash, third-party code review, and a dedicated compaction model",
   "type": "module",
   "license": "MIT",

package/src/features/compact/compact.test.ts

@@ -133,11 +133,14 @@ interface CtxOverrides {
 		options: { maxTokens?: number; signal?: AbortSignal },
 	) => Promise<AssistantMessageLike>;
 	hasUI?: boolean;
+	mode?: string;
+	customResult?: AvailableModel | undefined;
 	selectResult?: string | undefined;
 }
 
 function fakeCtx(overrides: CtxOverrides = {}) {
 	const notify = vi.fn();
+	const custom = vi.fn(async () => overrides.customResult);
 	const select = vi.fn(async () => overrides.selectResult);
 	const setStatus = vi.fn();
 	const complete =
@@ -146,16 +149,16 @@ function fakeCtx(overrides: CtxOverrides = {}) {
 			CtxOverrides["complete"]
 		>);
 	const ctx = {
-		mode: "tui",
+		mode: overrides.mode ?? "tui",
 		hasUI: overrides.hasUI ?? true,
 		isIdle: () => true,
 		modelRegistry: {
 			getAvailable: () => overrides.models ?? MODELS,
 			complete,
 		},
-		ui: { notify, select, setStatus },
+		ui: { notify, custom, select, setStatus },
 	} as unknown as ExtensionContext;
-	return { ctx, notify, select, setStatus, complete };
+	return { ctx, notify, custom, select, setStatus, complete };
 }
 
 function fakePi() {
@@ -279,10 +282,10 @@ describe("CompactStore", () => {
 
 describe("pickCompactModel", () => {
 	it("notifies and returns when there is no dialog UI", async () => {
-		const { ctx, notify, select } = fakeCtx({ hasUI: false });
+		const { ctx, notify, custom } = fakeCtx({ hasUI: false });
 		const model = await pickCompactModel(ctx, getCompactStore());
 		expect(model).toBeUndefined();
-		expect(select).not.toHaveBeenCalled();
+		expect(custom).not.toHaveBeenCalled();
 		expect(notify).toHaveBeenCalledWith(
 			expect.stringContaining("pi-toolkits-compact.json"),
 			"error",
@@ -298,24 +301,20 @@ describe("pickCompactModel", () => {
 		);
 	});
 
-	it("clears config when the clear option is chosen", async () => {
+	it("hints how to clear the config when cancelled", async () => {
 		getCompactStore().setModel("google/gemini-2.5-flash");
-		const { ctx, notify } = fakeCtx({
-			selectResult: "✕ 清除配置（用 pi 默认压缩）",
-		});
+		const { ctx, notify } = fakeCtx({ customResult: undefined });
 		const model = await pickCompactModel(ctx, getCompactStore());
 		expect(model).toBeUndefined();
-		expect(getCompactStore().getModel()).toBeUndefined();
+		expect(getCompactStore().getModel()).toBe("google/gemini-2.5-flash");
 		expect(notify).toHaveBeenCalledWith(
-			expect.stringContaining("已清除"),
+			expect.stringContaining("置为 null"),
 			"info",
 		);
 	});
 
 	it("persists the picked model", async () => {
-		const { ctx } = fakeCtx({
-			selectResult: "Gemini 2.5 Flash (google/gemini-2.5-flash)",
-		});
+		const { ctx } = fakeCtx({ customResult: MODELS[0] });
 		const model = await pickCompactModel(ctx, getCompactStore());
 		expect(modelKey(model!)).toBe("google/gemini-2.5-flash");
 		expect(getCompactStore().getModel()).toBe("google/gemini-2.5-flash");
@@ -323,7 +322,7 @@ describe("pickCompactModel", () => {
 
 	it("keeps config on cancel", async () => {
 		getCompactStore().setModel("google/gemini-2.5-flash");
-		const { ctx, notify } = fakeCtx({ selectResult: undefined });
+		const { ctx, notify } = fakeCtx({ customResult: undefined });
 		await pickCompactModel(ctx, getCompactStore());
 		expect(getCompactStore().getModel()).toBe("google/gemini-2.5-flash");
 		expect(notify).toHaveBeenCalledWith(
@@ -331,6 +330,30 @@ describe("pickCompactModel", () => {
 			"info",
 		);
 	});
+
+	it("warns when the configured model is unavailable", async () => {
+		getCompactStore().setModel("google/nonexistent");
+		const { ctx, notify } = fakeCtx({ customResult: MODELS[0] });
+		await pickCompactModel(ctx, getCompactStore());
+		expect(notify).toHaveBeenCalledWith(
+			expect.stringContaining("不存在或不可用"),
+			"warning",
+		);
+		expect(getCompactStore().getModel()).toBe("google/gemini-2.5-flash");
+	});
+
+	it("works in rpc mode via the host selector", async () => {
+		const { ctx, custom, select } = fakeCtx({
+			mode: "rpc",
+			selectResult: "Gemini 2.5 Flash (google/gemini-2.5-flash)",
+		});
+		const model = await pickCompactModel(ctx, getCompactStore());
+		// rpc cannot host custom components — the host renders select instead.
+		expect(custom).not.toHaveBeenCalled();
+		expect(select).toHaveBeenCalledTimes(1);
+		expect(getCompactStore().getModel()).toBe("google/gemini-2.5-flash");
+		expect(modelKey(model!)).toBe("google/gemini-2.5-flash");
+	});
 });
 
 // ─── session_before_compact handler ────────────────────────────

package/src/features/compact/index.ts

@@ -18,7 +18,8 @@
  *    compaction worse than stock.
  *
  * Config lives in `<agent-dir>/pi-toolkits-compact.json` ("provider/id",
- * see store.ts). /compact-model views/changes/clears it; auto-compact paths
+ * see store.ts). /compact-model opens the /model-style picker (configured
+ * model preselected; picking persists); auto-compact paths
  * never open dialogs (handler only uses notify).
  */
 import type {
@@ -40,6 +41,7 @@ import {
 	resolveConfiguredModel,
 	type AvailableModel,
 } from "../../lib/model-config.js";
+import { openModelPicker } from "../../lib/model-picker.js";
 import { COMPACT_STATUS_KEY } from "./constants.js";
 import {
 	buildHistoryPromptText,
@@ -249,8 +251,8 @@ async function runCompactModelCompaction(
 }
 
 /**
- * Let the user pick a compact model (or clear the config) and persist the
- * choice. Mirrors review's pickReviewModel, plus a leading clear option.
+ * Let the user pick a compact model with the /model-style picker and persist
+ * the choice. Mirrors review's pickReviewModel.
  */
 export async function pickCompactModel(
 	ctx: ExtensionContext,
@@ -263,45 +265,31 @@ export async function pickCompactModel(
 		);
 		return undefined;
 	}
-	const available = ctx.modelRegistry.getAvailable();
-	if (available.length === 0) {
+	const configured = store.getModel();
+	const configuredModel = resolveConfiguredModel(ctx, configured);
+	if (!configuredModel && configured) {
 		ctx.ui.notify(
-			"compact-model: 当前没有可用模型，请先在 pi 中配置模型。",
-			"error",
+			`compact-model: 配置的压缩模型 ${configured} 不存在或不可用，请重新选择。`,
+			"warning",
 		);
-		return undefined;
 	}
-	const configured = store.getModel();
-	const clearLabel = "✕ 清除配置（用 pi 默认压缩）";
-	const options = [
-		clearLabel,
-		...available.map(
-			(m: AvailableModel) => `${m.name} (${m.provider}/${m.id})`,
-		),
-	];
-	const choice = await ctx.ui.select(
-		configured
-			? `选择压缩模型 (当前: ${configured})`
-			: "选择压缩模型 (compact-model)",
-		options,
-	);
-	if (choice === undefined) {
-		ctx.ui.notify("compact-model: 已取消，压缩模型配置未变更。", "info");
-		return undefined;
-	}
-	if (choice === clearLabel) {
-		store.setModel(undefined);
+	const model = await openModelPicker(ctx, configuredModel, {
+		selectTitle: "选择压缩模型（首项为当前默认，回车使用）",
+	});
+	if (!model) {
 		ctx.ui.notify(
-			"compact-model: 已清除配置，压缩恢复 pi 默认（当前会话模型）。",
+			"compact-model: 已取消，压缩模型配置未变更。清除配置请编辑 <agent-dir>/pi-toolkits-compact.json（把 model 置为 null）。",
 			"info",
 		);
 		return undefined;
 	}
-	const model = available[options.indexOf(choice) - 1];
-	if (!model) return undefined;
-	store.setModel(modelKey(model));
+	const key = modelKey(model);
+	if (key !== configured) {
+		// Persist immediately (disk + in-memory + footer) — next compaction uses it.
+		store.setModel(key);
+	}
 	ctx.ui.notify(
-		`compact-model: 已设置压缩模型「${model.name}」，后续压缩总结将由它执行。`,
+		`compact-model: 压缩模型已设置为「${model.name}」，后续压缩总结将由它执行。`,
 		"info",
 	);
 	return model;
@@ -330,10 +318,10 @@ export function registerCompact(pi: ExtensionAPI): void {
 		},
 	);
 
-	// Config entry point: view, change, or clear the compact model.
+	// Config entry point: view and change the compact model.
 	pi.registerCommand("compact-model", {
 		description:
-			"Set, change, or clear the dedicated model used for /compact summaries",
+			"Set or change the dedicated model used for /compact summaries",
 		handler: async (_args: string, ctx: ExtensionContext) => {
 			await pickCompactModel(ctx, getCompactStore());
 		},

package/src/features/review/index.ts

@@ -12,13 +12,14 @@
  *
  * Review-model config lives in `<agent-dir>/pi-toolkits-review.json`
  * ("provider/id", see store.ts) and doubles as the picker default. Every
- * /third-review run opens the model picker (ctx.ui.select, same
- * getAvailable() source as /model) with the configured model as the FIRST
- * row — one Enter accepts it and starts the review. Picking a different
- * model persists it immediately (disk + in-memory) as the new default for
- * next time; cancelling aborts the review without changing anything. When
- * the configured model is gone/unavailable (e.g. deleted from pi's
- * models.json) the user is warned and the picker opens on the plain list.
+ * /third-review run opens the /model-style picker (the REAL built-in
+ * ModelSelectorComponent — height-limited scrolling list + fuzzy search)
+ * with the configured model preselected and ✓-marked: one Enter accepts it
+ * and starts the review. Picking a different model persists it immediately
+ * (disk + in-memory) as the new default for next time; cancelling aborts
+ * the review without changing anything. When the configured model is
+ * gone/unavailable (e.g. deleted from pi's models.json) the user is warned
+ * and the picker opens without a preselection.
  *
  * Guards: never fires while the agent is streaming (the review needs the
  * just-finished work as context) and never runs two reviews concurrently.
@@ -34,19 +35,19 @@ import {
 	resolveConfiguredModel,
 	type AvailableModel,
 } from "../../lib/model-config.js";
+import { openModelPicker } from "../../lib/model-picker.js";
 import { REVIEW_STATUS_KEY } from "./constants.js";
 import { REVIEW_PROMPT } from "./prompt.js";
 import { getReviewStore, type ReviewStore } from "./store.js";
 
 /**
- * Let the user pick a review model from the available list and persist the
- * choice. Returns the picked model, or undefined when cancelled/unavailable.
+ * Let the user pick a review model with the /model-style picker and persist
+ * the choice. Returns the picked model, or undefined when cancelled.
  *
- * The configured model is placed FIRST: the select dialog always highlights
- * its first row, so one Enter accepts the current default. Picking any other
- * model persists it (disk + in-memory) as the new default. The title shows
- * the current config, so /review-model doubles as a view-and-change entry
- * point; cancelling leaves the config untouched.
+ * The configured model is the picker's default (preselected + ✓-marked +
+ * first), so one Enter accepts it. Picking any other model persists it
+ * (disk + in-memory) as the new default. /review-model doubles as a
+ * view-and-change entry point; cancelling leaves the config untouched.
  */
 export async function pickReviewModel(
 	ctx: ExtensionContext,
@@ -61,45 +62,21 @@ export async function pickReviewModel(
 		);
 		return undefined;
 	}
-	const available = ctx.modelRegistry.getAvailable();
-	if (available.length === 0) {
-		ctx.ui.notify(
-			"third-review: 当前没有可用模型，请先在 pi 中配置模型。",
-			"error",
-		);
-		return undefined;
-	}
 	const configured = store.getModel();
 	const configuredModel = resolveConfiguredModel(ctx, configured);
-	// Configured model first → highlighted by default (Enter accepts it);
-	// the rest keep the registry order.
-	const ordered: AvailableModel[] = configuredModel
-		? [
-				configuredModel,
-				...available.filter(
-					(m) => modelKey(m) !== modelKey(configuredModel),
-				),
-			]
-		: available;
-	// Same display source as the /model selector: name + [provider]/id.
-	const options = ordered.map(
-		(m: AvailableModel) => `${m.name} (${m.provider}/${m.id})`,
-	);
-	// Title reflects what Enter actually accepts: the configured model when it
-	// is available, a clear "unavailable" marker otherwise.
-	let title = "选择评审模型 (third-review)";
-	if (configuredModel) {
-		title = `选择评审模型 (当前: ${configured}，回车使用)`;
-	} else if (configured) {
-		title = `选择评审模型 (当前: ${configured} 不可用)`;
+	if (!configuredModel && configured) {
+		ctx.ui.notify(
+			`third-review: 配置的评审模型 ${configured} 不存在或不可用，请重新选择。`,
+			"warning",
+		);
 	}
-	const choice = await ctx.ui.select(title, options);
-	if (choice === undefined) {
+	const model = await openModelPicker(ctx, configuredModel, {
+		selectTitle: "选择评审模型（首项为当前默认，回车使用）",
+	});
+	if (!model) {
 		ctx.ui.notify("third-review: 已取消，评审模型配置未变更。", "info");
 		return undefined;
 	}
-	const model = ordered[options.indexOf(choice)];
-	if (!model) return undefined;
 	const key = modelKey(model);
 	if (key !== configured) {
 		// Persist immediately (disk + in-memory + footer) — next run defaults here.
@@ -139,29 +116,24 @@ export function createReviewRunner(
 		running = true;
 		try {
 			const store = getReviewStore();
-			const configured = store.getModel();
-			let model = resolveConfiguredModel(ctx, configured);
-			if (!model) {
-				ctx.ui.notify(
-					configured
-						? `third-review: 配置的评审模型 ${configured} 不存在或不可用，请重新选择。`
-						: "third-review: 尚未配置评审模型，请选择。",
-					"warning",
-				);
-			}
+			let model: AvailableModel | undefined;
 			if (ctx.hasUI) {
-				// Always show the picker: the configured model is the first row
-				// (one Enter accepts it); picking another persists it as default.
+				// Always show the /model-style picker: the configured model is
+				// preselected (one Enter accepts it); picking another persists it.
+				// (The unavailable-config warning lives inside pickReviewModel.)
 				model = await pickReviewModel(ctx, store);
 				if (!model) return;
-			} else if (!model) {
+			} else {
 				// No dialogs (json/print/headless): the configured-model path keeps
 				// working; without one, point at the config file.
-				ctx.ui.notify(
-					"third-review: 当前环境不支持模型选择对话框，请编辑 <agent-dir>/pi-toolkits-review.json 手动配置。",
-					"error",
-				);
-				return;
+				model = resolveConfiguredModel(ctx, store.getModel());
+				if (!model) {
+					ctx.ui.notify(
+						"third-review: 当前环境不支持模型选择对话框，请编辑 <agent-dir>/pi-toolkits-review.json 手动配置。",
+						"error",
+					);
+					return;
+				}
 			}
 			const switched = await pi.setModel(model);
 			if (!switched) {
@@ -190,18 +162,18 @@ export function registerReview(pi: ExtensionAPI): void {
 	// the runner, which may block on the model picker and the review turn.
 	pi.registerCommand("third-review", {
 		description:
-			"Summon the configured review model to review the just-completed work (check + fix)",
+			"Pick the review model (defaults to the configured one) and review the just-completed work (check + fix)",
 		handler: async (_args: string, ctx: ExtensionContext) => {
 			await runReview(ctx);
 		},
 	});
 
 	// Manual config entry point: view and change the review model. Always
-	// opens the picker (title shows the current config); cancelling keeps
-	// the existing config, so it is also safe as a view-only command.
+	// opens the /model-style picker (configured model preselected); cancelling
+	// keeps the existing config, so it is also safe as a view-only command.
 	pi.registerCommand("review-model", {
 		description:
-			"Set or change the review model used by third-review (picker shows the current one)",
+			"Set or change the review model used by third-review (picker preselects the current one)",
 		handler: async (_args: string, ctx: ExtensionContext) => {
 			await pickReviewModel(ctx, getReviewStore());
 		},

package/src/features/review/review.test.ts

@@ -38,6 +38,7 @@ import {
 import {
 	modelKey,
 	resolveConfiguredModel,
+	type AvailableModel,
 } from "../../lib/model-config.js";
 import { REVIEW_PROMPT } from "./prompt.js";
 import {
@@ -98,10 +99,12 @@ function fakeCtx(
 		models?: Model<Api>[];
 		mode?: string;
 		hasUI?: boolean;
+		customResult?: AvailableModel | undefined;
 		selectResult?: string | undefined;
 	} = {},
 ) {
 	const notify = vi.fn();
+	const custom = vi.fn(async () => overrides.customResult);
 	const select = vi.fn(async () => overrides.selectResult);
 	const ctx = {
 		mode: overrides.mode ?? "tui",
@@ -110,9 +113,9 @@ function fakeCtx(
 		modelRegistry: {
 			getAvailable: () => overrides.models ?? MODELS,
 		} as unknown as ModelRegistry,
-		ui: { notify, select },
+		ui: { notify, custom, select },
 	} as unknown as ExtensionContext;
-	return { ctx, notify, select };
+	return { ctx, notify, custom, select };
 }
 
 function fakePi(switched = true) {
@@ -228,34 +231,28 @@ describe("ReviewStore", () => {
 // ─── pickReviewModel ───────────────────────────────────────────
 
 describe("pickReviewModel", () => {
-	it("shows the available models and persists the pick", async () => {
-		const { ctx, select } = fakeCtx({
-			selectResult: "GPT-5 (openrouter/openai/gpt-5)",
-		});
+	it("opens the picker and persists the picked model", async () => {
 		const store = new ReviewStore(freshStoreFile());
+		const { ctx, custom } = fakeCtx({ customResult: MODELS[2] });
 		const picked = await pickReviewModel(ctx, store);
 		expect(picked).toBe(MODELS[2]);
-		expect(select).toHaveBeenCalledWith("选择评审模型 (third-review)", [
-			"Claude Sonnet 4 (anthropic/claude-sonnet-4)",
-			"Claude Opus 4 (anthropic/claude-opus-4)",
-			"GPT-5 (openrouter/openai/gpt-5)",
-		]);
+		expect(custom).toHaveBeenCalledTimes(1);
 		expect(store.getModel()).toBe("openrouter/openai/gpt-5");
 	});
 
 	it("returns undefined and does not persist when cancelled", async () => {
-		const { ctx, select } = fakeCtx({ selectResult: undefined });
 		const store = new ReviewStore(freshStoreFile());
+		const { ctx, custom } = fakeCtx({ customResult: undefined });
 		expect(await pickReviewModel(ctx, store)).toBeUndefined();
-		expect(select).toHaveBeenCalledTimes(1);
+		expect(custom).toHaveBeenCalledTimes(1);
 		expect(store.getModel()).toBeUndefined();
 	});
 
 	it("fails gracefully when no models are available", async () => {
-		const { ctx, notify, select } = fakeCtx({ models: [] });
+		const { ctx, notify, custom } = fakeCtx({ models: [] });
 		const store = new ReviewStore(freshStoreFile());
 		expect(await pickReviewModel(ctx, store)).toBeUndefined();
-		expect(select).not.toHaveBeenCalled();
+		expect(custom).not.toHaveBeenCalled();
 		expect(notify).toHaveBeenCalledWith(
 			expect.stringContaining("没有可用模型"),
 			"error",
@@ -263,52 +260,56 @@ describe("pickReviewModel", () => {
 	});
 
 	it("refuses when no dialog-capable UI is available", async () => {
-		const { ctx, notify, select } = fakeCtx({ hasUI: false });
+		const { ctx, notify, custom } = fakeCtx({ hasUI: false });
 		const store = new ReviewStore(freshStoreFile());
 		expect(await pickReviewModel(ctx, store)).toBeUndefined();
-		expect(select).not.toHaveBeenCalled();
+		expect(custom).not.toHaveBeenCalled();
 		expect(notify).toHaveBeenCalledWith(
 			expect.stringContaining("不支持模型选择对话框"),
 			"error",
 		);
 	});
 
-	it("works in rpc mode (dialogs are available there)", async () => {
-		const { ctx, select } = fakeCtx({
+	it("works in rpc mode via the host selector", async () => {
+		const store = new ReviewStore(freshStoreFile());
+		const { ctx, custom, select } = fakeCtx({
 			mode: "rpc",
 			selectResult: "Claude Opus 4 (anthropic/claude-opus-4)",
 		});
-		const store = new ReviewStore(freshStoreFile());
 		const picked = await pickReviewModel(ctx, store);
 		expect(picked).toBe(MODELS[1]);
+		// rpc cannot host custom components — the host renders select instead.
+		expect(custom).not.toHaveBeenCalled();
 		expect(select).toHaveBeenCalledTimes(1);
 		expect(store.getModel()).toBe("anthropic/claude-opus-4");
 	});
 
-	it("puts the configured model first (Enter accepts it) and keeps config on cancel", async () => {
+	it("keeps the config untouched when cancelled", async () => {
 		const store = new ReviewStore(freshStoreFile());
 		store.setModel("anthropic/claude-opus-4");
-		const { ctx, select } = fakeCtx({ selectResult: undefined });
+		const { ctx, custom } = fakeCtx({ customResult: undefined });
 		await pickReviewModel(ctx, store);
-		expect(select).toHaveBeenCalledWith(
-			"选择评审模型 (当前: anthropic/claude-opus-4，回车使用)",
-			[
-				"Claude Opus 4 (anthropic/claude-opus-4)",
-				"Claude Sonnet 4 (anthropic/claude-sonnet-4)",
-				"GPT-5 (openrouter/openai/gpt-5)",
-			],
-		);
+		expect(custom).toHaveBeenCalledTimes(1);
 		// Cancelling a change keeps the existing config.
 		expect(store.getModel()).toBe("anthropic/claude-opus-4");
 	});
 
+	it("warns when the configured model is unavailable", async () => {
+		const store = new ReviewStore(freshStoreFile());
+		store.setModel("anthropic/claude-opus-4-5"); // deleted in pi
+		const { ctx, notify } = fakeCtx({ customResult: undefined });
+		await pickReviewModel(ctx, store);
+		expect(notify).toHaveBeenCalledWith(
+			expect.stringContaining("不存在或不可用"),
+			"warning",
+		);
+	});
+
 	it("re-picking the configured model does not rewrite the store", async () => {
 		const store = new ReviewStore(freshStoreFile());
 		store.setModel("anthropic/claude-opus-4");
 		const spy = vi.spyOn(store, "setModel");
-		const { ctx } = fakeCtx({
-			selectResult: "Claude Opus 4 (anthropic/claude-opus-4)",
-		});
+		const { ctx } = fakeCtx({ customResult: MODELS[1] });
 		const picked = await pickReviewModel(ctx, store);
 		expect(picked).toBe(MODELS[1]);
 		expect(spy).not.toHaveBeenCalled();
@@ -317,9 +318,7 @@ describe("pickReviewModel", () => {
 	it("persists and confirms when a different model is picked", async () => {
 		const store = new ReviewStore(freshStoreFile());
 		store.setModel("anthropic/claude-opus-4");
-		const { ctx, notify } = fakeCtx({
-			selectResult: "GPT-5 (openrouter/openai/gpt-5)",
-		});
+		const { ctx, notify } = fakeCtx({ customResult: MODELS[2] });
 		const picked = await pickReviewModel(ctx, store);
 		expect(picked).toBe(MODELS[2]);
 		expect(store.getModel()).toBe("openrouter/openai/gpt-5");
@@ -348,12 +347,10 @@ describe("createReviewRunner", () => {
 	it("shows the picker and runs on the configured model when accepted", async () => {
 		getReviewStore().setModel("anthropic/claude-sonnet-4");
 		const { pi, setModel, sendUserMessage } = fakePi();
-		const { ctx, notify, select } = fakeCtx({
-			selectResult: "Claude Sonnet 4 (anthropic/claude-sonnet-4)",
-		});
+		const { ctx, notify, custom } = fakeCtx({ customResult: MODELS[0] });
 		await createReviewRunner(pi)(ctx);
 		// The picker is always shown, even with a configured model.
-		expect(select).toHaveBeenCalledTimes(1);
+		expect(custom).toHaveBeenCalledTimes(1);
 		expect(setModel).toHaveBeenCalledWith(MODELS[0]);
 		expect(sendUserMessage).toHaveBeenCalledWith(REVIEW_PROMPT);
 		expect(notify).toHaveBeenCalledWith(
@@ -365,35 +362,27 @@ describe("createReviewRunner", () => {
 	it("runs with the configured model without dialogs when the UI cannot pick", async () => {
 		getReviewStore().setModel("anthropic/claude-sonnet-4");
 		const { pi, setModel, sendUserMessage } = fakePi();
-		const { ctx, select } = fakeCtx({ hasUI: false });
+		const { ctx, custom } = fakeCtx({ hasUI: false });
 		await createReviewRunner(pi)(ctx);
-		expect(select).not.toHaveBeenCalled();
+		expect(custom).not.toHaveBeenCalled();
 		expect(setModel).toHaveBeenCalledWith(MODELS[0]);
 		expect(sendUserMessage).toHaveBeenCalledWith(REVIEW_PROMPT);
 	});
 
 	it("picks, persists and runs when no model is configured", async () => {
 		const { pi, setModel, sendUserMessage } = fakePi();
-		const { ctx, notify, select } = fakeCtx({
-			selectResult: "GPT-5 (openrouter/openai/gpt-5)",
-		});
+		const { ctx, custom } = fakeCtx({ customResult: MODELS[2] });
 		await createReviewRunner(pi)(ctx);
 		expect(getReviewStore().getModel()).toBe("openrouter/openai/gpt-5");
 		expect(setModel).toHaveBeenCalledWith(MODELS[2]);
 		expect(sendUserMessage).toHaveBeenCalledWith(REVIEW_PROMPT);
-		expect(select).toHaveBeenCalledTimes(1);
-		expect(notify).toHaveBeenCalledWith(
-			expect.stringContaining("尚未配置评审模型"),
-			"warning",
-		);
+		expect(custom).toHaveBeenCalledTimes(1);
 	});
 
 	it("re-picks, persists and runs when the configured model is unavailable", async () => {
 		getReviewStore().setModel("anthropic/claude-opus-4-5"); // deleted in pi
 		const { pi, setModel, sendUserMessage } = fakePi();
-		const { ctx, notify, select } = fakeCtx({
-			selectResult: "Claude Sonnet 4 (anthropic/claude-sonnet-4)",
-		});
+		const { ctx, notify, custom } = fakeCtx({ customResult: MODELS[0] });
 		await createReviewRunner(pi)(ctx);
 		expect(notify).toHaveBeenCalledWith(
 			expect.stringContaining("不存在或不可用"),
@@ -402,20 +391,14 @@ describe("createReviewRunner", () => {
 		expect(getReviewStore().getModel()).toBe("anthropic/claude-sonnet-4");
 		expect(setModel).toHaveBeenCalledWith(MODELS[0]);
 		expect(sendUserMessage).toHaveBeenCalledWith(REVIEW_PROMPT);
-		expect(select).toHaveBeenCalledTimes(1);
-		// The title marks the configured model as unavailable (Enter picks the
-		// first available row, not the configured one).
-		expect(select).toHaveBeenCalledWith(
-			"选择评审模型 (当前: anthropic/claude-opus-4-5 不可用)",
-			expect.any(Array),
-		);
+		expect(custom).toHaveBeenCalledTimes(1);
 	});
 
 	it("aborts when the user cancels the model pick", async () => {
 		const { pi, setModel, sendUserMessage } = fakePi();
-		const { ctx, select } = fakeCtx({ selectResult: undefined });
+		const { ctx, custom } = fakeCtx({ customResult: undefined });
 		await createReviewRunner(pi)(ctx);
-		expect(select).toHaveBeenCalledTimes(1);
+		expect(custom).toHaveBeenCalledTimes(1);
 		expect(setModel).not.toHaveBeenCalled();
 		expect(sendUserMessage).not.toHaveBeenCalled();
 		expect(getReviewStore().getModel()).toBeUndefined();
@@ -424,9 +407,7 @@ describe("createReviewRunner", () => {
 	it("reports and aborts when switching to the review model fails", async () => {
 		getReviewStore().setModel("anthropic/claude-sonnet-4");
 		const { pi, setModel, sendUserMessage } = fakePi(false); // setModel → false
-		const { ctx, notify } = fakeCtx({
-			selectResult: "Claude Sonnet 4 (anthropic/claude-sonnet-4)",
-		});
+		const { ctx, notify } = fakeCtx({ customResult: MODELS[0] });
 		await createReviewRunner(pi)(ctx);
 		expect(setModel).toHaveBeenCalledWith(MODELS[0]);
 		expect(sendUserMessage).not.toHaveBeenCalled();
@@ -438,10 +419,10 @@ describe("createReviewRunner", () => {
 
 	it("serializes concurrent triggers (one review at a time)", async () => {
 		const { pi } = fakePi();
-		// First run blocks inside ui.select until we resolve it.
-		let release: ((v: string | undefined) => void) | undefined;
-		const select = vi.fn(
-			() => new Promise<string | undefined>((resolve) => (release = resolve)),
+		// First run blocks inside the picker until we resolve it.
+		let release: ((v: AvailableModel | undefined) => void) | undefined;
+		const custom = vi.fn(
+			() => new Promise<AvailableModel | undefined>((resolve) => (release = resolve)),
 		);
 		const ctx = {
 			mode: "tui",
@@ -450,7 +431,7 @@ describe("createReviewRunner", () => {
 			modelRegistry: {
 				getAvailable: () => MODELS,
 			} as unknown as ModelRegistry,
-			ui: { notify: vi.fn(), select },
+			ui: { notify: vi.fn(), custom },
 		} as unknown as ExtensionContext;
 
 		const runner = createReviewRunner(pi);
@@ -462,14 +443,14 @@ describe("createReviewRunner", () => {
 			hasUI: true,
 			isIdle: () => true,
 			modelRegistry: { getAvailable: () => MODELS } as unknown as ModelRegistry,
-			ui: { notify: notify2, select: vi.fn(async () => undefined) },
+			ui: { notify: notify2, custom: vi.fn(async () => undefined) },
 		} as unknown as ExtensionContext;
 		await runner(ctx2);
 		expect(notify2).toHaveBeenCalledWith(
 			expect.stringContaining("评审已在执行中"),
 			"warning",
 		);
-		release?.("Claude Sonnet 4 (anthropic/claude-sonnet-4)");
+		release?.(MODELS[0]);
 		await first;
 		expect(pi.setModel).toHaveBeenCalledTimes(1);
 		expect(pi.sendUserMessage).toHaveBeenCalledTimes(1);

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

@@ -0,0 +1,191 @@
+/**
+ * model-picker — tests.
+ *
+ * Mocks ModelSelectorComponent (the real built-in /model component) to
+ * capture how openModelPicker drives it: the preselected currentModel, the
+ * modelRuntime facade wiring over the registry, and select/cancel
+ * resolution. The preselection + scrolling list behavior itself belongs to
+ * pi's component (covered by pi) — here we assert OUR wiring.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AvailableModel } from "./model-config.js";
+import { openModelPicker } from "./model-picker.js";
+
+const { instances } = vi.hoisted(() => ({
+	instances: [] as Array<{
+		currentModel: unknown;
+		modelRuntime: unknown;
+		onSelect: (model: unknown) => void;
+		onCancel: () => void;
+	}>,
+}));
+
+vi.mock("@earendil-works/pi-coding-agent", async (importOriginal) => {
+	const actual =
+		await importOriginal<typeof import("@earendil-works/pi-coding-agent")>();
+	class FakeSelector {
+		currentModel: unknown;
+		modelRuntime: unknown;
+		onSelect: (model: unknown) => void;
+		onCancel: () => void;
+		constructor(
+			_tui: unknown,
+			currentModel: unknown,
+			modelRuntime: unknown,
+			_scopedModels: unknown,
+			onSelect: (model: unknown) => void,
+			onCancel: () => void,
+		) {
+			this.currentModel = currentModel;
+			this.modelRuntime = modelRuntime;
+			this.onSelect = onSelect;
+			this.onCancel = onCancel;
+			instances.push(this);
+		}
+		dispose(): void {}
+	}
+	return { ...actual, ModelSelectorComponent: FakeSelector };
+});
+
+function fakeModel(provider: string, id: string, name = id): AvailableModel {
+	return {
+		id,
+		name,
+		provider,
+		api: "anthropic-messages",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: false,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 200000,
+		maxTokens: 8192,
+	} as AvailableModel;
+}
+
+const MODELS: AvailableModel[] = [
+	fakeModel("google", "gemini-2.5-flash", "Gemini 2.5 Flash"),
+	fakeModel("anthropic", "claude-sonnet-4", "Claude Sonnet 4"),
+];
+
+function fakeCtx(models: AvailableModel[] = MODELS) {
+	const notify = vi.fn();
+	const custom = vi.fn((factory: (...args: unknown[]) => unknown) => {
+		// Mimic pi's mounting: the factory runs, constructing the component;
+		// the component's done() callback resolves the dialog.
+		return new Promise((resolve) => {
+			factory(
+				{ requestRender: vi.fn() },
+				undefined,
+				undefined,
+				(result: unknown) => resolve(result),
+			);
+		});
+	});
+	const select = vi.fn(async () => undefined as string | undefined);
+	const ctx = {
+		hasUI: true,
+		mode: "tui",
+		model: undefined,
+		modelRegistry: {
+			getAvailable: () => models,
+			find: (provider: string, id: string) =>
+				models.find((m) => m.provider === provider && m.id === id),
+			getError: () => undefined,
+			refresh: async () => ({ aborted: false, errors: new Map() }),
+		},
+		ui: { notify, custom, select },
+	} as unknown as ExtensionContext;
+	return { ctx, notify, custom, select };
+}
+
+describe("openModelPicker", () => {
+	beforeEach(() => {
+		instances.length = 0;
+	});
+
+	it("resolves undefined without dialogs when the UI cannot pick", async () => {
+		const { ctx, custom } = fakeCtx();
+		(ctx as { hasUI: boolean }).hasUI = false;
+		expect(await openModelPicker(ctx)).toBeUndefined();
+		expect(custom).not.toHaveBeenCalled();
+	});
+
+	it("notifies when no models are available", async () => {
+		const { ctx, notify } = fakeCtx([]);
+		expect(await openModelPicker(ctx)).toBeUndefined();
+		expect(notify).toHaveBeenCalledWith(
+			expect.stringContaining("没有可用模型"),
+			"error",
+		);
+	});
+
+	it("preselects the current model as the component's currentModel", async () => {
+		const { ctx } = fakeCtx();
+		const promise = openModelPicker(ctx, MODELS[1]);
+		const selector = instances.at(-1)!;
+		expect(selector.currentModel).toBe(MODELS[1]);
+		selector.onSelect(MODELS[0]);
+		expect(await promise).toBe(MODELS[0]);
+	});
+
+	it("falls back to the session model when nothing is configured", async () => {
+		const { ctx } = fakeCtx();
+		const sessionModel = MODELS[0];
+		(ctx as { model: unknown }).model = sessionModel;
+		const promise = openModelPicker(ctx);
+		const selector = instances.at(-1)!;
+		expect(selector.currentModel).toBe(sessionModel);
+		selector.onCancel();
+		expect(await promise).toBeUndefined();
+	});
+
+	it("backs the component with a modelRuntime facade over the registry", async () => {
+		const { ctx } = fakeCtx();
+		const promise = openModelPicker(ctx, MODELS[0]);
+		const selector = instances.at(-1)!;
+		const runtime = selector.modelRuntime as {
+			getAvailableSnapshot(): AvailableModel[];
+			getModel(p: string, id: string): AvailableModel | undefined;
+			getError(): string | undefined;
+			refresh(o?: {
+				signal?: AbortSignal;
+			}): Promise<{ aborted: boolean; errors: Map<string, Error> }>;
+		};
+		expect(runtime.getAvailableSnapshot()).toEqual(MODELS);
+		expect(runtime.getModel("google", "gemini-2.5-flash")).toBe(MODELS[0]);
+		expect(runtime.getError()).toBeUndefined();
+		await expect(runtime.refresh()).resolves.toEqual({
+			aborted: false,
+			errors: new Map(),
+		});
+		selector.onCancel();
+		await promise;
+	});
+
+	it("falls back to the host selector in rpc mode (default first)", async () => {
+		const { ctx, custom, select } = fakeCtx();
+		(ctx as { mode: string }).mode = "rpc";
+		select.mockResolvedValue("Claude Sonnet 4 (anthropic/claude-sonnet-4)");
+		const picked = await openModelPicker(ctx, MODELS[1]);
+		expect(custom).not.toHaveBeenCalled();
+		expect(select).toHaveBeenCalledWith(
+			"选择模型（首项为当前默认，回车使用）",
+			[
+				"Claude Sonnet 4 (anthropic/claude-sonnet-4)",
+				"Gemini 2.5 Flash (google/gemini-2.5-flash)",
+			],
+		);
+		expect(picked).toBe(MODELS[1]);
+	});
+
+	it("uses the provided select title in rpc mode and treats cancel as undefined", async () => {
+		const { ctx, select } = fakeCtx();
+		(ctx as { mode: string }).mode = "rpc";
+		select.mockResolvedValue(undefined);
+		expect(
+			await openModelPicker(ctx, MODELS[0], { selectTitle: "选择评审模型" }),
+		).toBeUndefined();
+		expect(select).toHaveBeenCalledWith("选择评审模型", expect.any(Array));
+	});
+});

package/src/lib/model-picker.ts

@@ -0,0 +1,101 @@
+/**
+ * /model-style model picker for extension features (review, compact-model).
+ *
+ * Reuses pi's REAL built-in ModelSelectorComponent via ctx.ui.custom instead
+ * of ctx.ui.select: the extension select dialog (ExtensionSelectorComponent)
+ * renders every option unbounded — with many models it overflows the
+ * terminal — while ModelSelectorComponent is the actual /model experience:
+ * height-limited scrolling list, fuzzy search, current-model marker.
+ *
+ * The component is driven through a small ModelRuntime facade backed by
+ * ctx.modelRegistry (pi's extension-facing wrapper). SAFETY: verified
+ * against pi 0.87.1 dist (modes/interactive/components/model-selector.js +
+ * model-catalog-refresh.js) — the component only calls getAvailableSnapshot,
+ * getModel, getError and refresh on modelRuntime, and ModelRegistry provides
+ * exactly those (getAvailable/find/getError/refresh).
+ *
+ * `current` is passed as the component's currentModel: the built-in selector
+ * preselects, ✓-marks and sorts-first its currentModel, so one Enter accepts
+ * it. Enter resolves with the chosen model; Esc resolves undefined.
+ *
+ * Non-TUI dialog modes (rpc) cannot host custom components — pi's rpc
+ * ui.custom() resolves undefined immediately — so the host-rendered
+ * ctx.ui.select is used there with the default as the first option
+ * (ExtensionContext.mode docs: "Use 'tui' to guard terminal-only UI such as
+ * custom components").
+ */
+import {
+	ModelRuntime,
+	ModelSelectorComponent,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { modelKey, type AvailableModel } from "./model-config.js";
+
+/** ModelRuntime facade backed by the extension-facing ModelRegistry. */
+function modelRuntimeFacade(ctx: ExtensionContext): ModelRuntime {
+	const facade = {
+		getAvailableSnapshot: () => ctx.modelRegistry.getAvailable(),
+		getModel: (providerId: string, modelId: string) =>
+			ctx.modelRegistry.find(providerId, modelId),
+		getError: () => ctx.modelRegistry.getError(),
+		refresh: (options?: { signal?: AbortSignal }) =>
+			ctx.modelRegistry.refresh(options),
+	};
+	// SAFETY: the selector only touches the four members above (pi 0.87.1
+	// model-selector.js); everything else on ModelRuntime is never reached
+	// from this component.
+	return facade as unknown as ModelRuntime;
+}
+
+/**
+ * Open the picker. `current` (the preselected/default model) is highlighted
+ * and ✓-marked in TUI mode — one Enter accepts it. In dialog-capable modes
+ * without custom-component support (rpc), the host renders a plain selector
+ * instead, with `current` as the first option (Enter accepts it too).
+ * Resolves with the picked model, or undefined when the user cancels.
+ */
+export async function openModelPicker(
+	ctx: ExtensionContext,
+	current?: AvailableModel,
+	options?: { selectTitle?: string },
+): Promise<AvailableModel | undefined> {
+	if (!ctx.hasUI) return undefined;
+	const available = ctx.modelRegistry.getAvailable();
+	if (available.length === 0) {
+		ctx.ui.notify("当前没有可用模型，请先在 pi 中配置模型。", "error");
+		return undefined;
+	}
+	if (ctx.mode === "tui") {
+		// The real built-in /model component: height-limited scrolling list +
+		// fuzzy search (ctx.ui.select renders every option unbounded).
+		return ctx.ui.custom<AvailableModel | undefined>(
+			(tui, _theme, _keybindings, done) =>
+				new ModelSelectorComponent(
+					tui,
+					current ?? ctx.model,
+					modelRuntimeFacade(ctx),
+					[],
+					(model) => done(model),
+					() => done(undefined),
+				),
+		);
+	}
+	// rpc and other dialog-capable modes: custom components are TUI-only
+	// (rpc's ui.custom() resolves undefined immediately), but the host
+	// renders select dialogs itself — default first so Enter accepts it.
+	const ordered: AvailableModel[] = current
+		? [
+				current,
+				...available.filter((m) => modelKey(m) !== modelKey(current)),
+			]
+		: available;
+	const labels = ordered.map(
+		(m: AvailableModel) => `${m.name} (${m.provider}/${m.id})`,
+	);
+	const choice = await ctx.ui.select(
+		options?.selectTitle ?? "选择模型（首项为当前默认，回车使用）",
+		labels,
+	);
+	if (choice === undefined) return undefined;
+	return ordered[labels.indexOf(choice)];
+}