@bolloon/bolloon-agent 0.5.4 → 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';
@@ -436,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([

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) };
+}

package/dist/cli/startup-notice.js

@@ -153,6 +153,31 @@ export function alertsFromSetup(ev) {
     }
     return out;
 }
+/**
+ * 这个未就绪状态是否**只差"连通性复测"** (2026-10-01)。
+ *
+ * 为什么单列这一类: 连通性实测结果 >24h 就"过期", 此后**每次启动**都会命中未就绪 ⇒
+ * 启动路径会去跑整个 setup 向导 ⇒ 向导按"真跑了步骤就要把前言放出来"的规矩刷约 30 行
+ * (初始化框 / Onboard 模式 / 每步 ✓✗ / 就绪度报告) —— 用户明确不要看到这些。
+ * 这类不需要在启动时抢跑: 门禁照旧拦住 agent 执行 (不绕过), 用户按需跑 `bolloon setup --test` 即可。
+ *
+ * 判据 (两条都满足才算):
+ *   ① 门禁是 setup 且 basic 就绪度没过;
+ *   ② basic 的原因里**只**出现连通性复测相关字样 (连通 / 过期 / 重测 / connectivity)。
+ * 首次使用 (缺 provider/key) 的 basic 原因不匹配 ⇒ 仍然照常跑向导 (onboarding 不能被跳过)。
+ */
+export function onlyConnectivityRetest(ev) {
+    if (!ev || ev.gate === 'ready')
+        return false;
+    const basic = ev.state?.readiness?.basic;
+    if (basic !== false)
+        return false;
+    const reasons = (ev.state?.readinessWhy?.basic || []).map((x) => String(x));
+    if (reasons.length === 0)
+        return false;
+    const connLike = /连通|过期|重测|connectivity|expired/i;
+    return reasons.every((r) => connLike.test(r));
+}
 /** verbose 模式下那句"现在是全量"的提示 (默认不出现) */
 export function preambleHintLine(env = process.env) {
     return `[startup] 诊断模式 (--verbose / ${VERBOSE_ENV}=1 / ${PREAMBLE_ENV}=1): 启动前言全量输出`

package/dist/cli/status-segments.js

@@ -38,11 +38,11 @@ export function statusSegments(f) {
  *   规则: 丢的顺序 = ↑ → ◎ → ✓ → ◷ (⚙ 永不丢 —— 它最短, 且"有没有在跑工具"最有信息量);
  *   每一段都按显示宽算 (中文 2 列)。
  */
-export function fitSegments(segs, avail) {
+export function fitSegments(segs, avail, widthFn = dispWidth) {
     // 2026-09-30: 宽度一律用 loading-tui 的 dispWidth (按 East Asian Width 表) ——
     //   之前这里和 getStatus 各写了一份 "charCode > 255 ⇒ 2" 的启发式, 它把 `│ ░ ◷ ▸ ◎ ✓ ↑ ⚙`
     //   这些**单宽**符号都算成 2 列 ⇒ 右对齐时每行凭空多占十几列 (leo: 「没有完全右对齐」)。
-    const w = (s) => dispWidth(s);
+    const w = (s) => widthFn(s);
     const dropOrder = ['↑', '◎', '✓', '◷']; // 先丢谁 (从重要性的低到高; ⚙ 永不丢)
     let cur = [...segs];
     const total = () => cur.reduce((n, s) => n + w(s), 0) + Math.max(0, cur.length - 1) * 3; // 3 = ' │ '
@@ -68,3 +68,88 @@ export function rightAlignPad(usedWidth, noteWidth, width) {
     const pad = (width - 1) - usedWidth - noteWidth;
     return pad >= 1 ? pad : null;
 }
+/**
+ * **保守测宽** (2026-10-01, 修"底栏整块重复打印")。
+ *
+ * 背景: `dispWidth` 按 East Asian Width 只把 **W/F 区**算 2 列, 而我们在底栏实际用了一批
+ * **Ambiguous(A) 区**的字符 —— `·`(00B7) `↑`(2191) `◎`(25CE) `≈`(2248) `│`(2502)
+ * `—`(2014) `─`(2500) 等。它们在**部分终端/字体**下占 **2 列**, 我们按 1 列算 ⇒ 整行可能
+ * 超宽 1–2 列 ⇒ 终端**自动折行**多出一行 ⇒ Ink 的光标数学被打乱 ⇒ **整个底栏被重复打印**
+ * (用户屏上同一条状态栏出现三份, 只有计时在变)。也正因为 `◎`/`↑` 不是每屏都有, 症状是"偶尔"。
+ *
+ * 口径: 这里把这些**我们确实用到的** Ambiguous 字符一律按 **2 列**算 (宁可短一列, 绝不超宽)。
+ * 取的是**保守子集** —— 不追求覆盖全部 A 区, 只覆盖底栏/状态栏里会出现的那些; 新增符号时补进来。
+ */
+const AMBIGUOUS_AS_WIDE = new Set([
+    '·', '↑', '↓', '◎', '≈', '│', '─', '—', '↕', '§', '¶', '×', '÷', '±', '°', 'µ', '∞', '≠',
+]);
+/** 保守宽度: dispWidth + Ambiguous 字符每个再加 1 列 (即按 2 列算) */
+export function dispWidthSafe(s) {
+    const plain = String(s || '');
+    let extra = 0;
+    for (const ch of plain)
+        if (AMBIGUOUS_AS_WIDE.has(ch))
+            extra += 1;
+    return dispWidth(plain) + extra;
+}
+/**
+ * 底栏左段的**可用宽度预算** (2026-10-01)。
+ * 不变量: 保守宽度(left) + 至少 1 格 + 保守宽度(title) ≤ width - 1
+ * ⇒ 在任何终端字体下都不会因为"正好等于终端宽"而自动折行 (折行会让 Ink 光标数学错位,
+ *   表现就是整块底栏被重复打印)。
+ */
+export function statusLineBudget(width, leftPlainWidth, notePlain, margin = 8) {
+    const room = width - 1 - dispWidthSafe(notePlain) - 1 - Math.max(0, leftPlainWidth) - margin;
+    return Math.max(20, room);
+}
+/** 按**保守宽度**截断 (兜底: 即便有没登记进表的歧义字符, 也不会把行撑出终端) */
+export function truncateSafe(s, maxWidth) {
+    const text = String(s || '');
+    if (dispWidthSafe(text) <= maxWidth)
+        return text;
+    let out = '';
+    let w = 0;
+    for (const ch of text) {
+        const cw = dispWidthSafe(ch);
+        if (w + cw > Math.max(0, maxWidth - 1))
+            break;
+        out += ch;
+        w += cw;
+    }
+    return `${out}…`;
+}
+/** 画线字符的**保守**宽度 (U+2500 属 East Asian Width = Ambiguous ⇒ 部分终端按 2 列渲染) */
+/**
+ * 分界线默认字符 (2026-10-01, 用户报「输入框宽度变窄了」)。
+ *
+ * 上一版把 `─`(U+2500, East Asian Width = **Ambiguous**)按 **2 列**算字符数 ⇒ 在"真的按 2 列渲染"
+ * 的终端上不折行了 ✓, 但线只剩**一半长** ✗ —— 用户看到的就是"输入框变窄"。
+ * 两难: Ambiguous 字符的宽度**由终端决定**, 想既全宽又绝不折行, 只能用**宽度确定是 1 列**的字符。
+ * **用户要的是好看**: 所以默认就用 `─` 且按 1 列算 ⇒ **满宽实线** ✓ (2026-10-01 用户明确: 「我不要这样的虚线」)。
+ * 如果哪台终端的 `─` 是 2 列宽, 那它这种满宽线会折行 ⇒ 用 `BOLLOON_RULE_CHAR_WIDTH=2` 一键退回半宽。
+ */
+export function defaultRuleChar() {
+    const env = String(process.env.BOLLOON_RULE_CHAR || '').trim();
+    return env ? env.slice(0, 1) : '─';
+}
+export const RULE_CHAR_SAFE_WIDTH = dispWidthSafe(defaultRuleChar());
+/**
+ * 生成一条**保证不折行**的水平线 (2026-10-01)。
+ *
+ * 用户实测: 底栏那块(输入提示行 + 三条分界线)整块被**重复打印 4 次** ✗。
+ * 根因: 分界线写的是 `'─'.repeat(W - 1)` —— `─`(U+2500) 是 **Ambiguous 宽度**:
+ *   按 1 列算应该是 W-1 个, 但很多终端按 **2 列**渲染 ⇒ 整行变成 2×(W-1) 列 ✗✗
+ *   ⇒ 超出终端宽 ⇒ 终端**自动折行** ⇒ Ink 光标数学错乱 ⇒ 整块反复重打。
+ * 规矩: 一律按**保守宽度**(Ambiguous 当 2 列)算字符数 —— 宁可线短一点, 绝不超宽。
+ *   另一端(终端真的按 1 列渲染)只会让线看起来短一半, 不会坏。
+ */
+export function ruleFor(width, char = defaultRuleChar()) {
+    // 2026-10-01 (用户: 「我不要这样的虚线」): 默认 `─` 且**按 1 列**算 ⇒ 满宽的实线 ✓
+    //   代价: 某些终端把 `─`(Ambiguous) 渲染成 2 列 ⇒ 这种全宽线会超过终端宽、触发折行(底栏重复打印)。
+    //   给那种机器留了一键开关:  BOLLOON_RULE_CHAR_WIDTH=2   ⇒ 按 2 列算(线短一半, 但不折行)。
+    //   也可以换字符:      BOLLOON_RULE_CHAR=-
+    const override = parseInt(String(process.env.BOLLOON_RULE_CHAR_WIDTH || ''), 10);
+    const per = Math.max(1, Number.isFinite(override) && override > 0 ? override : 1);
+    const cells = Math.max(2, Math.floor(Math.max(0, width) / per));
+    return char.repeat(cells);
+}

package/dist/cli/trace-line.js

@@ -0,0 +1,54 @@
+/**
+ * trace 执行描述 (2026-10-01, 用户: 「反思还是有错误，这里的思考能不能变成 trace 的执行描述」)。
+ *
+ * 用户实测的痛点: 原来显示的是模型的**思维流**(💭) —— 英文、常重复四遍、还夹着**错的推断** ✗
+ *   (例: 同一句 "The user wants to push to GitHub." 出现四次; 中途还有一句 `Reflection: ❌ …` 把
+ *    lefthook 的正常输出当成失败 ✗)。人要的是"它**在做什么**" ✓, 不是"它**在想什么**" ✗。
+ * 做法: 把思维流默认关掉, 改在**工具行**上写一句中文动作短语(trace ✓) —— 一行说清这一步干了什么 ✓。
+ * 纯函数 ⇒ 可测。
+ */
+/** 工具名 → 中文动作短语 (按"人看到这一步在干嘛"来写, 不照搬工具名) */
+const ACTIONS = [
+    [/^git_status$/, '查看 git 状态'],
+    [/^git_diff$/, '看改动差异'],
+    [/^git_log$/, '看提交历史'],
+    [/^git_commit$/, '提交改动'],
+    [/^git_push$/, '推送'],
+    [/^grep_files$/, '搜内容'],
+    [/^glob_files$/, '找文件'],
+    [/^list_files$/, '列目录'],
+    [/^read_file$/, '读文件'],
+    [/^read_document$/, '读文档'],
+    [/^write_file$/, '写文件'],
+    [/^(edit_file|patch)$/, '改文件'],
+    [/^(mkdir|move_file|delete_file|copy_file)$/, '改文件系统'],
+    [/^terminal$/, '跑命令'],
+    [/^execute_code$/, '跑代码'],
+    [/^tsc_check$/, '查类型'],
+    [/^list_tools$/, '看有哪些工具'],
+    [/^list_skills$/, '找技能'],
+    [/^read_skill$/, '读技能'],
+    [/^process$/, '管后台进程/服务'],
+    [/^task|^plan|^todo/i, '理计划/待办'],
+    [/^send_|^broadcast|^check_inbox|^list_peers/, '发消息/看连接'],
+    [/^group|^create_group|^join_group/, '群聊操作'],
+    [/^wallet|^get_balance|^tx|^token/, '链上/钱包操作'],
+    [/^fetch_url|^web_search/, '联网取信息'],
+    [/^get_identity|^set_persona|^bolloon_config/, '看/改身份与配置'],
+    [/^delegate_task|^agent_call/, '派子智能体'],
+];
+/** 一句话说清这一步在做什么; 认不出的工具 ⇒ 返回空(调用方退回显示工具名) ✓ */
+export function describeToolCall(name) {
+    const n = String(name ?? '').trim();
+    if (!n)
+        return '';
+    for (const [re, label] of ACTIONS)
+        if (re.test(n))
+            return label;
+    return '';
+}
+/** 渲染成工具行文字 (认不出就用工具名本身, 绝不显示空白 ✓) */
+export function traceLabel(name) {
+    const d = describeToolCall(name);
+    return d ? `${d} · ${name}` : name;
+}

package/dist/context-compaction/auto-compact.js

@@ -108,10 +108,12 @@ export async function autoCompact(history, opts = {}) {
             role: 'system',
             content: `[Auto-Compact Summary] ${summary}`,
         };
+        // 2026-10-01: **摘要后面紧跟一条"保目标"锚点** ✓ —— 摘要丢目标它还在(详见 buildGoalAnchor ✓)
+        const anchor = buildGoalAnchor(toCollapse, remaining);
         return {
-            history: [summaryMsg, ...remaining],
+            history: [summaryMsg, ...(anchor ? [anchor] : []), ...remaining],
             applied: true,
-            detail: `collapsed ${cutTo} messages into 1 summary (cache key: ${key})`,
+            detail: `collapsed ${cutTo} messages into 1 summary (cache key: ${key})${anchor ? ' + 保目标锚点' : ''}`,
         };
     }
     catch (err) {
@@ -142,3 +144,36 @@ export function _resetAutoCompactCacheForTest() {
     // 实际缓存由 readCache/writeCache 管理, 这里只暴露接口
     // 测试可以走 fs.rm CACHE_DIR() 清理
 }
+/**
+ * **压缩前后"保目标"锚点** (2026-10-01, 用户: 「压缩前后保目标」)。
+ * 为什么: auto-compact 会把较早的历史**整段换成一句摘要** ✗ —— 摘要写给"过去发生了什么",
+ *   而**当前目标**往往丢在里面 ⇒ 压完模型醒过来半失忆 ⇒ 答非所问 / 重头问 / 改目标 ✓(真机实测 ✓)。
+ * 做法: 折叠前从历史里**确定性**抽出三件事(用户要什么 · 已经做到哪 · 下一步 ✓)+ 落成一条 system 消息
+ *   **紧跟摘要**放回 ⇒ 摘要丢了目标它也还在 ✓。不调模型(便宜 ✓ 可测 ✓)。
+ */
+export function buildGoalAnchor(collapsed, remaining = []) {
+    const all = [...collapsed, ...remaining];
+    if (!all.length)
+        return null;
+    const clip = (s, n) => String(s ?? '').replace(/\s+/g, ' ').trim().slice(0, n);
+    // ⓐ 用户当前要的(最近一条 user ✓ —— 若在 remaining 里也没关系, 取全局最后一条 ✓)
+    const lastUser = [...all].reverse().find((m) => m.role === 'user');
+    const ask = lastUser ? clip(String(lastUser.content || ''), 300) : '';
+    // ⓑ 已经做到哪: 最近 3 个工具动作(名字 + 结果要点 ✓)
+    const tools = all.filter((m) => m.role === 'tool').slice(-3).map((m) => {
+        const r = m.toolResult;
+        const head = clip(String(r?.error || r?.output || m.content || ''), 80);
+        return `  · ${m.tool || 'tool'}: ${head}`;
+    });
+    // ⓒ 助手最后说的一句话(它的意图/下一步 ✓)
+    const lastAssistant = [...all].reverse().find((m) => m.role === 'assistant' && String(m.content || '').trim());
+    const said = lastAssistant ? clip(String(lastAssistant.content || ''), 200) : '';
+    const body = [
+        '【压缩前的现场 · 别丢】',
+        ask ? `用户当前要的: ${ask}` : '用户当前要的: (未捕捉到 —— 若不确定, 先按最近的目标继续, 别改题)',
+        tools.length ? `已经做过:\n${tools.join('\n')}` : '',
+        said ? `我上一步说的是: ${said}` : '',
+        '下一步: 接着把上面这件事**做完** —— 不要重头问、不要换目标、不要重复已完成的步骤。',
+    ].filter(Boolean).join('\n');
+    return { role: 'system', content: body };
+}