@bolloon/bolloon-agent 0.5.3 → 0.5.5

package/dist/cli/session-summary.js

@@ -0,0 +1,129 @@
+/**
+ * session-summary.ts — 用 AI 给**会话**起标题 + 一句话摘要 (leo 2026-09-30)
+ *
+ * 起因: `/sessions` 表格里 Title 那列原来只能显示会话 key (`20260930_171712_840093`),
+ *   Preview 常常是 `—` —— leo: 「Title, Preview 要有内容, 使用 AI 来总结进去」。
+ *
+ * 三条纪律:
+ *   1. **只算一次** —— 结果写回会话文件 `metadata.{title,preview,summarizedAt}`; 下次直接读, 不再花钱。
+ *   2. **不编** —— AI 不可用/输出不合规时, 退回"真实首条用户消息"当 preview, title 保持 key,
+ *      并把 `source` 如实标出来 (调用方据此决定要不要提示用户)。
+ *   3. **不卡** —— 单条会话有超时 (默认 12s), 失败不留半截标题 (整条要么写成功要么不写)。
+ */
+import { SessionStore } from '../agents/session-store.js';
+import { getMinimax } from '../llm/pi-ai.js';
+/**
+ * 自动注入的上下文块 (不是用户说的话)。
+ *   ⚠ 2026-09-30 真机发现 (leo: 「结束进程的时候没有加载 title 和总结」): CLI 把**用户那句话
+ *   **附在注入块末尾**, 用 `\n---\n` 分隔 —— 实测长这样:
+ *       <!-- current-turn: … -->
+ *       # 你的项目上下文 (自动 bootstrap …)
+ *       … [预算截断]
+ *
+ *       ---
+ *
+ *       你好
+ *   ⇒ 整块丢掉的话, 所有 CLI 会话都"没有用户内容" (标题永远出不来)。
+ *   正确做法: **取末尾那一段**当用户输入 (见 userTextFrom), 只把真正的上下文头当注入。
+ */
+const isInjected = (x) => /^<!--/.test(x.trim()) || /^#\s*你的项目上下文/.test(x.trim()) || /^\[cron\]/.test(x.trim()) || /^<!-- current-turn/.test(x.trim());
+/**
+ * 从一条 user 消息里取"真正属于用户的那句话":
+ *   · 普通消息 → 原样
+ *   · 注入块 → 取最后一个 `---` 分隔线之后的尾巴 (那是用户的输入)
+ *   · 拿不到有效尾巴 (还是上下文/太短) → 返回空串 (调用方跳过)
+ */
+export function userTextFrom(content) {
+    const c = String(content || '').trim();
+    if (!c)
+        return '';
+    if (!isInjected(c))
+        return c;
+    const parts = c.split(/\n\s*-{3,}\s*\n/);
+    const tail = (parts[parts.length - 1] || '').trim();
+    if (!tail || isInjected(tail))
+        return '';
+    // 尾巴太短 (一两个字符) 多半是分隔符残渣, 不算用户内容
+    return tail.length >= 2 ? tail : '';
+}
+const clip = (s, n) => s.replace(/\s+/g, ' ').trim().slice(0, n);
+const SYS = '你是终端会话的命名器。只输出一行 JSON, 不要解释、不要代码块、不要多余文字。';
+const buildPrompt = (head, tail) => `下面是同一个终端会话的「开头」和「结尾」。请用中文输出一行 JSON:\n` +
+    `{"title":"不超过 20 个字的标题, 说清这次会话在做什么", "preview":"不超过 40 个字, 一句话摘要, 最有信息量的那件事"}\n\n` +
+    `【开头】\n${head}\n\n【结尾】\n${tail}\n`;
+/** 从模型输出里抠出第一个 JSON 对象 (抗代码块/前后废话) */
+function parseDigest(raw) {
+    const m = raw.match(/\{[\s\S]*?\}/);
+    if (!m)
+        return null;
+    try {
+        const o = JSON.parse(m[0]);
+        const title = clip(String(o.title ?? ''), 28);
+        const preview = clip(String(o.preview ?? ''), 56);
+        if (!title)
+            return null;
+        return { title, preview };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 给一条会话生成标题 + 摘要。已经算过 (metadata.title) 就直接返回, 不再调模型。
+ * 失败时不抛错 —— 返回 raw/none, 让调用方如实显示。
+ */
+export async function summarizeSession(key, opts = {}) {
+    const store = opts.store ?? new SessionStore();
+    let msgs = [];
+    let meta = {};
+    try {
+        const raw = JSON.parse(await (await import('fs/promises')).readFile(store.pathFor(key), 'utf-8'));
+        msgs = Array.isArray(raw) ? raw : (raw?.messages || []);
+        meta = (!Array.isArray(raw) && raw?.metadata) || {};
+    }
+    catch {
+        return { title: key, preview: '', source: 'none' };
+    }
+    if (!opts.force && typeof meta.title === 'string' && meta.title.trim()) {
+        return { title: String(meta.title), preview: String(meta.preview ?? ''), source: 'ai' };
+    }
+    // 2026-09-30: 用 userTextFrom 而不是"整块丢掉" —— 用户的话在注入块末尾 (见上面注释)
+    const userTexts = msgs
+        .filter(m => m?.role === 'user' && typeof m.content === 'string')
+        .map(m => userTextFrom(String(m.content)))
+        .filter(t => t.length > 0);
+    const userMsgs = userTexts.map(t => ({ content: t }));
+    const rawPreview = userMsgs.length ? clip(String(userMsgs[0].content), 56) : '';
+    if (!userMsgs.length)
+        return { title: key, preview: '', source: 'none' };
+    const head = userMsgs.slice(0, 2).map(m => clip(String(m.content), 300)).join('\n');
+    const tailFrom = msgs.filter(m => typeof m?.content === 'string' && m.content.trim()).slice(-2);
+    const tail = tailFrom.map(m => `${m.role}: ${clip(String(m.content), 300)}`).join('\n');
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), Math.max(2000, opts.timeoutMs ?? 12_000));
+    try {
+        const llm = getMinimax();
+        const res = await llm.chat(buildPrompt(head, tail), SYS, ac.signal, undefined, 'auto-compact', 'session-summary');
+        // 2026-09-30 实测: chat() 返回的是**对象** `{reply, reasoningContent, toolCalls, messages, usage}`
+        //   —— 文本在 `reply` (第一版写成 String(raw) ⇒ 拿到 "[object Object]" ⇒ 总结永远退回 raw)。
+        const text = typeof res === 'string'
+            ? res
+            : String(res?.reply ?? res?.content ?? res?.text ?? '');
+        const parsed = parseDigest(text);
+        if (parsed) {
+            // 整条写回 (要么全写, 要么不写) —— 下次 /sessions 直接读, 不再调模型
+            try {
+                await store.updateMetadata(key, { title: parsed.title, preview: parsed.preview, summarizedAt: Date.now() });
+            }
+            catch { /* 写不进也不影响这次显示 */ }
+            return { title: parsed.title, preview: parsed.preview, source: 'ai' };
+        }
+        return { title: key, preview: rawPreview, source: 'raw' };
+    }
+    catch {
+        return { title: key, preview: rawPreview, source: 'raw' };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/cli/session-tree.js

@@ -0,0 +1,141 @@
+/**
+ * session-tree.ts — 会话树: 用 git 管理 fork 分支 (leo 2026-09-30)
+ *
+ * 语义 (leo 确认, 标准 branch 语义):
+ *   · `/fork <#|id>` 从某条会话**分叉出一条新会话**: 新会话**继承 fork 点之前的全部历史**,
+ *     之后两条各自独立 (各自继续写自己的文件)。
+ *   · 树用 **git** 管: `~/.bolloon/sessions/` 变成一个仓库, 每次 fork / 退出存档 = 一次 commit,
+ *     commit 里带 `session: <key>` 与 `parent: <源 key>` ⇒ `git log --graph` 就是会话树。
+ *
+ * 三条纪律:
+ *   1. **不吞 git 的输出** —— 成功给 commit 短哈希, 失败给原因 (调用方如实显示)。
+ *   2. **仓库是用户的会话历史** —— 只 init (无仓库时) + add/commit; **绝不** reset/checkout/clean。
+ *   3. **不阻塞对话** —— git 不可用/失败时, fork 本身仍然成功 (文件已写好), 只是树没记上, 如实标注。
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+const pexec = promisify(execFile);
+/** 会话仓库根 = sessions 目录 (里面 cache/ 与 channels.json 都进树) */
+function repoDir(store) {
+    return path.dirname(store.dir);
+}
+async function git(cwd, args) {
+    try {
+        const { stdout, stderr } = await pexec('git', args, { cwd, timeout: 20_000, maxBuffer: 8 * 1024 * 1024 });
+        return { ok: true, out: String(stdout), err: String(stderr) };
+    }
+    catch (e) {
+        return { ok: false, out: String(e?.stdout || ''), err: String(e?.stderr || e?.message || e).slice(0, 300) };
+    }
+}
+/** 仓库不存在就建 (并设本地 user.name/email, 不依赖用户全局 git 配置) */
+export async function ensureTree(store) {
+    const dir = repoDir(store);
+    try {
+        await fs.mkdir(dir, { recursive: true });
+    }
+    catch { /* 已存在 */ }
+    const inside = await git(dir, ['rev-parse', '--git-dir']);
+    if (!inside.ok) {
+        const init = await git(dir, ['init', '-q', '-b', 'main']);
+        if (!init.ok)
+            return { ok: false, error: `git init 失败: ${init.err}` };
+        await git(dir, ['config', 'user.name', 'bolloon']);
+        await git(dir, ['config', 'user.email', 'bolloon@localhost']);
+        // 忽略半截临时文件 (session-store 的原子写会留 .tmp 一瞬间)
+        try {
+            await fs.writeFile(path.join(dir, '.gitignore'), '*.tmp\n', { flag: 'wx' });
+        }
+        catch { /* 已存在 */ }
+    }
+    return { ok: true };
+}
+/**
+ * 把当前状态提交进树。
+ * @param subject 形如 `session: <key> · fork from <src>` —— 树里一眼能看出发生了什么
+ */
+export async function commitTree(store, subject, body) {
+    const ens = await ensureTree(store);
+    if (!ens.ok)
+        return ens;
+    const dir = repoDir(store);
+    const add = await git(dir, ['add', '-A', '--', '.']);
+    if (!add.ok)
+        return { ok: false, error: `git add 失败: ${add.err}` };
+    const args = ['commit', '-q', '--no-verify', '-m', subject];
+    if (body)
+        args.push('-m', body);
+    const c = await git(dir, args);
+    if (!c.ok) {
+        // 没有变化 (nothing to commit) 不算失败 —— 如实区分
+        if (/nothing to commit|no changes added/i.test(c.err) || /nothing to commit/i.test(c.out))
+            return { ok: true, commit: '(无变化)' };
+        return { ok: false, error: `git commit 失败: ${c.err}` };
+    }
+    const rev = await git(dir, ['rev-parse', '--short', 'HEAD']);
+    return { ok: true, commit: rev.ok ? rev.out.trim() : '' };
+}
+/**
+ * fork 一条会话: 继承 fork 点之前的全部历史 + 记 parent 关系 + 落一次 commit。
+ * 标准 branch 语义: 之后两条会话各自独立 (各写各的文件)。
+ */
+export async function forkSession(store, srcKey) {
+    let raw;
+    let srcPath = '';
+    for (const cand of [store.pathFor(srcKey), path.join(store.dir, `${srcKey}.json`)]) {
+        try {
+            raw = JSON.parse(await fs.readFile(cand, 'utf-8'));
+            srcPath = cand;
+            break;
+        }
+        catch { /* 试下一个 */ }
+    }
+    if (!raw)
+        return { ok: false, error: `源会话读不到: ${srcKey}` };
+    const msgs = Array.isArray(raw) ? raw : (raw?.messages || []);
+    const ts = new Date();
+    const p = (n) => String(n).padStart(2, '0');
+    const base = `${ts.getFullYear()}${p(ts.getMonth() + 1)}${p(ts.getDate())}_${p(ts.getHours())}${p(ts.getMinutes())}${p(ts.getSeconds())}`;
+    let newKey = `${base}_fork`;
+    for (let i = 2; i < 50; i++) {
+        try {
+            await fs.access(store.pathFor(newKey));
+            newKey = `${base}_fork${i}`;
+        }
+        catch {
+            break;
+        }
+    }
+    const out = {
+        key: newKey,
+        messages: msgs, // ← 共享 fork 点之前的全部历史 (标准 branch 语义)
+        metadata: {
+            ...(Array.isArray(raw) ? {} : (raw?.metadata || {})),
+            forkedFrom: srcKey,
+            forkPoint: msgs.length,
+            forkedAt: Date.now(),
+            savedAt: Date.now(),
+            cwd: process.cwd(),
+            totalCount: msgs.length,
+            // 继承来的标题加前缀, /sessions 里一眼看出它是分支
+            title: `↳ ${String((Array.isArray(raw) ? {} : raw?.metadata?.title) || srcKey)}`,
+            preview: `从 ${srcKey} 分叉 (fork 点 ${msgs.length} 条)`,
+        },
+    };
+    await fs.writeFile(store.pathFor(newKey), JSON.stringify(out, null, 2), 'utf-8');
+    const committed = await commitTree(store, `session: ${newKey} · fork from ${srcKey} @${msgs.length}`, `fork 点: ${msgs.length} 条消息\n源文件: ${path.relative(repoDir(store), srcPath) || srcKey}`);
+    return { ...committed, newKey, inherited: msgs.length, from: srcKey };
+}
+/** 会话树概览 (给 `/fork --tree` / 诊断用): 最近 N 次提交 + 分支名 */
+export async function treeLog(store, limit = 12) {
+    const ens = await ensureTree(store);
+    if (!ens.ok)
+        return { ok: false, text: '', error: ens.error };
+    const dir = repoDir(store);
+    const log = await git(dir, ['log', `-n${Math.max(1, limit)}`, '--pretty=format:%h %ad | %s', '--date=format:%m-%d %H:%M']);
+    if (!log.ok)
+        return { ok: false, text: '', error: log.err };
+    return { ok: true, text: log.out };
+}

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

@@ -0,0 +1,155 @@
+import { dispWidth } from './loading-tui.js';
+/** 字节 → token 的估算比 (只有这一步是估, 所以显示时标 ≈) */
+export const BYTES_PER_TOKEN = 3.5;
+/** 返回"标签 值"对 (无 ANSI, 调用方拼颜色) —— 顺序: ◷ ↑ ⚙ ✓ */
+export function statusSegments(f) {
+    const out = [];
+    if (f.running) {
+        const secs = Math.max(0.1, f.turnElapsedMs / 1000);
+        out.push(`◷ ${secs.toFixed(1)}s`);
+        const ti = f.aiTiming;
+        if (ti && ti.ms > 0 && ti.bytes > 0 && (!f.turnStartedAt || ti.at >= f.turnStartedAt)) {
+            const tps = Math.round(ti.bytes / BYTES_PER_TOKEN / (ti.ms / 1000));
+            if (tps > 0)
+                out.push(`↑ ≈${tps} t/s`);
+        }
+    }
+    else if (f.lastTurnMs > 0) {
+        out.push(`✓ ${(f.lastTurnMs / 1000).toFixed(1)}s`);
+        if (f.lastTurnReplyBytes > 0) {
+            const tps = Math.round(f.lastTurnReplyBytes / BYTES_PER_TOKEN / Math.max(0.1, f.lastTurnMs / 1000));
+            if (tps > 0)
+                out.push(`↑ ≈${tps} t/s`);
+        }
+    }
+    // ◎ 缓存命中率 = cached / prompt (provider 给的实测值; 没记录/没 prompt 就不显示)
+    const u = f.aiUsage;
+    if (u && u.prompt > 0) {
+        const pct = (u.cached / u.prompt) * 100;
+        out.push(`◎ ${pct.toFixed(1)}%`);
+    }
+    out.push(`⚙ ${f.toolCount}`); // 常显
+    // 会话 Title 不在这里拼 —— leo: 「这个 title 需要顶格右侧」⇒ 由 CLI 右对齐 (见 rightAlignPad)。
+    return out;
+}
+/**
+ * 按可用宽度取舍 (2026-09-30, 真机抓包照出来的问题):
+ *   整行 ~130 字符, 112 列终端里**右边的段直接被截掉** ⇒ 看着像"没出现"。
+ *   规则: 丢的顺序 = ↑ → ◎ → ✓ → ◷ (⚙ 永不丢 —— 它最短, 且"有没有在跑工具"最有信息量);
+ *   每一段都按显示宽算 (中文 2 列)。
+ */
+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) => 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 = ' │ '
+    for (const tag of dropOrder) {
+        if (total() <= avail)
+            break;
+        const i = cur.findIndex(s => s.startsWith(tag));
+        if (i >= 0)
+            cur.splice(i, 1);
+    }
+    return cur;
+}
+/**
+ * 右对齐一段注释 (会话 Title) 需要的**左填充空格数** (纯函数, 可确定性验证)。
+ *
+ * leo 2026-09-30: 「这个 title 需要顶格右侧」= 贴终端右边缘, 不在段后面跟着走。
+ * 规则:
+ *   · 目标右边缘 = width - 1 (**绝不出正好等于终端宽度的行** —— 终端自动换行会把版面撑歪);
+ *   · 至少留 1 个空格与左边内容分开 (挨着就分不清是标题还是段);
+ *   · 放不下 (pad < 1) 返回 null ⇒ 调用方**不显示**标题 (宁可没有, 不挤坏这一行)。
+ */
+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/stores.js

@@ -28,11 +28,27 @@ export function useStore(s) {
 /** transcript: 消息列表 (agent/用户/系统行) — 供虚拟化/滚动/桥接读写 */
 export const transcriptStore = createStore([]);
 export const uiStore = createStore({ status: '', thinking: false, transient: null });
+/**
+ * panel: **固定区**内容 (启动面板等) —— 与会话区**分开**存放.
+ *   2026-09-30 (leo: 「没有做切分区域, 导致顶部面板在回复的时候也被 AI 内容挤坏了」):
+ *   原来面板和会话共用一个 transcript 缓冲 ⇒ 回复一来窗口一滚, 面板就被挤烂/切掉.
+ *   现在面板活在独立 store, 渲染成"上半块固定区", 有自己的高度, 不随会话滚动.
+ */
+export const panelStore = createStore([]);
 // ── 纯函数 action (bridge 与组件都走这里) ────────────────────────────────────
 export function appendMsg(line) {
     const c = transcriptStore.get();
     transcriptStore.set([...c, line]);
 }
+export function appendPanelMsg(line) {
+    const c = panelStore.get();
+    panelStore.set([...c, line]);
+}
+/** 清空固定区 (面板重打时用; 保证"只一块") */
+export function clearPanelMsg() {
+    if (panelStore.get().length)
+        panelStore.set([]);
+}
 export function replaceLastMsg(line) {
     const c = transcriptStore.get();
     if (c.length === 0) {

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