@bolloon/bolloon-agent 0.4.6 → 0.4.8

package/dist/agents/memory-recall.js

@@ -0,0 +1,115 @@
+/**
+ * memory-recall.ts — 运行时记忆召回 (2026-08-12, TaskM1)
+ *
+ * 借鉴 hermes MemoryManager.prefetch_all: 每轮对话开始前, 根据用户消息自动检索
+ * 历史 memory 摘要, 注入 system prompt — 让 agent 运行时能"回忆起"之前的 session 记忆,
+ * 而不是只靠启动时批量压缩摘要.
+ *
+ * 机制:
+ *   - 从 ~/.bolloon/memory/<agentId>/sessions/*.summary.md 读历史摘要 (memory-compressor 落盘)
+ *   - 用关键词 + BM25 简单打分, 召回与用户消息最相关的 N 条
+ *   - 拼成 hermes 式 <memory-context> 围栏块注入 (含 sanitize, 防模型当新用户输入)
+ *   - 失败静默 (召回是增强层, 不阻塞对话主路径)
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { getMemoryDir } from '../bootstrap/memory-compressor.js';
+const home = () => process.env.HOME || os.homedir() || '/tmp';
+/** 提取查询关键词 (去掉停用词, 中文按 2-gram, 英文按词) */
+export function tokenizeQuery(query) {
+    const clean = String(query || '').trim().toLowerCase();
+    if (!clean)
+        return [];
+    const STOP = new Set(['的', '了', '是', '我', '你', '他', '她', '它', '我们', '你们', '在', '和', '与', '吗', '呢', '吧', '这', '那', '个', '请', '帮', '一下', '一个', '怎么', '如何', 'the', 'a', 'an', 'is', 'are', 'to', 'of', 'for']);
+    const tokens = new Set();
+    // 英文单词
+    for (const m of clean.match(/[a-z][a-z0-9_]*/g) || []) {
+        if (!STOP.has(m) && m.length > 1)
+            tokens.add(m);
+    }
+    // 中文 2-gram
+    const cjk = clean.replace(/[^\u4e00-\u9fff]/g, '');
+    for (let i = 0; i + 1 < cjk.length; i++) {
+        const big = cjk.slice(i, i + 2);
+        if (!STOP.has(big))
+            tokens.add(big);
+    }
+    return Array.from(tokens);
+}
+/** BM25 风格: 摘要中出现查询 token 的次数打分 (简化: 命中数 + 稀有度) */
+export function scoreSummary(text, tokens) {
+    if (tokens.length === 0)
+        return 0;
+    const lower = text.toLowerCase();
+    let score = 0;
+    for (const t of tokens) {
+        if (lower.includes(t))
+            score += 1;
+    }
+    return score;
+}
+/** 扫描 memory 目录的摘要文件 */
+async function listSummaryFiles(agentId, homeDir) {
+    const dir = path.join(getMemoryDir(agentId, homeDir), 'sessions');
+    let files;
+    try {
+        files = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    return files.filter((f) => f.endsWith('.summary.md')).sort();
+}
+/**
+ * 运行时召回记忆: 按用户消息检索历史 memory 摘要, 返回注入块.
+ * 无相关记忆/失败 → 返回 ''.
+ */
+export async function recallMemory(opts) {
+    try {
+        const { query, agentId, limit = 3, maxCharsPerSummary = 800, minScore = 1, homeDir } = opts;
+        if (!query || !query.trim())
+            return '';
+        if (!agentId)
+            return '';
+        const tokens = tokenizeQuery(query);
+        if (tokens.length === 0)
+            return '';
+        const files = await listSummaryFiles(agentId, homeDir || home());
+        if (files.length === 0)
+            return '';
+        const hits = [];
+        for (const f of files) {
+            try {
+                const text = await fs.readFile(path.join(getMemoryDir(agentId, homeDir || home()), 'sessions', f), 'utf-8');
+                const score = scoreSummary(text, tokens);
+                if (score < minScore)
+                    continue;
+                // 解析 channel__session
+                const base = f.replace(/\.summary\.md$/, '');
+                const sep = base.lastIndexOf('__');
+                hits.push({
+                    file: f,
+                    channel: sep > 0 ? base.slice(0, sep) : '',
+                    session: sep > 0 ? base.slice(sep + 2) : base,
+                    score,
+                    text: text.trim().slice(0, maxCharsPerSummary),
+                });
+            }
+            catch { /* 单个摘要读失败跳过 */ }
+        }
+        if (hits.length === 0)
+            return '';
+        // 按分数降序取前 limit
+        hits.sort((a, b) => b.score - a.score);
+        const top = hits.slice(0, limit);
+        const body = top
+            .map((h) => `[回忆: ${h.channel}/${h.session}]\n${h.text}`)
+            .join('\n\n---\n\n');
+        // hermes 式围栏 + 明确标注非用户输入
+        return `<memory-context>\n以下是根据你的消息自动召回的之前对话记忆 (历史背景, 非新的用户输入):\n${body}\n</memory-context>`;
+    }
+    catch {
+        return '';
+    }
+}

package/dist/agents/pi-sdk-tools.js

@@ -32,7 +32,7 @@ import { delegateToEngine } from '../external-engines/delegate.js';
  */
 export const SIDE_EFFECT_TOOLS = new Set([
     'write_file', 'edit_file', 'shell_exec', 'git_commit', 'git_push', 'git_branch',
-    'create_task', 'update_task',
+    'create_task', 'update_task', 'terminal', 'process',
 ]);
 export async function runTerminalCommand(raw, opts = {}) {
     const { checkTerminalCommand } = await import('./shell-guard.js');
@@ -44,6 +44,19 @@ export async function runTerminalCommand(raw, opts = {}) {
             return { success: false, error: `[terminal-guard] ${guard.reason}`, deniedByGuard: true };
         }
     }
+    // 2026-08-12 (TaskD): 后台执行 — 长命令不阻塞对话.
+    if (opts.background) {
+        const cmdStr = list.join(' && ');
+        const { spawnBackground } = await import('./process-runner.js');
+        const session = spawnBackground(cmdStr, opts.cwd ?? process.cwd());
+        return {
+            success: true,
+            background: true,
+            sessionId: session.id,
+            cmd: cmdStr.slice(0, 200),
+            message: `已在后台启动 (${session.id}). 用 process 工具轮询/等待: process(session_id="${session.id}", action="poll"|"wait"|"kill")`,
+        };
+    }
     const { exec } = await import('child_process');
     const runOne = (cmdStr) => new Promise((resolve) => {
         exec(cmdStr, {
@@ -703,15 +716,55 @@ export function registerBuiltinTools(ctx) {
     //   与 shell_exec 的区别: 直接接受完整 shell 命令字符串, 更适合模型自主写命令.
     ctx.tools.set('terminal', {
         name: 'terminal',
-        description: '执行完整 shell 命令 (支持管道/重定向/写文件/跑脚本). 护栏只挡高危破坏操作 (sudo/格式化/rm -rf 根目录/写 ~/.bolloon 数据), 其余灵活放行. 适合: 写 HTML 文件、跑 python/node 脚本、查系统状态、装依赖. 多条命令用 commands 数组并行执行.',
-        parameters: { command: '完整 shell 命令 (必填, 如: echo "<html>" > /tmp/site/index.html && ls /tmp/site)', commands: '可选: 多条命令数组 (并行执行), 每条独立字符串', timeoutMs: '超时毫秒, 默认 30000' },
+        description: '执行完整 shell 命令 (支持管道/重定向/写文件/跑脚本). 护栏只挡高危破坏操作 (sudo/格式化/rm -rf 根目录/写 ~/.bolloon 数据), 其余灵活放行. 适合: 写 HTML 文件、跑 python/node 脚本、查系统状态、装依赖. 多条命令用 commands 数组并行执行. 长命令 (服务器/构建/后台任务) 设 background=true 后台执行不阻塞对话.',
+        parameters: { command: '完整 shell 命令 (必填, 如: echo "<html>" > /tmp/site/index.html && ls /tmp/site)', commands: '可选: 多条命令数组 (并行执行), 每条独立字符串', timeoutMs: '超时毫秒, 默认 30000', background: '可选: true 后台执行, 立即返回 session_id (用 process 工具 poll/wait/kill)' },
         execute: async (args) => {
             const raw = String(args.command || '').trim();
             const commands = Array.isArray(args.commands) ? args.commands.map((c) => String(c || '').trim()).filter(Boolean) : [];
             if (!raw && commands.length === 0)
                 return { success: false, error: 'command 或 commands 必填' };
             const timeoutMs = Number(args.timeoutMs) || 30000;
-            return await runTerminalCommand(raw, { timeoutMs, cwd: ctx.cwd, commands: commands.length > 0 ? commands : undefined });
+            return await runTerminalCommand(raw, { timeoutMs, cwd: ctx.cwd, commands: commands.length > 0 ? commands : undefined, background: String(args.background).toLowerCase() === 'true' });
+        }
+    });
+    // 2026-08-12 (TaskD): process — 后台进程管理 (学 hermes terminal background session + poll/wait/kill).
+    //   长命令不阻塞对话: terminal(background=true) 启动 → process 工具轮询/等待/终止.
+    ctx.tools.set('process', {
+        name: 'process',
+        description: '管理后台进程 (terminal background=true 启动的). action: poll(查状态, 不阻塞) / wait(等结束, 最多 timeoutMs) / kill(终止) / list(列全部). 长期运行命令的阻塞问题用它解决.',
+        parameters: { session_id: '后台进程 session_id (必填, poll/wait/kill 用)', action: 'poll | wait | kill | list (默认 poll)', timeoutMs: 'wait 模式等待上限毫秒, 默认 30000' },
+        execute: async (args) => {
+            const action = String(args.action || 'poll').trim().toLowerCase();
+            try {
+                const { pollSession, waitSession, killSession, listSessions, isValidSessionId } = await import('./process-runner.js');
+                if (action === 'list') {
+                    const all = listSessions();
+                    return { success: true, output: all.length === 0 ? '(无后台进程)' : all.map((s) => `  [${s.status}] ${s.id} ${s.cmd}`).join('\n') };
+                }
+                const sid = String(args.session_id || '').trim();
+                if (!sid)
+                    return { success: false, error: 'session_id 必填' };
+                if (!isValidSessionId(sid))
+                    return { success: false, error: 'session_id 非法' };
+                if (action === 'kill') {
+                    const r = killSession(sid);
+                    return { success: r.ok, output: r.reason ?? `已终止 ${sid}` };
+                }
+                if (action === 'wait') {
+                    const t = Number(args.timeoutMs) || 30000;
+                    const r = await waitSession(sid, t);
+                    return { success: r.ok, output: r.session ? `${r.session.status} exit=${r.session.exitCode}${r.session.timedOut ? ' (超时)' : ''}\n${r.session.output || '(无输出)'}` : '未知 session' };
+                }
+                // poll
+                const r = pollSession(sid);
+                if (!r.ok || !r.session)
+                    return { success: false, error: `未知 session ${sid}` };
+                const s = r.session;
+                return { success: true, output: `[${s.status}] exit=${s.exitCode}${s.status === 'running' ? ' (运行中)' : ''}\n${s.output || '(无输出)'}` };
+            }
+            catch (e) {
+                return { success: false, error: `process ${action} 失败: ${String(e?.message || e).slice(0, 200)}` };
+            }
         }
     });
     // self_improve
@@ -746,6 +799,15 @@ export function registerBuiltinTools(ctx) {
             }
             try {
                 const absPath = path.resolve(ctx.cwd, relPath);
+                // 2026-08-12 (TaskC): 写前暂存 (准备阶段) — 记录变更前快照, 支持审计/撤销. 失败静默.
+                let before = '';
+                try {
+                    before = await fs.readFile(absPath, 'utf-8');
+                }
+                catch { /* 新文件 */ }
+                const action = before.length > 0 ? 'overwrite' : 'create';
+                const { stageWrite } = await import('./write-staging.js');
+                await stageWrite(relPath, before, content, action, ctx.cwd).catch(() => { });
                 await fs.mkdir(path.dirname(absPath), { recursive: true });
                 await fs.writeFile(absPath, content, 'utf-8');
                 return { success: true, output: `✅ wrote ${relPath} (${content.length} bytes)` };
@@ -778,6 +840,9 @@ export function registerBuiltinTools(ctx) {
                     return { success: false, error: `old_text 在 ${relPath} 中未找到, 拒绝静默写入. 请先用 read_document 读最新内容.` };
                 }
                 const updated = original.replace(oldText, newText);
+                // 2026-08-12 (TaskC): 写前暂存 (准备阶段) — 记录变更前快照, 支持审计/撤销. 失败静默.
+                const { stageWrite } = await import('./write-staging.js');
+                await stageWrite(relPath, original, updated, 'edit', ctx.cwd).catch(() => { });
                 await fs.writeFile(absPath, updated, 'utf-8');
                 return { success: true, output: `✅ edited ${relPath} (${oldText.length} → ${newText.length} 字节)` };
             }

package/dist/agents/pi-sdk.js

@@ -760,6 +760,16 @@ export class PiAgentSession {
         });
         // 2026-06-18: web server 喂的 markedPrompt 外的 contextHint 拼到 system 末尾 (而不是当 user message)
         this.contextHintAddition = contextHint;
+        // 2026-08-12 (TaskM1, hermes prefetch 模式): 运行时按用户消息召回历史记忆, 注入 system prompt.
+        //   让 agent 能"回忆起"之前 session 的记忆 (自动获取之前 session), 而非只靠启动时批量压缩.
+        try {
+            const { recallMemory } = await import('./memory-recall.js');
+            const recalled = await recallMemory({ query: userText, agentId: this.currentAgentId || this.peerId || '' });
+            if (recalled) {
+                this.contextHintAddition = [this.contextHintAddition, recalled].filter(Boolean).join('\n\n');
+            }
+        }
+        catch { /* 记忆召回失败静默 (增强层) */ }
         onStream({ type: 'thinking', content: '🤔 开始思考...' });
         if (!this.minimaxAvailable) {
             const response = await this.handleFallback(userText);

package/dist/agents/process-runner.js

@@ -0,0 +1,105 @@
+/**
+ * process-runner.ts — 后台进程管理 (2026-08-12, TaskD)
+ *
+ * 借鉴 hermes terminal_tool: 长期运行命令不应阻塞对话.
+ *   - foreground: 命令结束立即返回 (即使超时设长, 不 sleep 阻塞)
+ *   - background: spawn 后台执行, 返回 session_id, 用 process(action=poll/wait/kill) 管理
+ *   - 禁止 nohup/setsid/trailing '&' — 用 background 让系统跟踪进程
+ *
+ * 进程注册表: 模块级 Map<sessionId, {proc, cmd, startedAt, output[]}>, 供 process 工具查询.
+ */
+import { spawn } from 'child_process';
+import * as path from 'path';
+const sessions = new Map();
+let seq = 0;
+function genId() {
+    seq++;
+    return `proc-${Date.now().toString(36)}-${seq}`;
+}
+/**
+ * 后台启动一个 shell 命令. 立即返回 session 记录 (不阻塞).
+ * 命令字符串经调用方 (runTerminalCommand) 护栏检查.
+ */
+export function spawnBackground(raw, cwd = process.cwd()) {
+    const id = genId();
+    const session = { id, cmd: raw.slice(0, 300), cwd, startedAt: Date.now(), exitCode: null, status: 'running', output: '', proc: null };
+    sessions.set(id, session);
+    // Windows 用 cmd /c; POSIX 用 /bin/sh -c
+    const shell = process.platform === 'win32' ? 'cmd' : '/bin/sh';
+    const shellArgs = process.platform === 'win32' ? ['/c', raw] : ['-c', raw];
+    try {
+        const proc = spawn(shell, shellArgs, { cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }, windowsHide: true });
+        session.proc = proc;
+        proc.stdout.on('data', (d) => { session.output = (session.output + d.toString()).slice(-16000); });
+        proc.stderr.on('data', (d) => { session.output = (session.output + d.toString()).slice(-16000); });
+        proc.on('close', (code) => { session.exitCode = code; session.status = 'exited'; });
+        proc.on('error', (e) => { session.status = 'error'; session.error = e.message; });
+    }
+    catch (e) {
+        session.status = 'error';
+        session.error = e?.message;
+    }
+    return session;
+}
+/** 查询后台进程状态 (不阻塞). 返回脱敏视图. */
+export function pollSession(id) {
+    const s = sessions.get(id);
+    if (!s)
+        return { ok: false, found: false };
+    return {
+        ok: true,
+        found: true,
+        session: {
+            id: s.id, cmd: s.cmd, startedAt: s.startedAt, exitCode: s.exitCode,
+            status: s.status, output: s.output.slice(-4000), error: s.error,
+        },
+    };
+}
+/** 等待后台进程结束 (最多 timeoutMs). 返回最终状态. */
+export async function waitSession(id, timeoutMs = 30000) {
+    const s = sessions.get(id);
+    if (!s)
+        return { ok: false, error: `未知 session ${id}` };
+    if (s.status !== 'running') {
+        return { ok: true, session: { id: s.id, status: s.status, exitCode: s.exitCode, output: s.output.slice(-4000) } };
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline && s.status === 'running') {
+        await new Promise((r) => setTimeout(r, 250));
+    }
+    return {
+        ok: s.status !== 'running',
+        session: { id: s.id, status: s.status, exitCode: s.exitCode, output: s.output.slice(-4000), timedOut: s.status === 'running' },
+    };
+}
+/** 杀死后台进程. 返回是否已终止. */
+export function killSession(id) {
+    const s = sessions.get(id);
+    if (!s)
+        return { ok: false, reason: `未知 session ${id}` };
+    if (s.status !== 'running' || !s.proc) {
+        return { ok: true, reason: `进程已 ${s.status}` };
+    }
+    try {
+        if (process.platform === 'win32')
+            s.proc.kill('SIGTERM');
+        else
+            s.proc.kill('SIGTERM');
+        s.status = 'killed';
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, reason: `kill 失败: ${e?.message}` };
+    }
+}
+/** 列出所有后台进程 */
+export function listSessions() {
+    return Array.from(sessions.values()).map((s) => ({ id: s.id, cmd: s.cmd, status: s.status, exitCode: s.exitCode }));
+}
+/** session id 合法性 (防注入) */
+export function isValidSessionId(id) {
+    return /^proc-[a-z0-9]+-\d+$/.test(id || '');
+}
+export function sessionIdFromPath(p) {
+    return path.basename(String(p || '').trim());
+}

package/dist/agents/write-staging.js

@@ -0,0 +1,85 @@
+/**
+ * write-staging.ts — 写操作准备阶段适配 (2026-08-12, TaskC)
+ *
+ * 借鉴 hermes write_approval.py 的 staging gate: 写操作先 stage (暂存) 再 commit,
+ * 保留完整 payload (可重放/回滚) 用于审计与撤销 — 但不强制人工审批 (bolloon 是自主 agent,
+ * 写操作直接提交, 只是保留 stage 记录做"准备阶段"审计, 不打断自主循环).
+ *
+ * 设计:
+ *   - 每次 write_file / edit_file 写盘前, 记录一条 stage 到 ~/.bolloon/write-log/<ts>-<rand>.json
+ *   - stage 记录含: 相对路径 / 绝对路径 / action (create|overwrite|edit) / 变更前内容快照 / 变更意图 / 时间
+ *   - 提供 listStagedWrites / undoLastWrite (撤销最近一次写) / getStagedWrite
+ *   - 失败静默 (写日志不影响工具主路径)
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+const home = () => process.env.HOME || os.homedir() || '/tmp';
+export function writeLogDir(homeDir = home()) {
+    return path.join(homeDir, '.bolloon', 'write-log');
+}
+/** 生成唯一 stage id */
+function genId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+}
+/**
+ * 写前暂存: 记录一次写操作 (准备阶段). 返回记录; 失败静默返回 null.
+ * @param relPath 相对路径
+ * @param beforeContent 变更前内容 (读盘或空)
+ * @param afterContent 变更后内容
+ * @param action 动作类型
+ */
+export async function stageWrite(relPath, beforeContent, afterContent, action, cwd = process.cwd(), homeDir = home()) {
+    try {
+        const id = genId();
+        const absPath = path.resolve(cwd, relPath);
+        const rec = { id, absPath, relPath, action, beforeContent, afterContent, createdAt: Date.now() };
+        const dir = writeLogDir(homeDir);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(path.join(dir, `${id}.json`), JSON.stringify(rec, null, 2), 'utf-8');
+        return rec;
+    }
+    catch {
+        return null;
+    }
+}
+/** 列出最近的暂存写记录 (新→旧) */
+export async function listStagedWrites(homeDir = home()) {
+    const dir = writeLogDir(homeDir);
+    let files;
+    try {
+        files = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const f of files.filter(f => f.endsWith('.json')).sort().reverse()) {
+        try {
+            out.push(JSON.parse(await fs.readFile(path.join(dir, f), 'utf-8')));
+        }
+        catch { /* 坏文件跳过 */ }
+    }
+    return out;
+}
+/** 撤销最近一次写 (若文件内容仍等于 afterContent → 恢复 beforeContent). 返回是否撤销. */
+export async function undoLastWrite(homeDir = home()) {
+    const staged = await listStagedWrites(homeDir);
+    if (staged.length === 0)
+        return { ok: false, reason: '无暂存写记录' };
+    const rec = staged[0];
+    try {
+        // 仅当文件未被后续修改 (内容仍 = afterContent) 时才安全撤销
+        const current = await fs.readFile(rec.absPath, 'utf-8').catch(() => null);
+        if (current === rec.afterContent) {
+            await fs.writeFile(rec.absPath, rec.beforeContent, 'utf-8');
+            // 清理该 stage 记录
+            await fs.rm(path.join(writeLogDir(homeDir), `${rec.id}.json`), { force: true }).catch(() => { });
+            return { ok: true };
+        }
+        return { ok: false, reason: '文件已被后续修改, 跳过撤销' };
+    }
+    catch (e) {
+        return { ok: false, reason: `撤销失败: ${e?.message}` };
+    }
+}

package/dist/index.js

@@ -16,7 +16,7 @@ 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 } from './cli/loading-tui.js';
-import { startInk, stopInk, inkAppendLine as appendLine, inkReplaceLastLine as replaceLastLine, inkSetStatus, inkSetThinking, inkSetTransient } from './cli/ink-app.js';
+import { startInk, stopInk, inkAppendLine as appendLine, inkSetStatus, inkSetThinking, inkSetTransient } from './cli/ink-app.js';
 // 启动自动检查更新：后台、节流、检测到新版本自动安装（可被 --no-update / BOLLOON_SKIP_UPDATE 关闭）
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
@@ -1850,10 +1850,12 @@ async function processInput(input, comm) {
                     tuiToolCounter++;
                     const toolName = e.tool || '?';
                     tuiToolCalls.push({ tool: toolName, args: e.args, _t: Date.now() });
-                    // 2026-08-12 (Task4): 命令/工具调用显示加载态 — 追加一行 "运行中", done 时原地替换.
-                    //   system/loop 这类内部步骤不显示, 只显示真实工具/命令调用.
+                    // 2026-08-12 (TaskA): 工具命中要干净 — step_start 不 appendLine 到消息流 (避免重复),
+                    //   改用 transient 行显示"正在执行"(消息流只在 done 时出现一次完成行).
                     if (toolName !== 'system' && toolName !== 'loop' && toolName !== '?') {
-                        appendLine(`  ${C_DIM}🔧 ${toolName} 运行中...${RESET}`);
+                        const activeNames = tuiToolCalls.map(c => c.tool).filter(t => t !== 'system' && t !== 'loop' && t !== '?');
+                        const label = activeNames.length > 1 ? `执行 ${activeNames.length} 个工具: ${activeNames.join(', ')}` : `🔧 ${toolName}`;
+                        inkSetTransient(`${C_DIM}${label} 运行中...${RESET}`);
                     }
                 }
                 else if (e.type === 'step_done' || e.type === 'step_error') {
@@ -1872,13 +1874,20 @@ async function processInput(input, comm) {
                             runEndOkSteps.push({ status: 'ok', name: t, output: e.output });
                         }
                     }
-                    // 2026-08-12 (Task4): done/error 原地替换 step_start 的加载行 (若 tool 非内部).
+                    // 2026-08-12 (TaskA): 每个工具只在消息流出现一次 (done 时 appendLine 完成行).
+                    //   不 replaceLastLine (并行/thinking 交错会替换错行); 完成行固定追加.
                     const doneTool = e.tool ?? p?.tool;
                     if (doneTool !== 'system' && doneTool !== 'loop' && doneTool !== '?') {
-                        replaceLastLine(renderToolCallListItem(doneItem, tuiToolCalls.length + 1, tuiToolCounter));
+                        appendLine(renderToolCallListItem(doneItem, tuiToolCalls.length + 1, tuiToolCounter));
+                    }
+                    // 更新 transient: 还有进行中的工具 → 显示下一个; 否则清空 (交回 thinking 动画)
+                    const remaining = tuiToolCalls.filter(c => c.tool !== 'system' && c.tool !== 'loop' && c.tool !== '?');
+                    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}`);
                     }
                     else {
-                        appendLine(renderToolCallListItem(doneItem, tuiToolCalls.length + 1, tuiToolCounter));
+                        inkSetTransient(null);
                     }
                 }
             }
@@ -1903,6 +1912,33 @@ async function processInput(input, comm) {
                 }
             });
         }
+        // 2026-08-12 (TaskM2, hermes sync 模式): CLI 对话结束后同步记忆 — 每轮 compressSessionToMemory
+        //   把本会话消息压缩成摘要 (≥4 新消息触发), 供后续运行时 recallMemory 自动召回 (跨 session 记忆).
+        //   Web 模式 server.ts 已有, CLI 之前缺失 → CLI 下无摘要可召回. 失败静默, 不阻塞对话.
+        if (cliActiveChannelId) {
+            setImmediate(async () => {
+                try {
+                    const { compressSessionToMemory } = await import('./bootstrap/memory-compressor.js');
+                    const channelForMem = String(cliActiveChannelId || '');
+                    let sessionId = 'default';
+                    try {
+                        const { getIdentityStore } = await import('./agents/agent-identity-store.js');
+                        const store = getIdentityStore();
+                        await store.load();
+                        const ch = store.rawChannels.find((c) => c.id === channelForMem);
+                        if (ch && ch.currentSessionId)
+                            sessionId = String(ch.currentSessionId);
+                    }
+                    catch { /* 读 sessionId 失败用 default */ }
+                    await compressSessionToMemory({
+                        agentId: getCliAgentId(),
+                        channelId: channelForMem,
+                        sessionId,
+                    });
+                }
+                catch { /* 记忆压缩失败静默 */ }
+            });
+        }
         // 更新状态栏: 上下文进度 (2026-08-06: 每轮按当前 messageHistory 重算并写回 ContextManager,
         //   保证状态栏按需更新 — 不依赖 pi-sdk loop 内部上报, 1s 定时器读到的一定是最新值)
         // 2026-08-07 修复: pi-sdk loop 每轮已用 estimateHistoryTokens() 上报 ContextManager (pi-sdk.ts:1223),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bolloon/bolloon-agent",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "type": "module",
   "description": "P2P AI Document Agent - 全局安装后执行 `bolloon` 启动产品",
   "main": "dist/cli-entry.js",