@bolloon/bolloon-agent 0.5.3 → 0.5.5

package/dist/cli/input-paste.js

@@ -0,0 +1,218 @@
+/**
+ * 长输入/粘贴的"折叠" (2026-10-01, 用户: 「输入文本框有压缩吗…教给 bolloon」)。
+ *
+ * 学到并会照做的做法(研究得到的口径, 用自己的话写):
+ *   ① 折叠的**产出** = 把整段写到一个文件 + 输入处留**一行短引用**(带 序号/行数/路径) ⇒ 输入框和对话流都不会被一大段糊满;
+ *   ② 关键设计: 这个短引用**指向文件**, 需要细节时**读文件**就能拿到全文 ⇒ 效果上**无损**;
+ *   ③ 阈值由**前端**决定(没有硬阈值约定) ⇒ 我取"≥8 行 或 ≥1200 字符"。
+ * 顺带解决另一件事: 长用户消息不再整段躺在历史里 ⇒ 等价于"超长用户消息要精简"那条口径, 而且**在入口就收住**(比压缩时再精简更早 ✓)。
+ *
+ * 纪律: 只对**长输入**生效(短的一句不动 ✓) · 文件落 `~/.bolloon/pastes/`(0600 ✓) · 失败**绝不打断发送**(退化成原样发送 ✓)。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+/**
+ * 折叠阈值。**按真实数据定的** (2026-10-01 实测: 用户的一次粘贴 = 479 + 137 两块的纯文本,
+ * 旧阈值 8 行 / 1200 字符**两个都没到** ⇒ 不折叠 ⇒ 原文进输入框 ⇒ 里面 '/'/'@'/'#' 触发弹窗
+ * ⇒ "没编号 + 有弹窗" 同一个根因 ✓)。
+ * 新口径: **只要是多行(含换行)就折叠** ✓ —— 输入框里本来不可能有换行(回车即提交 ✓) ⇒ 含换行必是粘贴 ✓;
+ *   单行则到 300 字符就折叠 ✓。Enter 本身是单个 '\n' ⇒ 但 `looksLikePasteChunk` 已按长度排除 ⇒ 不会误解 ✓。
+ */
+export const PASTE_MIN_LINES = 2;
+export const PASTE_MIN_CHARS = 300;
+export function pastesDir(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'pastes');
+}
+export function pasteLineCount(text) {
+    return String(text ?? '').split('\n').length;
+}
+export function shouldCollapsePaste(text, opts = {}) {
+    const s = String(text ?? '');
+    if (!s.trim())
+        return false;
+    return pasteLineCount(s) >= (opts.minLines ?? PASTE_MIN_LINES) || s.length >= (opts.minChars ?? PASTE_MIN_CHARS);
+}
+/**
+ * 把长输入折叠成"一行引用 + 文件路径"。写盘失败 ⇒ 原样返回(不打断用户) ✓。
+ */
+export function collapsePaste(text, opts = {}) {
+    const s = String(text ?? '');
+    const lines = pasteLineCount(s);
+    const base = { inputText: s, sendText: s, lines, chars: s.length, collapsed: false };
+    if (!shouldCollapsePaste(s, opts))
+        return base;
+    try {
+        const home = opts.home || os.homedir();
+        const dir = pastesDir(home);
+        fs.mkdirSync(dir, { recursive: true });
+        const n = opts.counter ?? (() => {
+            try {
+                return fs.readdirSync(dir).filter((f) => f.startsWith('paste_')).length + 1;
+            }
+            catch {
+                return 1;
+            }
+        })();
+        const hhmmss = (opts.now || new Date()).toTimeString().slice(0, 8).replace(/:/g, '');
+        const file = path.join(dir, `p${n}_${hhmmss}.txt`);
+        fs.writeFileSync(file, s, { encoding: 'utf-8', mode: 0o600 });
+        // 输入框那份**不能带 '@' '/' '#'** —— 它们会触发补全弹窗(实测: 粘贴后弹窗冒出来 ✗)。
+        //   所以输入框只放"序号 + 行数"; **完整路径只出现在发送出去的那份**(sendText)里 ✓。
+        // 2026-10-01 用户指定形态(并要求"比这个短一点"): `[粘贴 #N: M 行 → 路径]` ✓
+        //   · 路径**必须留着** ✓ —— 所以"路径里的 '/' + '#N' 会触发补全弹窗"不能靠摘路径来躲 ✗,
+        //     改为**确定性判断**: 输入框里只要是"粘贴引用"就一律不当补全来源 ✓(见 `isPasteRef` ✓)。
+        //   · 短一点: 文件名从 `paste_<n>_<HHMMSS>` 缩成 `p<n>_<HHMMSS>` ✓; 家目录显示成 `~` ✓。
+        const shortFile = `~/${path.relative(home, file).split(path.sep).join('/')}`;
+        const ref = `[粘贴 #${n}: ${lines} 行 → ${shortFile}]`;
+        return {
+            inputText: ref,
+            sendText: ref,
+            path: file,
+            lines,
+            chars: s.length,
+            collapsed: true,
+        };
+    }
+    catch {
+        return base;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// 粘贴"真实形态"处理 (2026-10-01, 用户连报三次「还是会有弹窗，无法进入输入框」后补)
+//
+// 教训: 我先前假设"一次粘贴 = 一个 chunk" ✗ —— 真实终端里至少两种形态会打脸:
+//   ① **括号粘贴**: 终端把整段包在 `\x1b[200~ … \x1b[201~` 里 ⇒ 我的"含 ESC 就不当粘贴"直接放弃 ✗
+//      ⇒ 原文进了输入框 ⇒ 里面的 '@'/'/'/'#' 触发补全弹窗 ⇒ 弹窗又把后续按键吃掉 ⇒ "无法进入输入框" ✗;
+//   ② **逐行成块**: 多行粘贴可能一行一个 chunk ⇒ 每块都短 ⇒ 都不够折叠阈值 ✗。
+// 对策: 先剥括号标记 ⇒ 再判断"像不像粘贴" ⇒ 把**一串**粘贴块**攒起来**(80ms 静默算一次粘贴结束) ⇒ 整段折叠 ✓;
+//   并且在粘贴进行期间**抑制补全弹窗** ✓(粘进来的文本不该弹窗 ✓)。
+// ─────────────────────────────────────────────────────────────────────────────
+/** 括号粘贴标记 (终端自动加的, 必须剥掉再判断) */
+const PASTE_START = '\u001b[200~';
+const PASTE_END = '\u001b[201~';
+export function stripBracketedPaste(text) {
+    return String(text ?? '').split(PASTE_START).join('').split(PASTE_END).join('');
+}
+export function hasBracketedPasteMarker(text) {
+    const s = String(text ?? '');
+    return s.includes(PASTE_START) || s.includes(PASTE_END);
+}
+/** 一个 chunk 是否"像粘贴"(而不是手敲/方向键): 长、含换行、或带括号粘贴标记 */
+export const PASTE_CHUNK_MIN_CHARS = 40;
+export function looksLikePasteChunk(chunk) {
+    const s = String(chunk ?? '');
+    if (!s)
+        return false;
+    // ⚠️ 2026-10-01 修正: **单个 \n 就是回车** —— 早先"含换行即粘贴"会把回车吞掉 ✗(Enter 提交不了 ✗)。
+    //   现在: 长度够才算粘贴; 换行只在"已经够长"时作为辅助信号; 括号粘贴标记也要有实际内容。
+    if (s.length >= PASTE_CHUNK_MIN_CHARS)
+        return true;
+    // 带括号粘贴标记 ⇒ 只要剥掉标记后**有内容**就是粘贴(标记只可能来自终端的粘贴路径 ✓)
+    if (hasBracketedPasteMarker(s) && s.replace(/\u001b\[20[01]~/g, '').length > 0)
+        return true;
+    return false;
+}
+/** 攒块的静默窗口: 这么久没有新块 ⇒ 认为"这次粘贴结束了" */
+export const PASTE_BURST_IDLE_MS = 80;
+/**
+ * 粘贴形态**观测** (有界, 只记形态不记正文) ⇒ `~/.bolloon/logs/input-chunks.jsonl`。
+ * 为什么留它: 这次"弹窗/进不去输入框"连报三轮, 全靠**猜** chunk 形态 ✗ ⇒ 以后一眼能看出真实形态 ✓。
+ * 纪律: best-effort(失败静默) · 只记 长度/有无括号标记/有无换行/有无 ESC · 上限 500 行(超了就重写)。
+ */
+export function logPasteChunk(info, home = os.homedir()) {
+    try {
+        const dir = path.join(home, '.bolloon', 'logs');
+        fs.mkdirSync(dir, { recursive: true });
+        const file = path.join(dir, 'input-chunks.jsonl');
+        try {
+            if (fs.existsSync(file) && fs.readFileSync(file, 'utf-8').split('\n').length > 500)
+                fs.writeFileSync(file, '', 'utf-8');
+        }
+        catch { /* 忽略 */ }
+        fs.appendFileSync(file, JSON.stringify({ ts: new Date().toISOString(), ...info }) + '\n', 'utf-8');
+    }
+    catch { /* 观测失败绝不影响输入 */ }
+}
+/**
+ * **输入框只能是单行** (2026-10-01, 用户: 「发送框也会分成好几行」)。
+ * 为什么必须净化: Ink 的输入组件拿到带 `\n` 的值就会**撑成多行** ⇒ 底部输入栏被顶高、
+ *   内容置顶的布局跟着抖 ✗。所以: 值进输入框之前一律把换行压成空格 ✓(原文照旧进文件/照旧发出去 ✓,
+ *   只是**显示**单行 —— 显示单行不等于内容丢 ✓)。
+ */
+export function singleLine(text) {
+    return String(text ?? '').replace(/[\r\n]+/g, ' ').replace(/[\t]/g, ' ');
+}
+/**
+ * 粘贴后**短暂封住补全弹窗**的判定 (2026-10-01, 按真实数据收尾)。
+ * 实测: 一次粘贴是**一整块 762 字符纯文本** ✓(无括号标记/无换行) ⇒ 它的最后一个 token 只要以 '/' 开头,
+ *   或含不在字母数字后面的 '@'/'#' ⇒ `getMention` 就会返回命中 ⇒ 弹窗 ⇒ **抢走输入焦点** ✗。
+ * 双保险: ① 超长输入(>400 字符)本来就不该当 mention 来源 ✓; ② 粘贴后 **1.5 秒内** 一律不弹 ✓
+ *   —— 封禁期一过(或用户手动敲键)立刻恢复, 免得影响正常的 '@'/'/'/'#' 补全 ✓。
+ */
+export const PASTE_MENTION_SHIELD_MS = 1500;
+export const MENTION_MAX_INPUT_CHARS = 400;
+/**
+ * 输入框里是不是"粘贴引用"本身(形态: `[粘贴 #N: M 行 → ~/.bolloon/pastes/pN_…txt]`)。
+ * 是引用 ⇒ **一律不当补全来源** ✓ —— 这样引用里可以放心带 `#` 与路径的 `/` ✓(不必为躲弹窗牺牲信息 ✓)。
+ */
+export function isPasteRef(text) {
+    return /^\s*\[\s*粘贴\s*#?\d+\s*[:：]\s*\d+\s*行\s*→\s*\S+\s*\]\s*$/.test(String(text ?? ''));
+}
+export function shouldSuppressMention(input, shieldUntil, now = Date.now()) {
+    if (isPasteRef(input))
+        return true; // 确定性抑制(不靠时间窗) ✓
+    if (String(input ?? '').length > MENTION_MAX_INPUT_CHARS)
+        return true;
+    return Number(shieldUntil || 0) > now;
+}
+/**
+ * 补全弹窗**观测** (2026-10-01, 用户连报"还是跳出弹窗") —— 目的: 下一次粘贴一读日志就知道是**哪个**弹窗。
+ * 只记 事件名/类型/触发字符/输入长度/前 40 字符(足以定位, 不含大段正文) ✓; 上限 500 行 ✓; 失败静默 ✓。
+ */
+export function logPopupEvent(ev, home = os.homedir()) {
+    try {
+        const dir = path.join(home, '.bolloon', 'logs');
+        fs.mkdirSync(dir, { recursive: true });
+        const file = path.join(dir, 'popup-events.jsonl');
+        try {
+            if (fs.existsSync(file) && fs.readFileSync(file, 'utf-8').split('\n').length > 500)
+                fs.writeFileSync(file, '', 'utf-8');
+        }
+        catch { /* 忽略 */ }
+        fs.appendFileSync(file, JSON.stringify({ ts: new Date().toISOString(), ...ev, head: (ev.head || '').slice(0, 40) }) + '\n', 'utf-8');
+    }
+    catch { /* 观测失败绝不影响输入 */ }
+}
+/**
+ * 剥掉 UI 残影 (2026-10-01, 用户: 「颜文字被加载进去了，防一下」)。
+ * 为什么: 思考动画/状态行是**屏幕上的东西**, 但它们会被 Ink 重绘留进滚动区 ⇒ 用户框选/拖拽时
+ *   会把 `(◕‿◕) 思考中...`、`🔧 … 运行中...`、ANSI 控制符一起带进输入框 ⇒ 混进送给模型的正文 ✗。
+ * 做法: 只在**发送前**清洗(不碰用户真正打的字 ✓): 去 ANSI · 去行首颜文字 + "思考中/运行中" 状态片段 ✓。
+ */
+/**
+ * 判"整行只是状态残影" —— **按语义判, 不靠字符类** ✓:
+ *   把非字母数字的装饰(颜文字/组合变音符/符号)全部拿掉, 剩下的如果只有"思考中/运行中/自动整理经验中"
+ *   ⇒ 这行就是状态行 ⇒ 丢掉 ✓(实测 `ᕙ(▀̿̿Ĺ̯̿̿▀̿ ̿)ᕗ 思考中...` 带**组合变音符**, 用字符类必漏 ✗)。
+ */
+const STATUS_WORD = /(思考中|运行中|自动整理经验中)/;
+function isStatusOnlyLine(line) {
+    const t = line.trim();
+    if (!t)
+        return false;
+    const core = t.replace(/[^\p{Script=Han}]/gu, ''); // 只看汉字: 颜文字里的 Ĺ/ᕙ 也是\p{L} ⇒ 用\p{L} 会漏 ✗
+    return STATUS_WORD.test(core) && /^(思考中|运行中|自动整理经验中)+$/.test(core);
+}
+export function stripUiNoise(text) {
+    let out = String(text ?? '').replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+    const kept = [];
+    for (const line of out.split('\n')) {
+        const t = line.trim();
+        if (isStatusOnlyLine(t))
+            continue; // 纯状态行 ⇒ 整行丢掉(不管前面挂什么颜文字)
+        if (/^🔧\s+.*运行中[.．。…\s]*$/u.test(t))
+            continue; // 工具运行中行 ⇒ 丢掉
+        kept.push(line.replace(/^\s*[\u2190-\u2bff\u3000-\u303f]{1,3}\s*(思考中|运行中)[.．。…\s]*/u, ''));
+    }
+    return kept.join('\n');
+}

package/dist/cli/loading-tui.js

@@ -11,6 +11,7 @@
  *   renderDialog(opts)     带品牌边框的对话框 (艺术字在框内)
  *   LoadingTUI             原地刷新的启动仪表盘类
  */
+import { truncateSafe } from './status-segments.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
@@ -71,6 +72,17 @@ export const BOLLOON_BANNER = [
     `${C_TEXT}${BOLD}╚═════╝  ╚═════╝ ╚══════╝╚══════╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝${RESET}`,
     `${C_DIM}Bolloon Agent v${BOLLOON_VERSION}${RESET}`,
 ].join('\n');
+/**
+ * 窄终端档: 同一套风格的小号艺术字 (leo 2026-09-30: 「我看不到我的 logo」).
+ *   原来宽 < ~97 列时整块 87 列艺术字被丢掉、只剩一行文字 —— 那不是 logo.
+ *   现在按"装得下就上"挑档: 大(87) → 小(37) → 文字(兜底), 保证任何宽度都有字标.
+ */
+export const BOLLOON_BANNER_SMALL = [
+    `${C_TEXT}${BOLD} ___  ___  _    _    ___   ___  _  _${RESET}`,
+    `${C_TEXT}${BOLD}| _ )/ _ \\| |  | |  / _ \\ / _ \\| \\| |${RESET}`,
+    `${C_TEXT}${BOLD}| _ \\ (_) | |__| |_| (_) | (_) | .\` |${RESET}`,
+    `${C_TEXT}${BOLD}|___/\\___/|____|____\\___/ \\___/|_|\\_|${RESET}`,
+].join('\n');
 /** 艺术字全部行 (机器人头在左, BOLLOON 艺术字在右), 供框内渲染 */
 export function brandArtLines() {
     // 2026-08-09: icon 只取机器人头 (裁掉末行 BOLLOON 文字), 避免和右侧 banner 双 logo
@@ -114,6 +126,52 @@ export function termWidth() {
     const c = process.stdout.columns;
     return typeof c === 'number' && c > 24 ? c : 80;
 }
+/**
+ * 等真实终端尺寸就位 (2026-09-30, leo 报「TUI 渲染有问题: 顶框被重复打印 + 宽度一路涨」).
+ *
+ * 真 pty 下 `process.stdout.columns` 在启动最初那一刻可能**还没被写进来** ⇒ 面板先按兜底的 80 列
+ * 渲染一次; 等真尺寸到位后又渲染一次 —— 而面板落在 Ink 的静态输出(scrollback)里, 重画覆盖不掉旧内容,
+ * 于是**每渲染一次就多留一条顶框**, 宽度还在变 (实测 24x120: 110 → 120; 12x80: 80 → 76).
+ * 所以: 出任何一帧之前先等尺寸就位 (通常下一个 tick 或一次 resize 事件就到; 上限 timeoutMs).
+ */
+export async function waitForTermSize(timeoutMs = 600) {
+    const ok = () => {
+        const c = process.stdout.columns;
+        return typeof c === 'number' && c > 24;
+    };
+    if (ok())
+        return;
+    await new Promise((resolve) => {
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            clearInterval(iv);
+            clearTimeout(t);
+            try {
+                process.stdout.off('resize', finish);
+            }
+            catch { /* 老 Node 没有 off */ }
+            resolve();
+        };
+        const iv = setInterval(() => { if (ok())
+            finish(); }, 20);
+        const t = setTimeout(finish, timeoutMs);
+        try {
+            process.stdout.once('resize', finish);
+        }
+        catch { /* 忽略 */ }
+    });
+}
+/**
+ * 终端行数 (拿不到就按 24 —— 与 termWidth 同一套兜底口径).
+ * 2026-09-30 新增: 面板/盒子必须**知道自己有多少行可用**, 否则会长过屏幕把输入行顶出视野.
+ */
+export function termHeight() {
+    const r = process.stdout.rows;
+    return typeof r === 'number' && r > 8 ? r : 24;
+}
 function stripAnsi(s) {
     return s.replace(/\x1b\[[0-9;]*m/g, '');
 }
@@ -160,8 +218,8 @@ function fitLeft(text, inner) {
     }
     return out + '…';
 }
-/** 按显示宽度截断并加省略号 */
-function truncate(text, max) {
+/** 按显示宽度截断并加省略号 (导出: 调用方要自己把内容裁进盒子, 见 buildBootBox) */
+export function truncate(text, max) {
     if (dispWidth(text) <= max)
         return text;
     let out = '';
@@ -201,12 +259,15 @@ export function renderDashboard(opts) {
     const maxTitle = dispWidth(opts.title ?? 'Bolloon Agent · 仪表盘') + 4;
     const inner = Math.max(40, maxArt, maxRow, maxTitle);
     const width = Math.min(termWidth() - 2, opts.width ?? inner + 4);
+    // 2026-09-30: width 被夹到 termWidth()-2 之后, 内宽可能**小于**艺术字宽度 ——
+    //   那种情况下 boxRow 装不下, 终端会把每行折成两截 (实测: 艺术字裂成两列错位).
+    //   宁可不显示艺术字, 也不让它被折行.
+    const innerW = Math.max(0, width - 4);
+    const useArt = showBrand && maxArt <= innerW ? art : [];
     const lines = [];
     lines.push(boxTop(opts.title ?? 'Bolloon Agent · 仪表盘', width));
-    if (showBrand) {
-        for (const l of art)
-            lines.push(boxRow(l, width, 'center'));
-    }
+    for (const l of useArt)
+        lines.push(boxRow(l, width, 'center'));
     for (const r of opts.rows) {
         const sym = STATUS_SYMBOL[r.status ?? 'info'];
         const detail = r.detail ? `  ${C_DIM}${r.detail}${RESET}` : '';
@@ -376,7 +437,8 @@ function colorizeDiff(text) {
 export function renderToolCallListItem(item, index, total) {
     const dur = item.durationMs != null ? ` ${C_DIM}${item.durationMs}ms${RESET}` : '';
     const label = item.status === 'error' ? `${C_ERROR}${item.tool}${RESET}` : `${C_ACCENT}${item.tool}${RESET}`;
-    return `  🔧 ${label}${dur}`;
+    // 2026-10-01: 工具行也按**保守宽度**截断 —— 超宽会让终端折行、打乱 Ink 光标 (底栏那块就是这么坏的)
+    return truncateSafe(`  🔧 ${label}${dur}`, Math.max(20, (process.stdout.columns || 100) - 1));
 }
 /** 紧凑渲染工具输出 (检测到 diff 则着色, 否则普通截断) — 当前不显示 body */
 export function renderToolCallBody(item, width = 72) {

package/dist/cli/log-gate.js

@@ -51,6 +51,13 @@ const UNTAGGED_STARTUP_NARRATION = [
     /^(?:复用|新建) P2P 身份: /,
     /^P2P 身份已生成: /,
     /^DID: did:/,
+    // 2026-10-01 (用户连续三次: 「iroh: … / 主题: … 还没去掉」): 这几句**不带模块标签也不带时间戳** ✗
+    //   ⇒ 原来不在任何判据里 ⇒ 闸门、console 拦截、writeOut 三道全都拦不住 ✓。
+    //   仍然按行首锚定、只覆盖**实测观察到**的形状 ✓(不做宽泛匹配 ✓); 带缩进也要认 ✓。
+    /^[ \t]*iroh:\s*[0-9a-f]{6,}/i,
+    /^[ \t]*主题:\s*[0-9a-f]{8}/i,
+    /^[ \t]*复用 DID:\s*did:/i,
+    /^[ \t]+名称:\s*[\w.\-]{2,40}\s*$/,
 ];
 /** 「错误 / 降级 / 需人介入」信号 —— 命中的行**任何模式下都不许被吞** */
 const HUMAN_SIGNAL = new RegExp([
@@ -79,11 +86,49 @@ export function isStartupLogLine(line) {
         || UNTAGGED_STARTUP_NARRATION.some((re) => re.test(line));
     // inspect dump 的续行 (纯数字/逗号) 由 filterText 的 dump 状态机处理, 这里不判
 }
+/**
+ * 「可选启动富化」任务的失败 —— **落日志, 但默认不占屏**。
+ *
+ * 2026-09-30 (leo: 「都是启动期可选富化任务失败, 却用带时间戳的'失败'打在屏上」):
+ *   `[warn]: ⚠️ 本地 IPNS 发布失败: TimeoutError … ❌ 失败 (30003ms)` 这类来自 SDK / 内部后台任务,
+ *   用户启动时**无可行动**(看见了也没法处理), 但句子带'失败' ⇒ 按'错误不许被吞'被放上屏 = 纯噪音。
+ *   它们仍然**一字不漏落 startup.log**, `--verbose` 照原样上屏 ⇒ 诊断能力一点不丢。
+ *   这是把「要不要占屏」和「要不要留痕」分开, 不是把错误藏起来。
+ *
+ * 判据要求**同时**命中「上面这条窄规则」+「失败词」; 只命中一个照旧按人味信号上报。
+ *   **刻意只覆盖这两类**: SDK 的 IPNS 发布重试行 + 上下文扫描超时。
+ *   不收 `ipfs daemon 启动超时, 可稍后手动运行` 这类**可行动**提示 —— 门自己的契约测试
+ *   (`log-gate.test.ts` 的"信号行"用例) 就是拿它当反例, 第一版规则太宽时被它判红。
+ */
+const OPTIONAL_BOOT_TASK = /(?:本地\s*IPNS\s*发布失败|IPNS\s*发布失败[，,]\s*尝试备用发布|上下文扫描\s*未完成|上下文扫描\s*超时|Bolloon 上下文扫描)/;
+/**
+ * SDK(winston) 的**进度诊断**行形状: `2026-09-30T09:27:03.848Z [info]: 结果: ❌ 失败 (30004ms)`。
+ *
+ * 2026-09-30 (leo): 这类行来自 @diap/sdk 的 logger —— 它**直写控制台、绕过日志门**, 句子里带
+ *   "失败/❌" ⇒ 按"错误不许被吞"被放上屏, 但它是 `[info]` 级**进度尾巴**(IPNS 发布 30s 超时), 启动时不可行动。
+ *
+ * **只吞 info/debug, 绝不吞 warn/error** —— 这条收窄是门自己的契约测试逼出来的:
+ *   `log-gate.test.ts` 断言 `… [warn]: ⚠️ 守护进程启动超时, 可稍后手动运行 ipfs daemon` 必须算人味信号
+ *   (它确实可行动)。第一版规则连 warn 一起吞 ⇒ 被那条测试判红, 于是收窄。
+ */
+// 2026-09-30 真机修正: 原来只认"以 ISO 时间戳开头 + 未染色的 [info]:"。
+//   实测真身是 `[2026-…] 2026-…Z [info]: …` —— 行首可能有日志器加的 `[ts] ` 前缀,
+//   `[info]` 里的 info 还会被 ANSI 染色 ⇒ 两条都让旧规则漏网, 于是
+//   `2026-09-30T10:22:44.768Z [info]:   结果: ❌ 失败 (30004ms)` 照样上屏 (leo 报过多次)。
+const SDK_DIAG_LINE = /^(?:\[[^\]]*\]\s*)?\d{4}-\d{2}-\d{2}T[\d:.]+Z?\s*\[(?:\x1b\[[0-9;]*m)*(?:info|debug)(?:\x1b\[[0-9;]*m)*\]:/i;
 /** 这一行是不是「错误 / 降级 / 需人介入」—— 是则任何模式下都不许被静默 */
 export function carriesHumanSignal(line) {
     if (!line)
         return false;
-    return HUMAN_SIGNAL.test(line.replace(BENIGN_COUNT, ' '));
+    const l = line.replace(BENIGN_COUNT, ' ');
+    const isSignal = HUMAN_SIGNAL.test(l);
+    // SDK 诊断行 (info/warn/debug): 只落日志, 不占屏 —— error 级不在其中, 照旧上报
+    if (SDK_DIAG_LINE.test(l))
+        return false;
+    // 可选启动富化的失败: 留痕(日志)但默认不占屏 —— 见 OPTIONAL_BOOT_TASK 的说明
+    if (isSignal && OPTIONAL_BOOT_TASK.test(l))
+        return false;
+    return isSignal;
 }
 // ---------------------------------------------------------------------------
 // verbose / disabled / 日志路径

package/dist/cli/mention-data.js

@@ -37,6 +37,36 @@ const CLI_COMMANDS = [
     { kind: 'command', label: 'skill', hint: '技能候选', insert: 'skill' },
     { kind: 'command', label: 'mcp', hint: 'MCP 服务器列表', insert: 'mcp' },
     { kind: 'command', label: 'agent', hint: '当前智能体', insert: 'agent' },
+    // 2026-10-01 (用户报「/channel 没加入 cli 命令栏, 无法选中」): 有处理器但没有条目 ⇒ 打 / 选不到。
+    //   一并补上同样漏掉的 /fork (会话分叉)。
+    { kind: 'command', label: 'channel', hint: '切换智能体 (无参=列出所有)', insert: 'channel' },
+    { kind: 'command', label: 'fork', hint: '从第 N 条会话分叉 (/fork <#>)', insert: 'fork' },
+    { kind: 'command', label: 'answer', hint: '回答智能体提出的问题', insert: 'answer' },
+    { kind: 'command', label: 'approve', hint: '批准一次待审操作', insert: 'approve' },
+    { kind: 'command', label: 'contacts', hint: '联系人 (P2P)', insert: 'contacts' },
+    { kind: 'command', label: 'criteria', hint: '判据 / 评分标准', insert: 'criteria' },
+    { kind: 'command', label: 'cron', hint: '定时任务', insert: 'cron' },
+    { kind: 'command', label: 'dq', hint: '队列 (dequeue)', insert: 'dq' },
+    { kind: 'command', label: 'goals', hint: '目标', insert: 'goals' },
+    { kind: 'command', label: 'group', hint: 'OrbitDB 群聊 (new/join/send/log/members)', insert: 'group' },
+    { kind: 'command', label: 'judgments', hint: '判断记录', insert: 'judgments' },
+    { kind: 'command', label: 'net', hint: 'Agent 网络 (join/status/ctx)', insert: 'net' },
+    { kind: 'command', label: 'p2p', hint: 'P2P 节点 / 连接', insert: 'p2p' },
+    { kind: 'command', label: 'pause', hint: '暂停当前 run', insert: 'pause' },
+    { kind: 'command', label: 'payments', hint: '支付 / 任务公告', insert: 'payments' },
+    { kind: 'command', label: 'q', hint: '查队列', insert: 'q' },
+    { kind: 'command', label: 'questions', hint: '待回答的问题', insert: 'questions' },
+    { kind: 'command', label: 'reject', hint: '拒绝一次待审操作', insert: 'reject' },
+    { kind: 'command', label: 'runs', hint: '运行记录', insert: 'runs' },
+    { kind: 'command', label: 'sessions', hint: '会话列表', insert: 'sessions' },
+    { kind: 'command', label: 'setup', hint: '配置向导', insert: 'setup' },
+    { kind: 'command', label: 'skills', hint: '技能列表', insert: 'skills' },
+    { kind: 'command', label: 'suggestions', hint: '建议队列', insert: 'suggestions' },
+    { kind: 'command', label: 'supervise', hint: '监督视图', insert: 'supervise' },
+    { kind: 'command', label: 'trace', hint: '过程痕迹', insert: 'trace' },
+    { kind: 'command', label: 'tx', hint: '链上交易', insert: 'tx' },
+    { kind: 'command', label: 'wake', hint: '唤醒 / 继续目标', insert: 'wake' },
+    { kind: 'command', label: 'x402', hint: 'x402 支付信息', insert: 'x402' },
     { kind: 'command', label: 'did', hint: 'DID 身份', insert: 'did' },
     { kind: 'command', label: 'ipfs', hint: 'Kubo 状态', insert: 'ipfs' },
     { kind: 'command', label: 'ipns', hint: 'IPNS keys', insert: 'ipns' },

package/dist/cli/reasoning-view.js

@@ -0,0 +1,103 @@
+/**
+ * 思考记录的可视化 (2026-10-01, 用户: 「bolloon 智能体思考的记录可以也显示出来吗」)。
+ *
+ * 现状: 模型那边**是有**思考内容的 (deepseek 思考模式: `reasoning_content`, 非流式攒在
+ *   `ChatResult.reasoningContent`, 流式在 delta 里累), 但只被用来回带(wire 协议要求), **没显示** ✗。
+ * 规矩: 显示但要**可控** —— 默认开(用户要的), 能一键关(BOLLOON_SHOW_THINKING=0), 且有界(字符/行数封顶,
+ *   免得思考本身把屏幕和上下文吃爆)。显示形态是**暗色块**并标明"思考(未验证)", 与正式回答区分开。
+ */
+export const REASONING_MAX_CHARS = 1500;
+export const REASONING_MAX_LINES = 12;
+/** 是否显示思考 (默认**开**; BOLLOON_SHOW_THINKING=0/false/off 关) */
+export function shouldShowReasoning(env = process.env) {
+    const v = String(env.BOLLOON_SHOW_THINKING ?? '').trim().toLowerCase();
+    if (!v)
+        return true;
+    return !(v === '0' || v === 'false' || v === 'off' || v === 'no');
+}
+/** 归一化: 去掉多余空行; 无内容 ⇒ 空串 */
+export function normalizeReasoning(text) {
+    return String(text ?? '')
+        .replace(/\r\n?/g, '\n')
+        .split('\n')
+        .map((l) => l.replace(/\s+$/g, ''))
+        .filter((l, i, arr) => !(l.trim() === '' && (i === 0 || arr[i - 1].trim() === '')))
+        .join('\n')
+        .trim();
+}
+/**
+ * 渲染成给终端的一段 (纯函数, 便于门测)。有界 + 标出被省略的量。
+ * 返回空串 = 不该显示 (没内容/被关掉)。
+ */
+export function formatReasoningForDisplay(text, opts = {}) {
+    const enabled = opts.enabled ?? shouldShowReasoning();
+    if (!enabled)
+        return '';
+    const clean = normalizeReasoning(text);
+    if (!clean)
+        return '';
+    const maxChars = opts.maxChars ?? REASONING_MAX_CHARS;
+    const maxLines = opts.maxLines ?? REASONING_MAX_LINES;
+    let lines = clean.split('\n');
+    let truncated = false;
+    if (lines.length > maxLines) {
+        lines = lines.slice(0, maxLines);
+        truncated = true;
+    }
+    let out = lines.join('\n');
+    if (out.length > maxChars) {
+        out = out.slice(0, maxChars);
+        truncated = true;
+    }
+    return truncated ? `${out}\n…[思考已截断]` : out;
+}
+export function reasoningMode(env = process.env) {
+    const v = String(env.BOLLOON_SHOW_THINKING ?? '').trim().toLowerCase();
+    if (v === 'full' || v === 'chain' || v === 'long')
+        return 'full';
+    if (v === '0' || v === 'false' || v === 'off' || v === 'no')
+        return 'off';
+    if (v === 'short')
+        return 'short';
+    if (v === 'trace')
+        return 'trace';
+    // 2026-10-01 (用户: 「这里的思考能不能变成 trace 的执行描述」): 默认 = trace ——
+    //   不显示思维流(实测: 英文/重复四遍/还夹着错的推断), 改在工具行写这一步在做什么。
+    return 'trace';
+}
+/** 该模式下是否显示 (兼容旧 API: shouldShowReasoning) */
+export function isReasoningVisible(env = process.env) {
+    const m = reasoningMode(env);
+    return m !== 'off' && m !== 'trace'; // trace 模式不显示思维流(由工具行的执行描述替代)
+}
+/**
+ * 把思维链压成**一句** "在想什么" (纯函数)。
+ * 规矩: 取第一句人话; 去掉编号/项目符号/引号; 压空白; 超长截断加省略号; 出不来就空串。
+ */
+export function summarizeReasoning(text, maxChars = 120) {
+    const clean = normalizeReasoning(text);
+    if (!clean)
+        return '';
+    // 2026-10-01 (实跑发现): 第一行往往是**场景铺垫**("注意上下文有点混乱…") ⇒ 用户要的是"**要做什么**"那句。
+    //   规则: 跳过以"铺垫词"开头的行 (注意/背景/上下文/现在/刚才/首先看), 取第一行"像是判断/行动"的。
+    const SCENERY = /^(?:注意|背景|上下文|现在|刚才|首先看|先看|情况是)/;
+    const lines = clean.split('\n').map((l) => l.trim()).filter((l) => l.length > 0);
+    const firstLine = lines.find((l) => !SCENERY.test(l)) || lines[0] || '';
+    const noBullet = firstLine.replace(/^[-*•\d.、)\s]+/, '').trim();
+    // 取第一句 (中英句末都认); 太短就整行
+    const m = noBullet.match(/^(.{6,}?[。.!！?？;；])/);
+    let gist = (m ? m[1] : noBullet).replace(/\s+/g, ' ').trim();
+    if (gist.length > maxChars)
+        gist = `${gist.slice(0, maxChars - 1).trimEnd()}…`;
+    return gist;
+}
+/** 按模式渲染: short ⇒ 单行摘要; full ⇒ 有界块; off ⇒ 空串 */
+export function renderReasoning(text, opts = {}) {
+    const mode = opts.mode ?? reasoningMode();
+    // off 与 trace 都不给思维流(trace 的执行描述在工具行上, 见 trace-line.ts)
+    if (mode === 'off' || mode === 'trace')
+        return { mode, text: '' };
+    if (mode === 'full')
+        return { mode, text: formatReasoningForDisplay(text, { enabled: true, maxChars: opts.maxChars, maxLines: opts.maxLines }) };
+    return { mode, text: summarizeReasoning(text, opts.summaryChars ?? 120) };
+}