@bolloon/bolloon-agent 0.5.3 → 0.5.5

package/dist/index.js

@@ -1,9 +1,16 @@
 import { createHyperswarmCommunicator, createTopic, KeyManager, AgentAuthManager, createVerificationManager, } from '@diap/sdk';
 import { irohTransport } from './network/iroh-transport.js';
+import { getLastAiTiming, getLastAiUsage } from './llm/pi-ai.js';
+import { setHistoryScope } from './cli/input-history.js';
+import { statusSegments, fitSegments, rightAlignPad, dispWidthSafe, statusLineBudget } from './cli/status-segments.js';
+import { renderReasoning } from './cli/reasoning-view.js';
+import { traceLabel } from './cli/trace-line.js';
+import { loadWalletTool } from './agents/wallet-tools.js';
 import { HybridMessenger } from './network/hybrid-messenger.js';
 import * as ed25519 from '@noble/ed25519';
 import { sha512 } from '@noble/hashes/sha2.js';
 import * as fs from 'fs/promises';
+import * as fsSync from 'fs'; // 2026-09-30: 启动面板读技能快照(同步; 渲染路径上不能 await)
 import { existsSync, mkdirSync } from 'fs';
 import * as path from 'path';
 import { spawn, execSync } from 'child_process';
@@ -11,21 +18,96 @@ import * as os from 'os';
 import { documentReader } from './documents/reader.js';
 import { initMinimax } from './constraints/index.js';
 import { createAgentSession } from './agents/pi-sdk.js';
+import { SessionStore } from './agents/session-store.js'; // 2026-09-30: 退出存档 —— 只为把落盘路径如实打出来
+import { kuboAlreadyRunning } from './agents/pi-sdk-tools.js';
 import { createSubAgentManager } from './agents/subagent-manager.js';
 import { getGlobalSharedContext } from './social/global-shared-context.js';
 import { createBollharnessIntegration } from './bollharness-integration/index.js';
 import * as readline from 'readline';
-import { printBanner, renderDialog, renderUserMessage, renderAgentMessage, renderMessageBox, renderToolCallListItem, termWidth, ROBOT_HEAD, BOLLOON_BANNER, dispWidth } from './cli/loading-tui.js';
-import { startInk, stopInk, suspendInk, resumeInk, inkAppendLine as appendLine, inkReplaceMatchingLine, inkSetStatus, inkSetThinking, inkSetTransient } from './cli/ink-app.js';
+import { printBanner, termHeight, truncate, renderDialog, renderUserMessage, renderAgentMessage, renderMessageBox, renderToolCallListItem, termWidth, ROBOT_HEAD, BOLLOON_BANNER, BOLLOON_BANNER_SMALL, dispWidth } from './cli/loading-tui.js';
+import { startInk, stopInk, suspendInk, resumeInk, inkAppendLine as appendLine, inkSetStatus, inkSetThinking, inkSetTransient, bootPanelMaxLines } from './cli/ink-app.js';
 // 2026-09-26: 启动期日志闸门 (默认静默加载日志 + 写文件 + verbose 全量回流 + 信号行不吞)
 import { installStartupLogGate, isStartupVerbose, startupLogPath, VERBOSE_ENV, carriesHumanSignal, logStartupLine } from './cli/log-gate.js';
 // 2026-09-27: 回复流卫生 — 内部运行日志 (循环推进/运行登记/收尾计数…) 不进对话回复流, 改落日志文件
 import { isInternalRunLog, appendInternalRunLog } from './cli/reply-hygiene.js';
 // 2026-09-27: 启动**前言 / 就绪度报告**闸门 (默认不上屏 → 面板一行 + 显式查询命令; 失败折成面板提示)
-import { noticeLine as noticePreamble, flushStartupNotices, setStartupReadiness, alertsFromSetup, readinessLine, preambleHintLine, startupPreambleVisible, pushStartupAlert, takeStartupPanelNotes, clearBufferedNotices, } from './cli/startup-notice.js';
+import { onlyConnectivityRetest, SETUP_STATUS_CMD, noticeLine as noticePreamble, flushStartupNotices, setStartupReadiness, alertsFromSetup, readinessLine, preambleHintLine, startupPreambleVisible, pushStartupAlert, takeStartupPanelNotes, clearBufferedNotices, } from './cli/startup-notice.js';
 import { clipboardWrite } from './cli/clipboard.js';
 // 启动自动检查更新：后台、节流、检测到新版本自动安装（可被 --no-update / BOLLOON_SKIP_UPDATE 关闭）
 import { createRequire } from 'module';
+export function parseGroupSub(input) {
+    const rest = String(input || '').replace(/^\/group\b/i, '').trim();
+    if (!rest)
+        return { sub: 'list', arg: '' };
+    const sp = rest.indexOf(' ');
+    const head = (sp === -1 ? rest : rest.slice(0, sp)).toLowerCase();
+    const arg = sp === -1 ? '' : rest.slice(sp + 1).trim();
+    const aliases = { ls: 'list', l: 'list', n: 'new', create: 'new', add: 'join', msg: 'send', history: 'log', use_: 'use' };
+    const sub = aliases[head] || head;
+    // 2026-10-01 (用户: 「group 命令无法选中进群, 要可以选中」): 裸序号 ⇒ 直接选中该群
+    //   与 `/channel <序号>` 同一个习惯 ✓ (列表里就带序号)
+    if (/^\d+$/.test(head))
+        return { sub: 'use', arg: head };
+    const known = ['list', 'new', 'join', 'leave', 'use', 'send', 'log', 'members', 'help'];
+    return { sub: known.includes(sub) ? sub : 'help', arg: known.includes(sub) ? arg : rest };
+}
+export const CLI_KNOWN_COMMAND_HEADS = new Set([
+    '/group',
+    '/agent',
+    '/answer',
+    '/approve',
+    '/contacts',
+    '/copy',
+    '/criteria',
+    '/cron',
+    '/dequeue',
+    '/did',
+    '/dq',
+    '/dream',
+    '/email',
+    '/fork',
+    '/goal',
+    '/goals',
+    '/help',
+    '/insight',
+    '/ipfs',
+    '/ipns',
+    '/judgement',
+    '/judgments',
+    '/login',
+    '/logout',
+    '/loop',
+    '/mcp',
+    '/memory',
+    '/model',
+    '/net',
+    '/now',
+    '/p2p',
+    '/pause',
+    '/payments',
+    '/plan',
+    '/q',
+    '/questions',
+    '/queue',
+    '/reject',
+    '/resume',
+    '/runs',
+    '/session',
+    '/sessions',
+    '/setup',
+    '/skill',
+    '/skills',
+    '/suggestions',
+    '/supervise',
+    '/todo',
+    '/tools',
+    '/trace',
+    '/tx',
+    '/wake',
+    '/wallet',
+    '/wiki',
+    '/x402',
+]);
 const _require = createRequire(import.meta.url);
 const _BOLLOON_VERSION = (() => {
     try {
@@ -61,6 +143,75 @@ const MOVE_UP = '\x1b[A';
 const CLEAR_LINE = '\x1b[2K';
 const HIDE_CURSOR = '\x1b[?25l';
 const SHOW_CURSOR = '\x1b[?25h';
+/**
+ * 统一出口 (2026-10-01, 用户: 「还是UI有污染」)。
+ * 为什么: Ink 被显式设成 `patchConsole: false` ⇒ **不接管 console** ✗ ⇒ 运行期任何 `console.log`
+ *   都写在 Ink 托管区**之外** ⇒ 每次直写都把正在渲染的 footer(提示行 + 分界线)往下推一份 ✗
+ *   ⇒ 屏幕上重复出现「· 回车发送 · ↑↓ 历史 · PgUp 回看 · Esc 双击退出」✓(真机实测就是这个)。
+ * 判据复用已有的 `startupPanelReady`(启动面板画好了 = Ink 已在跑 ✓):
+ *   Ink 在跑 ⇒ **一律走它自己的消息流**; 没跑(boot 期)⇒ 才直写 ✓。
+ */
+function writeOut(line) {
+    // 2026-10-01 (用户: 「时间好像是面板后面启动的」+「继续，还没去掉」):
+    //   **关键**: 启动那几步**不是 await 的** ✗(fire-and-forget)⇒ 它们常在 `startupPanelReady = true`
+    //   **之后**才打印 ✓ ⇒ 用"面板好了没"当判据必然漏 ✗(我上一版就栽在这 ✓)。
+    //   改成**独立的启动期标志** `bootPhase` ✓: 启动期内的**进度类**输出一律只落盘 ✓, 与面板状态无关 ✓。
+    if (bootPhase) {
+        bootLogOnly(line);
+        return;
+    }
+    if (startupPanelReady) {
+        try {
+            appendLine(line);
+            return;
+        }
+        catch { /* 落到落盘 */ }
+    }
+    // 2026-10-01 (用户: 「启动那几行……继续，还没去掉」): **启动期的"进度类"输出直接不进屏** ✓
+    //   上一版我把它们**搬进对话流**了 ✗ —— 但用户要的是**去掉** ✓(面板已经把版本/模型/技能这些要点画了 ✓,
+    //   而 `复用 DID` / `iroh:` / `主题:` / `[N/5]` 这类属于**过程细节** ✓)。
+    //   现在: 启动期 ⇒ **只落日志**(~/.bolloon/logs/startup.log ✓ 事后照样能查 ✓), 不上屏 ✓。
+    bootLogOnly(line);
+}
+/**
+ * 启动期**警告/错误**仍然要上屏 ✓ (不许因为"想干净"把问题藏起来 ✗):
+ *   Ink 没起 ⇒ 先缓冲, `flushBootBuffer()` 在 Ink 起来后灌进对话流 ✓; Ink 已在跑 ⇒ 直接进 ✓。
+ */
+function writeOutWarn(line) {
+    if (startupPanelReady) {
+        try {
+            appendLine(line);
+            return;
+        }
+        catch { /* 落到缓冲 */ }
+    }
+    if (bootBuffer.length < 500) {
+        bootBuffer.push(line);
+        return;
+    }
+    console.log(line);
+}
+/** 启动期进度类输出: 只落盘(不上屏 ✓) */
+function bootLogOnly(line) {
+    try {
+        const clean = String(line).replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+        fsSync.appendFileSync(startupLogPath(), `[boot] ${clean}\n`);
+    }
+    catch { /* 落盘失败也不上屏(它本来就是过程细节 ✓) */ }
+}
+/** 启动期"警告/错误"缓冲: Ink 起来之前攒着, `flushBootBuffer()` 一次性灌进对话流 ✓ */
+const bootBuffer = [];
+export function flushBootBuffer() {
+    while (bootBuffer.length) {
+        const line = bootBuffer.shift();
+        try {
+            appendLine(line);
+        }
+        catch {
+            console.log(line);
+        }
+    }
+}
 const s = {
     banner: () => {
         printBanner(_BOLLOON_VERSION);
@@ -71,52 +222,48 @@ const s = {
                 status === 'warn' ? `${YELLOW}⚠` :
                     status === 'error' ? `${MAGENTA}✗` :
                         `${CYAN}●`;
-        console.log(`  ${check} ${WHITE}[${num}/${total}]${GRAY} ${text}${RESET}`);
+        writeOut(`  ${check} ${WHITE}[${num}/${total}]${GRAY} ${text}${RESET}`);
     },
-    success: (text) => console.log(`  ${GREEN}✓${RESET} ${text}`),
-    warn: (text) => console.log(`  ${YELLOW}⚠${RESET} ${text}`),
-    error: (text) => console.log(`  ${MAGENTA}✗${RESET} ${text}`),
-    info: (text) => console.log(`  ${CYAN}●${RESET} ${text}`),
+    success: (text) => writeOut(`  ${GREEN}✓${RESET} ${text}`),
+    warn: (text) => writeOutWarn(`  ${YELLOW}⚠${RESET} ${text}`),
+    error: (text) => writeOutWarn(`  ${MAGENTA}✗${RESET} ${text}`),
+    info: (text) => writeOut(`  ${CYAN}●${RESET} ${text}`),
     section: (title) => {
-        console.log(`\n${BLUE}━━━ ${WHITE}${BOLD}${title}${RESET} ${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}`);
+        writeOut(`\n${BLUE}━━━ ${WHITE}${BOLD}${title}${RESET} ${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}`);
     },
-    divider: () => console.log(`\n${GRAY}${'─'.repeat(50)}${RESET}\n`),
-    prompt: (text) => console.log(`\n${CYAN}❯ ${WHITE}${text}${RESET}`),
+    divider: () => writeOut(`\n${GRAY}${'─'.repeat(50)}${RESET}\n`),
+    prompt: (text) => writeOut(`\n${CYAN}❯ ${WHITE}${text}${RESET}`),
     response: (label, content) => {
-        console.log(`\n${GREEN}${label}${RESET}\n${content}\n`);
+        writeOut(`\n${GREEN}${label}${RESET}\n${content}\n`);
     },
     agentCard: (agent) => {
         const statusColor = agent.status === 'active' ? GREEN :
             agent.status === 'idle' ? YELLOW :
                 agent.status === 'busy' ? MAGENTA : GRAY;
-        console.log(`  ${WHITE}${BOLD}${agent.name}${RESET}`);
-        console.log(`    ${GRAY}ID:${RESET} ${agent.id}`);
-        console.log(`    ${GRAY}状态:${RESET} ${statusColor}${agent.status}${RESET}`);
-        console.log(`    ${GRAY}能力:${RESET} ${agent.capabilities.join(', ')}`);
+        writeOut(`  ${WHITE}${BOLD}${agent.name}${RESET}`);
+        writeOut(`    ${GRAY}ID:${RESET} ${agent.id}`);
+        writeOut(`    ${GRAY}状态:${RESET} ${statusColor}${agent.status}${RESET}`);
+        writeOut(`    ${GRAY}能力:${RESET} ${agent.capabilities.join(', ')}`);
         if (agent.did)
-            console.log(`    ${GRAY}DID:${RESET} ${agent.did}`);
-        console.log();
+            writeOut(`    ${GRAY}DID:${RESET} ${agent.did}`);
+        writeOut('');
     },
     Thinking: () => {
-        const frames = ['(｀・ω・´)', '(´･_･`)', '(｡•́︿•̀｡)', 'ᕙ(▀̿̿Ĺ̯̿̿▀̿ ̿)ᕗ', '(◕‿◕)'];
-        let i = 0;
-        let dots = 0;
-        const frame = frames[0];
-        appendLine(`  ${frame} 思考...`);
-        return setInterval(() => {
-            i = (i + 1) % frames.length;
-            dots = (dots + 1) % 4;
-            const dotStr = '.'.repeat(dots || 1);
-            appendLine(`\r  ${frames[i]} 思考${dotStr}   `);
-        }, 600);
+        // 2026-10-01 (用户: 「颜文字被加载进去了」/「可能是 ink 渲染的问题」): **真凶在这里** ✗ ——
+        //   原来每一帧都走 `appendLine` ⇒ 而对话流是 Ink 的 `<Static>`(**写一次永不重绘** ✓)
+        //   ⇒ 于是每 600ms 就有一条「思考中...」被**永久烙进滚动区** ✗, 带 `\r` 也擦不掉 ✗,
+        //   滚出来的残影还能被框选/拖进输入框 ⇒ 混进上下文 ✓。
+        //   现在改成走 **Ink 的瞬时行**(footer 自己帧进动画 ✓, 只重绘一行 ✓, 不落进 Static ✓)。
+        inkSetThinking(true);
+        return setInterval(() => { }, 600);
     },
     clearThinking: (interval) => {
         clearInterval(interval);
-        process.stdout.write('\r' + ' '.repeat(40) + '\r');
+        inkSetThinking(false);
     },
     dialog: async (title, promptText) => {
         return new Promise((resolve) => {
-            console.log(renderDialog({ title, prompt: promptText }));
+            writeOut(renderDialog({ title, prompt: promptText }));
             const rl = readline.createInterface({
                 input: process.stdin,
                 output: process.stdout
@@ -142,6 +289,21 @@ ed25519.hashes.sha512 = sha512;
 let startupPanelFirst = false;
 /** 面板第一帧已经画出来了 (startCLI 取走面板提示之后): 晚到的降级提示直接追加进面板 */
 let startupPanelReady = false;
+/**
+ * **启动期**标志 (2026-10-01): 与 `startupPanelReady` **不是一回事** ✗ ——
+ *   启动那几步是 fire-and-forget, 打印时间常在面板之后 ✓ ⇒ 只有用独立标志才拦得住 ✓。
+ * 结束条件: **用户第一次发消息** ✓(他真正接管了)或启动后 **20s 兜底** ✓。
+ */
+let bootPhase = true;
+function endBootPhase() { bootPhase = false; }
+setTimeout(() => { bootPhase = false; }, 20_000).unref?.();
+/**
+ * 2026-09-30: 启动面板 / 就绪行**各只许追加一次**.
+ *   防任何重入路径 (会话切换 / 重复 boot / 恢复) 把面板再叠一条 —— leo 报的「顶框重复 14 次」那一类
+ *   都落在这个类里; 叠了就再也说不清屏上哪一条是真的.
+ */
+let bootPanelPrinted = false;
+let bootReadinessPrinted = false;
 /**
  * 启动期(面板之前)一行进度 / 降级输出 —— 交互默认口径下的**唯一出路**。
  *
@@ -221,8 +383,8 @@ async function bootstrapIdentity() {
     const username = getUserName();
     const suffix = did.split(':').pop()?.substring(0, 4);
     const name = `blln-${username}-${suffix}`;
-    console.log(`     ${reused ? GRAY + '复用 ' : ''}${GRAY}DID:${RESET} ${did}`);
-    console.log(`     ${GRAY}名称:${RESET} ${name}`);
+    writeOut(`     ${reused ? GRAY + '复用 ' : ''}${GRAY}DID:${RESET} ${did}`);
+    writeOut(`     ${GRAY}名称:${RESET} ${name}`);
     s.step(1, 5, reused ? '复用 DIAP 身份' : '生成 DIAP 身份', 'ok');
     return { keypair: kp, did, name };
 }
@@ -283,7 +445,7 @@ async function bootstrapP2P(verifier) {
     await comm.start();
     const topic = createTopic('bolloon-agent-harness');
     await comm.joinTopic(topic);
-    console.log(`     ${GRAY}主题:${RESET} ${topic.slice(0, 8).toString('hex')}...`);
+    writeOut(`     ${GRAY}主题:${RESET} ${topic.slice(0, 8).toString('hex')}...`);
     s.step(3, 5, '启动 P2P 网络', 'ok');
     return comm;
 }
@@ -301,20 +463,20 @@ async function bootstrapIroh(keypair, name) {
     s.step(4, 5, '启动 iroh P2P', 'loading');
     try {
         const node = await irohTransport.start();
-        console.log(`     ${GRAY}iroh:${RESET} ${node.nodeId.substring(0, 16)}...`);
+        writeOut(`     ${GRAY}iroh:${RESET} ${node.nodeId.substring(0, 16)}...`);
         hybridMessenger = new HybridMessenger({
             preferIrohForLarge: true,
             largeThresholdBytes: 64 * 1024,
             enableRelay: true,
         });
         hybridMessenger.onMessage('task', async (msg) => {
-            console.log(`[iroh] Task from ${msg.from.substring(0, 12)}...: ${new TextDecoder().decode(msg.payload).substring(0, 50)}...`);
+            writeOut(`[iroh] Task from ${msg.from.substring(0, 12)}...: ${new TextDecoder().decode(msg.payload).substring(0, 50)}...`);
         });
         hybridMessenger.onMessage('blob', async (msg) => {
-            console.log(`[iroh] Blob from ${msg.from.substring(0, 12)}...: ${msg.payload.length} bytes`);
+            writeOut(`[iroh] Blob from ${msg.from.substring(0, 12)}...: ${msg.payload.length} bytes`);
         });
         hybridMessenger.onMessage('response', async (msg) => {
-            console.log(`[iroh] Response from ${msg.from.substring(0, 12)}...`);
+            writeOut(`[iroh] Response from ${msg.from.substring(0, 12)}...`);
         });
         if (agentIdentity) {
             agentIdentity.irohNodeId = node.nodeId;
@@ -323,14 +485,132 @@ async function bootstrapIroh(keypair, name) {
     }
     catch (e) {
         s.step(4, 5, '启动 iroh P2P', 'warn');
-        console.log(`     ${YELLOW}iroh 启动失败: ${e.message}${RESET}`);
-        console.log(`     ${GRAY}继续使用 Hyperswarm P2P${RESET}`);
+        writeOut(`     ${YELLOW}iroh 启动失败: ${e.message}${RESET}`);
+        writeOut(`     ${GRAY}继续使用 Hyperswarm P2P${RESET}`);
     }
 }
 // ---------------------------------------------------------------------------
 // Agent 懒加载
 // ---------------------------------------------------------------------------
+// 2026-10-01: /group 的"当前群"(进程内; 重启后需重新 /group use)
+let currentGroupId;
 let agent = null;
+/**
+ * 退出存档 (2026-09-30, leo: 「按 ctrl+c / esc 退出的时候, 自动存档 session 进程, 最后显示再见👋」)
+ *
+ * 三条纪律:
+ *   1. **幂等** —— 两条退出路径 (Ctrl+C/双击 Esc 与输入 exit) 都调它, 只存一次 (sessionArchivedOnExit).
+ *   2. **如实** —— 存成功给 key 与落盘路径; 没建过会话就直说"无需存档"; 失败给原因。**不许静默**。
+ *   3. **不阻塞退出** —— 存档失败也照常走完退出流程 (存不下不是不退出的理由)。
+ */
+let sessionArchivedOnExit = false;
+/**
+ * 退出期上屏 (2026-09-30): `stopInk()` 之后 Ink 已卸载, 此时 `appendLine()` 只进 store、**打不到终端**
+ *   —— 既有代码就是这样, 所以「👋 再见！」用户**从来没真看见过** (这次真机日志坐实)。
+ *   退出期的最后几句话必须用 `process.stdout.write` 直写。
+ */
+function writeExitLine(line) {
+    try {
+        process.stdout.write(line + '\n');
+    }
+    catch { /* 写不出去也不能挡住退出 */ }
+}
+/** 本次 CLI 会话的 key (bootSessionId 算好后写进来; 退出存档两条路径都读它) */
+let cliSessionKey = null;
+async function archiveSessionOnExit(key) {
+    if (sessionArchivedOnExit)
+        return '';
+    sessionArchivedOnExit = true;
+    const t0 = Date.now();
+    try {
+        if (!agent || !key || typeof agent.saveCurrentSession !== 'function') {
+            return `${C_DIM}(本次没建会话, 无需存档)${RESET}`;
+        }
+        await agent.saveCurrentSession(key);
+        // 2026-09-30 (leo: 「结束进程的时候没有加载 title 和总结，以至于打开 session 后没有内容」):
+        //   退出存档时**顺手把 AI 标题/摘要算好写回** —— 否则 /sessions 里那条只有会话 ID (数据在, 只是没标题)。
+        //   纪律: 12s 内不回来就放行 (存档已完成, 标题是附加品); 失败**如实标注**, 不挡退出, 不编标题。
+        let titleNote = '';
+        try {
+            const { summarizeSession } = await import('./cli/session-summary.js');
+            const d = await summarizeSession(key, { store: new SessionStore() });
+            if (d.source === 'ai' && d.title)
+                titleNote = ` · ${C_TEXT}${d.title}${RESET}${C_DIM}`;
+            else if (d.source === 'raw' && d.title)
+                titleNote = ` · ${C_DIM}(AI 不可用, 标题用了首条消息)`;
+            else
+                titleNote = ` · ${C_DIM}(没有可总结的用户内容)`;
+        }
+        catch (e) {
+            titleNote = ` · ${C_WARN}(标题没生成: ${String(e?.message || e).slice(0, 40)})${RESET}${C_DIM}`;
+        }
+        // 2026-09-30: 退出也落一次 commit —— 会话树 (git) 靠 fork/退出两个时点建起来, 不做消息级提交
+        let treeNote = '';
+        try {
+            const { commitTree } = await import('./cli/session-tree.js');
+            const tr = await commitTree(new SessionStore(), `session: ${key} · exit save`);
+            if (!tr.ok)
+                treeNote = ` · ${C_WARN}树未记上: ${String(tr.error).slice(0, 60)}${RESET}${C_DIM}`;
+        }
+        catch { /* 树失败不挡退出 */ }
+        let where = '';
+        try {
+            where = new SessionStore().pathFor(key);
+        }
+        catch { /* 路径拿不到不影响存档本身 */ }
+        // 2026-09-30 (leo: 「没有结束时间，没有总花费时间和日期记录」): 退出的那一行要能回答
+        //   「这次会话从几点到几点、一共多久」—— 起点取会话真起点 (cliStartTime, 与状态栏 ⏱ 同一个钟)。
+        const p2 = (n) => String(n).padStart(2, '0');
+        const stamp = (d) => `${d.getFullYear()}-${p2(d.getMonth() + 1)}-${p2(d.getDate())} ${p2(d.getHours())}:${p2(d.getMinutes())}:${p2(d.getSeconds())}`;
+        const ended = new Date();
+        const timeNote = cliStartTime
+            ? ` · ${stamp(new Date(cliStartTime))} → ${stamp(ended)} · 用时 ${fmtDuration(Date.now() - cliStartTime)}`
+            : ` · ${stamp(ended)}`;
+        return `${C_DIM}📦 session 已存档: ${key}${timeNote}${RESET}\n  ${C_DIM}${where ? where : ''} · ${Date.now() - t0}ms${titleNote}${treeNote}${RESET}`;
+    }
+    catch (e) {
+        const msg = String(e?.message || e);
+        // 2026-09-30: "没内容可存档" 与 "存档失败" 是两件事 —— 前者不该报成 ⚠ 吓人。
+        //   (历史事故: 写路径误用读语义 ⇒ 新会话一律抛 not found ⇒ 用户看到红字却什么也没坏)
+        if (/session not found/i.test(msg)) {
+            return `${C_DIM}(本次没有可存档的会话内容 — 会话文件还没落盘)${RESET}`;
+        }
+        return `${C_WARN}⚠ session 存档失败: ${msg.slice(0, 90)}${RESET}`;
+    }
+}
+/**
+ * 读一条会话的 metadata.title 并刷新工具栏右侧 (没有就清空)。
+ *   2026-09-30 (leo: 「切换 session 后也要有 title 加载」): 启动 / 切会话 / 回合结束三处共用同一套口径 ——
+ *   否则切完会话右侧还挂上一条的标题 (或空着), 看着像没生效。
+ */
+async function refreshSessionTitle(key) {
+    // 2026-09-30 (leo: 「切换后没有立刻刷新」): **先立刻清空并重绘** —— 否则等待异步读盘那几十毫秒里,
+    //   工具栏右侧还挂着上一条会话的标题, 看着就是"没刷新"。读完再填。
+    cliSessionPreview = '';
+    cliSessionTitleKey = key || null;
+    try {
+        inkSetStatus(getStatus());
+    }
+    catch { /* Ink 未起 */ }
+    if (!key)
+        return;
+    try {
+        const fs = await import('fs/promises');
+        const store = new SessionStore();
+        const raw = JSON.parse(await fs.readFile(store.pathFor(key), 'utf-8'));
+        const md = (Array.isArray(raw) ? {} : raw?.metadata) || {};
+        const t = String(md.title || '').trim();
+        // 只认"这条读的确实是当前会话" —— 读盘期间可能又切了一次
+        cliSessionPreview = (t && t !== key && cliSessionTitleKey === key) ? t.slice(0, 24) : '';
+    }
+    catch {
+        cliSessionPreview = ''; // 读不到/没标题 ⇒ 空着 (不拿旧标题冒充)
+    }
+    try {
+        inkSetStatus(getStatus());
+    }
+    catch { /* Ink 未起 */ }
+}
 /** 2026-08-09: agent 当前绑定的 channel id (null = 默认 harness 身份) — 切换时据此重建 */
 let agentBoundChannelId = null;
 let harness = null;
@@ -358,15 +638,34 @@ async function getAgent() {
         catch { /* 读不到就退默认 */ }
     }
     let identityDoc;
-    if (chIdentity?.did && chIdentity.publicKey) {
-        // channel 已有持久 DID → 用 channel 身份
+    // 2026-10-01 (用户实测: 两个不同 channel 都答同一个名字, get_identity 的 DID 为空):
+    //   旧逻辑要求 channel 记录**同时**有 did + publicKey, 否则落到 `agentIdentity`(进程级**共享**) ⇒
+    //   多个 channel 共用一个身份 ✗; 且 channel 里可能存着假 DID (did:local:…) 或干脆没有 did。
+    //   现在: 归属以 channel 的 agentId 为准 —— 现取现造**该 agent 的**真 did:key, 名字用**它自己的** persona。
+    const { channelIdentityUsable, nameForChannel } = await import('./agents/channel-identity.js');
+    let perAgentIdentity;
+    if (chIdentity?.agentId) {
+        try {
+            const { loadOrCreateAgentIdentity } = await import('./agents/agent-identity.js');
+            const mine = loadOrCreateAgentIdentity(chIdentity.agentId);
+            if (mine?.did)
+                perAgentIdentity = { did: mine.did, publicKey: mine.publicKey, name: nameForChannel(chIdentity, chIdentity.agentId) };
+        }
+        catch { /* 退回落 */ }
+    }
+    if (channelIdentityUsable(chIdentity)) {
+        // channel 自带**可用**的持久 DID (真 did:key) → 用它, 名字仍按该 agent 取 (不再用共享名)
         identityDoc = {
             did: chIdentity.did,
-            name: chIdentity.persona?.name || chIdentity.name || 'agent',
+            name: nameForChannel(chIdentity, chIdentity.agentId),
             publicKey: chIdentity.publicKey,
             createdAt: Date.now(),
         };
     }
+    else if (perAgentIdentity) {
+        // channel 缺身份 / 只有假 DID ⇒ 用**该 agent 自己的**真身份 (按 agentId 落盘密钥, 稳定)
+        identityDoc = { ...perAgentIdentity, createdAt: Date.now() };
+    }
     else if (agentIdentity) {
         identityDoc = {
             did: agentIdentity.did,
@@ -382,15 +681,60 @@ async function getAgent() {
     else {
         identityDoc = undefined;
     }
+    // 2026-10-01: **身份取值自证** —— 只在"可疑"时打一行事实 (不是刷屏):
+    //   缺 did / 假 did / channel 有 agentId 却没被用上 ⇒ 打出来, 免得靠猜。
+    //   用户实测过 DID 为空、名字串台、以及一个数据里根本不存在的 did ⇒ 这行能直接指认哪条分支被走了。
+    try {
+        const d = String(identityDoc?.did ?? '');
+        const suspicious = !d || /^did:(local|pi):/i.test(d) || (!chIdentity?.agentId && !!targetChannelId);
+        if (suspicious) {
+            console.warn(`[identity] 身份可疑: channel=${targetChannelId ?? '(无)'} · channel.agentId=${chIdentity?.agentId ?? '(无)'} · ` +
+                `分支=${channelIdentityUsable(chIdentity) ? 'channel 自带' : perAgentIdentity ? 'per-agent' : agentIdentity ? '**共享 agentIdentity**' : '默认'} · ` +
+                `did=${d ? d.slice(0, 30) : '(空)'} · name=${String(identityDoc?.name ?? '(空)')}`);
+        }
+    }
+    catch { /* 自证失败不影响主流程 */ }
+    // 2026-10-01: 把当前 agent 告诉进程 —— 项目上下文(context-collector)据此取**该 agent 的** persona,
+    //   否则它会读全局 persona.json, 于是 get_identity 已是「小龙」而上下文里还写着「小宝」✗。
+    if (chIdentity?.agentId)
+        process.env.BOLLOON_ACTIVE_AGENT_ID = chIdentity.agentId;
+    // 2026-10-01: **身份取值一行事实** —— 每次**建/切 agent** 打一行(不是每回合, 不刷屏)。
+    //   用户报「xiaomi 频道却拿到 233 的 DID + 小龙」而可疑判据没触发 ⇒ 猜不动了, 让代码直说。
+    try {
+        console.warn(`[identity] channel=${targetChannelId ?? '(无)'} · 查到=${chIdentity ? 'yes' : '**no**'} · ` +
+            `channel.agentId=${chIdentity?.agentId ?? '(无)'} · channel.did=${String(chIdentity?.did ?? '(无)').slice(0, 26)} · ` +
+            `分支=${channelIdentityUsable(chIdentity) ? 'channel自带' : perAgentIdentity ? 'per-agent' : agentIdentity ? '**共享' : '默认'} · ` +
+            `结果 did=${String(identityDoc?.did ?? '(空)').slice(0, 26)} name=${String(identityDoc?.name ?? '(空)')}`);
+    }
+    catch { /* 自证失败不影响主流程 */ }
     const loadSessionKey = targetChannelId
         ? `${targetChannelId}:${chIdentity?.currentSessionId || 'default'}`
         : undefined;
+    // 2026-10-01: 确保该 agent 名下有身份文档 (此前仓里没有任何"建文档"的路径 ⇒
+    //   用户四个 agent 的 persona/<agentId>/ 全空 ⇒ loadPersonaDocs 读回空 ⇒ 所有智能体一个样)。
+    //   挂在这里 = 建 agent / 切 channel 两条路都会走到; 幂等, 已存在的不覆盖。
+    if (chIdentity?.agentId) {
+        try {
+            const { ensurePersonaDocs } = await import('./bootstrap/persona-init.js');
+            // 2026-10-01: 名字必须和该 agent 的 persona.json 一致 —— 之前传的是**渠道名**,
+            //   于是 soul.md 写「我是 233」而 persona.json 写「小龙」⇒ 用户看到"身份没匹配上" ✗。
+            const r = await ensurePersonaDocs(chIdentity.agentId, { name: nameForChannel(chIdentity, chIdentity.agentId) });
+            if (r.created.length)
+                console.warn(`[persona] 已为 ${r.agentId} 生成 ${r.created.length} 份起步身份文档: ${r.created.join(' · ')} → ${r.dir}`);
+        }
+        catch { /* 非致命 */ }
+    }
     agent = await createAgentSession({
         cwd: process.cwd(),
         peerId: targetChannelId ?? 'harness',
-        identityDoc,
         // 2026-08-09: 透传 channel.agentId → persona docs 按 agent 加载 (身份真正变化)
         agentId: chIdentity?.agentId || (targetChannelId ? undefined : agentIdentity?.name),
+        // 2026-10-01 ★ **必须传 identityDoc** —— 之前漏了 ✗, 后果有两层:
+        //   ① 上面按频道算好的身份(名字 + 该 agent 自己的 did)被**丢掉**, session 用自己造/复用的;
+        //   ② session 工厂的更新路径 (pi-sdk-session-factory.updateIdentity) 以 `config.identityDoc?.did`
+        //      为条件 ⇒ 缺它 **永不触发** ⇒ 切频道时复用同一个 session 实例, 身份却**不换** ✗✗
+        //   (实测: 233→智能体 后答 233 的身份; 智能体→233 后答 智能体的身份 = 身份"差一格" ✓ 根因在此)
+        identityDoc,
         loadSessionKey,
     });
     agentBoundChannelId = targetChannelId;
@@ -418,7 +762,7 @@ async function dispatchTask(raw) {
     const task = safeParse(body);
     if (!task)
         return `ERR|${JSON.stringify({ code: 'bad_format' })}`;
-    console.log(`\n📥 [${task.type}]  from=${task.from?.substring(0, 18)}...  id=${task.id}`);
+    writeOut(`\n📥 [${task.type}]  from=${task.from?.substring(0, 18)}...  id=${task.id}`);
     try {
         switch (task.type) {
             case 'summarize':
@@ -438,7 +782,7 @@ async function handleSummarize(task) {
         return `ERR|${JSON.stringify({ code: 'no_path' })}`;
     const a = await getAgent();
     const { summary, qualityScore } = await a.summarizeDocument(task.documentPath);
-    console.log(`     ✅ 质量=${(qualityScore * 10).toFixed(1)}/10`);
+    writeOut(`     ✅ 质量=${(qualityScore * 10).toFixed(1)}/10`);
     return `OK|${JSON.stringify({ id: task.id, type: 'summarize', qualityScore, summary })}`;
 }
 async function handleImprove(task) {
@@ -452,7 +796,7 @@ async function handleImprove(task) {
         context: `来自节点: ${task.from}`,
     });
     const ok = res.improved ?? false;
-    console.log(`     ✅ 改进${ok ? '成功' : '失败'}  质量=${(res.qualityScore * 10).toFixed(1)}/10  自动发送=${res.shouldAutoSend}`);
+    writeOut(`     ✅ 改进${ok ? '成功' : '失败'}  质量=${(res.qualityScore * 10).toFixed(1)}/10  自动发送=${res.shouldAutoSend}`);
     return `OK|${JSON.stringify({
         id: task.id, type: 'improve', improved: ok,
         qualityScore: res.qualityScore, shouldAutoSend: res.shouldAutoSend,
@@ -483,8 +827,23 @@ let _startupLogGate = null;
 const pendingQueue = [];
 let cliStartTime = 0;
 let cliModelName = '…';
-let cliAgentName = '…';
+let cliAgentName = 'bolloon'; // 2026-09-30: 别用 '…' —— 身份没解析出来时状态栏显示个省略号, 看着像"没有 bolloon 标识"
 let cliActiveChannelId = null;
+/**
+ * 状态栏"活数据" (leo 2026-09-30: 参考别家 CLI 的 ◎ / ◷ / ↑ t/s / ⚙ / ⏲ / ✓ 那一行)
+ *   · cliTurnStartedAt / cliLastTurnMs —— 本轮用时(◷) 与 上一步用时(✓)
+ *   · cliTurnReplyBytes —— 本轮回复字节数, 折 ≈t/s (按 ~3.5B/token 估, 所以标"≈")
+ *   · 在跑工具数不另存 —— 直接用已有的 tuiToolCalls (它就是"还没结束的工具"清单)
+ *   测不到的段 (比如"限流窗口还剩 20m") 一律不显示 —— 不编数字。
+ */
+let cliTurnStartedAt = 0;
+let cliLastTurnMs = 0;
+let cliTurnReplyBytes = 0;
+let cliTurnToolCount = 0; // 在跑工具数 (回合内由工具事件更新)
+/** 当前会话的 Title/Preview (工具栏右侧显示用; 回合结束后后台生成一次, 生成过就不再跑) */
+let cliSessionPreview = '';
+let cliSessionTitleKey = null; // 这条标题属于哪个会话 —— 不是当前会话一律不显示 (防串台)
+let cliSessionSummarizing = false;
 // 2026-08-12: 当前 active channel 的 agentId (如 agent-alice). memory 落盘按 agentId 存,
 //   /memory /resume /did 读路径必须用 agentId 而非 display name (cliAgentName), 否则路径不一致读不到.
 let cliAgentId = null;
@@ -548,16 +907,76 @@ function buildContextBar(usage) {
         suffix = ` ${C_OK}✓ 已压缩${RESET}`;
     return `${usageTxt} ${C_DIM}│${RESET} ${bar} ${barColor}${pctTxt}${RESET}${suffix}`;
 }
+/**
+ * 状态栏里的模型名: **只留型号**。
+ *   2026-09-30 leo: 「deepseek · deepseek-flash v0.5.3，这里有重复冗余，保留模型型号就行，provider 可以不要」
+ *   (`cliModelName` 仍是 'deepseek · deepseek-flash' —— 启动面板那边保持原样, 只有状态栏缩。)
+ */
+function statusModelName() {
+    const parts = String(cliModelName || '').split(' · ');
+    return parts.length > 1 ? parts.slice(1).join(' · ') : String(cliModelName || '');
+}
 /** 状态栏: 模型 │ 当前智能体 (含 channel) │ ⏱ 时间 │ 320k/1M │ [██████░░░░] 32% (bolloon 色系) */
 function getStatus() {
     const usage = getCliCtxUsage();
-    const agentPart = cliActiveChannelId ? `${cliAgentName} ${C_DIM}(ch:${cliActiveChannelId.slice(0, 10)})${RESET}` : cliAgentName;
-    return `${C_ACCENT}${cliModelName}${RESET}${C_DIM}  │${RESET} ${agentPart} ${C_DIM}│${RESET} ⏱ ${C_TEXT}${fmtDuration(Date.now() - cliStartTime)}${RESET}${C_DIM} │${RESET} ${buildContextBar(usage)}`;
+    // 名字兜底: 空/'…' 一律显示 bolloon —— 标识必须一直在 (leo: 「bolloon 标识没出现」)
+    const __name = (!cliAgentName || cliAgentName === '…') ? 'bolloon' : cliAgentName;
+    // 2026-09-30: 左半边按宽压扁 —— 窄终端里 `(ch:xxx)` 与 token 计数让位给右边的活数据段
+    const __w = termWidth();
+    const agentPart = (cliActiveChannelId && __w >= 120) ? `${__name} ${C_DIM}(ch:${cliActiveChannelId.slice(0, 10)})${RESET}` : __name;
+    // 左半边先建好 —— 后面对右侧活数据段做宽度取舍要用它的纯文本长度
+    const __left = `${C_ACCENT}${statusModelName()}${RESET} ${C_DIM}v${_BOLLOON_VERSION}${RESET}${C_DIM}  │${RESET} ${agentPart} ${C_DIM}│${RESET} ⏱ ${C_TEXT}${fmtDuration(Date.now() - cliStartTime)}${RESET}${C_DIM} │${RESET} ${buildContextBar(usage)}`;
+    const __leftPlainLen = __left.replace(/\x1b\[[0-9;]*m/g, '').length;
+    // 2026-09-30 (leo): 四段抽到 src/cli/status-segments.ts (纯函数 ⇒ "什么时候显示什么"可确定性验证)
+    const __segs = statusSegments({
+        running: cliTurnStartedAt > 0,
+        turnElapsedMs: cliTurnStartedAt > 0 ? Date.now() - cliTurnStartedAt : 0,
+        lastTurnMs: cliLastTurnMs,
+        lastTurnReplyBytes: cliTurnReplyBytes,
+        toolCount: cliTurnToolCount,
+        aiTiming: getLastAiTiming(),
+        aiUsage: getLastAiUsage(),
+        turnStartedAt: cliTurnStartedAt,
+    }).map(s => {
+        const m = /^(\S+)\s(.*)$/.exec(s);
+        const icon = m ? m[1] : '';
+        const val = m ? m[2] : s;
+        const color = icon.startsWith('✓') ? C_OK : C_TEXT;
+        return `${C_DIM}${icon}${RESET} ${color}${val}${RESET}`;
+    });
+    // 按剩余宽度取舍 (真机 112 列时右段被截 ⇒ 看着像没出现)
+    // 2026-10-01: 底栏一律用**保守测宽** (Ambiguous 字符按 2 列) —— 超 1 列就会让终端折行、
+    //   进而打破 Ink 光标数学, 表现是整块底栏被重复打印 (见 status-segments.dispWidthSafe 注释)
+    // 2026-10-01: 预算按**保守宽度**给 (left + ≥1 格 + title ≤ width-1) ⇒ 任何字体下都不折行
+    const __notePlain = (cliSessionPreview && cliSessionTitleKey === cliSessionKey) ? `▸ ${cliSessionPreview}` : '';
+    const __budget = statusLineBudget(termWidth(), __leftPlainLen, String(__notePlain || ''));
+    const __segsFit = fitSegments(__segs.map(x => x.replace(/\x1b\[[0-9;]*m/g, '')), __budget, dispWidthSafe);
+    const __live = __segsFit.length
+        ? ` ${C_DIM}│${RESET} ` + __segsFit.map(x => {
+            const m = /^(\S+)\s(.*)$/.exec(x);
+            const icon = m ? m[1] : '';
+            const val = m ? m[2] : x;
+            return `${C_DIM}${icon}${RESET} ${icon.startsWith('✓') ? C_OK : C_TEXT}${val}${RESET}`;
+        }).join(` ${C_DIM}│${RESET} `)
+        : '';
+    // 2026-09-30 (leo: 「这个 title 需要顶格右侧」): 会话 Title **右对齐**贴右边缘 ——
+    //   先算左半边+活数据段的显示宽, 再补空格把 `▸ 标题` 推到 width-1 处; 放不下就不显示 (不挤坏这一行)。
+    let __noteStr = '';
+    if (__notePlain) {
+        // 宽度必须用 dispWidth (East Asian Width 表): 行内的 `│ ░ ◷ ▸ ◎ ✓ ↑ ⚙` 都是**单宽**,
+        //   用 "charCode > 255 ⇒ 2" 的启发式会每行多算十几列 ⇒ 右对齐留一大截 (leo: 「没有完全右对齐」)。
+        const used = dispWidthSafe(`${__left}${__live}`);
+        // 保守测宽 (同上): 右对齐后整行最多到 width-1, 在任何终端字体下都不会折行
+        const pad = rightAlignPad(used, dispWidthSafe(__notePlain), termWidth());
+        if (pad !== null)
+            __noteStr = ' '.repeat(pad) + `${C_DIM}${__notePlain}${RESET}`;
+    }
+    return `${__left}${__live}${__noteStr}`;
 }
 function statusBarLine() {
     const dur = cliStartTime ? fmtDuration(Date.now() - cliStartTime) : '0s';
     const usage = getCliCtxUsage();
-    return `${C_ACCENT}${cliModelName}${RESET}${C_DIM}  │${RESET} ${cliAgentName} ${C_DIM}│${RESET} ⏱ ${C_ACCENT}${dur}${RESET} ${C_DIM}│${RESET} ${buildContextBar(usage)}`;
+    return `${C_ACCENT}${statusModelName()}${RESET}${C_DIM}  │${RESET} ${cliAgentName} ${C_DIM}│${RESET} ⏱ ${C_ACCENT}${dur}${RESET} ${C_DIM}│${RESET} ${buildContextBar(usage)}`;
 }
 /**
  * 启动会话面板 — 按类别展示启动加载的 skills (真实类别 = 目录名去掉 frontmatter.name 后缀),
@@ -565,31 +984,91 @@ function statusBarLine() {
  */
 /** 启动面板框: BOLLOON 字标 logo 顶部居中 → 下方两栏 = face 艺术字(左) + 加载内容(右) */
 function buildBootBox(face, banner, rest) {
-    const faceW = Math.max(1, ...face.map((l) => dispWidth(l)));
-    const bannerMax = Math.max(1, ...banner.map((l) => dispWidth(l)));
-    const restMax = Math.max(1, ...rest.map((l) => dispWidth(l)));
+    /**
+     * 2026-09-30 修复 (leo 报「TUI 渲染出错 + 回复被截断」):
+     *   盒子外宽 = min(终端宽-2, 内容宽+4, 调用方上限) ⇒ **内容宽一旦超过 终端宽-6, 每行都被终端折行**,
+     *   艺术字因此裂成两列错位 (实测 110 列终端下 BOLLOON 艺术字宽 108 > 内宽 104).
+     *   另外原来 maxLines: 0 = 不限高 ⇒ 面板长过屏幕, 把输入行顶出视野 (30 行终端下实测输入行消失).
+     *   所以这里先把内容**裁进真实可用宽高**, 再画盒子:
+     *     宽度: 艺术字太宽 ⇒ 整块丢掉(宁可不显示) · 两栏装不下 ⇒ 先丢 face 列 · 右侧行超宽 ⇒ 逐行截断
+     *     高度: 面板 ≤ 终端行数 - 10 (给输入行/状态栏留位置), 砍掉的尾部如实标注行数与自查入口
+     */
     const gap = 4;
-    const twoColW = faceW + gap + restMax;
-    const contentW = Math.max(bannerMax + 8, twoColW);
-    const center = (rows) => rows.map((l) => ' '.repeat(Math.max(0, Math.floor((contentW - dispWidth(l)) / 2))) + l);
-    const n = rest.length;
-    const fStart = Math.max(0, Math.floor((n - face.length) / 2)); // face 列对内容垂直居中 = 等高
-    const twoCol = rest.map((r, i) => {
-        const f = (i >= fStart && i < fStart + face.length) ? face[i - fStart] : null;
-        const fpart = f ? `${f}${' '.repeat(Math.max(0, faceW - dispWidth(f)) + gap)}` : ' '.repeat(faceW + gap);
+    const maxInner = Math.max(24, termWidth() - 6); // 外框 = │ + 空 + 内容 + 空 + │
+    const rows = termHeight();
+    const bannerW = banner.reduce((m, l) => Math.max(m, dispWidth(l)), 0);
+    // 装不下(极窄终端)仍退回一行文字 —— 保证任何宽度都有字标, 不再是空白
+    const useBanner = bannerW > 0 && bannerW + 4 <= maxInner ? banner : [`${C_ACCENT}${BOLD}BOLLOON${RESET}`];
+    let useFace = face;
+    const faceW0 = face.reduce((m, l) => Math.max(m, dispWidth(l)), 0);
+    const restMax0 = rest.reduce((m, l) => Math.max(m, dispWidth(l)), 0);
+    /**
+     * 2026-09-30 (leo: 「我说的 logo 是面板里面的小吉祥物, 它看不到了」):
+     *   原来的判据是「吉祥物 + 最宽内容行 > 内宽 ⇒ **把吉祥物整块丢掉**」——
+     *   而技能类目行天生很长 (openclaw-imports: 3d-web-experience, …), 于是**每次都触发、吉祥物永远不显示**。
+     *   优先级反了: 吉祥物是面板的标识, 内容行可以裁。现在只在
+     *   「连最小内容宽度都放不下」(真的窄) 时才丢吉祥物; 否则**裁窄右侧内容**让它俩共存。
+     */
+    const MIN_REST_W = 30;
+    if (useFace.length > 0 && faceW0 + gap + MIN_REST_W > maxInner)
+        useFace = [];
+    const faceW = useFace.reduce((m, l) => Math.max(m, dispWidth(l)), 0);
+    const room = Math.max(16, maxInner - (useFace.length > 0 ? faceW + gap : 0));
+    const restFit = rest.map((l) => (dispWidth(l) > room ? truncate(l, room) : l));
+    const bannerRows = useBanner.length > 0 ? useBanner.length + 1 : 0; // +1 = banner 与两栏之间的空行
+    // 2026-09-30 (leo: 「还是启动后会出现顶部的刷新」): 面板高过**消息窗口**时, Ink 清不掉上一帧
+    //   ⇒ 退化成追加模式, 顶框和艺术字被一条条重复写到屏上. 所以高度按窗口真高算, 不拍脑袋 (原来 rows-10).
+    const bootWinH = bootPanelMaxLines(rows, termWidth());
+    // 2026-09-30 (leo: 「面板右侧的 skills 内容不见了」): **内容优先** —— 面板内容按终端高度留出
+    //   输入栏/状态栏的余量来给 (不按"面板区"的高度砍); 装不下的部分由**面板区滚动**看全.
+    //   上一版按区域高算 ⇒ 小终端下面板只剩 3 行内容, skills 直接没了 (回归, 已改回).
+    // 2026-09-30 (leo: 「内容出现了, logo 消失了」): 面板进 <Static>(无限高度) 后, 一旦
+    //   "面板 + 底部块" 超过可视行数, **被顶出视野的正是顶部的 logo** (内容在下面反而留着)。
+    //   原来 rows-10 正好卡满(0 余量) ⇒ 最后那个换行就把顶行(logo)滚掉。
+    //   底部块实测 6 行 + 就绪行 1 行 ⇒ 这里留 3 行余量, 启动这一刻 logo 一定看得见。
+    const bodyCap = Math.max(4, rows - 13 - bannerRows); // 下限 4: 宁可少列类目, 也要保住整只 logo
+    void bootWinH;
+    let restLines = restFit;
+    if (restLines.length > bodyCap) {
+        const dropped = restLines.length - (bodyCap - 1);
+        restLines = [...restLines.slice(0, bodyCap - 1), `${C_DIM}… 还有 ${dropped} 行 (PgUp 滚面板 / bolloon status 看全量)${RESET}`];
+    }
+    const restMax = restLines.reduce((m, l) => Math.max(m, dispWidth(l)), 0);
+    const twoColW = useFace.length > 0 ? faceW + gap + restMax : restMax;
+    const contentW = Math.max(useBanner.length > 0 ? bannerW + 8 : 0, twoColW);
+    const center = (rs) => rs.map((l) => ' '.repeat(Math.max(0, Math.floor((contentW - dispWidth(l)) / 2))) + l);
+    const n = restLines.length;
+    const fStart = Math.max(0, Math.floor((n - useFace.length) / 2)); // face 列对内容垂直居中 = 等高
+    const twoCol = restLines.map((r, i) => {
+        const f = (useFace.length > 0 && i >= fStart && i < fStart + useFace.length) ? useFace[i - fStart] : null;
+        const fpart = f
+            ? `${f}${' '.repeat(Math.max(0, faceW - dispWidth(f)) + gap)}`
+            : (useFace.length > 0 ? ' '.repeat(faceW + gap) : '');
         return fpart + r;
     });
-    const body = [...center(banner), '', ...twoCol];
-    return renderMessageBox({ title: '🚀 Bolloon · 启动面板', body: body.join('\n'), color: C_ACCENT, maxLines: 0 });
+    const body = [...(useBanner.length > 0 ? [...center(useBanner), ''] : []), ...twoCol];
+    const outer = Math.min(termWidth() - 2, Math.max(contentW + 4, 40));
+    return renderMessageBox({ title: '🚀 Bolloon · 启动面板', body: body.join('\n'), color: C_ACCENT, maxLines: 0, width: outer });
+}
+/** 启动面板的技能快照 (成功扫描后写; 下次超时/读失败时兜底 —— 跟启动日志同目录) */
+function skillsCachePath() {
+    return path.join(path.dirname(startupLogPath()), 'panel-skills.json');
 }
 async function bootPanel(boot) {
     const sub = []; // tools / MCP (Promise.all 里填充, 最后统一排到类别下方)
     const catNames = new Map();
+    let skillsScanTimedOut = false; // 技能扫描到点没收完 ⇒ 面板里如实标出来, 不假装"就是这些"
+    const skillsScanErrors = []; // 2026-09-30: 读失败**必须计数写出来** —— 静默吞掉 = 屏上"0 skills"(假 0, 比不显示更坏)
+    let skillsFromCache = false; // 本次没扫到 ⇒ 用上次成功扫描的快照, 并如实标注来源
+    let skillsCacheAt = '';
     await Promise.all([
         (async () => {
             try {
                 // 真实类别 = 目录名前缀去掉技能名后缀 (SKILL.md 无 category 字段, 但 frontmatter.name 是真名:
                 //   software-development-bolloon-development / name=bolloon-development → software-development)
+                // 2026-09-30: **先把模块导进来, 再开始计时** —— 原写法把 4s 预算从 import 之前就开始算,
+                //   而冷启动那一刻 import 技能模块(带 yaml 等)本身要好几秒 ⇒ 预算被 import 吃掉, 面板报
+                //   "扫描超时 / 0 个技能"(实测: 扫描真身只 702ms/1300 个, 却显示 0).
                 const { loadSkillsDir, defaultSkillPaths } = await import('./agents/skill-loader.js');
                 const pushCat = (cat, name) => {
                     const arr = catNames.get(cat) || [];
@@ -597,32 +1076,63 @@ async function bootPanel(boot) {
                         arr.push(name);
                     catNames.set(cat, arr);
                 };
-                for (const root of defaultSkillPaths()) {
-                    const metas = await loadSkillsDir(root);
-                    for (const m of metas) {
-                        if (m.status === 'archived')
-                            continue;
-                        const dir = m.sourcePath ? path.basename(path.dirname(m.sourcePath)) : '';
-                        const nm = m.name || '';
-                        let cat = dir;
-                        if (dir && nm && dir.endsWith(nm)) {
-                            const pre = dir.slice(0, dir.length - nm.length).replace(/-+$/, '');
-                            if (pre)
-                                cat = pre;
+                // 2026-09-30: 多个技能根**并行**扫 (原来顺序 await ⇒ 实测 4399ms, 并行 297ms, 1300 个技能);
+                //   并给一个上限: 超时就如实标出来, 不让"出面板"被一次磁盘抖动无限期拖住.
+                const roots = defaultSkillPaths();
+                const all = await Promise.race([
+                    Promise.all(roots.map((r) => loadSkillsDir(r).catch((e) => {
+                        // 2026-09-30: 原来这里 `.catch(() => [])` **静默**吞错 ⇒ 屏上"0 skills · 0 类",
+                        //   谁也看不出是"真 0"还是"读不动" (leo 报「面板内容变少了」)。现在计数 + 写出来。
+                        skillsScanErrors.push(`${path.basename(r)}: ${String(e?.message || e).slice(0, 70)}`);
+                        return [];
+                    }))),
+                    new Promise((res) => setTimeout(() => res(null), 6000)), // 冷 FS 上留足余量
+                ]);
+                if (all === null) {
+                    skillsScanTimedOut = true;
+                }
+                else {
+                    for (const metas of all) {
+                        for (const m of metas) {
+                            if (m.status === 'archived')
+                                continue;
+                            const dir = m.sourcePath ? path.basename(path.dirname(m.sourcePath)) : '';
+                            const nm = m.name || '';
+                            let cat = dir;
+                            if (dir && nm && dir.endsWith(nm)) {
+                                const pre = dir.slice(0, dir.length - nm.length).replace(/-+$/, '');
+                                if (pre)
+                                    cat = pre;
+                            }
+                            pushCat(cat || 'other', nm || dir);
                         }
-                        pushCat(cat || 'other', nm || dir);
                     }
                 }
+                // 扫到东西就落一份快照 —— 下次超时/读失败时用它兜底(并标注来源), 不再"内容突然变少"
+                if (catNames.size > 0) {
+                    try {
+                        const totalNow = [...catNames.values()].reduce((s2, a) => s2 + a.length, 0);
+                        await fs.mkdir(path.dirname(skillsCachePath()), { recursive: true });
+                        await fs.writeFile(skillsCachePath(), JSON.stringify({
+                            at: new Date().toLocaleString('zh-CN', { hour12: false }), total: totalNow, cats: [...catNames.entries()],
+                        }), 'utf8');
+                    }
+                    catch { /* 快照写不进去不影响面板 */ }
+                }
             }
             catch { /* 省略 */ }
         })(),
         (async () => {
+            /**
+             * 2026-09-30 (leo: 「面板的加载没有和输入框一起出现, 有时间差, 且面板内部内容有缺失」):
+             *   这里原来是 `getAgent()` —— 建**整个 agent 会话**(模型/工具/身份). 插桩实测它把事件循环
+             *   **同步阻塞**几十秒 (调用后 20s 连 end 都没打出来, 2.5s/4s 上限的定时器都点不着) ⇒ 面板被拖到
+             *   十几秒后才出, 技能那一段也没跑完(=内容缺失). 面板只为一行 `🔧 N tools` 付这个代价不值得
+             *   ⇒ **不再等它**: 已建好的 agent 才取工具数; 全量清单看 `bolloon status`.
+             */
             try {
-                const a = await Promise.race([
-                    getAgent().catch(() => null),
-                    new Promise((res) => setTimeout(() => res(null), 2500)),
-                ]);
-                const tools = a && typeof a.getToolList === 'function' ? a.getToolList() : null;
+                const a = agent && typeof agent.getToolList === 'function' ? agent : null;
+                const tools = a ? a.getToolList() : null;
                 if (tools && tools.length > 0)
                     sub.push(`🔧 ${tools.length} tools`);
             }
@@ -640,7 +1150,20 @@ async function bootPanel(boot) {
     ]);
     // 栈式布局: face 艺术字居中 → BOLLOON 字标 logo 在其下 → 内容左对齐
     const art = ROBOT_HEAD;
-    const banner = BOLLOON_BANNER.split('\n');
+    // 2026-09-30 (leo: 「我看不到我的 logo」): 按宽度**挑档**, 不再"窄就丢".
+    //   原来只有一档 87 列艺术字, 终端宽 < ~97 列时整块被丢、只剩一行文字.
+    //   挑"装得下的最大档": 大(87 列) → 小(37 列) → 都装不下才在框里退回一行文字.
+    const candInner = Math.max(24, termWidth() - 6);
+    // 2026-09-30 (leo: 「内容出现了, logo 消失了」): 挑档**宽和高都要装得下** ——
+    //   面板进 <Static>(无限高度) 后, 一旦"面板 + 底部块"超过可视行数, 被顶出视野的正是顶部 logo。
+    //   所以: 整块艺术字(87 列)装不下高就换窄版(37 列), 都不行才退回一行文字 —— 任何行数都有 logo。
+    const candRows = termHeight();
+    const bannerFits = (b) => {
+        const w = Math.max(...b.map(dispWidth));
+        const panelRows = b.length + 4 /* 最少内容行 */ + 2 /* 上下边框 */;
+        return w + 4 <= candInner && panelRows + 7 /* 底部块+就绪行 */ <= candRows - 2;
+    };
+    const banner = [BOLLOON_BANNER, BOLLOON_BANNER_SMALL].map(b => b.split('\n')).find(bannerFits) || [];
     // 头: 目录 / 模型 / Session (预先加载信息)
     const rest = [];
     if (boot.dir)
@@ -650,6 +1173,20 @@ async function bootPanel(boot) {
     if (boot.session)
         rest.push(`Session: ${boot.session}`);
     rest.push('');
+    // 2026-09-30 (leo 的屏面: 提示写了"快照"但数字还是 0): 回落必须在 normalized/sorted **之前** ——
+    //   先把快照填进 catNames, 再统计, 否则出现"有提示没数字"的假面板。
+    if (catNames.size === 0) {
+        try {
+            const c = JSON.parse(fsSync.readFileSync(skillsCachePath(), 'utf8'));
+            for (const [k, arr] of (c.cats || []))
+                catNames.set(k, arr);
+            if (catNames.size > 0) {
+                skillsFromCache = true;
+                skillsCacheAt = String(c.at || '');
+            }
+        }
+        catch { /* 没快照就照实显示 0 */ }
+    }
     // 类别行 (全部展开, 不截断类别; 每类列前 8 名 + '+N more') — 单一实例归 other
     const normalized = new Map();
     for (const [cat, arr] of catNames) {
@@ -664,12 +1201,20 @@ async function bootPanel(boot) {
     }
     const sorted = [...normalized.entries()].sort((a, b) => b[1].length - a[1].length);
     const total = sorted.reduce((s, [, arr]) => s + arr.length, 0);
+    // 2026-09-30 (leo 报「回复渲染时被截断」): 面板**压矮** —— 技能类目只列前 4 类(其余归到计数行),
+    //   否则 20+ 行面板把消息区占满, 后面的回复没地方站 (= 挤成窄列/看起来被截断).
+    // 2026-09-30 (真机日志: 计数行被面板裁掉): **计数行放类目之前** —— 面板装不下时裁的是尾部,
+    //   原来的顺序 (类目 → 计数) 会让"⚡ N skills · M 类"这个最要紧的数先被丢掉。
+    rest.push(`⚡ ${total} skills · ${sorted.length} 类${skillsFromCache ? ` (上次成功扫描的快照 · ${skillsCacheAt})` : ''}`, '');
     for (const [cat, arr] of sorted) {
         const shown = arr.slice(0, 8);
         const more = arr.length > shown.length ? `, +${arr.length - shown.length} more` : '';
         rest.push(`${cat}: ${shown.join(', ')}${more}`);
     }
-    rest.push(`⚡ ${total} skills · ${sorted.length} 类`, '');
+    if (skillsScanTimedOut)
+        rest.push(`${C_DIM}(本次技能扫描超时, 上面是${skillsFromCache ? '快照' : '已扫到的部分'} —— bolloon status 看全量)${RESET}`, '');
+    if (skillsScanErrors.length)
+        rest.push(`${C_WARN}(技能根读取失败 ${skillsScanErrors.length} 个: ${skillsScanErrors[0]})${RESET}`, '');
     if (sub.length)
         rest.push(...sub, '');
     // 自动整理 (经验/技能整理心跳) 模式并入面板
@@ -744,6 +1289,10 @@ async function startCLI(commReady) {
     if (process.env.BOLLOON_SKIP_KUBO !== '1') {
         void (async () => {
             try {
+                // 2026-09-30: 已经在跑就别让 SDK 再走装配 —— 那步会跑 `ipfs init` 并在启动面板前打一行
+                //   [warn](含"失败"⇒ 日志门按信号放行), 就是 leo 报的「开启过程的日志没去掉」.
+                if (await kuboAlreadyRunning())
+                    return;
                 const sdk = await import('@diap/sdk');
                 const checkKuboSetup = sdk.checkKuboSetup;
                 if (typeof checkKuboSetup === 'function') {
@@ -762,6 +1311,7 @@ async function startCLI(commReady) {
         if (active) {
             cliAgentName = active.name;
             cliActiveChannelId = active.channelId ?? null;
+            setHistoryScope(active.channelId ?? null);
             // 2026-08-12: 同步 agentId (memory 路径一致) — 从 rawChannels 按 channelId 取 agentId
             const raw = active.channelId ? store.rawChannels.find((c) => c.id === active.channelId) : undefined;
             cliAgentId = raw?.agentId || null;
@@ -777,7 +1327,7 @@ async function startCLI(commReady) {
         _ctxManagerRef = await import('./bootstrap/context-manager.js');
     }
     catch { /* 降级: getCliCtxUsage 返回 0/1M */ }
-    const initialStatus = `${C_ACCENT}${cliModelName}${RESET}${C_DIM}  │${RESET} ${cliAgentName} ${C_DIM}│${RESET} ⏱ 0s${C_DIM} │${RESET} ${buildContextBar(getCliCtxUsage())}`;
+    const initialStatus = `${C_ACCENT}${statusModelName()}${RESET} ${C_DIM}v${_BOLLOON_VERSION}${RESET}${C_DIM}  │${RESET} ${cliAgentName} ${C_DIM}│${RESET} ⏱ 0s${C_DIM} │${RESET} ${buildContextBar(getCliCtxUsage())}`;
     // 2026-09-08 (leo 规格): 图标下元信息层数据 — 目录(home→~) / 模型 / Session id (Hermes 风格: YYYYMMDD_HHMMSS_xxxx)
     const bootDirShort = process.cwd().replace(os.homedir(), '~');
     const bootSessionId = (() => {
@@ -785,7 +1335,42 @@ async function startCLI(commReady) {
         const p = (n, l = 2) => String(n).padStart(l, '0');
         return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}_${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}_${Math.random().toString(16).slice(2, 8)}`;
     })();
+    const notes = takeStartupPanelNotes();
+    const verbosePreamble = startupPreambleVisible();
+    const bootBox = bootPanelPrinted ? null : await bootPanel({
+        dir: bootDirShort,
+        model: (cliModelName && cliModelName !== '…') ? cliModelName : undefined,
+        session: bootSessionId,
+    });
+    cliSessionKey = bootSessionId; // 2026-09-30: 退出存档要用 (两条退出路径都读它)
+    void refreshSessionTitle(cliSessionKey); // 启动就把当前会话的标题带上
+    if (bootBox) {
+        // 2026-09-30 (leo: 「面板和回复要往上面无限推」): 面板就是这条流的**第一条** —— 渲染侧走 <Static>, 高度无限
+        appendLine(bootBox);
+        bootPanelPrinted = true;
+    }
+    // 2026-09-27 (leo 口径: `bolloon --cli` 起来直接就是面板, 启动前不刷前言):
+    //   就绪度报告 / 初始化续跑前言**默认不上屏** —— 但它们不是消失, 而是变成**面板里的行**:
+    //     · 就绪度折成一行 `就绪: basic ✓ · agent ✓ · durable ✗ · network ✓ · 详情: …`
+    //     · 失败 / 需人介入 (缺 key、连通性实测失败、初始化中断) 折成 `/!\` 开头的提示行 —— **不许吞**
+    //   注: 字面量里必须写 `\\ ` (反斜杠要转义), 否则 JS 会把 `\ ` 吃成空格 —— 屏上就变成 `/! ` 了
+    //   (验收门 `verify-cli-panel` 的 A4 按 `/!\` 判, 真踩过一次)。
+    //   全量版仍在 `startup.log`; `--verbose` / BOLLOON_VERBOSE=1 下逐字回到启动前的位置 (走 stderr)。
+    if (notes.readiness && !verbosePreamble && !bootReadinessPrinted) {
+        appendLine(`${C_DIM}${notes.readiness}${RESET}`);
+        bootReadinessPrinted = true;
+    }
+    for (const a of notes.alerts)
+        appendLine(`${C_WARN}/!\\ ${a}${RESET}`);
+    // 已经到面板了: 缓冲里剩下的纯前言**不上屏**(已在 startup.log), 丢掉引用免得下次启动重放
+    clearBufferedNotices();
+    // 面板第一帧之后: 晚到的降级提示 (后台 iroh / bootstrap / DID 发布…) 直接追加进面板,
+    //   不再等下一次 `takeStartupPanelNotes()` —— 否则它们会静静地烂在告警数组里 (= 吞)
+    startupPanelReady = true;
+    // 2026-09-30: 面板在起帧前已进 store ⇒ 首帧里与输入框一起出现
     startInk((text) => { processInput(text, comm); }, initialStatus, getStatus);
+    // 2026-10-01: Ink 起来了 ⇒ 把启动期缓冲的日志一次性灌进对话流(不丢, 也不跟面板交错 ✓)
+    flushBootBuffer();
     // 2026-08-10: 自动整理心跳 (CLI 侧, 与社交心跳并列) — 启动后立即"固定看一下 skills view"
     //   (扫描遗留 skills), 之后按周期 (默认 30min, env BOLLOON_ORGANIZE_HEARTBEAT_MS) 完整进化经验.
     //   显示走 transient 颜文字行: 触发时显示, 结束后清空 (显示为空).
@@ -811,7 +1396,15 @@ async function startCLI(commReady) {
                     boxLines.push(`🧠 知识整理: ${kSections.map(s => s.error ? `${s.label}✗` : `${s.label}✓`).join(' ')}`);
                 }
                 if (boxLines.length > 0) {
-                    appendLine(renderMessageBox({ title: '自动整理完成', body: boxLines.join('\n'), color: C_ACCENT, maxLines: 10 }));
+                    /**
+                     * 2026-09-30 (leo: 「还是没有把开启过程的日志去掉」): 自动整理是**内部运行日志** ——
+                     *   ① 开机第一轮是纯扫描(不取 LLM、什么都没改) ⇒ 一个字符都不该上屏;
+                     *   ② 周期轮就算真做了事, 也不许**往对话回复流塞一个 10 行盒子** ——
+                     *      那会挤掉/截断正在渲染的回复(实测回复被压成窄列).
+                     * 处置: 只落盘(与其它内部运行日志同一条路径/同一个 [运行] 标记), 屏上只留 transient 颜文字.
+                     * 去哪儿查: grep '[运行]' ~/.bolloon/logs/startup.log
+                     */
+                    appendInternalRunLog(`自动整理完成: ${boxLines.join(' | ')}`, 'organize-heartbeat');
                 }
             },
             onError: () => inkSetTransient(null),
@@ -887,35 +1480,11 @@ async function startCLI(commReady) {
     }
     catch { /* cron 调度启动失败不阻塞 CLI */ }
     // 启动会话面板 (大框): 栈式 = face 艺术字居中 + BOLLOON 字标 logo 在其下 + 预设信息(skills/工具/模型/目录/Session/分支/时间)
-    //   先立即渲染「艺术字 + logo + 正在加载...」, bootPanel 就绪后 inkReplaceMatchingLine 按标记原位替换为完整内容
-    //   (用匹配替换而非 replaceLast — P2P/连接消息可能先于 bootPanel 追加, replaceLast 会覆盖错一条)
-    const bootBox = buildBootBox(ROBOT_HEAD, BOLLOON_BANNER.split('\n'), [
-        `${bootDirShort}  ·  ${(cliModelName && cliModelName !== '…') ? cliModelName : ''}  ·  Session: ${bootSessionId}`,
-        '',
-        '⟳ 正在加载技能 / 工具...',
-    ]);
-    appendLine(bootBox);
-    // 2026-09-27 (leo 口径: `bolloon --cli` 起来直接就是面板, 启动前不刷前言):
-    //   就绪度报告 / 初始化续跑前言**默认不上屏** —— 但它们不是消失, 而是变成**面板里的行**:
-    //     · 就绪度折成一行 `就绪: basic ✓ · agent ✓ · durable ✗ · network ✓ · 详情: …`
-    //     · 失败 / 需人介入 (缺 key、连通性实测失败、初始化中断) 折成 `/!\` 开头的提示行 —— **不许吞**
-    //   注: 字面量里必须写 `\\ ` (反斜杠要转义), 否则 JS 会把 `\ ` 吃成空格 —— 屏上就变成 `/! ` 了
-    //   (验收门 `verify-cli-panel` 的 A4 按 `/!\` 判, 真踩过一次)。
-    //   全量版仍在 `startup.log`; `--verbose` / BOLLOON_VERBOSE=1 下逐字回到启动前的位置 (走 stderr)。
-    const notes = takeStartupPanelNotes();
-    const verbosePreamble = startupPreambleVisible();
-    if (notes.readiness && !verbosePreamble)
-        appendLine(`${C_DIM}${notes.readiness}${RESET}`);
-    for (const a of notes.alerts)
-        appendLine(`${C_WARN}/!\\ ${a}${RESET}`);
-    // 已经到面板了: 缓冲里剩下的纯前言**不上屏**(已在 startup.log), 丢掉引用免得下次启动重放
-    clearBufferedNotices();
-    // 面板第一帧之后: 晚到的降级提示 (后台 iroh / bootstrap / DID 发布…) 直接追加进面板,
-    //   不再等下一次 `takeStartupPanelNotes()` —— 否则它们会静静地烂在告警数组里 (= 吞)
-    startupPanelReady = true;
-    void bootPanel({ dir: bootDirShort, model: (cliModelName && cliModelName !== '…') ? cliModelName : undefined, session: bootSessionId })
-        .then((box) => { if (box)
-        inkReplaceMatchingLine(bootBox, box); }).catch(() => { });
+    //
+    // 2026-09-30 (leo: 「加载过程不渲染, 直接展示结果」): **不再先打「⟳ 正在加载技能 / 工具...」占位框再替换** ——
+    //   先把内容算完 (skills/tools 各有 2.5s 预算), 然后**一次性**把成品框打出来.
+    //   代价: 起来到出框之间屏幕是空的 (不给任何假的"加载中"画面); 好处: 屏上只会出现一份面板, 没有替换中间态.
+    // (面板已在上面一次性打出 —— 不再有占位框需要替换)
     // Wait on a promise that resolves on Ctrl+C / 双击 Esc
     // (ink-app 的 requestExit 调 __inkRequestExit → resolve, 清理后 process.exit)
     let cliExitResolve = () => { };
@@ -924,7 +1493,14 @@ async function startCLI(commReady) {
     await exitPromise;
     delete globalThis.__inkRequestExit;
     stopInk();
-    appendLine(`\n${CYAN}👋 再见！${RESET}`);
+    // 2026-09-30 (leo): 退出前**自动存档 session**, 存档结果先上屏, 最后才是「再见👋」
+    try {
+        const note = await archiveSessionOnExit(cliSessionKey);
+        if (note)
+            writeExitLine(note);
+    }
+    catch { /* 存档绝不阻塞退出 */ }
+    writeExitLine(`\n${CYAN}👋 再见！${RESET}`);
     try {
         cliOrganizeHeartbeat?.stop();
     }
@@ -948,6 +1524,7 @@ async function startCLI(commReady) {
  * scheduler 的每个 tick 会先查 resolveDnd(), 处于勿扰时把 due job 记 deferred 并留到下一轮.
  */
 async function processInput(input, comm) {
+    endBootPhase(); // 用户已接管 ⇒ 启动期结束(之后的输出照常上屏 ✓)
     const gate = globalThis.__bolloonMainTask;
     if (gate?.enterMainTask) {
         try {
@@ -1072,6 +1649,7 @@ async function processInputInner(input, comm) {
             await store.setActive(r.channel.id);
             cliAgentName = r.identity.name;
             cliActiveChannelId = r.channel.id;
+            setHistoryScope(r.channel.id);
             cliAgentId = r.channel.agentId || null; // 2026-08-12: memory 路径一致
             // 2026-08-09: 切 channel 必须重建 agent session — 否则身份/记忆停留在旧 channel (bug 修复)
             invalidateAgent();
@@ -1084,7 +1662,31 @@ async function processInputInner(input, comm) {
             const extra = prev && prev.name !== r.identity.name ? ` (从 ${prev.name} 切换)` : '';
             appendLine(`${C_ACCENT}→ 当前智能体: ${r.identity.name}${RESET}${extra}`);
             appendLine(`${C_DIM}  channel: ${r.channel.id}  [${r.match}]${RESET}`);
-            appendLine(`${C_DIM}  persona: ${r.channel.persona?.description || r.channel.persona?.personality || '无'}${RESET}`);
+            // 2026-10-01 (用户报「切换身份还没有成功」): 把**CLI 认为的身份**打进对话流 —— 之前用 console.warn,
+            //   在这套 TUI 里被吞掉, 用户从来看不到 ✗。切频道才一行, 不刷屏。
+            try {
+                const live = agent?.getIdentity?.() ?? null;
+                appendLine(`${C_DIM}  [identity] 频道身份=${r.identity.name} (did=${String(r.identity?.did ?? '(无)').slice(0, 26)})` +
+                    ` · agent 当前身份=${live?.name ?? '(读不到)'} (did=${String(live?.did ?? '(无)').slice(0, 26)})` +
+                    ` · agentId=${r.channel.agentId ?? '(无)'}${RESET}`);
+            }
+            catch { /* 自证失败不影响切换 */ }
+            // 2026-10-01: 这行原先读 channels.json 里**内联的 metadata** (你四条 channel 都空 ⇒ 恒打"无"),
+            //   而身份真源是 ~/.bolloon/persona/<agentId>/ 的 6 份文档 ⇒ 改读真源, 如实报"加载到几份"。
+            try {
+                const { loadPersonaDocs, PERSONA_DOC_FILES_HINT } = await import('./bootstrap/persona-loader.js').then(async (m) => ({ loadPersonaDocs: m.loadPersonaDocs, PERSONA_DOC_FILES_HINT: ['soul', 'identity', 'project', 'user', 'agent', 'wiki'] }));
+                const agentId = r.channel.agentId || '';
+                const docs = agentId ? await loadPersonaDocs(agentId) : null;
+                const loaded = docs ? PERSONA_DOC_FILES_HINT.filter((k) => String(docs[k] || '').trim().length > 0) : [];
+                appendLine(agentId
+                    ? (loaded.length
+                        ? `${C_DIM}  persona: ${loaded.length}/6 份身份文档 (${loaded.join(' · ')}) · agentId=${agentId}${RESET}`
+                        : `${C_DIM}  persona: 未初始化 (agentId=${agentId}, 目录 ${'~/.bolloon/persona/' + agentId}/ 为空 — 下次加载会自动生成起步模板)${RESET}`)
+                    : `${C_DIM}  persona: 该 channel 没有 agentId ⇒ 无法按 agent 加载身份文档${RESET}`);
+            }
+            catch {
+                appendLine(`${C_DIM}  persona: (读身份文档失败, 不影响本次切换)${RESET}`);
+            }
         }
         catch (e) {
             appendLine(`${C_ERROR}/channel 失败: ${String(e.message || e).slice(0, 200)}${RESET}`);
@@ -1166,7 +1768,7 @@ async function processInputInner(input, comm) {
                     });
                 }
                 await fs.writeFile(agentsPath, JSON.stringify(arr, null, 2), 'utf-8');
-                console.log(`[创建频道] agent 同步进 agents.json: ${agentId} → channel ${id}`);
+                writeOut(`[创建频道] agent 同步进 agents.json: ${agentId} → channel ${id}`);
             }
             catch { /* agents.json 写失败不阻塞创建 */ }
             // 刷新 store 缓存 (updateChannels 走了 server-storage, store 内存还是旧的)
@@ -1174,6 +1776,7 @@ async function processInputInner(input, comm) {
             await store.setActive(id);
             cliAgentName = name.trim();
             cliActiveChannelId = id;
+            setHistoryScope(id);
             cliAgentId = agentId; // 2026-08-12: memory 路径一致
             // 2026-08-09: 新建 agent 后立即重建 session — 否则新 agent 身份不加载 (bug 修复)
             invalidateAgent();
@@ -1257,6 +1860,19 @@ async function processInputInner(input, comm) {
     }
     // ==================== 2026-08-06: 系统命令组 (/model /now /ipfs /memory ...) ====================
     const cmd = trimmed.toLowerCase();
+    // 2026-09-30 (leo: 「/session 1 是切换到该 session，目前这个命令还没成功」「bolloon 把这个命令当成了 prompt」):
+    //   `cmd` 是**整行**小写 ⇒ '/session 1' ≠ '/session' ⇒ 带参数的命令掉进 prompt 路径 (被当用户消息发下去)。
+    //   不能全局改成"首词" —— 同文件里 `/email clear` 这类多词命令就是靠整行匹配的。
+    //   所以加一个**首词**给"带参数的命令"用 (cmd 保持原样给多词命令用)。
+    const cmdHead = cmd.split(/\s+/)[0];
+    // 2026-10-01: **未知命令兜底** —— 以 / 开头但不在白名单里的输入, 不当消息发下去 ✗
+    //   (用户实测: /group 不是命令 ⇒ 却发给模型, 白烧一轮工具调用)
+    if (cmd.startsWith('/') && !CLI_KNOWN_COMMAND_HEADS.has(cmdHead)) {
+        const near = [...CLI_KNOWN_COMMAND_HEADS].filter((h) => h.includes(cmdHead.slice(1)) || cmdHead.includes(h.slice(1))).slice(0, 6);
+        appendLine(`${C_WARN}未知命令 ${cmdHead}${RESET}${C_DIM} —— 输入${RESET} / ${C_DIM}看命令列表, 或 /help 看用法${RESET}`
+            + (near.length ? `${C_DIM} · 你是不是想用: ${near.join(' / ')}${RESET}` : ''));
+        return;
+    }
     // /net — Agent 网络快捷命令 (join/status/ctx, 2026-09-08)
     if (cmd === '/net' || cmd.startsWith('/net ')) {
         const arg = trimmed.slice(4).trim();
@@ -2173,17 +2789,190 @@ async function processInputInner(input, comm) {
         }
         return;
     }
-    // /session — 当前会话信息
-    if (cmd === '/session') {
+    // /session — 会话信息 + **最近会话列表**(用 /session <序号> 继续)
+    //   2026-09-30 (leo: 「/session 没有反应, 没有展示最新的记录, 无法选择继续」):
+    //   原来只打三行信息, 且整段被 `catch {}` **静默吞错** ⇒ getAgent 一抛错就"什么都没发生"。
+    //   现在: 错误如实说出来; 并列出最近会话(最新在上), 可直接选一个接着聊。
+    // /fork <#|id> — 从某条会话分叉出新会话 (标准 branch 语义: 共享 fork 点之前历史, 之后各自独立)
+    //   树用 git 管: ~/.bolloon/sessions/ 是仓库, 每次 fork / 退出存档 = 一次 commit (git log --graph 即会话树)
+    if (cmdHead === '/fork') {
+        const forkArg = trimmed.split(/\s+/)[1] || '';
+        if (!forkArg || forkArg === '--tree') {
+            try {
+                const { treeLog } = await import('./cli/session-tree.js');
+                const store = new SessionStore();
+                if (forkArg === '--tree') {
+                    const t = await treeLog(store, 12);
+                    appendLine(t.ok ? `${C_ACCENT}会话树 (最近 12 次提交):${RESET}\n${t.text.split('\n').map(l => `  ${C_DIM}${l}${RESET}`).join('\n')}` : `${C_WARN}⚠ 读会话树失败: ${t.error}${RESET}`);
+                }
+                else {
+                    appendLine(`${C_DIM}用法: ${RESET}${C_ACCENT}/fork <#|id>${RESET}${C_DIM} — 从某条会话分叉 (语义 = 共享 fork 点之前历史, 之后各自独立)${RESET}`);
+                    appendLine(`${C_DIM}      ${RESET}${C_ACCENT}/fork --tree${RESET}${C_DIM}    — 看会话树 (git log) · 序号见 /sessions${RESET}`);
+                }
+            }
+            catch (e) {
+                appendLine(`${C_WARN}⚠ ${String(e?.message || e).slice(0, 120)}${RESET}`);
+            }
+            return;
+        }
+        try {
+            const store = new SessionStore();
+            const list = await store.listRecent(12);
+            const idx = Number(forkArg);
+            const src = Number.isFinite(idx) && idx >= 1 ? list[idx - 1] : list.find(r => r.key === forkArg);
+            if (!src) {
+                appendLine(`${C_WARN}⚠ 没有第 ${forkArg} 个会话 —— 用 /sessions 列表里的 # 或完整 ID${RESET}`);
+                return;
+            }
+            const { forkSession } = await import('./cli/session-tree.js');
+            const r = await forkSession(store, src.key);
+            if (!r.ok || !r.newKey) {
+                appendLine(`${C_ERROR}/fork 失败: ${r.error || '未知原因'}${RESET}`);
+                return;
+            }
+            cliSessionKey = r.newKey; // 之后就在这条分支上继续 (独立)
+            let resumed = 0;
+            try {
+                const a = await getAgent();
+                if (typeof a.resumeSession === 'function')
+                    resumed = await a.resumeSession(r.newKey, 30);
+            }
+            catch { /* 载入失败不影响 fork 本身 */ }
+            // channel 的 currentSessionId 指到新分支 (与 /sessions <#> 同一套落盘口径)
+            try {
+                const { readFile, writeFile } = await import('fs/promises');
+                const { join } = await import('path');
+                const cp = join(process.env.HOME || '/tmp', '.bolloon', 'sessions', 'channels.json');
+                const parsed = JSON.parse(await readFile(cp, 'utf-8'));
+                const channels = Array.isArray(parsed) ? parsed : parsed?.channels || [];
+                for (const c of channels) {
+                    if (cliActiveChannelId && c.id === cliActiveChannelId)
+                        c.currentSessionId = r.newKey;
+                    else if (!cliActiveChannelId && c.id === channels[0]?.id)
+                        c.currentSessionId = r.newKey;
+                }
+                await writeFile(cp, JSON.stringify(Array.isArray(parsed) ? channels : { ...parsed, channels }, null, 2), 'utf-8');
+            }
+            catch { /* 无 channels.json 也能继续 */ }
+            appendLine(`${C_OK}✓ 已分叉${RESET} ${C_DIM}${r.newKey}${RESET} ← ${C_DIM}${src.key}${RESET} ${C_DIM}(继承 ${r.inherited} 条历史 · 已载入 ${resumed} 条 · 之后两条各自独立)${RESET}`);
+            appendLine(r.commit ? `  ${C_DIM}git: ${r.commit}${RESET}` : `  ${C_WARN}⚠ 树未记上: ${r.error}${RESET}`);
+        }
+        catch (e) {
+            appendLine(`${C_ERROR}/fork 失败: ${String(e?.message || e).slice(0, 200)}${RESET}`);
+        }
+        return;
+    }
+    if (cmdHead === '/session' || cmdHead === '/sessions') { // 带参数 (如 /session 1) 也认
+        const sessArg = trimmed.split(/\s+/)[1] || '';
+        const sessStore = new SessionStore();
         try {
             const a = await getAgent();
             const h = a.messageHistory ?? [];
-            appendLine(`${C_ACCENT}会话:${RESET}`);
-            appendLine(`  ${C_DIM}channel:${RESET} ${a.currentChannelId || '—'}`);
-            appendLine(`  ${C_DIM}agent:${RESET} ${a.currentAgentId || '—'}`);
-            appendLine(`  ${C_DIM}消息:${RESET} ${h.length} 条 (${h.length > 15 ? `${h.length - 15} 条已压缩` : '窗口内'})`);
+            appendLine(`${C_ACCENT}当前会话:${RESET} ${C_DIM}${cliSessionKey || '—'}${RESET}`);
+            appendLine(`  ${C_DIM}channel:${RESET} ${a.currentChannelId || cliActiveChannelId || '—'}  ${C_DIM}agent:${RESET} ${a.currentAgentId || cliAgentId || '—'}`);
+            appendLine(`  ${C_DIM}消息:${RESET} ${h.length} 条 ${h.length > 15 ? `${C_DIM}(${h.length - 15} 条已压缩)${RESET}` : ''}`);
+        }
+        catch (e) {
+            appendLine(`${C_WARN}⚠ 读当前会话失败: ${String(e?.message || e).slice(0, 120)}${RESET}`);
+        }
+        let recent = [];
+        try {
+            recent = await sessStore.listRecent(10);
+        }
+        catch (e) {
+            appendLine(`${C_WARN}⚠ 读会话目录失败: ${String(e?.message || e).slice(0, 120)}${RESET}`);
+        }
+        if (!recent.length) {
+            appendLine(`${C_DIM}没有可继续的历史会话 (${sessStore.dir})${RESET}`);
+        }
+        else {
+            // 2026-09-30 (leo: 「Title, Preview 要有内容, 使用 AI 来总结进去」):
+            //   缺标题的会话 (title == key) 现场用 AI 总结一次, 结果写回文件 metadata (只算一次)。
+            //   每次最多 3 条 (每条 12s 超时), 免得 /sessions 变成一次长跑; 失败的**如实标注**不编。
+            const need = recent.filter(r => r.title === r.key).slice(0, 3);
+            if (need.length) {
+                appendLine(`${C_DIM}正在用 AI 总结 ${need.length} 个会话的标题/摘要…${RESET}`);
+                try {
+                    const { summarizeSession } = await import('./cli/session-summary.js');
+                    for (const r of need) {
+                        const d = await summarizeSession(r.key, { store: sessStore });
+                        r.title = d.title;
+                        if (d.preview)
+                            r.preview = d.preview;
+                        r.summarySource = d.source;
+                    }
+                }
+                catch (e) {
+                    appendLine(`${C_WARN}⚠ AI 总结不可用 (标题保持会话 ID): ${String(e?.message || e).slice(0, 100)}${RESET}`);
+                }
+            }
+            // 表格 (leo 2026-09-30 指定格式): # / Title / Preview / Last Active / ID
+            //   列宽按终端宽动态分配 (先给 Preview 让位), 中文按**显示宽**对齐 (dispWidth)。
+            const relEn = (ms) => {
+                const age = Math.max(0, Date.now() - ms);
+                if (age < 60_000)
+                    return 'just now';
+                if (age < 3_600_000)
+                    return `${Math.floor(age / 60_000)}m ago`;
+                if (age < 86_400_000)
+                    return `${Math.floor(age / 3_600_000)}h ago`;
+                return `${Math.floor(age / 86_400_000)}d ago`;
+            };
+            const PAD = (v, w) => v + ' '.repeat(Math.max(0, w - dispWidth(v)));
+            const avail = Math.max(60, termWidth() - 2);
+            const wN = 3, wTitle = 32, wAgo = 13, wId = 24;
+            const wPrev = Math.max(12, Math.min(40, avail - (wN + wTitle + wAgo + wId + 4)));
+            const hdr = [PAD('#', wN), PAD('Title', wTitle), PAD('Preview', wPrev), PAD('Last Active', wAgo), PAD('ID', wId)];
+            const rule = [wN, wTitle, wPrev, wAgo, wId].map(w => '─'.repeat(w));
+            appendLine(`${C_ACCENT}Recent sessions:${RESET}`);
+            appendLine('');
+            appendLine(`  ${C_DIM}${hdr.join(' ')}${RESET}`);
+            appendLine(`  ${C_DIM}${rule.join(' ')}${RESET}`);
+            recent.forEach((r, i) => {
+                const cur = r.key === cliSessionKey ? ` ${C_OK}←当前${RESET}` : '';
+                appendLine(`  ${C_ACCENT}${PAD(String(i + 1), wN)}${RESET} ${PAD(truncate(r.title, wTitle), wTitle)} ${C_DIM}${PAD(truncate(r.preview || '—', wPrev), wPrev)}${RESET} ${PAD(relEn(r.mtimeMs), wAgo)} ${C_DIM}${PAD(truncate(r.key, wId), wId)}${RESET}${cur}`);
+            });
+            appendLine('');
+            appendLine(`  ${C_DIM}继续某个会话: ${C_ACCENT}/sessions <#>${C_DIM} (例如 /sessions 1)${RESET}`);
+        }
+        if (sessArg) {
+            const idx = Number(sessArg);
+            const pick = Number.isFinite(idx) && idx >= 1 ? recent[idx - 1] : recent.find(r => r.key === sessArg);
+            if (!pick) {
+                appendLine(`${C_WARN}⚠ 没有第 ${sessArg} 个会话 —— 用上面列表的 # 或完整 ID${RESET}`);
+                return;
+            }
+            try {
+                const a = await getAgent();
+                const n = typeof a.resumeSession === 'function' ? await a.resumeSession(pick.key, 30) : 0;
+                cliSessionKey = pick.key; // 之后退出存档也写回这个会话
+                let saved = false;
+                try {
+                    const { readFile, writeFile } = await import('fs/promises');
+                    const { join } = await import('path');
+                    const cp = join(process.env.HOME || '/tmp', '.bolloon', 'sessions', 'channels.json');
+                    const parsed = JSON.parse(await readFile(cp, 'utf-8'));
+                    const channels = Array.isArray(parsed) ? parsed : parsed?.channels || [];
+                    for (const c of channels) {
+                        if (cliActiveChannelId && c.id === cliActiveChannelId) {
+                            c.currentSessionId = pick.key;
+                            saved = true;
+                        }
+                        else if (!cliActiveChannelId && c.id === channels[0]?.id) {
+                            c.currentSessionId = pick.key;
+                            saved = true;
+                        }
+                    }
+                    await writeFile(cp, JSON.stringify(Array.isArray(parsed) ? channels : { ...parsed, channels }, null, 2), 'utf-8');
+                }
+                catch { /* 无 channels.json 也能继续 */ }
+                await refreshSessionTitle(pick.key); // 切完立刻把这条会话的标题带上 (leo 2026-09-30)
+                appendLine(`${C_OK}✓ 已切到会话 ${pick.key}${RESET} ${C_DIM}(载入 ${n} 条历史${saved ? ' · 已写入 channel' : ''}; 屏上不重放旧消息, 直接接着聊)${RESET}`);
+            }
+            catch (e) {
+                appendLine(`${C_ERROR}/session ${sessArg} 失败: ${String(e?.message || e).slice(0, 200)}${RESET}`);
+            }
         }
-        catch { /* 静默 */ }
         return;
     }
     // /memory — 记忆摘要 (memory-compressor 落盘文件)
@@ -2307,7 +3096,7 @@ async function processInputInner(input, comm) {
         return;
     }
     // /todo — 循环过程工具: 查看/勾选步骤 (2026-08-08)
-    if (cmd === '/todo') {
+    if (cmdHead === '/todo') {
         try {
             const { listActivePlans } = await import('./agents/plan-store.js');
             const plans = await listActivePlans();
@@ -2670,24 +3459,142 @@ async function processInputInner(input, comm) {
         return;
     }
     // /wallet — 钱包状态
-    if (cmd === '/wallet') {
+    // /wallet — 钱包台账 (2026-09-30 做实: 以前只读一个**从来没人写过**的 wallets.json ⇒ 永远「钱包 (0)」)
+    //   纪律: 私钥/助记词只落 0600 台账 (~/.bolloon/wallets.json), **命令输出永不回显**;
+    //        不读别的 agent 的钱包目录 (chain-config.ts 硬规则), 要收编只能 /wallet import <path> 显式指定。
+    if (cmdHead === '/wallet') {
         try {
-            const { readFile } = await import('fs/promises');
-            const { join } = await import('path');
-            let wallets = [];
-            try {
-                wallets = JSON.parse(await readFile(join(process.env.HOME || '/tmp', '.bolloon', 'wallets.json'), 'utf-8'));
+            const { loadWallets, addWallet, walletsDir, shortAddr } = await import('./cli/wallet-store.js');
+            const arg = trimmed.split(/\s+/).slice(1);
+            const sub = (arg[0] || '').toLowerCase();
+            const list = await loadWallets();
+            const pick = (spec) => {
+                const n = Number(spec);
+                if (spec && Number.isFinite(n) && n >= 1)
+                    return list[n - 1];
+                if (spec?.startsWith('0x'))
+                    return list.find(w => w.address.toLowerCase() === spec.toLowerCase());
+                return list.find(w => w.name === spec);
+            };
+            if (!sub) {
+                // 表格 (leo 2026-09-30: 「钱包格式也统一一个表格」) —— 与 /sessions 同一套 idiom:
+                //   列宽按终端宽动态分配, 中文按**显示宽**对齐 (PAD/dispWidth), 宽不够就让 Name 先窄。
+                //   地址优先给满 42 字符 (能直接复制); 列宽不足时退回缩写 (0x1234…abcd), 不截半截地址。
+                appendLine(`${C_ACCENT}钱包 (${list.length}):${RESET}`);
+                if (!list.length) {
+                    appendLine('');
+                    appendLine(`  ${C_DIM}无 — 用 ${RESET}${C_ACCENT}/wallet new [名字]${RESET}${C_DIM} 生成一个 EVM 钱包${RESET}`);
+                }
+                else {
+                    // 表格渲染抽到 src/cli/wallet-table.ts (纯函数 ⇒ 可确定性验证对齐, 不用靠 PTY 抓包)
+                    const { renderWalletTable } = await import('./cli/wallet-table.js');
+                    const rows = renderWalletTable(list, { width: termWidth(), shortAddr });
+                    appendLine('');
+                    rows.forEach((r, k) => {
+                        appendLine(k < 2 ? `  ${C_DIM}${r}${RESET}` : `  ${C_TEXT}${r}${RESET}`);
+                    });
+                }
+                appendLine('');
+                appendLine(`  ${C_DIM}台账目录: ${walletsDir()}/ (一钱包一文件 · 0600 · 私钥不回显)${RESET}`);
+                appendLine(`  ${C_DIM}用法: ${RESET}${C_ACCENT}/wallet new [名字]${RESET}${C_DIM} · ${RESET}${C_ACCENT}/wallet import <文件路径> [名字]${RESET}${C_DIM} · ${RESET}${C_ACCENT}/wallet show <#|地址>${RESET}${C_DIM} · ${RESET}${C_ACCENT}/wallet bal <#|地址>${RESET}`);
+                return;
             }
-            catch { /* 无 */ }
-            appendLine(`${C_ACCENT}钱包 (${Array.isArray(wallets) ? wallets.length : 0}):${RESET}`);
-            if (!Array.isArray(wallets) || wallets.length === 0) {
-                appendLine(`  ${C_DIM}无 — 可用 wallet_create 工具创建 EVM 钱包${RESET}`);
+            if (sub === 'new') {
+                const name = arg[1] || `wallet-${new Date().toISOString().slice(0, 10)}`;
+                const mod = await loadWalletTool('createWallet');
+                if (!mod?.createWallet) {
+                    appendLine(`${C_ERROR}/wallet new 失败: 找不到 createWallet 实现${RESET}`);
+                    return;
+                }
+                const r = await mod.createWallet();
+                const { rec, replaced } = await addWallet({
+                    name, address: r.address, network: '—', source: 'created',
+                    createdAt: r.createdAt || new Date().toISOString(), privateKey: r.privateKey, mnemonic: r.mnemonic,
+                });
+                appendLine(`${C_OK}✓ 钱包${replaced ? '已在台账 (补齐信息)' : '已创建'}${RESET} ${C_ACCENT}${rec.name}${RESET}`);
+                appendLine(`  ${C_DIM}地址:${RESET} ${rec.address}`);
+                appendLine(`  ${C_DIM}私钥/助记词: 已写入 ${walletsDir()}/${rec.name}.json (0600) — 不回显, 需要时自己打开看${RESET}`);
+                return;
+            }
+            if (sub === 'import') {
+                const src = arg[1];
+                if (!src) {
+                    appendLine(`${C_WARN}用法: /wallet import <文件路径> [名字] — 路径必须你显式给出 (不扫别的 agent 目录)${RESET}`);
+                    return;
+                }
+                let raw;
+                try {
+                    raw = JSON.parse(await (await import('fs/promises')).readFile(src.replace(/^~/, process.env.HOME || ''), 'utf-8'));
+                }
+                catch (err) {
+                    appendLine(`${C_ERROR}读不了 ${src}: ${String(err?.message || err).slice(0, 100)}${RESET}`);
+                    return;
+                }
+                const pk = raw?.privateKey || raw?.private_key;
+                const mn = raw?.mnemonic || raw?.phrase;
+                if (!pk && !mn) {
+                    appendLine(`${C_ERROR}文件里没有 privateKey / mnemonic — 不收${RESET}`);
+                    return;
+                }
+                let addr = raw?.address;
+                if (!addr && pk) {
+                    const mod = await loadWalletTool('importWallet');
+                    try {
+                        const r = await mod.importWallet({ privateKey: pk, mnemonic: mn });
+                        addr = r.address;
+                    }
+                    catch { /* 下面照实报 */ }
+                }
+                if (!addr) {
+                    appendLine(`${C_ERROR}拿不到地址 — 文件里没有 address 且无法从私钥推导${RESET}`);
+                    return;
+                }
+                const { rec, replaced } = await addWallet({
+                    name: arg[2] || String(src).split('/').pop().replace(/\.json$/, ''), address: addr,
+                    network: raw?.network || '—', source: 'imported', createdAt: new Date().toISOString(), privateKey: pk, mnemonic: mn,
+                });
+                appendLine(`${C_OK}✓ 已收编${RESET} ${C_ACCENT}${rec.name}${RESET}${replaced ? ` ${C_DIM}(同地址已在台账, 已合并)${RESET}` : ''}`);
+                appendLine(`  ${C_DIM}地址:${RESET} ${rec.address} ${C_DIM}(私钥只进 0600 台账, 不回显)${RESET}`);
+                return;
             }
-            for (const w of (Array.isArray(wallets) ? wallets : []).slice(0, 5)) {
-                appendLine(`  ${C_DIM}·${RESET} ${w.name || w.address?.slice(0, 12) || '?'} ${C_DIM}${String(w.address || '').slice(0, 16)}...${RESET}`);
+            if (sub === 'show') {
+                const w = pick(arg[1] || '1');
+                if (!w) {
+                    appendLine(`${C_WARN}没有这个钱包 — /wallet 看列表${RESET}`);
+                    return;
+                }
+                appendLine(`${C_ACCENT}${w.name}${RESET}`);
+                appendLine(`  ${C_DIM}地址:${RESET} ${w.address}`);
+                appendLine(`  ${C_DIM}网络:${RESET} ${w.network || '—'} ${C_DIM}· 来源:${RESET} ${w.source === 'imported' ? '导入' : '生成'} ${C_DIM}· 建立:${RESET} ${String(w.createdAt).slice(0, 19).replace('T', ' ')}`);
+                appendLine(`  ${C_DIM}密钥:${RESET} ${w.privateKey || w.mnemonic ? '已存 (只在本机 0600 文件里)' : '未存 (只有地址)'}`);
+                return;
+            }
+            if (sub === 'bal' || sub === 'balance') {
+                const w = pick(arg[1] || '1');
+                if (!w) {
+                    appendLine(`${C_WARN}没有这个钱包 — /wallet 看列表${RESET}`);
+                    return;
+                }
+                const mod = await loadWalletTool('getBalance');
+                if (!mod?.getBalance) {
+                    appendLine(`${C_ERROR}找不到 getBalance 实现${RESET}`);
+                    return;
+                }
+                appendLine(`${C_DIM}查询中… ${shortAddr(w.address)}${RESET}`);
+                try {
+                    const r = await mod.getBalance({ address: w.address, rpcUrl: arg[2] });
+                    appendLine(`${C_OK}💰${RESET} ${w.name} ${C_DIM}${r.address || w.address}${RESET} ${C_ACCENT}${r.balanceEth} ${r.symbol || 'ETH'}${RESET} ${C_DIM}(${r.balance} wei)${RESET}`);
+                }
+                catch (err) {
+                    appendLine(`${C_ERROR}查余额失败: ${String(err?.message || err).slice(0, 140)}${RESET}`);
+                }
+                return;
             }
+            appendLine(`${C_WARN}未知子命令 ${sub} — 用法: /wallet [new|import|show|bal]${RESET}`);
+        }
+        catch (e) {
+            appendLine(`${C_ERROR}/wallet 失败: ${String(e?.message || e).slice(0, 200)}${RESET}`);
         }
-        catch { /* 静默 */ }
         return;
     }
     // /email — 邮件配置管理; /email <host:port:user:from> 设置 / /email clear 清除 (2026-08-08)
@@ -2923,6 +3830,153 @@ async function processInputInner(input, comm) {
         }
         return;
     }
+    // 「当前群」的取用: 没选过时, 只有恰好一个群就自动用它; 否则提示先 /group use
+    const ensureCurrentGroup = async (gg) => {
+        if (currentGroupId)
+            return currentGroupId;
+        const gs = await gg.listGroups();
+        if (gs.length === 1) {
+            currentGroupId = gs[0].id;
+            return currentGroupId;
+        }
+        if (!gs.length) {
+            appendLine(`${C_DIM}本地还没有群 —— 用 /group new <名字> 建一个${RESET}`);
+            return undefined;
+        }
+        appendLine(`${C_DIM}本地有 ${gs.length} 个群, 先 /group use <名字|id> 选一个${RESET}`);
+        return undefined;
+    };
+    // /group — OrbitDB 群聊 (2026-10-01; 接 gateway-group 那套: 建群/加入/收发/成员/日志)
+    if (cmd === '/group' || cmd.startsWith('/group ')) {
+        const { sub, arg } = parseGroupSub(trimmed);
+        const gg = await import('./agents/gateway-group.js');
+        const dim = (t) => appendLine(`${C_DIM}${t}${RESET}`);
+        try {
+            if (sub === 'help') {
+                appendLine(`${C_ACCENT}/group${RESET} —— OrbitDB 群聊`);
+                dim('  /group                    列出本地群');
+                dim('  /group new <名字>          建群 (默认创建者独占写; 会打印可分享地址)');
+                dim('  /group join <链接|地址>     加入');
+                dim('  /group leave <名字|id>     退出');
+                dim('  /group use <名字|id>       选定当前群 (之后 send/log/members 都指它)');
+                dim('  /group send <文本>         往当前群发一条');
+                dim('  /group log [N]             看当前群最近 N 条 (默认 10)');
+                dim('  /group members             列当前群成员');
+                return;
+            }
+            if (sub === 'list') {
+                const gs = await gg.listGroups();
+                if (!gs.length) {
+                    dim('本地还没有群 —— 用 /group new <名字> 建一个');
+                    return;
+                }
+                const rows = [];
+                gs.forEach((g, i) => {
+                    const cur = currentGroupId === g.id ? '●' : '○';
+                    const n = String(i + 1).padStart(2, ' ');
+                    rows.push(`${n}. ${cur} ${g.name}  ${String(g.id).slice(0, 18)}…`);
+                });
+                rows.push('');
+                rows.push('选中进群: /group <序号>   (或 /group use <名字|id>)');
+                appendLine(renderMessageBox({ title: 'OrbitDB 群', body: rows.join('\n'), color: C_ACCENT, maxLines: 24 }));
+                return;
+            }
+            if (sub === 'new') {
+                const r = await gg.createGroup(arg || '');
+                if (!r.ok) {
+                    appendLine(`${C_WARN}建群失败: ${r.error}${RESET}`);
+                    return;
+                }
+                currentGroupId = r.group?.id || currentGroupId;
+                appendLine(renderMessageBox({ title: '✅ 群已建立', body: `名字: ${r.group?.name || arg}\nid: ${r.group?.id || '-'}\n地址: ${r.group?.link || r.group?.address || '(未返回地址)'}\n\n把地址发给同伴, 用 /group join <地址> 加入`, color: C_ACCENT, maxLines: 12 }));
+                return;
+            }
+            if (sub === 'join') {
+                if (!arg) {
+                    dim('用法: /group join <链接|地址>');
+                    return;
+                }
+                const r = await gg.joinGroup(arg);
+                if (!r.ok) {
+                    appendLine(`${C_WARN}加入失败: ${r.error}${RESET}`);
+                    return;
+                }
+                currentGroupId = r.group?.id || currentGroupId;
+                appendLine(`${C_ACCENT}✓ 已加入 ${r.group?.name || arg}${RESET}`);
+                return;
+            }
+            if (sub === 'leave') {
+                if (!arg) {
+                    dim('用法: /group leave <名字|id>');
+                    return;
+                }
+                const r = await gg.leaveGroup(arg);
+                appendLine(r.ok ? `${C_ACCENT}✓ 已退出 ${r.removed || arg}${RESET}` : `${C_WARN}退出失败: ${r.error}${RESET}`);
+                if (r.ok && currentGroupId === arg)
+                    currentGroupId = undefined;
+                return;
+            }
+            if (sub === 'use') {
+                if (!arg) {
+                    dim('用法: /group use <名字|id>');
+                    return;
+                }
+                const gs = await gg.listGroups();
+                // 序号 (与 /group 列表里的编号一致) → 名字 → id → 名字子串
+                let hit = /^\d+$/.test(arg) ? gs[parseInt(arg, 10) - 1] : undefined;
+                if (!hit)
+                    hit = gs.find((g) => g.id === arg || g.name === arg) || gs.find((g) => String(g.name).includes(arg));
+                if (!hit) {
+                    appendLine(`${C_WARN}没找到群: ${arg}${RESET}${C_DIM} —— 先 /group 看编号${RESET}`);
+                    return;
+                }
+                currentGroupId = hit.id;
+                appendLine(`${C_ACCENT}✓ 当前群: ${hit.name} (${String(hit.id).slice(0, 18)}…)${RESET}${C_DIM}  现在可以 /group send <文本> 或 /group log${RESET}`);
+                return;
+            }
+            if (sub === 'send') {
+                if (!arg) {
+                    dim('用法: /group send <文本>');
+                    return;
+                }
+                const gid = await ensureCurrentGroup(gg);
+                if (!gid)
+                    return;
+                const r = await gg.groupSend(gid, arg, String(agentIdentity?.did || 'cli')).catch((e) => ({ ok: false, error: String(e?.message || e) }));
+                appendLine(r.ok === false ? `${C_WARN}发送失败: ${r.error}${RESET}` : `${C_ACCENT}✓ 已发到群${RESET}`);
+                return;
+            }
+            if (sub === 'log') {
+                const gid = await ensureCurrentGroup(gg);
+                if (!gid)
+                    return;
+                const n = Math.max(1, Math.min(100, parseInt(arg || '10', 10) || 10));
+                const msgs = await gg.groupMessages(gid, n);
+                if (!msgs.length) {
+                    dim('这个群还没有消息');
+                    return;
+                }
+                appendLine(renderMessageBox({ title: `群消息 (最近 ${msgs.length})`, body: msgs.map((m) => `${m.from ? String(m.from).slice(0, 10) : '?'}: ${String(m.text || '').slice(0, 200)}`).join('\n'), color: C_ACCENT, maxLines: 24 }));
+                return;
+            }
+            if (sub === 'members') {
+                const gid = await ensureCurrentGroup(gg);
+                if (!gid)
+                    return;
+                const ms = await gg.groupMembers(gid);
+                dim(ms.length ? ms.join('\n') : '(暂无成员记录)');
+                return;
+            }
+            dim('用法: /group help');
+        }
+        catch (e) {
+            // GroupStoreUnreachableError 等: 说清"本地群存储没起来", 不要笼统报错
+            const msg = String(e?.message || e);
+            const unreachable = e?.name === 'GroupStoreUnreachableError' || /unreachable|not open|未就绪/i.test(msg);
+            appendLine(`${C_WARN}${unreachable ? '本地群存储未就绪 —— 需要本机服务/OrbitDB 起来后才行' : '群操作失败'}: ${msg}${RESET}`);
+        }
+        return;
+    }
     if (trimmed.toLowerCase() === '/help' || trimmed === 'help') {
         appendLine(`${C_DIM}命令:${RESET}`);
         appendLine(`  ${C_ACCENT}!<cmd>${RESET}  执行终端命令  ${C_DIM}如 !ls -la${RESET}`);
@@ -2980,6 +4034,13 @@ async function processInputInner(input, comm) {
         return;
     }
     if (trimmed === '退出' || trimmed === 'exit' || trimmed === 'quit') {
+        // 同一条退出纪律: 先存档, 再告别 (幂等 —— 与 Ctrl+C 路径共用)
+        try {
+            const note = await archiveSessionOnExit(cliSessionKey);
+            if (note)
+                appendLine(note);
+        }
+        catch { /* 非致命 */ }
         appendLine(`\n${CYAN}👋 再见！${RESET}`);
         isRunning = false;
         return;
@@ -3047,12 +4108,27 @@ async function processInputInner(input, comm) {
         const a = await getAgent();
         const boxW = Math.min(termWidth() - 2, 76);
         // 工具调用显示由 tui-shell 的 onStream handler 处理
+        cliTurnStartedAt = Date.now();
+        cliTurnReplyBytes = 0;
+        cliTurnToolCount = 0;
         const response = await a.prompt(trimmed, {
             onStream: (e) => {
                 // 2026-08-07: 中间思考/状态显示 — 之前只显示工具步骤, LLM 的思考过程
                 //   (thinking / status / phase / Reflection) 全被丢弃 → 用户只能看到输入和最终输出
                 // 用户偏好 (2026-08-07): 思考过程 = 圆角框渲染 (和回复同路径 renderMessageBox),
                 //   颜文字动画 (inkSetThinking) 只表示"正在运行", 不承载思考内容
+                // 2026-10-01: 思考记录 (模型的思维链) —— 暗色块 + 明确标注"未验证", 与正式回答分开 ✓
+                if (e.type === 'reasoning' && e.content) {
+                    // 2026-10-01 (用户: 「我要的是那种**短的**思考, 长思维链可以不显示」): 默认只显示**一句**"在想什么";
+                    //   想看全链 ⇒ BOLLOON_SHOW_THINKING=full; 不想看 ⇒ =0。
+                    const r = renderReasoning(String(e.content));
+                    if (r.text) {
+                        if (r.mode === 'short')
+                            appendLine(`${C_DIM}💭 ${r.text}${RESET}`);
+                        else
+                            appendLine(renderMessageBox({ title: '💭 思考 (未验证)', body: r.text, color: C_DIM, maxLines: 16 }));
+                    }
+                }
                 if (e.type === 'thinking' && e.content) {
                     // thinking 事件只有 "🤔 开始思考..." 占位 → 不 appendLine, 运行过程由动画表示;
                     //   真正思考内容在 status 的 Reflection/💡 事件 → 下方框渲染
@@ -3079,7 +4155,10 @@ async function processInputInner(input, comm) {
                     // Reflection / 反思 / 💡 → 圆角思考框 (和回复一样走 renderMessageBox, 白字+亮边框)
                     else if (content.includes('Reflection') || content.includes('反思') || content.includes('💡')) {
                         const body = content.replace(/^💡\s*/, '').slice(0, 1500);
-                        if (body.trim())
+                        // 2026-10-01: 只有标记词 (Reflection: / 反思 / 💡) 而无正文 ⇒ **不渲染**, 免得出空框 ✗
+                        const plain = body.replace(/\x1b\[[0-9;]*m/g, '').trim(); // 2026-10-01: 先剥 ANSI —— 只有彩色控制符的正文看着就是**空框** ✗
+                        const onlyMarker = /^(?:reflection|反思)\s*[:：\-—]?\s*$/i.test(plain);
+                        if (plain && !onlyMarker)
                             appendLine(renderMessageBox({ title: '💡 反思', body, color: C_WARN }));
                     }
                     else if (!content.includes('🔄 循环') && !content.includes('📋 参数')
@@ -3095,11 +4174,14 @@ async function processInputInner(input, comm) {
                     tuiToolCounter++;
                     const toolName = e.tool || '?';
                     tuiToolCalls.push({ tool: toolName, args: e.args, _t: Date.now() });
+                    cliTurnToolCount = tuiToolCalls.filter(c => c.tool !== 'system' && c.tool !== 'loop' && c.tool !== '?').length; // ⚙ 启动即算
                     // 2026-08-12 (TaskA): 工具命中要干净 — step_start 不 appendLine 到消息流 (避免重复),
                     //   改用 transient 行显示"正在执行"(消息流只在 done 时出现一次完成行).
                     if (toolName !== 'system' && toolName !== 'loop' && toolName !== '?') {
                         const activeNames = tuiToolCalls.map(c => c.tool).filter(t => t !== 'system' && t !== 'loop' && t !== '?');
-                        const label = activeNames.length > 1 ? `执行 ${activeNames.length} 个工具: ${activeNames.join(', ')}` : `🔧 ${toolName}`;
+                        const label = activeNames.length > 1
+                            ? `执行 ${activeNames.length} 个工具: ${activeNames.join(', ')}`
+                            : `🔧 ${traceLabel(toolName)}`; // trace 执行描述: 写清这一步在做什么
                         inkSetTransient(`${C_DIM}${label} 运行中...${RESET}`);
                     }
                 }
@@ -3127,8 +4209,9 @@ async function processInputInner(input, comm) {
                     }
                     // 更新 transient: 还有进行中的工具 → 显示下一个; 否则清空 (交回 thinking 动画)
                     const remaining = tuiToolCalls.filter(c => c.tool !== 'system' && c.tool !== 'loop' && c.tool !== '?');
+                    cliTurnToolCount = remaining.length; // ⚙ 状态栏用 (模块级)
                     if (remaining.length > 0) {
-                        const label = remaining.length > 1 ? `执行 ${remaining.length} 个工具: ${remaining.map(c => c.tool).join(', ')}` : `🔧 ${remaining[0].tool}`;
+                        const label = remaining.length > 1 ? `执行 ${remaining.length} 个工具: ${remaining.map(c => c.tool).join(', ')}` : `🔧 ${traceLabel(remaining[0].tool)}`; // trace 执行描述
                         inkSetTransient(`${C_DIM}${label} 运行中...${RESET}`);
                     }
                     else {
@@ -3139,6 +4222,59 @@ async function processInputInner(input, comm) {
         });
         // 智能体回复框
         appendLine(renderAgentMessage(response));
+        try {
+            cliLastTurnMs = cliTurnStartedAt ? Date.now() - cliTurnStartedAt : 0;
+            cliTurnReplyBytes = String(response ?? '').length;
+            cliTurnStartedAt = 0;
+            cliTurnToolCount = 0;
+        }
+        catch { /* 结算失败不影响回复 */ }
+        // 2026-09-30 (leo: 「session 的 Preview 在对话框工具栏右侧做显示」):
+        //   回合结束后**后台**给这条会话生成一次标题/摘要 (600ms 级, 失败不打扰), 生成后工具栏右侧就有内容;
+        //   顺带把 metadata 写盘 ⇒ 这段会话在 /sessions 里也立刻有 Title/Preview。
+        if (cliSessionKey && !cliSessionPreview && !cliSessionSummarizing) {
+            cliSessionSummarizing = true;
+            const keyForNote = cliSessionKey;
+            setImmediate(async () => {
+                try {
+                    const { summarizeSession } = await import('./cli/session-summary.js');
+                    const store = new SessionStore();
+                    // 先存档! 2026-09-30 诊断日志挖出的根因: 回合结束时**会话还没落盘**
+                    //   (CLI 只在退出时存档) ⇒ 总结器看到的文件里没有用户那句话 ⇒ source=none ⇒ 永远没标题
+                    //   (屏幕上因此看不到 ▸; 退出后才出现, 因为那次存档把消息写进去了)。
+                    try {
+                        await agent?.saveCurrentSession?.(keyForNote);
+                    }
+                    catch { /* 存不下也继续试总结 */ }
+                    const d = await summarizeSession(keyForNote, { store });
+                    // 2026-09-30 (leo: 「Title 放在右侧吧，不要摘要了」): 右侧显示的是**标题** (≤20 字, 比摘要短得多);
+                    //   优先用调用的返回值, 取不到再回读文件 (标题可能由退出存档/别的进程写进去)。
+                    let note = String(d?.title && d.title !== keyForNote ? d.title : '').trim();
+                    if (!note) {
+                        try {
+                            const fs = await import('fs/promises');
+                            const raw = JSON.parse(await fs.readFile(store.pathFor(keyForNote), 'utf-8'));
+                            const md = (Array.isArray(raw) ? {} : raw?.metadata) || {};
+                            note = String(md.title || '').trim();
+                        }
+                        catch { /* 回读失败就用返回值 */ }
+                    }
+                    if (note && note !== keyForNote) {
+                        cliSessionPreview = note.slice(0, 24);
+                        inkSetStatus(getStatus());
+                        console.error(`[session-note] 已更新: ${note.slice(0, 24)}`);
+                    }
+                    else
+                        console.error(`[session-note] 没拿到标题 (source=${d?.source}, key=${keyForNote})`);
+                }
+                catch (e) {
+                    console.error(`[session-note] 失败: ${String(e?.message || e).slice(0, 120)}`);
+                }
+                finally {
+                    cliSessionSummarizing = false;
+                }
+            });
+        }
         // 停止思考动画
         inkSetThinking(false);
         // 2026-08-04: run-end 经验整理 — 连续成功工具 ≥2 自动写 skill 候选
@@ -3213,7 +4349,7 @@ async function processInputInner(input, comm) {
                 maxTokens: usage.maxTokens,
                 stage: usage.stage,
             };
-            const statusText = `${C_ACCENT}${cliModelName}${RESET}${C_DIM}  │${RESET} ${cliAgentName} ${C_DIM}│${RESET} ⏱ ${fmtDuration(Date.now() - cliStartTime)}${C_DIM} │${RESET} ${buildContextBar(usageView)}`;
+            const statusText = `${C_ACCENT}${statusModelName()}${RESET}${C_DIM}  │${RESET} ${cliAgentName} ${C_DIM}│${RESET} ⏱ ${fmtDuration(Date.now() - cliStartTime)}${C_DIM} │${RESET} ${buildContextBar(usageView)}`;
             inkSetStatus(statusText);
         }
         catch { /* 降级容忍 */ }
@@ -4177,18 +5313,18 @@ goalFlag) {
             error,
             metadata
         };
-        console.log(JSON.stringify(result, null, 2));
+        writeOut(JSON.stringify(result, null, 2));
     }
     else {
         if (error) {
             s.divider();
-            console.log(`${MAGENTA}${error}${RESET}\n`);
+            writeOut(`${MAGENTA}${error}${RESET}\n`);
         }
         else {
             s.divider();
-            console.log(`${response}\n`);
+            writeOut(`${response}\n`);
         }
-        console.log(`${GRAY}耗时: ${metadata.duration}ms${RESET}`);
+        writeOut(`${GRAY}耗时: ${metadata.duration}ms${RESET}`);
     }
 }
 async function runNonInteractive(args, comm) {
@@ -4204,11 +5340,11 @@ async function runNonInteractive(args, comm) {
         }
         else if (prompt) {
             const a = await getAgent();
-            console.log(await a.prompt(prompt));
+            writeOut(await a.prompt(prompt));
         }
         console.log = originalLog;
         await fs.writeFile(output, outputBuffer.trim(), 'utf-8');
-        console.log(`✅ 结果已保存到: ${output}`);
+        writeOut(`✅ 结果已保存到: ${output}`);
         return;
     }
     if (tool === 'prompt' && prompt) {
@@ -4220,20 +5356,20 @@ async function runNonInteractive(args, comm) {
             const response = await a.prompt(prompt);
             const elapsed = Date.now() - startTime;
             if (json) {
-                console.log(JSON.stringify({ success: true, response, elapsedMs: elapsed }, null, 2));
+                writeOut(JSON.stringify({ success: true, response, elapsedMs: elapsed }, null, 2));
             }
             else {
-                console.log(response);
-                console.log(`\n耗时: ${elapsed}ms`);
+                writeOut(response);
+                writeOut(`\n耗时: ${elapsed}ms`);
             }
         }
         catch (e) {
             const error = e?.message || String(e);
             if (json) {
-                console.log(JSON.stringify({ success: false, error }, null, 2));
+                writeOut(JSON.stringify({ success: false, error }, null, 2));
             }
             else {
-                console.log(`\n错误: ${error}`);
+                writeOut(`\n错误: ${error}`);
             }
             process.exit(1);
         }
@@ -4261,10 +5397,10 @@ async function runNonInteractive(args, comm) {
                 error: response.startsWith('错误:') ? response : undefined,
                 metadata: { duration, peers }
             };
-            console.log(JSON.stringify(result, null, 2));
+            writeOut(JSON.stringify(result, null, 2));
         }
         else {
-            console.log(response);
+            writeOut(response);
         }
     }
 }
@@ -4582,7 +5718,7 @@ function parseArgs() {
     return result;
 }
 function printHelp() {
-    console.log(`
+    writeOut(`
 🤖 Bolloon Agent - AI 可调用文档处理智能体
 
 用法:
@@ -4810,21 +5946,21 @@ async function main() {
             const res = await runStandaloneSupervisorHost({
                 once: !!args.superviseOnce,
                 dryRun: !!args.superviseDryRun,
-                log: (m) => console.log(m),
+                log: (m) => writeOut(m),
             });
             if (args.superviseOnce) {
                 const rep = res.lastReport;
                 if (rep) {
-                    console.log(`调度周期 #${rep.tick}: 认领 ${rep.claimed.length} · 执行 ${rep.executed.length} · 跳过 ${rep.skipped.length}${rep.errors.length ? ` · 错误 ${rep.errors.length}` : ''}`);
+                    writeOut(`调度周期 #${rep.tick}: 认领 ${rep.claimed.length} · 执行 ${rep.executed.length} · 跳过 ${rep.skipped.length}${rep.errors.length ? ` · 错误 ${rep.errors.length}` : ''}`);
                     for (const s of rep.skipped.slice(0, 8))
-                        console.log(`  跳过 ${s.goalId}: ${s.reason}`);
+                        writeOut(`  跳过 ${s.goalId}: ${s.reason}`);
                     for (const e of rep.executed)
-                        console.log(`  ▶ ${e.goalId} → run=${e.runId || '-'} ${e.status || ''}${e.error ? ` (${e.error})` : ''}`);
+                        writeOut(`  ▶ ${e.goalId} → run=${e.runId || '-'} ${e.status || ''}${e.error ? ` (${e.error})` : ''}`);
                 }
-                console.log(`supervisor 宿主: owner=${res.state.owner} worker=${res.state.workerId} ticks=${res.ticks} 状态文件=~/.bolloon/supervisor.json`);
+                writeOut(`supervisor 宿主: owner=${res.state.owner} worker=${res.state.workerId} ticks=${res.ticks} 状态文件=~/.bolloon/supervisor.json`);
             }
             else {
-                console.log(`[supervisor] 常驻宿主已启动 (owner=${res.state.owner}, worker=${res.state.workerId}); Ctrl-C 优雅停止`);
+                writeOut(`[supervisor] 常驻宿主已启动 (owner=${res.state.owner}, worker=${res.state.workerId}); Ctrl-C 优雅停止`);
             }
             return;
         }
@@ -4875,6 +6011,14 @@ async function main() {
                     if (process.env.BOLLOON_SKIP_SETUP === '1') {
                         noticePreamble('⚠ BOLLOON_SKIP_SETUP=1 → 诊断模式: 可以看状态/修配置, 但 agent 执行被门禁拦住 (不能绕过)');
                     }
+                    else if (onlyConnectivityRetest(gateEv)) {
+                        // 2026-10-01 (用户报「启动时候的日志也没去掉」):
+                        //   只差"连通性结果过期(需重测)"这一类 ⇒ **不在启动时跑 setup 向导** (跑一次要刷约 30 行前言)。
+                        //   改为: 面板内一行告警 + 让用户按需跑 `bolloon setup --test`; 门禁照旧拦住 agent 执行 (不绕过)。
+                        const a = `⚠ 连通性结果过期 → 跑 \`bolloon setup --test\` 复测 (启动时不自动跑), 全量: ${SETUP_STATUS_CMD}`;
+                        pushStartupAlert(a);
+                        noticePreamble(a);
+                    }
                     else {
                         const { runSetupWizard } = await import('./cli/setup-wizard.js');
                         // quietStartup: 向导的续跑前言默认不上屏 (它自己会在"要人回答/有失败"时先 flush)
@@ -4960,12 +6104,19 @@ async function main() {
         void (async () => {
             let kuboReady = false;
             try {
-                const sdk = await import('@diap/sdk');
-                const checkKuboSetup = sdk.checkKuboSetup;
-                if (typeof checkKuboSetup === 'function') {
-                    const setup = await checkKuboSetup(true, true);
-                    kuboReady = !!(setup?.ready && setup?.daemonRunning);
-                    bootNotice('info', kuboReady ? 'IPFS 本地 Kubo 就绪 → IPNS 发布/解析可用' : 'Kubo 不可用, IPFS 降级本地模式');
+                // 2026-09-30: 已经在跑 → 直接算就绪, 不触发 SDK 那次注定失败的 `ipfs init`(它会在面板前打一行 warn)
+                if (await kuboAlreadyRunning()) {
+                    kuboReady = true;
+                    bootNotice('info', 'IPFS 本地 Kubo 已在运行 → IPNS 发布/解析可用');
+                }
+                else {
+                    const sdk = await import('@diap/sdk');
+                    const checkKuboSetup = sdk.checkKuboSetup;
+                    if (typeof checkKuboSetup === 'function') {
+                        const setup = await checkKuboSetup(true, true);
+                        kuboReady = !!(setup?.ready && setup?.daemonRunning);
+                        bootNotice('info', kuboReady ? 'IPFS 本地 Kubo 就绪 → IPNS 发布/解析可用' : 'Kubo 不可用, IPFS 降级本地模式');
+                    }
                 }
             }
             catch (e) {
@@ -5043,7 +6194,7 @@ async function main() {
                     bootNotice('info', `Bootstrap 完成 (${bs.durationMs}ms, ${bs.errors.length} 个非致命错误)`);
                 }
                 catch (err) {
-                    bootNotice('warn', `Bootstrap 失败 (非致命, 主流程继续): ${err.message}`);
+                    bootNotice('warn', `上下文扫描未完成 (可选步骤, 已跳过, 主流程继续): ${err.message} —— 详情见 startup.log`);
                 }
             })();
         }
@@ -5059,7 +6210,7 @@ async function main() {
                 bootNotice('info', `Bootstrap 完成 (${bs.durationMs}ms, ${bs.errors.length} 个非致命错误)`);
             }
             catch (err) {
-                bootNotice('warn', `Bootstrap 失败 (非致命, 主流程继续): ${err.message}`);
+                bootNotice('warn', `上下文扫描未完成 (可选步骤, 已跳过, 主流程继续): ${err.message} —— 详情见 startup.log`);
             }
         }
         if (mode === 'web') {
@@ -5068,7 +6219,7 @@ async function main() {
             // 默认用户模式: 不自迭代, 自改卡片不自动出现, 仍可 POST /api/self-improve/trigger 手动触发
             const selfImprove = process.env.BOLLOON_DEV_MODE === '1' || process.env.BOLLOON_DEV_MODE === 'true';
             if (selfImprove) {
-                console.log('[startup] BOLLOON_DEV_MODE=1, 开发者模式: 自迭代已启用');
+                writeOut('[startup] BOLLOON_DEV_MODE=1, 开发者模式: 自迭代已启用');
             }
             const { createWebServer, openBrowser } = await import('./web/server.js');
             // 2026-06-24: CLI 默认 loopback bind (安全), LAN 访问需 BOLLOON_HOST=0.0.0.0
@@ -5083,7 +6234,7 @@ async function main() {
             console.info = originalInfo;
             process.stdout.write = originalStdoutWrite;
             s.info('执行命令...');
-            console.log();
+            writeOut('');
             await runNonInteractive(args, comm);
             comm?.stop();
             // chat-watch / chat-p2p-listen 是长循环, 不会自然 return, 走 SIGINT 自然退出