@bolloon/bolloon-agent 0.6.1 → 0.6.3

package/dist/cli/model-selector.js

@@ -4,10 +4,13 @@
  * 流程 (与命令面同一条路, 只是把参数逐步问出来):
  *
  * ```
- * 1 选择供应商 → 2 未配置则输 API key → 3 选择模型 (模糊搜索) → 4 reasoning/temperature
- *   → 5 Session 还是 Global → 6 测试连接 → 7 确认切换
+ * 1 选择供应商 → 2 (需要 key 则) 凭证 → 3 选择模型 (模糊搜索) → 4 确认 (连通测试+确认)
  * ```
  *
+ * 2026-10-05 (leo: 不该七层嵌套): 从 7 步压成 4 步 —— 删掉单独的
+ * `生成参数` 与 `作用域` 两步 (一律走全局默认、沿用配置里的参数), 把 `测试连接`
+ * 与 `确认切换` 合并成第 4 步 (一次点完)。
+ *
  * ## 两条硬纪律
  *
  * ① **切换只有一次写盘动作, 且只走统一入口**。本文件不碰配置文件、不碰模型运行时 ——
@@ -26,8 +29,8 @@
  * 三态到人话的翻译与排版**, 一个能力值都不产生 —— 拿不到真数据时列表上写的是"未知",
  * 而不是一个看起来像真的常量。
  */
-import { buildProviderSummaries, listModelsFor, formatModelMenuRow, providerGroupSummary, providerTierOf, providerTierCollapsedByDefault, orderProvidersForMenu, PROVIDER_GROUPS, providerRowTone, formatProviderMenuRow, unknownFootnote, searchModelEntries, resolvedApiKeyOf, } from '../llm/model-catalog.js';
-import { selectModel, probeSelection, credentialFingerprintOf, envKeyNamesOf as envKeysOf, } from '../llm/model-selection.js';
+import { buildProviderSummaries, listModelsFor, formatModelMenuRow, providerGroupSummary, orderProvidersForMenu, providerRowTone, formatProviderMenuRow, unknownFootnote, searchModelEntries, resolvedApiKeyOf, } from '../llm/model-catalog.js';
+import { selectModel, probeSelection, credentialFingerprintOf, envKeyNamesOf as envKeysOf, baseDefaultsOf, } from '../llm/model-selection.js';
 import { admitManualModel } from '../llm/model-discovery.js';
 // 颜色只从 `theme.ts` 来 (唯一事实源): 调子→token 的映射与 `tint()` 都住在那边。
 import { tint } from './theme.js';
@@ -200,8 +203,8 @@ export async function runModelSelector(io, opts = {}) {
         return done({ ok: false, reachedStep: 'provider', message: `读供应商列表失败: ${String(e?.message || e).slice(0, 160)}` });
     }
     const live = summaries.filter((s) => s.configured);
-    // "共 N 家" 从盘上真算 (内置 + 自定义 + 目录全部), 不写死 —— 验收门拿它跟盘上数字对。
-    push(`步骤 1/7 供应商 (共 ${summaries.length} 家登记: 内置+自定义+目录全部 · 可用 ${live.length} 家 · 分组可折叠)`);
+    // 2026-10-05 (leo: 不该七层嵌套 → 压成 4 步): 供应商 → 凭证(仅需 key) → 模型 → 确认(合并原测试/作用域/参数)
+    push(`步骤 1/4 供应商 (共 ${summaries.length} 家登记: 内置+自定义+目录全部 · 可用 ${live.length} 家 · 全部平铺可滚动)`);
     verbose(`  ${providerGroupSummary(summaries)}`);
     try {
         // 动态 import: 选择器 → provider-catalog 是单向的 (目录层不 import 选择器), 不构成环;
@@ -218,19 +221,14 @@ export async function runModelSelector(io, opts = {}) {
     if (!summaries.length)
         return done({ ok: false, reachedStep: 'provider', message: '没有任何登记在册的供应商' });
     // 排序 = 分组优先级 (当前 → 可用 → 未配置凭据 → 需专用鉴权 → 无 api 基址);
-    //   **全部家都在候选数组里** (包括后三组), 只是它们的分组**默认收起** (标题上照写家数)。
+    //   全部家都是平铺的单选行 (固定高度视窗 + 滚动消化一屏放不下的部分), 不再分组折叠。
     const ordered = orderProvidersForMenu(summaries);
     const providerChoices = ordered.map((s) => {
-        const tier = providerTierOf(s);
         return {
             value: s.id,
             label: formatProviderMenuRow(s),
             hint: `${s.name}${s.providerReasoning === 'yes' ? ' · 登记支持 reasoning' : ''}${s.configuredModel ? ` · 配置里 model=${s.configuredModel}` : ''}`,
-            // 分组标题只在切换分组时印一次; 家数由选择器写在标题行上 (`── 名字 (N 家) ›`)
-            group: PROVIDER_GROUPS[tier],
-            // 后三组默认收起: 页面放得下, 而家数照样看得见 (`空格`/`→` 一键展开)
-            groupCollapsed: providerTierCollapsedByDefault(tier),
-            // 颜色只做**第二通道**: 语义本体是 label 里的符号 (●/○) 与分组标题 (special/无基址 → warn)
+            // 颜色只做**第二通道**: 语义本体是 label 里的符号 (●/○) 与分组 (special/无基址 → warn)
             tone: providerRowTone(s),
         };
     });
@@ -249,7 +247,7 @@ export async function runModelSelector(io, opts = {}) {
         : summary.keyState === 'missing' ? '缺 key'
             : summary.keyState === 'env' ? '来自环境变量' : '已配置';
     const envKeys = envKeysOf(providerId);
-    push(`步骤 2/7 凭证 — ${providerId}: ${keyZh}${fp ? ` (指纹 ${fp})` : ''}`);
+    push(`步骤 2/4 凭证 — ${providerId}: ${keyZh}${fp ? ` (指纹 ${fp})` : ''}`);
     if (summary.requiresApiKey && io.askHidden) {
         const choices = [];
         if (summary.keyState !== 'missing')
@@ -298,6 +296,56 @@ export async function runModelSelector(io, opts = {}) {
     else if (summary.requiresApiKey) {
         push(`沿用现有 key (指纹 ${fp || '已配置'})`);
     }
+    // ── 2.5) URL 怎么处理 (leo 2026-10-05: TUI 里要能管理 URL, 和 key 同级) ──────
+    // 展示口径: 当前值 + **官方默认**并排 —— 默认给官方来源, 用户再决定 保持/替换/清除。
+    let baseUrlAction = 'keep';
+    let pendingBaseUrl;
+    const officialUrl = (() => {
+        try {
+            return baseDefaultsOf(providerId, null)?.baseUrl || '';
+        }
+        catch {
+            return '';
+        }
+    })();
+    const currentUrl = summary.baseUrl || officialUrl || '(无)';
+    if (io.choose || io.ask) {
+        const urlChoices = [
+            { value: 'keep', label: '[K]eep 保持当前 URL', hint: `当前: ${currentUrl}`, tone: 'ok' },
+            { value: 'replace', label: '[R]eplace 输入新 URL', hint: '覆盖配置里这一格', tone: 'accent' },
+            // 清除 = 回落官方默认 (目录家没有官方基址则这步会拦下)
+            { value: 'clear', label: '[C]lear 回落官方默认', hint: officialUrl ? `官方: ${officialUrl}` : '这家没有官方基址, 需自定义', tone: 'warn' },
+        ];
+        const urlAct = await pick(urlChoices, `URL 怎么处理 (当前: ${currentUrl} · 官方: ${officialUrl || '(无)'}):`);
+        if (!urlAct)
+            return done({ ok: false, cancelled: true, reachedStep: 'key', message: '已取消, 未改动任何配置' });
+        if (urlAct === 'replace') {
+            const raw = await text(`输入 ${providerId} 的 base URL (含 https://, 不带 /v1 尾缀)`);
+            if (raw === null) {
+                push(EOF_CANCEL);
+                return done({ ok: false, cancelled: true, reachedStep: 'key', message: '输入已结束 (EOF/Ctrl-D) —— 未改动任何配置' });
+            }
+            if (!raw.trim()) {
+                push('URL 为空 → 按保持当前处理');
+            }
+            else {
+                pendingBaseUrl = raw.trim();
+                baseUrlAction = 'replace';
+            }
+        }
+        else if (urlAct === 'clear') {
+            if (!officialUrl) {
+                push(`✗ ${providerId} 没有官方基址可回落 —— 只能保持或替换。未改动任何配置。`);
+            }
+            else {
+                baseUrlAction = 'clear';
+                push(`将回落官方默认: ${officialUrl}`);
+            }
+        }
+        else {
+            push(`保持当前 URL: ${currentUrl}`);
+        }
+    }
     // ── 3) 模型 (模糊搜索 + 当前置顶) ─────────────────────────
     let entries;
     try {
@@ -312,7 +360,7 @@ export async function runModelSelector(io, opts = {}) {
             message: `${providerId} 没有可用模型 (无内置目录且配置为空) —— 请用 \`/model ${providerId} <model>\` 直接指定, 或先配好目录`,
         });
     }
-    push(`步骤 3/7 模型 — ${providerId}, ${entries.length} 个候选`);
+    push(`步骤 3/4 模型 — ${providerId}, ${entries.length} 个候选`);
     for (const f of unknownFootnote(entries))
         verbose(`  ${f}`);
     let candidates = entries;
@@ -386,92 +434,23 @@ export async function runModelSelector(io, opts = {}) {
             : entry?.upstreamSeen === true ? ` · ${entry.upstreamOrigin === 'live' ? '上游目录' : '上游目录(缓存)'}`
                 : '';
     push(`已选模型: ${chosenModelId}${srcTag}`);
-    // ── 4) 生成参数 (reasoning / temperature) ────────────────
+    // ── 4) 确认 (原 测试+作用域+参数 合并收进一步; 只写全局默认, 参数沿用配置) ──────
+    // 2026-10-05 (leo: 不该七层嵌套 → 压成 4 步): 参数/作用域不再单列 —— 参数沿用配置,
+    //   作用域由 opts.scope 显式传 (不传 = global; `--session` 语义靠它保留)。
     const params = {};
-    push('步骤 4/7 生成参数');
-    // reasoning: 只有"登记为支持"时才提供开关; 能力未知就不给这一项 (不猜)
-    if (summary.providerReasoning === 'yes') {
-        const r = await pick([
-            { value: 'unset', label: '不设 (沿用配置里的值)' },
-            { value: 'on', label: '开 (请求推理/思考模式)' },
-            { value: 'off', label: '关' },
-        ], `${providerId} 登记支持 reasoning — 要不要开? (本机偏好, 不是模型能力数据)`);
-        if (r === 'on')
-            params.reasoningMode = true;
-        else if (r === 'off')
-            params.reasoningMode = false;
-    }
-    else {
-        verbose(`reasoning: 该供应商的模型级能力未知 → 不提供开关, 也不写默认值`);
-    }
-    const temp = await pick([
-        { value: 'skip', label: '不设 (沿用配置里的值)' },
-        { value: '0', label: 'temperature = 0' },
-        { value: '0.3', label: 'temperature = 0.3' },
-        { value: '0.7', label: 'temperature = 0.7' },
-        { value: '1.0', label: 'temperature = 1.0' },
-        { value: '1.5', label: 'temperature = 1.5' },
-        ...(io.ask ? [{ value: '__custom__', label: '手工输入 (0~2)' }] : []),
-    ], 'temperature (0~2)');
-    if (temp === null)
-        return done({ ok: false, cancelled: true, reachedStep: 'params', message: '已取消, 未改动任何配置' });
-    if (temp === '__custom__') {
-        const raw = await text('temperature (0~2)', '0.7');
-        if (raw === null) {
-            push(EOF_CANCEL);
-            return done({ ok: false, cancelled: true, reachedStep: 'params', message: '输入已结束 (EOF/Ctrl-D) —— 未改动任何配置' });
-        }
-        if (raw === '') {
-            push('没输入 → 本项不设');
-        }
-        else {
-            const n = Number(raw);
-            if (!Number.isFinite(n) || n < 0 || n > 2) {
-                return done({ ok: false, reachedStep: 'params', failureClass: 'invalid_temperature', message: `temperature 只接受 0~2 的数字, 收到 '${raw}' — 未改动任何配置` });
-            }
-            params.temperature = n;
-        }
-    }
-    else if (temp !== 'skip') {
-        params.temperature = Number(temp);
-    }
-    push(`temperature: ${params.temperature === undefined ? '不设' : params.temperature}`);
-    // ── 5) 作用域 ────────────────────────────────────────────
-    let scope = 'global';
-    push('步骤 5/7 作用域');
-    for (let round = 0; round < 2; round++) {
-        const s = await pick([
-            { value: 'global', label: '全局默认 (影响新会话 + 未绑定模型的任务)' },
-            { value: 'session', label: '仅当前会话 (不动全局默认)' },
-        ], '这次切换的作用域?');
-        if (s === null)
-            return done({ ok: false, cancelled: true, reachedStep: 'scope', message: '已取消, 未改动任何配置' });
-        scope = s === 'session' ? 'session' : 'global';
-        if (scope === 'session' && pendingKey) {
-            push('✗ 会话级切换只做路由、不写凭证 —— 要么改成全局默认, 要么先 `bolloon model key ' + providerId + '` 再回来只切路由。');
-            continue;
-        }
-        break;
-    }
-    if (scope === 'session' && pendingKey) {
-        return done({
-            ok: false, reachedStep: 'scope', failureClass: 'credential_scope_conflict',
-            message: '会话级切换不写凭证 — 未改动任何配置 (请先配全局凭证, 再用 --session 只切路由)',
-        });
-    }
-    push(`作用域: ${scope === 'global' ? '全局默认' : '仅当前会话'}`);
+    const scope = opts.scope === 'session' ? 'session' : 'global';
     return await commit(done, push, confirm, verbose, {
-        providerId, summary, pendingKey, credentialAction, modelId: chosenModelId, baseUrl: summary.baseUrl, opts, params, scope,
+        providerId, summary, pendingKey, credentialAction, modelId: chosenModelId, baseUrl: summary.baseUrl,
+        baseUrlAction, pendingBaseUrl, opts, params, scope,
     });
 }
 async function commit(done, push, confirm, verbose, a) {
     const params = a.params || {};
     const scope = a.scope || 'global';
-    // ── 6) 测试连接 (对**候选**配置探测; 不写任何东西) ─────────
-    // 版面: **失败就直接停**, 一行说清"什么错 + 怎么办" —— 不再问"还要不要继续"
-    //   (那种问句按 y 也照样被第 7 步拦下, 是假选择)。
+    // ── 4) 确认 (对**候选**配置连通测试, 一次直接到确认; 不写任何东西前置) ──────────
+    // 版面: **失败就直接停**, 一行说清"什么错 + 怎么办" —— 不再问"还要不要继续"。
     if (a.opts.verify === false) {
-        verbose('步骤 6/7 已按 --no-verify 跳过连通探测 (第 6 步预检与第 7 步切换前校验都关)');
+        verbose('步骤 4/4 已按 --no-verify 跳过连通探测 (预检与切换前校验都关)');
     }
     else if (!a.opts.skipProbe) {
         // 预检必须用**和落盘时同一份凭证**: 本次新输入的 key 优先, 否则用该供应商已配置/环境变量里的那一份。
@@ -487,16 +466,11 @@ async function commit(done, push, confirm, verbose, a) {
                     + (probe.failureClass === 'model_not_found' ? ` 换个模型, 或用 \`bolloon model ${a.providerId} <model>\` 直接指定。` : ''),
             });
         }
-        push(`步骤 6/7 连通测试通过 (${a.modelId} @ ${a.baseUrl}, ${ms} ms)`
+        push(`步骤 4/4 连通测试通过 (${a.modelId} @ ${a.baseUrl}, ${ms} ms)`
             + (probe.modelAcceptedOutsideCatalog ? ' — 上游目录未列出, 但端点接受' : ''));
-        // 第 7 步的"确认"必须先把**要提交的东西**印出来 —— 否则用户是在确认一份看不见的配置。
-        //   版面压到最少: 供应商/模型/作用域/参数 (探测结论上一步已说, 不重复; 基址只在 verbose)。
-        push('步骤 7/7 确认');
+        // "确认"必须先把**要提交的东西**印出来 —— 否则用户是在确认一份看不见的配置。
+        //   版面压到最少: 供应商/模型/作用域 (参数沿用配置, 基址只在 verbose)。
         push(`  ${a.providerId} / ${a.modelId} · ${scope === 'global' ? '全局默认' : '仅当前会话'}`);
-        if (params.temperature !== undefined || params.reasoningMode !== undefined) {
-            push(`  参数: ${params.temperature === undefined ? '' : `temperature=${params.temperature}`}`
-                + `${params.reasoningMode === undefined ? '' : `${params.temperature === undefined ? '' : ' · '}reasoning=${params.reasoningMode ? '开' : '关'}`}`);
-        }
         verbose(`  基址: ${a.baseUrl}`);
         verbose(`  凭证: ${a.pendingKey ? '本次新输入的 key (掩码输入, 落盘为全局凭证)' : '沿用已配置 / 环境变量里的那一份'}`);
         const proceed = a.opts.assumeYes ? true : await confirm('确认按上面的配置切换?', true);
@@ -504,14 +478,20 @@ async function commit(done, push, confirm, verbose, a) {
             return done({ ok: false, cancelled: true, reachedStep: 'test', message: '已取消, 未改动任何配置' });
     }
     else {
-        verbose('步骤 6/7 已跳过预检 (skipProbe) —— 第 7 步的切换前校验仍在');
+        verbose('步骤 4/4 已跳过预检 (skipProbe) —— 切换前校验仍在');
     }
-    // ── 7) 唯一写盘点 ───────────────────────────────────────
+    // ── 唯一写盘点 (第 4 步确认后执行) ───────────────────────────
     const req = {
         provider: a.providerId,
         model: a.modelId,
-        baseUrl: a.baseUrl,
         scope,
+        // URL 意图 (leo 2026-10-05): replace 用新输入的 URL; clear 让 selectModel 回落官方默认;
+        //   keep 则只带当前值 (与历史语义一致)。baseUrlAction 缺省时传 baseUrl 保持旧行为。
+        ...(a.baseUrlAction === 'replace' && a.pendingBaseUrl
+            ? { baseUrl: a.pendingBaseUrl, baseUrlAction: 'replace' }
+            : a.baseUrlAction === 'clear'
+                ? { baseUrlAction: 'clear' }
+                : { baseUrl: a.baseUrl }),
         ...(a.pendingKey ? { apiKey: a.pendingKey } : {}),
         ...(a.credentialAction !== 'keep' ? { credentialAction: a.credentialAction } : {}),
         ...(params.temperature !== undefined ? { temperature: params.temperature } : {}),

package/dist/cli/setup-wizard.js

@@ -21,7 +21,7 @@ import * as path from 'path';
 import * as os from 'os';
 import { llmConfigStore } from '../llm/config-store.js';
 import { selectModel, resetModelSelection, probeSelection, effectiveModelConfig, formatEffectiveModel, normalizeBaseUrl, validateBaseUrlShape, currentSessionKey, } from '../llm/model-selection.js';
-import { buildProviderSummaries, formatProviderMenuRow, providerGroupSummary, providerTierOf, providerTierCollapsedByDefault, orderProvidersForMenu, PROVIDER_GROUPS, } from '../llm/model-catalog.js';
+import { buildProviderSummaries, formatProviderMenuRow, providerGroupSummary, orderProvidersForMenu, } from '../llm/model-catalog.js';
 import { runModelSelector } from './model-selector.js';
 // 着色判据只有一处 (`theme.ts`) —— 主屏与全屏选择器共用
 import { colorEnabled } from './theme.js';
@@ -551,19 +551,11 @@ export function parseModelCommand(arg) {
 async function providerLines(sessionKey) {
     const summaries = await buildProviderSummaries({ sessionKey });
     // 2026-09-27 (目录驱动, 二改): 这里**列全量** (内置 13 + 自定义 + 目录全部), 并按第 1 步同一套
-    //   分组优先级排出分组标题 (带家数)。纯文本这条路没有视窗/折叠 (那是全屏选择器的事), 所以逐行列全 ——
+    //   分组优先级排序, **不再带分组分隔条** (全平铺)。纯文本这条路没有视窗/折叠 (那是全屏选择器的事), 所以逐行列全 ——
     //   门禁钉着"不许只给计数": 任何一家都要能在这份输出里被看见。
     const lines = [];
     const ordered = orderProvidersForMenu(summaries);
-    let lastGroup = '';
     for (const s of ordered) {
-        const tier = providerTierOf(s);
-        const g = PROVIDER_GROUPS[tier];
-        if (g !== lastGroup) {
-            lastGroup = g;
-            lines.push(`  ── ${g} (${ordered.filter((x) => providerTierOf(x) === tier).length} 家)`
-                + `${providerTierCollapsedByDefault(tier) ? ' · 全屏选择器里默认收起 (空格/→ 展开)' : ''}`);
-        }
         lines.push(`  ${formatProviderMenuRow(s)}`);
     }
     lines.push(`  ${providerGroupSummary(summaries)}`);

package/dist/cli/tui-select.js

@@ -87,10 +87,19 @@ const CURSOR_SGR = `${REVERSE}${BOLD}${fg(THEME.cursor)}${bg(THEME.accent)}`;
  * 大清单靠"固定高度视窗 + 分组折叠"消化, 所以折叠/展开键必须与 ↑↓ 同权写在头行。
  */
 export const TUI_HINT = '↑↓ 移动 · ←→/空格 折叠分组 · Enter 确认 · / 搜索 · 数字跳行 · Esc 取消';
+/**
+ * 纯平铺单选列表 (无分组) 的提示 —— 不带折叠键, 与参考的 provider 单选列表一致
+ * (leo 2026-10-05: `bolloon model` 显示一直折叠不方便 → 供应商列表改纯平铺)。
+ * 折叠键只在候选真的带分组 (有 `group` 字段) 时才出现在头行。
+ */
+export const TUI_HINT_FLAT = '↑↓ 移动 · Enter 确认 · / 搜索 · 数字跳行 · Esc 取消';
 /** 掩码字符 (屏幕上绝不出现明文) */
 export const MASK_CHAR = '•';
-/** 中间候选区的**固定高度上限** (每步可见行数 ≤ 12; 超出靠滚窗, 不是靠减少家数) */
-export const VIEWPORT_MAX = 12;
+/**
+ * 中间候选区的**固定高度上限** (每步可见行数上限; 实际视窗 = min(VIEWPORT_MAX, 终端高-头尾),
+ * leo 2026-10-05: 「选择高度窗口要扩大」→ 从 12 提到 40, 高终端下一屏能看到更多家, 超出靠滚窗)。
+ */
+export const VIEWPORT_MAX = 40;
 /** 分组收起的标记 (收起 = 只画标题 + 家数; 展开 = 标题 + 成员) */
 export const GROUP_COLLAPSED_MARK = '›';
 /** 分组展开的标记 */
@@ -220,6 +229,20 @@ function seqEvent(seq) {
         default: return null;
     }
 }
+/**
+ * SGR 鼠标上报的滚轮码 (触控板两指滚动 / 鼠标滚轮)。
+ * 序列形如 `\x1b[<状态码;列;行M` (按下) 或 `…m` (释放, 滚轮无释放)。状态码 = 基准 + 修饰位：
+ *   · 64 = 滚轮上 / 65 = 滚轮下 (卷滚类没有"行坐标", 但上报仍带; 我们只用方向)
+ *   · 滚轮方向键 (向上滚 = 看更早内容 ⇒ 等价 ↑; 向下滚 = 看更后内容 ⇒ 等价 ↓)
+ * 注意: 只有卷滚状态码 (64-67) 会持续滚动期间反复出现; 按下类 (0-2) 是点击, 由调用方忽略。
+ */
+export function wheelFromSgr(code) {
+    if (code === 64)
+        return { dy: 1 }; // 滚轮上 → 列表往上滚 (等价 ↑)
+    if (code === 65)
+        return { dy: -1 }; // 滚轮下 → 列表往下滚 (等价 ↓)
+    return null; // 其它码 (左/中/右键、平移) 不当作滚动
+}
 /**
  * 把一块输入拆成按键事件。**返回的 `rest` 是"还没凑齐的尾巴"** —— 调用方留着与下一块拼。
  *
@@ -243,6 +266,24 @@ export function parseKeys(chunk, rest = '') {
             continue;
         }
         if (buf.startsWith('\x1b')) {
+            // SGR 鼠标上报 (触控板/鼠标滚轮): `\x1b[<状态码;列;行M`(按下) 或 `…m`(释放)。
+            //   状态码前有个 `<`, 通用 `ESC[ 参数 终字符` 正则会把它吞掉, 所以要在这里单独吃。
+            //   只把滚轮 (64/65) 转成 `wheel` 事件; 点击/平移 (0-2 等) 就此忽略 —— 用户只要滚动翻列表。
+            if (buf.startsWith('\x1b[<')) {
+                const sm = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])/.exec(buf);
+                if (sm) {
+                    const w = wheelFromSgr(Number(sm[1]));
+                    if (w)
+                        events.push({ type: 'wheel', dy: w.dy });
+                    buf = buf.slice(sm[0].length);
+                    continue;
+                }
+                // `\x1b[<` 或 `\x1b[<64` 这种不完整尾巴: 等下一块拼全 (别把数字当输入)
+                if (/^\x1b\[<[0-9;]*$/.test(buf))
+                    break;
+                buf = buf.slice(1);
+                continue;
+            }
             // 尽量吃掉一个完整转义序列: ESC [ 参数 终字符 / ESC O 字符
             const m = /^\x1b\[([0-9;]*)([a-zA-Z~])/.exec(buf) || /^\x1b(O.)/.exec(buf);
             if (m) {
@@ -290,6 +331,10 @@ export function parseKeys(chunk, rest = '') {
 function tailIsEscapePrefix(rest) {
     if (!rest.startsWith('\x1b'))
         return false;
+    // SGR 鼠标尾巴 (`\x1b[<`, `\x1b[<64`, …): 是不完整的上报序列, **不是**孤独 Esc —— 等完整 `…M/m` 来
+    //   再解析成滚轮/忽略。若 30ms 后仍不完整, 丢弃即可 (鼠标上报被终端自己保证成块到达)。
+    if (rest.startsWith('\x1b[<'))
+        return true;
     return SEQ_PREFIXES.some((p) => p.startsWith(rest) || rest.startsWith(p));
 }
 // ============================================================
@@ -369,6 +414,9 @@ class RawSession {
             this.resizeFn = onResize;
             process.on('SIGWINCH', this.resizeFn);
         }
+        // 开 SGR 鼠标上报 (触控板/滚轮) —— 让终端把两指滚动当成 `\x1b[<64|65;…` 发进来,
+        //   `?1006h` = SGR 坐标格式, `?1000h` = 按下/释放事件。关闭时还原 (`close`)。
+        this.write(`${E}[?1006h${E}[?1000h`);
         this.write(HIDE_CURSOR);
     }
     write(s) { this.stdout.write(s); }
@@ -384,6 +432,11 @@ class RawSession {
             this.stdin.removeListener('data', this.dataFn);
         if (this.resizeFn)
             process.removeListener('SIGWINCH', this.resizeFn);
+        // 还原鼠标上报 + 显示光标 (退出后触控板/鼠标回到终端自己的行为: 能划选文本、能正常右键)
+        try {
+            this.write(`${E}[?1000l${E}[?1006l`);
+        }
+        catch { /* 已关闭 */ }
         this.write(SHOW_CURSOR);
         try {
             this.stdin.setRawMode(false);
@@ -559,12 +612,16 @@ export function tuiSelect(choices, title, opts = {}) {
         const below = top + H - (above ? 1 : 0) < total;
         const body = Math.max(1, H - (above ? 1 : 0) - (below ? 1 : 0));
         const start = top + (above ? 1 : 0);
-        // `已筛` = **命中筛选的家数** (与折叠无关: 收起只是不画成员行, 家数照数) ——
-        //   这是"折叠不是隐藏"的可读证据: 全量时 `共 231 家 · 已筛 231 家`, 收起 3 组也不变。
+        // `已筛` = **命中筛选的家数** ——
+        //   折叠是通用能力: 只在候选真的带分组时才出现在提示与状态里 (模型选择器现为纯平铺单选列表,
+        //   不带分组 → 提示里不出现折叠键, 与参考图一致)。折叠机制仍保留给需要分组的调用方用。
         const filteredItems = real.filter((c) => matchesQuery(c, query)).length;
         const collapsedGroups = [...collapsed].filter((g) => real.some((c) => c.group === g));
-        // 头行: 标题 + 计数 (共 N 家 · 已筛 M 家) + 键位提示 —— **不滚** (每帧都画)
-        const head = `${String(title).replace(/[::]\s*$/, '')} · 共 ${real.length} ${unit} · 已筛 ${filteredItems} ${unit}  ${TUI_HINT}`;
+        const hasGroups = real.some((c) => c.group);
+        // 头行: 标题 + 计数 (共 N 家 · 已筛 M 家) + 键位提示 —— **不滚** (每帧都画)。
+        //   提示按候选是否带分组裁剪: 无分组 (纯平铺) 时只给移动/确认/搜索/数字/Esc, 不带折叠键。
+        const hint = hasGroups ? TUI_HINT : TUI_HINT_FLAT;
+        const head = `${String(title).replace(/[::]\s*$/, '')} · 共 ${real.length} ${unit} · 已筛 ${filteredItems} ${unit}  ${hint}`;
         // 状态行: `第 i/N` 与 `筛选 "x"` 必须相邻 (既有验收门按这个形状钉"数字真的跟着动")
         const shownIdx = cursor + 1;
         const status = [
@@ -576,11 +633,18 @@ export function tuiSelect(choices, title, opts = {}) {
             query ? '' : 'q=取消',
         ].filter(Boolean).join(' · ');
         const buf = [];
+        // ★ 重绘回退 = **实际画出的行数** (drawn), 不是视窗容量 body。
+        //   leo 2026-10-05 报「切换吞掉之前的内容 + 高度回退」的根因: 筛选后候选只剩 2 项,
+        //   帧实际只画 4 行, 但 rendered 用 body(=27) 记成了 28 → finish 发 `ESC[28A` 上移 28 行,
+        //   把上面主屏的 `步骤 1/4`/`已选供应商` 全吞掉。VIEWPORT_MAX 12→40 后 body 变大, 吞得更狠。
         buf.push(`${first ? '' : `${E}[${rendered}A`}${ERASE_DOWN}`);
         // 头行: 先按纯文本截到宽度, 再上色 (顺序反了的话颜色码会被截断丢掉)
         buf.push(`${toneWrap(truncateToWidth(head, cols), 'accent', color)}${ERASE_EOL}\r\n`);
-        if (above)
+        let drawn = 1; // 头行
+        if (above) {
             buf.push(`${toneWrap(truncateToWidth(`  ↑ 上面还有 ${top} ${unit}`, cols), 'muted', color)}${ERASE_EOL}\r\n`);
+            drawn++;
+        }
         for (let i = 0; i < body; i++) {
             const line = lines[start + i];
             // 先算**纯文本**行内容并按宽度截断/补齐, 再决定怎么上色 —— 保证"颜色不被截断抹掉 + 不撑破"
@@ -613,15 +677,22 @@ export function tuiSelect(choices, title, opts = {}) {
                 // ★ 光标行: `→ ` 前缀 + **accent 底 / 近黑字** (见 CURSOR_SGR; 反白序列同时是结构判据)
                 const padded = padToWidth(truncateToWidth(plain, cols), cols);
                 buf.push(`${color ? `${CURSOR_SGR}${padded}${RESET}` : truncateToWidth(plain, cols)}${ERASE_EOL}\r\n`);
+                drawn++;
                 continue;
             }
             buf.push(`${toneWrap(truncateToWidth(plain, cols), tone, color)}${ERASE_EOL}\r\n`);
+            drawn++;
         }
-        if (below)
+        if (below) {
             buf.push(`${toneWrap(truncateToWidth(`  ↓ 下面还有 ${total - (start + body)} ${unit}`, cols), 'muted', color)}${ERASE_EOL}\r\n`);
+            drawn++;
+        }
         buf.push(`${toneWrap(truncateToWidth(status, cols), 'muted', color)}${ERASE_EOL}`);
-        // 帧共 1(头) + (above?1:0) + body + (below?1:0) + 1(状态) ≤ 终端高度 行 (硬预算)
-        rendered = 1 + (above ? 1 : 0) + body + (below ? 1 : 0);
+        drawn++; // 状态行
+        // 帧共 drawn 行 (头 + 上下指示 + 实际候选行数 + 状态) ≤ 终端高度 (硬预算)。
+        //   finish 的 `ESC[nA` 用 drawn-1: 光标从状态行回到帧首行, ESC[J 清掉整帧;
+        //   用容量 body 会导致上移过头, 把上面的主屏行也吞掉 (本 bug 的根因)。
+        rendered = Math.max(1, drawn - 1);
         out.write(buf.join(''));
         first = false;
     };
@@ -658,6 +729,24 @@ export function tuiSelect(choices, title, opts = {}) {
                 note = '';
                 break;
             }
+            // 触控板两指滚动 / 鼠标滚轮 (SGR 上报): 滚上=↑, 滚下=↓ —— 和方向键同一套移动逻辑
+            case 'wheel': {
+                if (k.dy === 1) {
+                    if (cursor > 0)
+                        cursor--;
+                    else
+                        cursor = maxIdx;
+                }
+                else {
+                    if (cursor < maxIdx)
+                        cursor++;
+                    else
+                        cursor = 0;
+                }
+                numBuf = '';
+                note = '';
+                break;
+            }
             case 'pageup': {
                 cursor = Math.max(0, cursor - Math.max(1, Math.floor(viewportHeight(termSize(out, opts).rows) / 2)));
                 numBuf = '';

package/dist/cli-entry.js

@@ -636,18 +636,10 @@ async function handleModelCommand(modelArgs) {
             console.log(`  ${formatEffectiveModel(eff)}`);
         console.log('─'.repeat(58));
         // 非终端里没有"固定高度视窗 + 折叠"那套交互 (那是全屏 TUI 的事), 所以这里**整份列全**:
-        //   内置 13 + 自定义 + 目录全部 逐行出, 分组标题带家数。只给"分组计数"是这条线要修的病 ——
+        //   内置 13 + 自定义 + 目录全部 逐行出, 不再带分组分隔条。只给"分组计数"是这条线要修的病 ——
         //   脚本要能 grep 到任何一家 (含"需专用鉴权 (未支持)""无基址"的那些)。
         const ordered = mc.orderProvidersForMenu(summaries);
-        let lastGroup = '';
         for (const s of ordered) {
-            const tier = mc.providerTierOf(s);
-            const g = mc.PROVIDER_GROUPS[tier];
-            if (g !== lastGroup) {
-                lastGroup = g;
-                const n = ordered.filter((x) => mc.providerTierOf(x) === tier).length;
-                console.log(`  ── ${g} (${n} 家)${mc.providerTierCollapsedByDefault(tier) ? ' · 交互界面里默认收起, 空格/→ 展开' : ''}`);
-            }
             console.log(`  ${mc.formatProviderMenuRow(s)}`);
         }
         console.log(`  ${mc.providerGroupSummary(summaries)}`);