@bolloon/bolloon-agent 0.4.33 → 0.5.1

package/dist/cli/update-commands.js

@@ -13,8 +13,9 @@
  *   2  检查不可用 (离线 / registry 不可用 / 读不到本地版本) —— 与"没有更新"区分开
  */
 import { resolveBolloonHome } from '../setup/setup-store.js';
-import { collectVersionInfo, renderVersionText, renderVersionJson, } from '../utils/version-info.js';
-import { checkForUpdate, buildUpdatePlan, renderUpdatePlan, applyUpdate, readUpdateStatus, readHistory, renderHistory, updateSummaryFor, compareVersions, } from '../utils/update-manager.js';
+import { collectVersionInfo, renderVersionText, renderVersionJson, DEV_CHANNEL_WARNING, DEV_BACK_TO_STABLE_HINT, channelKindOf, isDevIdentity, } from '../utils/version-info.js';
+import { checkForUpdate, buildUpdatePlan, renderUpdatePlan, applyUpdate, readUpdateStatus, readHistory, renderHistory, updateSummaryFor, compareVersions, checkExitCode, REFUSED_STATUSES, } from '../utils/update-manager.js';
+import { renderGithubReportLine } from '../utils/dual-source.js';
 import { runDoctor, renderDoctor } from '../utils/update-health.js';
 import { detectRuntimeReport, bootstrapRuntimes, renderRuntimeReport, renderBootstrapPlan, RUNTIME_MIN, readRuntimeConfigWithFallback, } from '../utils/runtime-bootstrap.js';
 const RESET = '\x1b[0m';
@@ -25,6 +26,45 @@ const YELLOW = '\x1b[38;2;245;158;11m';
 const RED = '\x1b[38;2;239;68;68m';
 const out = (s) => process.stdout.write(s + '\n');
 const err = (s) => process.stderr.write(s + '\n');
+// ── --channel (§12.2: 只覆盖本次进程, 不落盘) ───────────────────────────────
+/** 允许的通道字面量 (`--channel stable|dev`; beta 仍是"与 stable 同源"的老口径)。 */
+const CHANNEL_VALUES = ['stable', 'dev', 'beta'];
+/**
+ * 解析 `--channel <v>` / `--channel=<v>`。
+ * 给了不认识的值 → **拒绝并说清** (不静默落回 stable, 那会让人以为切成功了)。
+ */
+export function parseChannelArg(args) {
+    let raw = null;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--channel') {
+            raw = args[i + 1] ?? '';
+            break;
+        }
+        if (a.startsWith('--channel=')) {
+            raw = a.slice('--channel='.length);
+            break;
+        }
+        if (a === 'channel') {
+            raw = args[i + 1] ?? '';
+            break;
+        }
+    }
+    if (raw === null)
+        return { given: false };
+    const v = raw.trim().toLowerCase();
+    if (!CHANNEL_VALUES.includes(v)) {
+        return { given: true, error: `--channel 只接受 ${CHANNEL_VALUES.join('|')}, 收到 "${raw}" — 拒绝执行 (没有静默落回 stable)` };
+    }
+    return { channel: v, given: true };
+}
+/** dev 通道的三条硬约束 (§12.4) 在这里统一打印: 显式警告 + 记录 sha + 一键回 stable。 */
+function printDevNotice() {
+    out('');
+    out(DEV_CHANNEL_WARNING);
+    out(DEV_BACK_TO_STABLE_HINT);
+    out('');
+}
 // ── 版本 ────────────────────────────────────────────────────────────────────
 export async function runVersionCommand(args = []) {
     // 2026-09-19 (leo): 子命令一律**裸词**, 不再带 `--` 前缀 (只有 `--version` 本身保留 --)
@@ -78,22 +118,39 @@ function statusConclusion(status, latest, current) {
             const cmp = !latest ? '' : compareVersions(current, latest) < 0 ? ` — 已有更新版 ${latest}, 需按该安装方式手动升级` : ` — 本地 ${current} 已是 registry 上最新`;
             return `${YELLOW}当前安装方式不支持自动更新${RESET}${cmp}`;
         }
+        case 'github_unavailable': return `${RED}GitHub 源不可用${RESET} — ${BOLD}不能判定为最新${RESET}`;
+        case 'cross_check_mismatch': return `${RED}两个源不一致${RESET} — npm 与 GitHub 指向不同版本, ${BOLD}拒绝更新${RESET}`;
         default: return '尚未检查';
     }
 }
 export function renderCheckResult(r) {
+    const dev = r.channelKind === 'git-ref';
     const L = [];
-    L.push(`当前版本: ${r.currentVersion}`);
-    L.push(`最新版本: ${r.latestVersion || '未知'}`);
-    L.push(`更新通道: ${r.channel} (来源: ${r.source})`);
+    L.push(`当前版本: ${r.currentVersion}${r.installedDevSha ? ` (dev 快照 commit ${r.installedDevSha})` : ''}`);
+    L.push(`${dev ? '最新快照' : '最新版本'}: ${r.latestVersion || '未知'}`);
+    L.push(`更新通道: ${r.channel} (比较语义: ${r.channelKind || channelKindOf(r.channel)})`);
+    L.push(`当前来源: ${r.installedChannel === 'dev' ? `dev (GitHub master 快照 @ ${r.installedDevSha})` : 'stable (npm registry)'}`);
     L.push(`安装方式: ${r.installMethod}`);
+    if (dev)
+        L.push(renderGithubReportLine(r.github));
+    else {
+        L.push(renderGithubReportLine(r.github));
+        if (r.crossCheck)
+            L.push(`交叉校验: ${r.crossCheck.kind}${r.crossCheck.blocking ? ' (阻塞)' : ''} — ${r.crossCheck.detail}`);
+    }
+    if (r.dev)
+        L.push(`dev 判定: ${r.dev.detail}`);
+    if (r.switchableTo)
+        L.push(`能切回: ${r.switchableTo.channel} (${r.switchableTo.source}${r.switchableTo.target ? ` @ ${r.switchableTo.target}` : ''})`);
     L.push(`检查时间: ${r.checkedAt}${r.fromCache ? ' (缓存)' : ''}`);
     L.push(`结论: ${statusConclusion(r.status, r.latestVersion, r.currentVersion)}`);
     if (r.reason)
         L.push(`说明: ${r.reason}`);
     L.push('');
     if (r.status === 'update_available') {
-        L.push(`下一步: ${BOLD}bolloon update plan${RESET} 看计划, ${BOLD}bolloon update now${RESET} 执行更新`);
+        L.push(`下一步: ${BOLD}bolloon update plan --channel ${r.channel}${RESET} 看计划, ${BOLD}bolloon update now --channel ${r.channel}${RESET} 执行更新`);
+        if (dev)
+            L.push(DEV_CHANNEL_WARNING), L.push(DEV_BACK_TO_STABLE_HINT);
     }
     else if (r.status === 'unsupported_installation') {
         L.push('下一步: 按上面"说明"里对应安装方式更新 (源码目录: git pull && npm install && npm run build:all)');
@@ -101,6 +158,14 @@ export function renderCheckResult(r) {
     else if (r.status === 'offline' || r.status === 'registry_unavailable') {
         L.push('下一步: 检查网络/代理后重跑 `bolloon update`; 也可以 `bolloon update status` 看上次结论');
     }
+    else if (r.status === 'github_unavailable') {
+        L.push('下一步: 检查到 GitHub 的网络/代理/限流后重跑 `bolloon update --channel dev`;'
+            + `${BOLD}dev 通道不会退回 stable 装旧版${RESET} —— 要稳定版请显式 --channel stable`);
+    }
+    else if (r.status === 'cross_check_mismatch') {
+        L.push('下一步: 两个发布源不一致, 先查清哪个是对的 (npm: registry dist-tags / GitHub: Release 记录);'
+            + '本条不执行任何安装, 也不会按 GitHub 的 tag 去装。');
+    }
     else if (r.status === 'local_version_unknown') {
         L.push('下一步: 重新安装 (npm install -g @bolloon/bolloon-agent) 以恢复 package.json');
     }
@@ -109,32 +174,63 @@ export function renderCheckResult(r) {
 export function renderStatusReport(s) {
     const L = [];
     const lu = s.lastUpdate;
+    const dev = s.installedChannel === 'dev';
     L.push(`${BOLD}更新状态${RESET}`);
     L.push(`当前版本:   ${s.currentVersion}`);
+    // ── §12.5: 必须说清"当前装的是哪个源 + 哪个版本/commit sha + 能切回哪个源" ──
+    L.push(`安装来源:   ${dev
+        ? `dev (GitHub master 快照, ref ${s.devRef || 'refs/heads/master'}, commit ${s.installedDevSha || '未知'})`
+        : 'stable (npm registry)'}`);
+    L.push(`身份标识:   ${dev ? `commit ${s.installedDevSha || '未知'}` : s.currentVersion}`);
+    L.push(`能切回:     ${s.switchableTo
+        ? `${s.switchableTo.channel} (${s.switchableTo.source}${s.switchableTo.target ? ` @ ${s.switchableTo.target}` : ''}) — 一键切: bolloon update now --channel ${s.switchableTo.channel}`
+        : '无 (未知来源)'}`);
+    if (s.lastDevSha && !dev)
+        L.push(`上次 dev:   commit ${s.lastDevSha}${s.devCheckedAt ? ` @ ${s.devCheckedAt}` : ''} (已切回 stable)`);
     L.push(`最新版本:   ${s.latestVersion || (s.lastCheckStatus ? '未知' : '尚未检查')}`);
     L.push(`是否最新:   ${statusConclusion(s.lastCheckStatus, s.latestVersion, s.currentVersion)}`);
-    L.push(`更新通道:   ${s.channel}`);
+    L.push(`更新通道:   ${s.channel} (比较语义: ${s.channelKind})`);
     L.push(`安装方式:   ${s.installMethod}`);
     L.push(`安装目录:   ${s.installDir}`);
     L.push(`运行入口:   ${s.entryPath}`);
+    if (s.sourceFacts) {
+        const f = s.sourceFacts;
+        L.push(`源事实:     npm ${f.npm?.reachable ? `可达 (latest=${f.npm.latest || '未知'})` : `不可达${f.npm?.detail ? ` (${f.npm.detail})` : ''}`}`
+            + ` · GitHub ${f.github?.reachable
+                ? `可达 (HEAD ${f.github.headSha ? f.github.headSha.slice(0, 7) : '未知'}, Release ${f.github.releases ?? 0}, Tag ${f.github.tags ?? 0})`
+                : `不可达${f.github?.reason ? ` (github_unavailable(${f.github.reason}))` : ' (未查询)'}`}`);
+        if (f.crossCheck)
+            L.push(`交叉校验:   ${f.crossCheck.kind}${f.crossCheck.blocking ? ' (阻塞)' : ''} — ${f.crossCheck.detail}`);
+    }
     L.push(`最近检查:   ${s.lastCheckAt || '从未'}${s.lastCheckReason ? ` (${s.lastCheckReason})` : ''}`);
     L.push(`最近更新:   ${lu ? `${lu.at} ${lu.from} → ${lu.to} [${lu.status}]${lu.reason ? ` ${lu.reason}` : ''}` : '无记录'}`);
     L.push(`最近失败:   ${s.lastFailure ? `${s.lastFailure.at} @${s.lastFailure.stage}: ${s.lastFailure.reason}` : '无'}`);
     L.push(`需要重启:   ${s.needsRestart ? '是 (新版已就位, 重启后生效)' : '否'}`);
     L.push(`更新锁:     ${s.lock ? `有 (pid ${s.lock.pid}, ${s.lock.at}${s.lock.stale ? ', 已陈旧' : ''})` : '无'}`);
     L.push(`开关:       检查更新=${s.prefs.checkUpdates} (${s.prefs.sources.checkUpdates}) · 自动安装=${s.prefs.autoInstall} (${s.prefs.sources.autoInstall}) · 自动重启=${s.prefs.autoRestart} (${s.prefs.sources.autoRestart})`);
+    if (dev) {
+        L.push('');
+        L.push(DEV_CHANNEL_WARNING);
+        L.push(DEV_BACK_TO_STABLE_HINT);
+    }
     return L.join('\n');
 }
 // ── update 子命令 ───────────────────────────────────────────────────────────
 export async function runUpdateCommand(args = []) {
     const home = resolveBolloonHome();
-    // 裸词优先 (bolloon update plan / status / history / now / wait / force / json),
+    // 裸词优先 (bolloon update plan / status / history / now / wait / force / json / --channel dev),
     // 同时兼容旧的 --plan / --status / ... 写法 (已有脚本不断裂)。
     const has = (...f) => f.some((x) => args.includes(x));
     const json = has('json', '--json');
+    const ch = parseChannelArg(args);
+    if (ch.error) {
+        err(`${RED}✗ ${ch.error}${RESET}`);
+        return 2;
+    }
+    const channel = ch.channel;
     // ── 状态 ──
     if (has('status', '--status')) {
-        const s = await readUpdateStatus({ home });
+        const s = await readUpdateStatus({ home, channel });
         if (json) {
             out(JSON.stringify(s, null, 2));
             return 0;
@@ -156,21 +252,26 @@ export async function runUpdateCommand(args = []) {
     }
     // ── 计划 ──
     if (has('plan', '--plan')) {
-        const plan = await buildUpdatePlan({ home, force: true });
+        const plan = await buildUpdatePlan({ home, force: true, channel });
         if (json) {
             out(JSON.stringify(plan, null, 2));
             return 0;
         }
         out(renderUpdatePlan(plan));
+        if (plan.channelKind === 'git-ref')
+            printDevNotice();
         return 0;
     }
     // ── 执行 ──
     if (has('now', '--now')) {
         const wait = has('wait', '--wait');
         const force = has('force', '--force', '-f');
-        const plan = await buildUpdatePlan({ home, force: true });
-        if (!json)
+        const plan = await buildUpdatePlan({ home, force: true, channel });
+        if (!json) {
             out(renderUpdatePlan(plan));
+            if (plan.channelKind === 'git-ref')
+                printDevNotice();
+        }
         if (!plan.ok && plan.blockers.length > 0) {
             if (json)
                 out(JSON.stringify({ stage: 'blocked', reason: plan.blockers.join('; ') }, null, 2));
@@ -178,6 +279,17 @@ export async function runUpdateCommand(args = []) {
             return 1;
         }
         if (!plan.targetVersion) {
+            /**
+             * §12.5: 源不可达 / 版本不存在 → **拒绝并说清**, 退出码 2。
+             * 绝不打印"✅ 已是最新, 无需更新" (那正是这次要收敛掉的骗人行为)。
+             */
+            if (REFUSED_STATUSES.includes(plan.check.status)) {
+                if (json)
+                    out(JSON.stringify({ stage: 'blocked', refused: true, status: plan.check.status, reason: plan.check.reason }, null, 2));
+                err(`${RED}✗ 拒绝更新${RESET} (${plan.check.status}): ${plan.check.reason || '源不可达 / 版本不存在'}`);
+                err('  没有安装任何东西, 也没有静默退回旧版。');
+                return 2;
+            }
             if (json)
                 out(JSON.stringify({ stage: 'succeeded', ok: true, reason: '已是最新', from: plan.currentVersion, to: plan.currentVersion }, null, 2));
             out(`${GREEN}✓ 已是最新, 无需更新${RESET} (${plan.currentVersion})`);
@@ -185,27 +297,34 @@ export async function runUpdateCommand(args = []) {
         }
         const res = await applyUpdate({
             home,
+            channel,
             strategy: wait ? 'wait' : 'now',
             force,
             onStage: json ? undefined : (stage, detail) => out(`  [${stage}] ${detail}`),
         });
         if (json) {
             out(JSON.stringify(res, null, 2));
-            return res.ok ? 0 : 1;
+            return res.ok ? 0 : (res.stage === 'blocked' ? 2 : 1);
         }
         if (res.ok) {
             out(`${GREEN}✓ 更新成功${RESET}: ${res.from} → ${res.to} (${(res.durationMs / 1000).toFixed(1)}s)`);
+            if (isDevIdentity(res.to)) {
+                out(`  dev 快照已记录: commit ${res.to.split('+dev.')[1] || '未知'} (ref refs/heads/master) — bolloon update status 可查`);
+            }
             out('  正在做更新后健康检查...');
             const health = await runDoctor({ bolloonHome: home }).catch(() => null);
             if (health) {
                 out(renderDoctor(health));
             }
+            if (isDevIdentity(res.to))
+                printDevNotice();
             out(`${YELLOW}请重启 bolloon 以使用新版本${RESET}`);
             return 0;
         }
         if (res.stage === 'blocked') {
+            const refused = /拒绝更新|github_unavailable|cross_check_mismatch/.test(res.reason || '');
             err(`${YELLOW}! ${res.reason}${RESET}`);
-            return 1;
+            return refused ? 2 : 1;
         }
         err(`${RED}✗ 更新失败${RESET} (${res.stage}): ${res.reason}`);
         err(`  旧版本仍在: ${res.from} — 可继续使用; 详情: bolloon update status`);
@@ -214,21 +333,17 @@ export async function runUpdateCommand(args = []) {
         return 1;
     }
     // ── 默认: 只检查, 给清晰结论 (显式命令 = 忽略节流) ──
-    const r = await checkForUpdate({ home, force: true });
+    const r = await checkForUpdate({ home, force: true, channel });
     if (json) {
         out(JSON.stringify(r, null, 2));
-        return r.status === 'offline' || r.status === 'registry_unavailable' || r.status === 'local_version_unknown' ? 2 : 0;
+        return checkExitCode(r.status);
     }
     out(renderCheckResult(r));
     if (r.status !== 'up_to_date' && r.status !== 'check_skipped') {
         out('');
         out(`${YELLOW}提示${RESET}: 本次只检查, 没有安装任何东西。`);
     }
-    if (r.status === 'offline' || r.status === 'registry_unavailable' || r.status === 'local_version_unknown')
-        return 2;
-    if (r.status === 'update_available' && compareVersions(r.currentVersion, r.latestVersion || r.currentVersion) >= 0)
-        return 0;
-    return 0;
+    return checkExitCode(r.status);
 }
 // ── doctor ──────────────────────────────────────────────────────────────────
 export async function runDoctorCommand(args = []) {
@@ -323,12 +438,12 @@ export async function runRuntimeCommand(args = []) {
 }
 export const UPDATE_HELP = `
 ${BOLD}版本与更新:${RESET} (子命令一律裸词, 不带 -- 前缀)
-  bolloon --version                  版本 + 安装方式/目录/入口/通道/上游/是否最新
+  bolloon --version                  版本 + 安装方式/目录/入口/通道/来源身份/上游/是否最新
   bolloon --version verbose          诊断版 (构建时间/git/Node/npm/Python/配置目录/最近更新)
   bolloon --version json             机器版 (同一份 VersionInfo, 给脚本与问题报告)
   bolloon update                     只检查并给结论 (不安装任何东西)
   bolloon update plan                更新计划: 要更新什么 / 不会动什么 / 风险检查
-  bolloon update status              更新状态: 最近检查/最近更新/失败/是否需重启/开关
+  bolloon update status              更新状态: 装的哪个源+版本/commit+能切回哪/最近检查/失败/开关
   bolloon update history [N]         最近 N 次更新 (时间 · 版本变化 · 结果 · 耗时 · 原因)
   bolloon update now                 真正执行更新 (默认先看计划)
   bolloon update now wait            等当前 Run 结束后再更新 (有长期任务时的默认建议)
@@ -336,6 +451,15 @@ ${BOLD}版本与更新:${RESET} (子命令一律裸词, 不带 -- 前缀)
   bolloon doctor json                同上, 机器可读
   bolloon runtime [plan|install|json] 运行时 (Node/npm/Git/Python) 检查与安装 (install 需显式 yes)
 
+${BOLD}双源 (--channel):${RESET}
+  --channel stable  (默认) npm registry 是权威 (dist-tags.latest), GitHub Tag/Release 只做交叉校验;
+                           比较语义 = semver (npm 的 latest ↔ GitHub 同名 tag)
+  --channel dev     GitHub master HEAD 是唯一源; 比较语义 = git ref + commit sha (不用 semver);
+                           身份 = <版本>+dev.<sha7>; 未走发布门, 会打印警告并记录 sha
+  一键回稳定版:     bolloon update now --channel stable
+  --channel 只覆盖本次进程, 不落盘 (config 里的 updateChannel 仍是默认值)
+  源不可达 / 版本不存在 → 拒绝并说清 (退出码 2), 不会静默装回旧版
+
 ${BOLD}开关 (config.json):${RESET}
   checkUpdates (默认 true)   启动时后台检查
   autoInstall  (默认 false)  自动安装 —— 默认关, 需显式打开
@@ -344,6 +468,8 @@ ${BOLD}环境变量 (临时覆盖, 不落盘):${RESET}
   BOLLOON_SKIP_UPDATE=1      本次不检查
   BOLLOON_AUTO_UPDATE=1      本次允许自动安装
   BOLLOON_UPDATE_CHANNEL=stable|beta|dev
+  BOLLOON_GITHUB_API         覆盖 GitHub API 根 (镜像/受控验收用)
+  BOLLOON_DEV_SOURCE_DIR     dev 快照用本地源码树 (必须与该 sha 一致, 否则拒绝)
 
-${BOLD}退出码:${RESET} 0 正常 · 1 执行失败 · 2 检查不可用 (离线/registry 不可用/读不到本地版本)
+${BOLD}退出码:${RESET} 0 正常 · 1 执行失败 · 2 检查不可用 (离线/registry 不可用/GitHub 不可用/两源不一致/读不到本地版本)
 `;

package/dist/cli-entry.js

@@ -22,15 +22,19 @@ import { discoverEngines, delegateToEngine } from './external-engines/index.js';
 import { x402CheckBalance, x402Fetch } from './agents/x402/x402Pay.js';
 import { runVersionCommand, runUpdateCommand, runDoctorCommand, runRuntimeCommand, UPDATE_HELP } from './cli/update-commands.js';
 import { collectVersionInfo } from './utils/version-info.js';
+// 2026-09-27: 启动前言的默认静默 + 显式查询命令 (与 `src/index.ts` 同一套判断)
+import { startupPreambleVisible } from './cli/startup-notice.js';
+import { logStartupLine } from './cli/log-gate.js';
 // 2026-09-21 (P3): 统一 JSON 信封 + 命令组 (network/agent/task/wallet/payment/trade)
 import { runServiceGroup, GROUPS_HELP } from './cli/commands/index.js';
 // 2026-09-21 (P4): MCP 适配层 (`bolloon mcp serve` = stdio, 只调 P3 服务层)
 import { runMcpCommand } from './cli/commands/mcp.js';
-import { legacyJson } from './cli/protocol-envelope.js';
+import { legacyJson, parseFlags, runCommand } from './cli/protocol-envelope.js';
+import { identityCommand } from './cli/identity-command.js';
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
 /** P3 `bolloon task <子命令>` 的已知子命令 —— 其它一律当 M1 任务正文 (既有体验不动) */
-const TASK_SUBCOMMANDS = new Set(['send', 'list', 'status', 'cancel', 'retry', 'result', 'inbox', 'accept', 'reject', 'run', 'complete', 'publish', 'board', 'claim']);
+const TASK_SUBCOMMANDS = new Set(['send', 'list', 'status', 'cancel', 'retry', 'result', 'inbox', 'accept', 'reject', 'run', 'complete', 'publish', 'board', 'claim', 'announce', 'trail', 'post', 'group']);
 const isWindows = process.platform === 'win32';
 // ANSI 颜色 — Bolloon Web UI 配色 truecolor
 function _fg(r, g, b) { return `\x1b[38;2;${r};${g};${b}m`; }
@@ -62,12 +66,17 @@ ${BOLD}选项:${RESET}
 
 ${BOLD}命令:${RESET}
   bolloon setup                     初始化向导 (你的称呼 + 模型供应商 + API key + 连通性测试)
+  bolloon identity init             非交互建本机身份 (~/.bolloon/identity.json, 0600, 幂等; 新机器/第二实例用)
+  bolloon identity show             看本机身份 (只出 DID/指纹, 绝不打印私钥)
   bolloon update [plan|status|history|now]   检查更新 / 计划 / 状态 / 历史 / 执行 (默认只检查)
   bolloon doctor                    安装入口 + 版本事实 + 更新状态自洽性诊断
   bolloon runtime [plan|install]    运行时 (Node/npm/Git/Python) 检查与安装
   bolloon model [name] [model]      列出 / 切换模型供应商 (如: bolloon model deepseek deepseek-v4-flash)
   bolloon model key <name>          配置某供应商的 API key (隐藏输入, 不回显)
   bolloon model test [name]         测试供应商连通性
+  bolloon model list [name]         看模型发现目录 (P5)
+  bolloon model refresh [name]      重取上游模型目录 (--clear 清缓存)
+  bolloon model admit <name> <model>  手输一个目录里没有的模型名
   bolloon read <file>               读取文档
   bolloon summarize <file>          总结文档
   bolloon improve <file> <req>      改进文档
@@ -203,6 +212,9 @@ function parseArgs() {
         case 'setup':
         case 'init':
             return { mode: 'setup', args: args.slice(1) };
+        // 2026-09-24: 非交互建本机身份 (`bolloon identity init` → ~/.bolloon/identity.json)
+        case 'identity':
+            return { mode: 'identity', args: args.slice(1) };
         case 'read':
         case 'summarize':
         case 'improve':
@@ -562,36 +574,121 @@ async function handleP2pCommand(p2pArgs) {
     // 那是常驻模块, 句柄不会自己关 → 不显式退出会"输出完了还挂着"。
     process.exit(info.ok ? 0 : 1);
 }
+/** 真终端判定: stdin 与 stdout 都是 TTY 才算交互 (管道 / 重定向 = 脚本可读输出) */
+function isRealTty() {
+    return !!process.stdin.isTTY && !!process.stdout.isTTY;
+}
+/**
+ * `bolloon model [...]` — 模型供应商/模型切换的唯一命令行入口。
+ *
+ * leo 2026-09-27 口径: **`bolloon model` 就是"切换"的启动命令** —— 真终端里敲完直接就是选择界面
+ * (与 `bolloon model pick` 同一实现, 只是用户不必知道 pick 这个词), 第一屏就是带序号/状态/当前项
+ * 标记的供应商列表, 选完往下走; **不许**先刷一坨供应商清单+用法再问。
+ * 管道/非 TTY 才退回清单+用法 (脚本可读, 不会卡在等待输入)。
+ * `pick` / `list` 两个子命令都保留 (pick 是显式写法, list 只读列表)。
+ */
 async function handleModelCommand(modelArgs) {
-    const { llmConfigStore, PROVIDER_INFO } = await import('./llm/config-store.js');
+    const { llmConfigStore } = await import('./llm/config-store.js');
+    const { effectiveModelConfig, formatEffectiveModel } = await import('./llm/model-selection.js');
     await llmConfigStore.initialize();
-    // 无参: 列出所有供应商 + 当前 active
+    const tty = isRealTty();
+    // ── 真终端 + 裸敲: 直接进选择器 (第一屏 = 供应商列表) ──────────
+    if (modelArgs.length === 0 && tty) {
+        const { runModelCommand, modelTtyIO, askHiddenLineEof, askLineEof } = await import('./cli/setup-wizard.js');
+        const out = await runModelCommand('pick', await useTui() ? modelTtyIO() : {
+            live: true, // 每一步当场打到终端 (不是等整轮结束才一次性回显)
+            print: (l) => process.stdout.write(l + '\n'),
+            askHidden: async (q) => { const r = await askHiddenLineEof(q); return r.eof ? null : r.value; },
+            ask: async (q, opts) => { const r = await askLineEof(q, opts); return r.eof ? null : r.value; },
+        });
+        for (const line of String(out).split('\n'))
+            if (line !== '')
+                console.log(line);
+        return;
+    }
+    // ── 无参 + 非终端 (管道/脚本): 列出**全部**供应商 (分组带家数) + 当前**真实生效**的那一份 + 用法 ──
     if (modelArgs.length === 0) {
-        const config = await llmConfigStore.getConfig();
-        console.log(`\n${BOLD}模型供应商${RESET} (当前: ${config.activeProvider})\n`);
+        const eff = await effectiveModelConfig({}).catch(() => null);
+        const mc = await import('./llm/model-catalog.js');
+        const summaries = await mc.buildProviderSummaries({});
+        const pc = await import('./llm/provider-catalog.js');
+        await pc.initializeProviderCatalog();
+        console.log(`\n${BOLD}模型供应商${RESET} (当前生效: ${eff ? `${eff.provider}/${eff.model}` : '读不出来'})\n`);
+        if (eff)
+            console.log(`  ${formatEffectiveModel(eff)}`);
         console.log('─'.repeat(58));
-        for (const [name, p] of Object.entries(config.providers)) {
-            const info = PROVIDER_INFO[name] || {};
-            const active = name === config.activeProvider ? '●' : '○';
-            const keyState = p.apiKey ? '🔑' : p.requiresApiKey ? '⚠ 无 key' : '';
-            const model = p.model || (info.models && info.models[0]) || '';
-            console.log(`  ${active} ${name.padEnd(10)} ${String(info.name || '').padEnd(16)} ${keyState.padEnd(8)} model: ${model}`);
+        // 非终端里没有"固定高度视窗 + 折叠"那套交互 (那是全屏 TUI 的事), 所以这里**整份列全**:
+        //   内置 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)}`);
+        console.log(`  ${pc.catalogStatusLine()}`);
+        console.log(`  ${pc.catalogGroupLine()}`);
         console.log(`\n${BOLD}用法:${RESET}`);
+        console.log(`  bolloon model                    # 终端里直接进选择界面 (固定高度视窗 + 分组折叠; 上面这份全量列表是管道/脚本的可读输出)`);
+        console.log(`  bolloon model pick               # 同上, 显式写法 (供应商→凭证→模型→参数→作用域→测试→确认)`);
         console.log(`  bolloon model <name>             # 切换到该供应商`);
         console.log(`  bolloon model <name> <model>     # 切换并指定模型`);
+        console.log(`  bolloon model list [name]        # 看模型发现目录 (只读)`);
+        console.log(`  bolloon model refresh [name]     # 重取上游目录 (--clear 清缓存)`);
+        console.log(`  bolloon model admit <name> <m>   # 手输一个目录里没有的模型名`);
+        console.log(`  bolloon model catalog            # 供应商目录: 是几号的/新鲜度/族分布 (只读)`);
+        console.log(`  bolloon model catalog list [词]  # 逐家看 (**默认全量**, 含"需专用鉴权/无基址"并标原因; --usable 只看能用的)`);
+        console.log(`  bolloon model catalog refresh    # 运行期真拉最新目录 (落盘 0600, 记来源与时间)`);
         console.log(`  示例: bolloon model deepseek deepseek-v4-flash`);
         return;
     }
-    // 有参: 统一交给 setup-wizard 的 runModelCommand
-    //   (切换 / <provider> <model> / key <provider> / test / status 一套语义, 与 CLI 会话内 /model 完全一致)
-    const { runModelCommand, askHiddenLine } = await import('./cli/setup-wizard.js');
-    const out = await runModelCommand(modelArgs.join(' '), {
-        // 正常终端里可以安全收 key (隐藏输入, 不回显)
-        askHidden: (q) => askHiddenLine(q),
+    // ── 有参: 统一交给 setup-wizard 的 runModelCommand ───────────
+    //   (pick 分步选择 / 切换 / <provider> <model> / key <provider> / test / status 一套语义,
+    //    与 CLI 会话内 /model 完全一致 —— 写配置与重建运行时的逻辑只有 selectModel 一处)
+    const { runModelCommand, modelTtyIO, askHiddenLineEof, askLineEof } = await import('./cli/setup-wizard.js');
+    // `--verbose` 交给界面层决定"打不打内部细节", 不进参数解析 (解析器不认识这个词会被当值)
+    const wantVerbose = modelArgs.includes('--verbose');
+    const args = modelArgs.filter((a) => a !== '--verbose');
+    const out = await runModelCommand(args.join(' '), (await useTui()) && tty ? {
+        ...modelTtyIO(),
+        ...(wantVerbose ? { verbose: true } : {}),
+    } : {
+        // 非 TTY (管道/脚本) / 显式关掉 TUI: 逐行问答 —— 输出可读、不卡死、行为与以前一致
+        live: tty,
+        print: (l) => process.stdout.write(l + '\n'),
+        askHidden: async (q) => { const r = await askHiddenLineEof(q); return r.eof ? null : r.value; },
+        ask: async (q, opts) => { const r = await askLineEof(q, opts); return r.eof ? null : r.value; },
+        ...(wantVerbose ? { verbose: true } : {}),
     });
     for (const line of String(out).split('\n'))
-        console.log(line);
+        if (line !== '')
+            console.log(line);
+}
+/**
+ * 这个环境要不要用全屏 TUI 选择器。
+ * 三判据: ① 用户没显式关 (`BOLLOON_NO_TUI=1`); ② 真 TTY; ③ `tuiCapable()` (终端够高/能拿 raw mode)。
+ * 任何一条不满足 → 退回逐行问答 (**不静默变样子**: 管道输出仍是可读清单+用法)。
+ */
+function useTui() {
+    return (async () => {
+        if (process.env.BOLLOON_NO_TUI)
+            return false;
+        try {
+            // 同步判据在 tui-select 里 (它不许在非 TTY 里抢输入)
+            const { tuiCapable } = await import('./cli/tui-select.js');
+            return !!tuiCapable();
+        }
+        catch {
+            return false;
+        }
+    })();
 }
 /** `bolloon setup` — 首次运行初始化向导 (用户身份 + 模型供应商 + API key + 连通性测试) */
 async function handleSetupCommand(setupArgs) {
@@ -609,6 +706,7 @@ async function handleSetupCommand(setupArgs) {
         console.log(`${BOLD}bolloon setup${RESET} — 初始化 Bolloon (用户身份 + 模型供应商 + API key)`);
         console.log('');
         console.log('  无参数            交互式向导 (推荐)');
+        console.log('  status            只读: 看初始化状态/门禁/就绪度全量 (启动面板那一行"详情"指的就是它)');
         console.log('  --provider <名>   指定供应商 (deepseek / minimax / openai / anthropic / ...)');
         console.log('  --api-key <key>   直接给 key (脚本用; 交互模式会隐藏输入)');
         console.log('  --model <名>      指定模型');
@@ -617,6 +715,15 @@ async function handleSetupCommand(setupArgs) {
         console.log('  repair-runtime    检查并补装缺失运行时 (Node/npm/Git/Python)');
         return;
     }
+    // 2026-09-27: `bolloon setup status` —— **启动前言搬去的地方**。
+    //   启动时那一整段 (初始化状态/就绪度/已完成/配置来源/已存输入/缺什么/下一步) 默认不上屏,
+    //   要看全量就显式敲这条 (只读, 不写任何文件; 退出码 0 = ready, 1 = 未就绪 —— 脚本可用)。
+    if (setupArgs[0] === 'status' || setupArgs.includes('--status')) {
+        const { evaluateSetup, describeSetup } = await import('./setup/setup-store.js');
+        const ev = await evaluateSetup();
+        process.stdout.write(describeSetup(ev) + '\n');
+        process.exit(ev.gate === 'ready' ? 0 : 1);
+    }
     const apiKey = val('--api-key');
     const needsInteractive = !apiKey;
     const r = await runSetupWizard({
@@ -795,7 +902,13 @@ async function startWebServer(additionalArgs) {
 }
 // 启动 CLI
 async function startCLI(additionalArgs) {
-    log('启动命令行界面...', CYAN);
+    // 2026-09-27 (leo 口径: 打完 `bolloon --cli` 直接看到面板): 这句"启动命令行界面..."属于**启动前言**,
+    //   默认不上屏 (照落启动日志); `--verbose` / `BOLLOON_VERBOSE=1` / `BOLLOON_STARTUP_PREAMBLE=1` 逐字回来。
+    //   (gui/web 那两个面的 banner 不动 —— 它们没有"面板", 输出就是交付物。)
+    if (startupPreambleVisible())
+        log('启动命令行界面...', CYAN);
+    else
+        logStartupLine('启动命令行界面...');
     try {
         const mainPath = getMainScript();
         const cliArgs = [...additionalArgs];
@@ -890,6 +1003,10 @@ async function main() {
         case 'setup':
             await handleSetupCommand(args);
             break;
+        // 2026-09-24: bolloon identity — 非交互建/看本机身份 (新机器/第二实例用; 幂等, 不打印私钥)
+        case 'identity':
+            process.exit(await runCommand(parseFlags(args), identityCommand));
+            break;
         case 'passthrough':
             // 传递所有参数给主程序
             try {

package/dist/electron-build/agents/contacts/chain.js

@@ -56,6 +56,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.maskPhone = exports.maskEmail = exports.ContactChain = void 0;
 exports.contactChain = contactChain;
 const goal_store_js_1 = require("../goal-store.js");
+// 2026-09-25 (M0 接线冻结, 规则 ②): Goal 状态变更只有一个漏斗
+const goal_state_reducer_js_1 = require("../goal-state-reducer.js");
 const run_store_js_1 = require("../run-store.js");
 const external_events_js_1 = require("../external-events.js");
 const store_js_1 = require("./store.js");
@@ -360,7 +362,14 @@ class ContactChain {
                 note: `等 ${contact.displayValue} 回复 (通道 ${contact.provider})`,
             };
             await (0, external_events_js_1.bindExternalWait)(opts.goalId, wait);
-            await (0, goal_store_js_1.updateGoal)(opts.goalId, { status: 'awaiting_external' });
+            // 规则 ②: 进入"等外部"也是一种 Goal 状态变更 → 走 Goal reducer
+            await (0, goal_state_reducer_js_1.reduceGoalState)({
+                goalId: opts.goalId,
+                intent: 'external_wait_enter',
+                now: new Date(this.now()).toISOString(),
+                by: 'contacts',
+                externalWait: `等 ${contact.displayValue} 回复 (通道 ${contact.provider})`,
+            });
             const g = await (0, goal_store_js_1.readGoal)(opts.goalId);
             await this.ledger({
                 activity: 'contact.authorization_requested', contactId: contact.contactId, goalId: opts.goalId, runId: opts.runId,
@@ -492,9 +501,14 @@ class ContactChain {
             await (0, external_events_js_1.clearExternalWait)(s.goalId);
             const g = await (0, goal_store_js_1.readGoal)(s.goalId);
             await (0, goal_store_js_1.setUnresolved)(s.goalId, Array.from(new Set([...(g?.unresolvedItems || []), `联系方式授权 ${grantId} 已撤销, 该联系不可自动重试 (转人工)`])));
-            // 撤等待 + 转人工: 不再自动唤醒, 由人接手 (Supervisor 下一轮看到 needs_human)
-            await (0, goal_store_js_1.setContinuation)(s.goalId, { wakeReason: 'needs_human', needsExternal: undefined, autoContinue: false }).catch(() => null);
-            await (0, goal_store_js_1.updateGoal)(s.goalId, { status: 'needs_human' }).catch(() => null);
+            // 撤等待 + 转人工: 不再自动唤醒, 由人接手 (规则 ②: 状态经 Goal reducer 写, 单一漏斗)
+            await (0, goal_state_reducer_js_1.reduceGoalState)({
+                goalId: s.goalId,
+                intent: 'contact_revoked_human',
+                now: new Date().toISOString(),
+                by: 'contacts',
+                revokeNote: `联系方式授权 ${grantId} 已撤销, 该联系不可自动重试`,
+            }).catch(() => null);
             affected.push(s.goalId);
         }
         return { ok: true, affectedGoals: affected };
@@ -594,8 +608,14 @@ class ContactChain {
             await (0, external_events_js_1.clearExternalWait)(s.goalId);
             const g = await (0, goal_store_js_1.readGoal)(s.goalId);
             await (0, goal_store_js_1.setUnresolved)(s.goalId, Array.from(new Set([...(g?.unresolvedItems || []), `联系人 ${c.displayValue} 已撤销授权, 该联系不可重试`])));
-            await (0, goal_store_js_1.setContinuation)(s.goalId, { wakeReason: 'needs_human', needsExternal: undefined, autoContinue: false }).catch(() => null);
-            await (0, goal_store_js_1.updateGoal)(s.goalId, { status: 'needs_human' }).catch(() => null);
+            // 规则 ②: 经 Goal reducer 写 (单一漏斗)
+            await (0, goal_state_reducer_js_1.reduceGoalState)({
+                goalId: s.goalId,
+                intent: 'contact_revoked_human',
+                now: new Date().toISOString(),
+                by: 'contacts',
+                revokeNote: `联系人 ${c.displayValue} 已撤销授权, 该联系不可重试`,
+            }).catch(() => null);
             affected.push(s.goalId);
         }
         return { ok: true, evidenceRef: ev.evidenceRef, affectedGoals: affected };