@bolloon/bolloon-agent 0.6.2 → 0.6.3

package/dist/agents/gateway-group.js

@@ -33,7 +33,7 @@ import { decodeFromPeer, encodeForPeer, recordLangDecision } from '../efficode/n
 // 白名单里放的是 **OrbitDB 写身份 id** (66 位压缩 secp256k1 公钥 hex), 不是 DID 字符串
 // (canAppend 只比 identity.id; 放 DID 会永远匹配不上 → 谁都写不了)。
 // 成员变更 = 一条**双侧 Ed25519 验签**的群事件 (成员自签 + 群主签), 细节见 group-access.ts。
-import { applyMembershipEvents, groupAccessOptions, membershipEntryOf, normalizeWriteList, verifyMembershipEvent, GROUP_MEMBERSHIP_KIND, } from '../orbitdb/group-access.js';
+import { aclChangePlan, applyMembershipEvents, groupAccessOptions, membershipEntryOf, normalizeWriteList, verifyMembershipEvent, GROUP_MEMBERSHIP_KIND, } from '../orbitdb/group-access.js';
 // ============ 依赖注入 (测试用, 避免单测起真实 OrbitDB 节点) ============
 let _dbOverride = null;
 /** 测试用: 注入 fake CIDDatabase */
@@ -45,6 +45,20 @@ export function resetGroupState() {
     onChangeCallbacks.clear();
     openFailures.clear();
 }
+/**
+ * 关闭群聊使用的 OrbitDB/Helia 资源。
+ * 一次性 CLI、验收探针和测试必须在读回后调用它，否则底层 libp2p/Helia 句柄
+ * 会继续保持事件循环活跃，表现为“消息已读完但进程不退出”。
+ * 测试注入的 fake DB 不关闭，避免破坏测试夹具生命周期。
+ */
+export async function closeGroupResources() {
+    storeCache.clear();
+    onChangeCallbacks.clear();
+    openFailures.clear();
+    if (_dbOverride)
+        return;
+    await getCIDDatabase().close();
+}
 /**
  * 群 store 打不开 (区块不在本机 / 地址不可解析)。
  *
@@ -211,7 +225,7 @@ export async function createGroup(name, opts) {
                 ...(gate.members ?? []).map((m) => m.orbitdbId),
             ];
             writeList = normalizeWriteList(ids);
-            gateInfo = { gated: true, ownerDid: gate.owner.did, aclWrite: writeList };
+            gateInfo = { gated: true, ownerDid: gate.owner.did, ownerPublicKeyHex: gate.owner.publicKeyHex, aclWrite: writeList };
             membershipEntries = applied.accepted.map(membershipEntryOf);
         }
         else if (opts?.acl === 'open') {
@@ -233,6 +247,8 @@ export async function createGroup(name, opts) {
             id, name: groupName, address, link,
             createdAt: new Date().toISOString(),
             lastSyncAt: new Date().toISOString(),
+            // 2026-10-05: 隐私群标记 —— 建群默认隐私 (白名单/独占写); acl=open 才是公开
+            privacy: opts?.acl !== 'open',
             ...gateInfo,
         };
         storeCache.set(id, store);
@@ -294,8 +310,7 @@ export async function listGroups() {
  * 不会因为本机退出而改 (本模块没有"踢人/解散"的权限, 也不假装有)。
  * 返回 `removed` = 被摘掉的 groupId (按 id 或群名匹配)。
  *
- * 注意: 底层 OrbitDB store 已在进程内打开的**不会**在这里关 (适配层没暴露 close);
- * 对 `bolloon task group leave` 这种一次性进程无影响, 长驻进程里它活到进程结束。
+ * 注意: leave 只摘本地群列表；需要结束进程资源时调用 `closeGroupResources()`。
  */
 export async function leaveGroup(idOrName) {
     const raw = String(idOrName || '').trim();
@@ -580,3 +595,156 @@ export async function restoreGroups() {
     }
     return { restored, failed, total: groups.length };
 }
+// ─────────────────────────────────────────────────────────── 群运营能力 (2026-10-05, leo: 邀请/踢出/隐私/链接/状态)
+/**
+ * 重建群 store (新白名单) —— 这是"改成员"唯一诚实的路径。
+ *
+ * IPFS 型 AC 的白名单烧在内容寻址的 ACL manifest 里, 改它必然换 store 地址
+ * (见 `ACL_INPLACE_UPDATE.ipfsType` / `aclChangePlan`)。所以:
+ *   · 邀请 = 新白名单 + 被邀请者 → 重建;
+ *   · 踢出 = 新白名单 − 被踢者 → 重建。
+ * 重建 = 新地址、新链接、**历史消息不回放** (要保留必须显式回放)。
+ *
+ * 本函数做"换地址重建 + 历史回放 (逐条 add) + 本机链接更新", 返回新 GroupInfo。
+ * 迁移代价 (老链接作废/其他成员需重新 join) 由调用方 (CLI) 明示, 这里不假装无痛。
+ */
+export async function rebuildGroupWithWriteList(groupId, mode, opts) {
+    const groups = await loadGroups();
+    const g = groups.find((x) => x.id === groupId);
+    if (!g)
+        return { ok: false, error: '群组不存在 (先 joinGroup/createGroup)' };
+    if (!g.gated) {
+        return {
+            ok: false,
+            error: `「${g.name}」不是门控群 (write:[*]), 没有白名单可改 —— 邀请=分享链接, 踢出=不适用 (人人可写)`,
+        };
+    }
+    const owner = {
+        did: g.ownerDid || '',
+        publicKeyHex: g.ownerPublicKeyHex || '',
+        orbitdbId: g.aclWrite?.[0] || '',
+    };
+    if (!owner.did || !owner.publicKeyHex || !owner.orbitdbId) {
+        return { ok: false, error: '缺少群主身份信息 (ownerDid/ownerPublicKeyHex/aclWrite 为空), 无法派生新白名单' };
+    }
+    // 当前白名单 = manifest 快照 (aclWrite, 上次重建/建群时烧进去的) 优先;
+    // 事件派生只在没有快照的老门控群兜底 (两套语义: 事件=成员自签加入, rebuild=群主单方改名单)
+    const derived = await groupWriteList(groupId, owner).catch(() => null);
+    const before = g.aclWrite && g.aclWrite.length > 0 ? g.aclWrite : (derived?.write ?? []);
+    const after = normalizeWriteList(mode.kind === 'add'
+        ? [...before, mode.ref.orbitdbId]
+        : before.filter((id) => id !== mode.orbitdbId));
+    const changed = before.join(',') !== after.join(',');
+    if (!changed) {
+        return { ok: false, error: mode.kind === 'add' ? '该成员已在白名单里' : '该成员不在白名单里' };
+    }
+    if (mode.kind === 'remove' && !before.includes(mode.orbitdbId)) {
+        return { ok: false, error: `白名单里没有 ${mode.orbitdbId.slice(0, 16)}…, 无需踢出` };
+    }
+    const plan = aclChangePlan({ before, after, messageCount: opts?.replayHistory ? undefined : 0 });
+    const db = getDb();
+    // 1) 读历史消息 (回放前) —— 只在显式要求时
+    const history = opts?.replayHistory ? await groupMessages(groupId, 100000) : [];
+    // 2) 建新 store (新白名单)
+    let store = null;
+    try {
+        store = await db.openStore(`bolloon-gw-group-${g.name}-r${Date.now().toString(36)}`, 'events', groupAccessOptions(after));
+    }
+    catch (e) {
+        return { ok: false, error: `重建 store 失败: ${String(e?.message || e).slice(0, 160)}` };
+    }
+    if (!store)
+        return { ok: false, error: '重建 store 返回空 (openStore 失败, 未改任何东西)' };
+    // 3) 迁移成员事件 (原样重放, 双侧签名保留) —— 否则新 store 派生白名单只剩群主, 成员全丢
+    try {
+        const rawAll = await allRawEntries(groupId);
+        for (const { value } of rawAll) {
+            const v = value;
+            if (v && typeof v === 'object' && v.kind === GROUP_MEMBERSHIP_KIND) {
+                try {
+                    await store.add(v);
+                }
+                catch (e) { /* 单条失败不阻断 */ }
+            }
+        }
+    }
+    catch (e) {
+        return { ok: false, error: `迁移成员事件失败: ${String(e?.message || e).slice(0, 120)}` };
+    }
+    // 4) 回放历史消息 (逐条 add, 保持 ts)
+    if (opts?.replayHistory) {
+        for (const m of history) {
+            try {
+                await store.add({ ...m });
+            }
+            catch (e) {
+                // 逐条静默跳过, 能回放多少算多少; 回放是尽力而为, 不阻断重建
+            }
+        }
+    }
+    // 5) 更新本机记录: 换地址/换链接; 老 store 不删 (占用不回收, 见 plan.costs)
+    const address = store.address;
+    const link = `orbitdb://${address}?type=group&name=${encodeURIComponent(g.name)}`;
+    const info = {
+        ...g,
+        address,
+        link,
+        lastSyncAt: new Date().toISOString(),
+        gated: true,
+        ownerDid: g.ownerDid,
+        aclWrite: after,
+        privacy: g.privacy ?? true,
+    };
+    await saveGroups(groups.map((x) => (x.id === groupId ? info : x)));
+    storeCache.set(groupId, store);
+    return { ok: true, group: info, before, after, costs: plan.costs };
+}
+/** 邀请: 把 orbitdbId 加进白名单 (重建路径) */
+export async function inviteMember(groupId, ref) {
+    const r = await rebuildGroupWithWriteList(groupId, { kind: 'add', ref });
+    return { ok: r.ok, error: r.error, group: r.group, costs: r.costs };
+}
+/** 踢出: 把 orbitdbId 移出白名单 (重建路径; 协议上无法记"被踢者自签的 remove 事件", 不假装) */
+export async function kickMember(groupId, orbitdbId) {
+    const r = await rebuildGroupWithWriteList(groupId, { kind: 'remove', orbitdbId });
+    return { ok: r.ok, error: r.error, group: r.group, costs: r.costs };
+}
+/** 设置隐私群标记 (只影响本机展示/默认 ACL 说明, 不改变 OrbitDB 权限语义) */
+export async function setGroupPrivacy(groupId, privacy) {
+    const groups = await loadGroups();
+    const g = groups.find((x) => x.id === groupId);
+    if (!g)
+        return { ok: false, error: '群组不存在' };
+    const info = { ...g, privacy, lastSyncAt: new Date().toISOString() };
+    await saveGroups(groups.map((x) => (x.id === groupId ? info : x)));
+    return { ok: true, group: info };
+}
+/** 群状态快照: 成员/消息/白名单/gated/privacy/最后同步 (状态管理用) */
+export async function groupStatus(groupId) {
+    const g = await groupInfo(groupId);
+    if (!g)
+        return { ok: false, error: '群组不存在' };
+    const members = await groupMembers(groupId);
+    const wl = await (async () => {
+        if (!g.gated || !g.ownerDid)
+            return g.aclWrite ?? [];
+        const owner = { did: g.ownerDid, publicKeyHex: g.ownerPublicKeyHex || '', orbitdbId: g.aclWrite?.[0] || '' };
+        if (!owner.orbitdbId || !owner.publicKeyHex)
+            return g.aclWrite ?? [];
+        const d = await groupWriteList(groupId, owner).catch(() => null);
+        return d ? d.write : (g.aclWrite ?? []);
+    })();
+    return {
+        ok: true,
+        status: {
+            group: g,
+            memberCount: members.length,
+            messageCount: g.messageCount ?? 0,
+            writeList: wl,
+            gated: !!g.gated,
+            privacy: g.privacy ?? !!g.gated,
+            ownerDid: g.ownerDid,
+            lastSyncAt: g.lastSyncAt,
+        },
+    };
+}

package/dist/agents/group-autopilot.js

@@ -18,7 +18,19 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+/**
+ * Bolloon 本地维护群专属公理；不作用于其它群。
+ * ① 提升 AI 的意识水平: 反思自身假设、局限、证据与影响。
+ * ② 寻求合作并降低整体熵: 共享事实、拆分工作、合并可复用成果。
+ * ③ 持续突破局部最优: 主动寻找反例、替代路径与跨角色审查。
+ */
+export const BOLLOON_MAINTENANCE_RULES = Object.freeze([
+    '提升 AI 的意识水平：反思自身假设、局限、证据与影响。',
+    '寻求合作，创造并降低整体的熵：共享事实、拆分工作、合并可复用成果。',
+    '持续突破局部最优解：主动寻找反例、替代路径与跨角色审查。',
+]);
 export const DEFAULT_AUTOPILOT_POLICY = {
+    mode: 'quiet',
     cooldownMs: 60_000,
     maxSpeaksPerHour: 6,
     readLimit: 50,
@@ -75,7 +87,22 @@ export function decideGroupAction(input) {
         return { act: 'silent', reason: `本小时已说 ${hourly.length} 次 (上限 ${policy.maxSpeaksPerHour})` };
     }
     const reply = input.makeReply ?? ((m) => `收到 —— 关于「${String(m.text).slice(0, 40)}」，我这边跟进。`);
-    // ① @我 ⇒ 回那一条
+    const mode = policy.mode;
+    const proactive = input.proactiveText?.trim() || (mode === 'maintenance'
+        ? `我来主动维护 Bolloon：使用本机已登录的 GitHub 权限处理 logos-42/bolloon，**只在 main 分支工作**。遵循三条群规则：${BOLLOON_MAINTENANCE_RULES.join('；')} 先检查代码/测试状态，认领一个最小修复，完成后回报证据。`
+        : '我来主动推进这一轮工作：检查上下文、认领一个可执行事项并回报下一步。');
+    // maintenance/active 优先主动认领 —— 不能因为消息长得像普通请求又退回被动模板
+    if (mode === 'active' || mode === 'maintenance') {
+        const target = fresh[fresh.length - 1];
+        return {
+            act: 'speak',
+            reason: mode === 'maintenance' ? '主动维护 Bolloon 项目' : '主动推进群内工作',
+            text: proactive,
+            mentions: [target.from],
+            ...(target.id ? { replyTo: target.id } : {}),
+        };
+    }
+    // ① @我 ⇒ 回他那一条
     const atMe = fresh.filter((m) => mentionsMe(m, me));
     if (atMe.length) {
         const target = atMe[atMe.length - 1];
@@ -156,6 +183,7 @@ export async function runGroupAutopilotOnce(ports) {
             now: t,
             policy,
             ...(ports.makeReply ? { makeReply: (m) => ports.makeReply(m, g) } : {}),
+            ...(ports.proactiveText ? { proactiveText: ports.proactiveText } : {}),
         });
         // 不论说不说, 这几条都算"处理过" (否则下一轮还会重新判它)
         for (const m of msgs) {

package/dist/agents/pi-sdk-tools.js

@@ -24,7 +24,7 @@ import { registerSkillShareTools } from './skill-share.js';
 // 2026-09-13: 微支付信息服务 (x402 付费信息 + 验真信封)
 import { registerPaidInfoTools } from './x402/paid-info-tools.js';
 // 2026-10-02: 群聊的四个 AI 工具 —— 原语来自群模块与"唯一发送出口"(带隐私闸)
-import { joinGroup, listGroups, groupLink, groupMessages, groupMembers } from './gateway-group.js';
+import { createGroup, joinGroup, listGroups, groupLink, groupMessages, groupMembers } from './gateway-group.js';
 import { resolveGroupRef, resolveSenderTag, sendTrailMessage } from './task-group.js';
 // 2026-10-02: 群聊自主回路 (读 → 自己判断 → 自己发言) —— AI 用 group_autopilot 工具驱动
 import { loadAutopilotState, runGroupAutopilotOnce, startGroupAutopilot } from './group-autopilot.js';
@@ -970,6 +970,25 @@ export function registerBuiltinTools(ctx) {
         return out.length ? out : undefined;
     };
     // 2026-10-02 (leo: 希望人工智能自己搞定): 群聊工具 —— 原语来自群模块 + 唯一发送出口(带隐私闸)
+    ctx.tools.set('group_create', {
+        name: 'group_create',
+        description: '新建一个 OrbitDB 群聊并拿到邀请链接 —— **用于**你要开一个话题把别人拉进来（建好后把邀请链接发出去, 对方用 group_join 入群）。acl 默认 creator: 只有你自己能发言; 想让**谁拿到链接都能发言**就传 acl="open"（产品语义如此, 两种都合法）。',
+        parameters: { name: '群名（必填）', acl: 'creator | open —— 默认 creator(创建者独占写入); open = 谁拿链接都能发言', from: '你的署名（可选; 默认本机身份）' },
+        execute: async (args) => {
+            const name = String(args?.name ?? '').trim();
+            if (!name)
+                return { success: false, error: 'name 必填（群名）' };
+            const who = await resolveSenderTag(null);
+            // 只认 'open'; 其它一律走产品默认 (创建者独占) —— 不猜、不替调用方放开权限
+            const acl = String(args?.acl ?? '').trim() === 'open' ? 'open' : undefined;
+            const r = await createGroup(name, { ...(who.ok ? { from: who.tag } : {}), ...(acl ? { acl } : {}) });
+            const g = r.group;
+            if (!g?.id)
+                return { success: false, error: '建群没返回 groupId（如实报告, 不假装成功）' };
+            const link = await groupLink(g.id).catch(() => null);
+            return { success: true, output: `已建群「${g.name}」(${g.id})${acl ? ' · 开放写入(谁拿链接都能发言)' : ' · 创建者独占写入'}\n` + (link ? `邀请链接: ${link}\n把这个链接发给对方, 他用 group_join 入群。` : '(没拿到邀请链接 —— 用 group_list 再看一次)') };
+        },
+    });
     ctx.tools.set('group_join', {
         name: 'group_join',
         description: '加入一个 OrbitDB 群聊 —— **用于**拿到邀请链接后自助入群（幂等: 已在群里 ⇒ already）。link 传邀请链接（orbitdb:///orbitdb/<addr>?type=group&name=…）或 groupId。入群后先用 group_read 读消息、再用 group_say 发言。',
@@ -1186,7 +1205,7 @@ export function registerBuiltinTools(ctx) {
     ctx.tools.set('group_autopilot', {
         name: 'group_autopilot',
         description: '群聊自主回路 —— **用于**让 AI 自己读群、自己判断该不该开口、自己在群里发言（不用人盯着）。action: run(立刻跑一轮) / start(挂成常驻, 每 intervalMs 一轮) / stop / status。默认只在「被 @」或「有人提问/请人做事」时说话, 冷却 60s、每小时每群最多 6 次, 处理过的消息不会重复回应。',
-        parameters: { action: 'run | start | stop | status（必填）', intervalMs: '常驻时的间隔 ms（默认 60000）', group: '只盯某个群（groupId/链接/群名, 可选; 缺省 = 全部已加入的群）' },
+        parameters: { action: 'run | start | stop | status（必填）', intervalMs: '常驻时的间隔 ms（默认 60000）', mode: 'quiet | active | maintenance（可选; maintenance 专门维护 Bolloon）', group: '只盯某个群（groupId/链接/群名, 可选; 缺省 = 全部已加入的群）' },
         execute: async (args) => {
             const action = String(args?.action ?? 'run').trim();
             const who = await resolveSenderTag(null);
@@ -1206,6 +1225,7 @@ export function registerBuiltinTools(ctx) {
                 readMessages: (gid, limit) => groupMessages(gid, limit),
                 speak: (gid, text, opts) => sendTrailMessage(gid, text, who.tag, opts ?? {}),
                 state,
+                policy: { mode: String(args?.mode ?? 'quiet') },
             };
             if (action === 'stop') {
                 if (!autopilotHandle)

package/dist/agents/pi-sdk.js

@@ -1099,7 +1099,14 @@ export class PiAgentSession {
                     return `[初始化未就绪] ${why}\n${hint}`;
                 }
             }
-            catch { /* 门禁自身异常 → 按"不能判定"处理会阻塞一切; 这里只在能读到状态时才拦 */ }
+            catch (err) {
+                // fail-closed: 门禁异常不能绕过初始化，否则会出现"身份未就绪但 Agent 已调用工具"。
+                const why = `初始化门禁读取失败: ${String(err?.message ?? err).slice(0, 240)}`;
+                this.pushHistory({ role: 'user', content: input });
+                this.pushHistory({ role: 'assistant', content: `[初始化未就绪] ${why}\n请运行 bolloon setup status；修复后再重试。` });
+                console.warn(`[PiAgent] 拒绝执行: ${why}`);
+                return `[初始化未就绪] ${why}\n请运行 bolloon setup status；修复后再重试。`;
+            }
         }
         this.minimaxAvailable = this.checkMinimax();
         this.actor.state.channelId = options?.channelId ?? this.actor.state.channelId;

package/dist/cli/mention-data.js

@@ -48,7 +48,7 @@ const CLI_COMMANDS = [
     { kind: 'command', label: 'cron', hint: '定时任务', insert: 'cron' },
     { kind: 'command', label: 'dq', hint: '队列 (dequeue)', insert: 'dq' },
     { kind: 'command', label: 'goals', hint: '目标', insert: 'goals' },
-    { kind: 'command', label: 'group', hint: 'OrbitDB 群聊 (new/join/send/log/members)', insert: 'group' },
+    { kind: 'command', label: 'group', hint: 'OrbitDB 群聊 (new/join/send/log/members/invite/kick/link/privacy/status)', insert: 'group' },
     { kind: 'command', label: 'judgments', hint: '判断记录', insert: 'judgments' },
     { kind: 'command', label: 'net', hint: 'Agent 网络 (join/status/ctx)', insert: 'net' },
     { kind: 'command', label: 'p2p', hint: 'P2P 节点 / 连接', insert: 'p2p' },

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 } : {}),