@bolloon/bolloon-agent 0.5.2 → 0.5.4

package/dist/index.js

@@ -1,9 +1,14 @@
 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 } from './cli/status-segments.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,12 +16,14 @@ 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: 回复流卫生 — 内部运行日志 (循环推进/运行登记/收尾计数…) 不进对话回复流, 改落日志文件
@@ -142,6 +149,13 @@ ed25519.hashes.sha512 = sha512;
 let startupPanelFirst = false;
 /** 面板第一帧已经画出来了 (startCLI 取走面板提示之后): 晚到的降级提示直接追加进面板 */
 let startupPanelReady = false;
+/**
+ * 2026-09-30: 启动面板 / 就绪行**各只许追加一次**.
+ *   防任何重入路径 (会话切换 / 重复 boot / 恢复) 把面板再叠一条 —— leo 报的「顶框重复 14 次」那一类
+ *   都落在这个类里; 叠了就再也说不清屏上哪一条是真的.
+ */
+let bootPanelPrinted = false;
+let bootReadinessPrinted = false;
 /**
  * 启动期(面板之前)一行进度 / 降级输出 —— 交互默认口径下的**唯一出路**。
  *
@@ -331,6 +345,122 @@ async function bootstrapIroh(keypair, name) {
 // Agent 懒加载
 // ---------------------------------------------------------------------------
 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;
@@ -483,8 +613,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 +693,71 @@ 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 列时右段被截 ⇒ 看着像没出现)
+    const __segsFit = fitSegments(__segs.map(x => x.replace(/\x1b\[[0-9;]*m/g, '')), Math.max(20, termWidth() - 2 - __leftPlainLen - 6));
+    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 处; 放不下就不显示 (不挤坏这一行)。
+    const __notePlain = (cliSessionPreview && cliSessionTitleKey === cliSessionKey) ? `▸ ${cliSessionPreview}` : '';
+    let __noteStr = '';
+    if (__notePlain) {
+        // 宽度必须用 dispWidth (East Asian Width 表): 行内的 `│ ░ ◷ ▸ ◎ ✓ ↑ ⚙` 都是**单宽**,
+        //   用 "charCode > 255 ⇒ 2" 的启发式会每行多算十几列 ⇒ 右对齐留一大截 (leo: 「没有完全右对齐」)。
+        const used = dispWidth(`${__left}${__live}`);
+        const pad = rightAlignPad(used, dispWidth(__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 +765,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 +857,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 +931,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 +954,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 +982,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 +1070,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 +1092,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 +1108,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,6 +1116,39 @@ 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-08-10: 自动整理心跳 (CLI 侧, 与社交心跳并列) — 启动后立即"固定看一下 skills view"
     //   (扫描遗留 skills), 之后按周期 (默认 30min, env BOLLOON_ORGANIZE_HEARTBEAT_MS) 完整进化经验.
@@ -811,7 +1175,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 +1259,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 +1272,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();
     }
@@ -1072,6 +1427,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();
@@ -1174,6 +1530,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 +1614,11 @@ 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];
     // /net — Agent 网络快捷命令 (join/status/ctx, 2026-09-08)
     if (cmd === '/net' || cmd.startsWith('/net ')) {
         const arg = trimmed.slice(4).trim();
@@ -2173,17 +2535,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 +2842,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 +3205,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)
@@ -2980,6 +3633,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,6 +3707,9 @@ 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 的思考过程
@@ -3095,6 +3758,7 @@ 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 !== '?') {
@@ -3127,6 +3791,7 @@ 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}`;
                         inkSetTransient(`${C_DIM}${label} 运行中...${RESET}`);
@@ -3139,6 +3804,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 +3931,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 { /* 降级容忍 */ }
@@ -3872,7 +4590,7 @@ goalFlag) {
                                     : 'ℹ 使用缓存结论';
                 response = `${head}\n\n当前版本: ${r.currentVersion}\n最新版本: ${r.latestVersion || '未知'}\n安装方式: ${r.installMethod}\n结论: ${r.status}${r.reason ? `\n说明: ${r.reason}` : ''}`;
                 if (r.status === 'update_available')
-                    response += `\n\n运行 bolloon update plan 看计划, bolloon update now 执行更新`;
+                    response += `\n\n运行 bolloon update 直接更新 (先打印计划与风险检查; 只看计划用 --dry-run)`;
                 if (r.status === 'offline' || r.status === 'registry_unavailable' || r.status === 'local_version_unknown')
                     error = response;
                 break;
@@ -4748,10 +5466,10 @@ async function main() {
         }
         // 启动时后台检查更新 (不阻塞主流程)。
         // 2026-09-19 行为变更: **默认只通知, 不自动安装** —— 发现新版本会打印一行提示 +
-        //   "bolloon update plan / now"。要恢复自动安装需显式 config.json `autoInstall: true`
+        //   "bolloon update"。要恢复自动安装需显式 config.json `autoInstall: true`
         //   (+ `autoRestart: true` 才自动重启)。
         // 关闭本次检查: --no-update / BOLLOON_SKIP_UPDATE=1; 临时开自动装: BOLLOON_AUTO_UPDATE=1
-        // 手动检查: bolloon update / bolloon update plan / bolloon doctor
+        // 手动检查: bolloon update / bolloon update --dry-run / bolloon doctor
         if (!args.updateCheck && !args.updateNow) {
             void (async () => {
                 try {
@@ -4960,12 +5678,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 +5768,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 +5784,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') {