@andares/pi-toolkits 0.4.0 → 0.4.2

package/README.md

@@ -161,14 +161,19 @@ pi -e ./src/index.ts
 
 **范围强约束** —— 评审仅限**当前本轮修改内容**,避免扩大范围;本轮改动范围内确认的问题才直接修复,范围外的历史遗留/无关问题只记录提示、不动手改。
 
-**评审模型配置**(`<agent-dir>/pi-toolkits-review.json`,默认 `~/.pi/agent/`):
+**评审模型选择**(每次 `/third-review` 都会弹出选择界面):
+
+- `/third-review` → 弹出 **`/model` 同款选择器**(限高滚动 + 模糊搜索):**默认选中当前配置的模型**(✓ 标记),直接**回车**即用它开始评审
+- **换选其他模型** → 立即写回配置(**落盘 + 内存**),**下次默认使用该模型**
+- **取消**(Esc)→ 不执行评审,配置不变
+- 配置持久化于 `<agent-dir>/pi-toolkits-review.json`(默认 `~/.pi/agent/`):
 
 ```json
 { "model": "anthropic/claude-sonnet-4" }
 ```
 
-- `/review-model` —— 查看/更换评审模型:弹出模型列表(标题显示当前配置),选中即写入;取消则不修改配置
-- **未配置 / 配置的模型已不可用**(如在 pi 的 models.json 里删掉了该模型)→ 提示「评审模型不存在」,弹出**可用模型选择列表**(与 `/model` 同源);选中后**写回配置并立即执行**
+- `/review-model` —— 单独的配置入口:弹出同一列表(不改会话模型,只更新默认配置)
+- **未配置 / 配置的模型已不可用**(如在 pi 的 models.json 里删掉了该模型)→ 提示后照常弹出列表(此时无默认项)
 - 任务仍在进行中(agent 未空闲)时触发 → 提示等待,不执行;同一时间只允许一个评审
 - footer 出现灰色 `review` 状态 = 已配置评审模型
 
@@ -201,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` 状态 = 已配置
 
 **无损回落**(本功能永远不会把压缩「做挂」):
@@ -217,45 +222,6 @@ pi 的 `/compact` 与 auto-compact 默认**用当前会话模型**做上下文
 
 ---
 
-**pnpm is the only supported toolchain** — never use `npm install` / `npm publish` in this repo.
-
-```bash
-pnpm install      # install deps
-pnpm typecheck    # tsc --noEmit
-pnpm test         # vitest (all feature unit tests)
-```
-
-### 项目结构 Project structure
-
-```text
-src/
-├── index.ts              # entry point: aggregates feature modules
-├── lib/                  # shared infrastructure (tool-set snapshot/restore)
-└── features/             # feature modules — one directory per feature
-    ├── ask/              # ask mode: command + state machine, bash sandbox,
-    │                     #           system prompt banner, tests
-    ├── favorites/        # model favorites: selector + cycle patches,
-    │                     #           persisted store, tests
-    ├── review/           # third-party review: input/command triggers,
-    │                     #           review-model config store, prompt, tests
-    └── stash/            # prompt stash: hotkey state machine + tests
-```
-
-**新增功能 · adding a feature**:create `src/features/<name>/` exporting `registerXxx(pi)` and call it from `src/index.ts`. Existing modules stay untouched. Each feature ships its own `*.test.ts` (vitest) — keep them deterministic (inject clocks/state, no real agent-dir writes).
-
-**发布 · publishing**(pnpm-only,one command):
-
-```bash
-pnpm release patch   # 0.1.2 → 0.1.3
-pnpm release minor   # 0.1.2 → 0.2.0   (patch zeroed)
-pnpm release major   # 0.1.2 → 1.0.0   (minor + patch zeroed)
-pnpm release patch --dry-run   # preview without changing anything
-```
-
-`release` 要求且仅要求 `major | minor | patch` 之一;上级递增清零下级。执行链:校验 → `typecheck + test` 门禁 → 改版本 → git commit + `vX.Y.Z` tag → `pnpm publish`(`prepublishOnly` 二次门禁)。
-
----
-
 ## 🛠️ 开发 Development
 
 <a name="development"></a>
@@ -299,7 +265,7 @@ pnpm release major   # 0.1.2 → 1.0.0   (minor + patch zeroed)
 pnpm release patch --dry-run   # preview without changing anything
 ```
 
-`release` 要求且仅要求 `major | minor | patch` 之一;上级递增清零下级。执行链:校验 → `typecheck + test` 门禁 → 改版本 → git commit + `vX.Y.Z` tag → `pnpm publish`(`prepublishOnly` 二次门禁)。
+`release` 要求且仅要求 `major | minor | patch` 之一;上级递增清零下级。执行链:**工作区必须干净(有未提交变更直接中止,保证 tag 内容 == 发布内容)** → `typecheck + test` 门禁 → 改版本 → git commit + `vX.Y.Z` tag(自检 tag==HEAD 且工作区干净) → `pnpm publish`(`prepublishOnly` 二次门禁) → 只推当前分支 + 当前 tag 并校验远端哈希一致(远端 tag 不一致则跳过 Release 创建)。
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andares/pi-toolkits",
-  "version": "0.4.0",
+  "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,
@@ -107,11 +109,7 @@ async function completeSummary(
 		);
 	}
 	const text = response.content
-		.filter(
-			(block): block is { type: "text"; text: string } =>
-				block.type === "text",
-		)
-		.map((block) => block.text)
+		.flatMap((block) => (block.type === "text" ? [block.text] : []))
 		.join("\n");
 	return { text, usage: response.usage };
 }
@@ -253,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,
@@ -267,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;
@@ -334,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/compact/prompt.ts

@@ -161,9 +161,11 @@ export function computeFileLists(fileOps: FileOpsLike): {
 	modifiedFiles: string[];
 } {
 	const modified = new Set([...fileOps.edited, ...fileOps.written]);
+	// pi-lens-ignore: no-sort-without-comparator, — 逐字对齐 pi 0.87.1 的裸 .sort()：文件路径按码元序排序（加 locale 比较器反而会改变顺序）
 	const readOnly = [...fileOps.read]
 		.filter((f) => !modified.has(f))
 		.sort();
+	// pi-lens-ignore: no-sort-without-comparator, — 同上（pi 0.87.1 computeFileLists 原文）
 	const modifiedFiles = [...modified].sort();
 	return { readFiles: readOnly, modifiedFiles };
 }

package/src/features/favorites/patch-cycle.ts

@@ -146,14 +146,11 @@ export function applyCyclePatch(): boolean {
 					.getAvailableSnapshot()
 					.map((model) => `${model.provider}\0${model.id}`),
 			);
-			candidates = this._scopedModels
-				.filter(
-					(sm) => availableIds.has(`${sm.model.provider}\0${sm.model.id}`),
-			)
-				.map((sm) => ({
-					model: sm.model,
-					thinkingLevel: sm.thinkingLevel,
-				}));
+			candidates = this._scopedModels.flatMap((sm) =>
+				availableIds.has(`${sm.model.provider}\0${sm.model.id}`)
+					? [{ model: sm.model, thinkingLevel: sm.thinkingLevel }]
+					: [],
+			);
 		} else {
 			candidates = this._modelRuntime
 				.getAvailableSnapshot()

package/src/features/favorites/patch-selector.ts

@@ -191,11 +191,8 @@ export function applyModelSelectorPatches(): boolean {
 				: "";
 			const cursor = isSelected ? theme.fg("accent", "→ ") : "  ";
 			const currentMarker = isCurrent ? theme.fg("accent", "✓ ") : "  ";
-			const modelText = isFavorite
-				? styleFavorite(item.id)
-				: isSelected
-					? theme.fg("accent", item.id)
-					: item.id;
+			const baseText = isSelected ? theme.fg("accent", item.id) : item.id;
+			const modelText = isFavorite ? styleFavorite(item.id) : baseText;
 			const providerBadge = theme.fg("muted", `[${item.provider}]`);
 			const line = `${cursor}${currentMarker}${modelText} ${providerBadge}${defaultBadge}`;
 			list.addChild(new Text(line, 0, 0));

package/src/features/review/index.ts

@@ -11,11 +11,15 @@
  * model as ordinary text, so an accidental send can never start a review.)
  *
  * Review-model config lives in `<agent-dir>/pi-toolkits-review.json`
- * ("provider/id", see store.ts). When no model is configured, or the
- * configured model is gone/unavailable (e.g. deleted from pi's models.json),
- * the user is told the review model doesn't exist and is shown the available
- * model list (ctx.ui.select, same getAvailable() source as /model); the pick
- * is written back to the config and the review runs immediately.
+ * ("provider/id", see store.ts) and doubles as the picker default. Every
+ * /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.
@@ -31,15 +35,18 @@ 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 picker title shows the current config so /review-model doubles as a
+ * 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(
@@ -55,30 +62,30 @@ export async function pickReviewModel(
 		);
 		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(
-			"third-review: 当前没有可用模型，请先在 pi 中配置模型。",
-			"error",
+			`third-review: 配置的评审模型 ${configured} 不存在或不可用，请重新选择。`,
+			"warning",
 		);
-		return undefined;
 	}
-	const configured = store.getModel();
-	// Same display source as the /model selector: name + [provider]/id.
-	const options = available.map((m: AvailableModel) => `${m.name} (${m.provider}/${m.id})`);
-	const choice = await ctx.ui.select(
-		configured
-			? `选择评审模型 (当前: ${configured})`
-			: "选择评审模型 (third-review)",
-		options,
-	);
-	if (choice === undefined) {
+	const model = await openModelPicker(ctx, configuredModel, {
+		selectTitle: "选择评审模型（首项为当前默认，回车使用）",
+	});
+	if (!model) {
 		ctx.ui.notify("third-review: 已取消，评审模型配置未变更。", "info");
 		return undefined;
 	}
-	const model = available[options.indexOf(choice)];
-	if (!model) return undefined;
-	store.setModel(modelKey(model));
+	const key = modelKey(model);
+	if (key !== configured) {
+		// Persist immediately (disk + in-memory + footer) — next run defaults here.
+		store.setModel(key);
+		ctx.ui.notify(
+			`third-review: 评审模型已保存为「${model.name}」，下次默认使用。`,
+			"info",
+		);
+	}
 	return model;
 }
 
@@ -109,17 +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 /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 {
+				// No dialogs (json/print/headless): the configured-model path keeps
+				// working; without one, point at the config file.
+				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) {
@@ -148,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,39 +260,72 @@ 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("shows the current config in the picker title", async () => {
+	it("keeps the config untouched when cancelled", async () => {
 		const store = new ReviewStore(freshStoreFile());
-		store.setModel("anthropic/claude-sonnet-4");
-		const { ctx, select } = fakeCtx({ selectResult: undefined });
+		store.setModel("anthropic/claude-opus-4");
+		const { ctx, custom } = fakeCtx({ customResult: undefined });
 		await pickReviewModel(ctx, store);
-		expect(select).toHaveBeenCalledWith(
-			"选择评审模型 (当前: anthropic/claude-sonnet-4)",
-			expect.any(Array),
-		);
+		expect(custom).toHaveBeenCalledTimes(1);
 		// Cancelling a change keeps the existing config.
-		expect(store.getModel()).toBe("anthropic/claude-sonnet-4");
+		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({ customResult: MODELS[1] });
+		const picked = await pickReviewModel(ctx, store);
+		expect(picked).toBe(MODELS[1]);
+		expect(spy).not.toHaveBeenCalled();
+	});
+
+	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({ customResult: MODELS[2] });
+		const picked = await pickReviewModel(ctx, store);
+		expect(picked).toBe(MODELS[2]);
+		expect(store.getModel()).toBe("openrouter/openai/gpt-5");
+		expect(notify).toHaveBeenCalledWith(
+			expect.stringContaining("已保存为"),
+			"info",
+		);
 	});
 });
 
@@ -314,11 +344,13 @@ describe("createReviewRunner", () => {
 		expect(pi.sendUserMessage).not.toHaveBeenCalled();
 	});
 
-	it("switches to the configured model and sends the review prompt", async () => {
+	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 } = fakeCtx();
+		const { ctx, notify, custom } = fakeCtx({ customResult: MODELS[0] });
 		await createReviewRunner(pi)(ctx);
+		// The picker is always shown, even with a configured model.
+		expect(custom).toHaveBeenCalledTimes(1);
 		expect(setModel).toHaveBeenCalledWith(MODELS[0]);
 		expect(sendUserMessage).toHaveBeenCalledWith(REVIEW_PROMPT);
 		expect(notify).toHaveBeenCalledWith(
@@ -327,28 +359,30 @@ 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, custom } = fakeCtx({ hasUI: false });
+		await createReviewRunner(pi)(ctx);
+		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("不存在或不可用"),
@@ -357,14 +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);
+		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();
@@ -373,7 +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();
+		const { ctx, notify } = fakeCtx({ customResult: MODELS[0] });
 		await createReviewRunner(pi)(ctx);
 		expect(setModel).toHaveBeenCalledWith(MODELS[0]);
 		expect(sendUserMessage).not.toHaveBeenCalled();
@@ -385,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",
@@ -397,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);
@@ -409,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)];
+}