@bolloon/bolloon-agent 0.3.24 → 0.3.25

package/dist/web/server.js

@@ -138,7 +138,7 @@ function isValidWalletAddress(addr) {
 // 2026-07-06: loadChannels / saveChannels / loadSession / saveSession / loadTheme / saveTheme
 // 已抽到 ./server-storage.ts — 这里只保留旧引用供 createWebServer 内部闭包使用
 // TODO: 后续让所有调用走 import, 然后删除这段冗余定义
-import { loadChannels as _loadChannels, saveChannels as _saveChannels, loadSession as _loadSession, saveSession as _saveSession, loadTheme as _loadTheme, saveTheme as _saveTheme, getLastChannelsWriteAt, } from './server-storage.js';
+import { loadChannels as _loadChannels, saveChannels as _saveChannels, loadSession as _loadSession, saveSession as _saveSession, loadTheme as _loadTheme, saveTheme as _saveTheme, getLastChannelsWriteAt, updateChannels, } from './server-storage.js';
 // 包装成闭包内可用的形式, 保持 createWebServer 内代码不用改
 const loadChannels = _loadChannels;
 const saveChannels = _saveChannels;
@@ -151,6 +151,10 @@ let sseClients = new Set();
 // v3: 远端 channel UI 元数据缓存 — key: peerId, value: sanitize 过的 channel 列表
 // in-memory only, 进程重启清空 (judgment 内容永远不在这里)
 let remoteChannelCache = new Map();
+// 2026-08-02: 待处理好友申请 (pending friend requests) — 收到 agent.friend.request 时暂存,
+//   人类通过 UI 处理, 智能体通过工具 list_pending_friend_requests / accept_friend_request 处理。
+//   key: requestId, value: 申请详情 (含 fromPublicKey / name / message / 备注)
+const pendingFriendRequests = new Map();
 // 2026-07-05: 一次性 prompt 附加块 — key: channelId, value: 下一次 LLM prompt 时 prepend 的内容
 //   用于 manifest-loader 加载对方能力后, 仅影响本次对话, 不污染主 prompt
 const nextPromptHints = new Map();
@@ -217,6 +221,48 @@ async function persistRemoteChannelCache() {
 }
 // 启动时立即同步读一次 (异步, 不阻塞)
 loadRemoteChannelCacheFromDisk();
+// 2026-08-02: pending 好友申请持久化 — 重启后智能体/人类仍能看到未处理的申请
+const PENDING_FRIEND_REQ_FILE = `${process.env.HOME || '/tmp'}/.bolloon/pending-friend-requests.json`;
+async function loadPendingFriendRequestsFromDisk() {
+    try {
+        const { readFile } = await import('fs/promises');
+        const { existsSync } = await import('fs');
+        if (!existsSync(PENDING_FRIEND_REQ_FILE))
+            return;
+        const raw = await readFile(PENDING_FRIEND_REQ_FILE, 'utf-8');
+        const obj = JSON.parse(raw);
+        if (obj && typeof obj === 'object') {
+            for (const [reqId, r] of Object.entries(obj)) {
+                if (r && typeof r === 'object' && r.fromPublicKey) {
+                    pendingFriendRequests.set(reqId, r);
+                }
+            }
+            console.log(`[v3-friend] 从磁盘恢复 ${pendingFriendRequests.size} 个待处理好友申请`);
+        }
+    }
+    catch (err) {
+        console.warn('[v3-friend] 恢复 pending 好友申请失败 (非致命):', err.message);
+    }
+}
+async function persistPendingFriendRequests() {
+    try {
+        const { writeFile, mkdir } = await import('fs/promises');
+        const { existsSync } = await import('fs');
+        if (!existsSync(`${process.env.HOME || '/tmp'}/.bolloon`)) {
+            await mkdir(`${process.env.HOME || '/tmp'}/.bolloon`, { recursive: true });
+        }
+        const obj = {};
+        for (const [reqId, r] of pendingFriendRequests.entries()) {
+            obj[reqId] = r;
+        }
+        await writeFile(PENDING_FRIEND_REQ_FILE, JSON.stringify(obj, null, 2), 'utf-8');
+    }
+    catch (err) {
+        console.warn('[v3-friend] 持久化 pending 好友申请失败 (非致命):', err.message);
+    }
+}
+// 启动时恢复 (异步, 不阻塞主流程)
+loadPendingFriendRequestsFromDisk();
 // v3: P2PDirect 引用 (Hyperswarm 薄包装) - 模块级, 因为 web server 闭包里不可用
 let v3P2PRef = null;
 // 2026-07-21: 智能体社交心跳实例 (beacon + 自主决策发起对话), data 事件处理器会引用它
@@ -459,12 +505,14 @@ async function handleV3P2PMessage(parsed, conn, comm) {
     if (op === 'agent.chat.send') {
         // B 端发来: 在 A 节点上对 channelId 跑 LLM, 结果回 B
         // judgment 永远在 A 节点 (buildJudgmentHint 已经用 bound_judgment_ids)
-        const { channelId, text, fromPublicKey } = parsed.payload || {};
+        const { channelId, text, fromPublicKey, autoInvokeTools } = parsed.payload || {};
         if (!channelId || !text) {
             console.warn(`[v3] agent.chat.send 缺少 channelId/text`);
             return;
         }
         const senderKey = fromPublicKey || peerKey;
+        // 2026-08-02: 发送方工具开关 (P2P 对话栏的 🔧 toggle) — 显式 false 时远端消息不调工具
+        const remoteToolsOverride = typeof autoInvokeTools === 'boolean' ? autoInvokeTools : null;
         // 2026-07-29: Dunbar Tier 检查 — 远端 agent 不能触发禁区工具
         const tierState = await loadPeerTier(senderKey);
         if (tierState.tier === 'blocked') {
@@ -588,7 +636,11 @@ async function handleV3P2PMessage(parsed, conn, comm) {
             // 2026-06-15: P2P 远端访客路径也用显式 marker 包裹 text
             // 2026-06-15 二次修: 把 text 放在最前 (与主路径 server.ts:1868 对齐),
             //   避免 LLM 被 judgmentHint 末尾的 "..." 误判为整个 input 被截断
-            const fullPrompt = `【本轮用户请求】\n${text}\n【请求结束】\n\n${visitorHint}${dirHint}${judgmentHint}\n`;
+            // 2026-08-02: 发送方工具开关 (P2P 🔧 toggle) — false 时禁止本轮工具调用
+            const toolsGateHint = remoteToolsOverride === false
+                ? '\n[系统指令] 本轮对话**禁止调用任何工具**, 直接基于已有知识回答即可.\n\n'
+                : '';
+            const fullPrompt = `【本轮用户请求】\n${text}\n【请求结束】\n\n${visitorHint}${dirHint}${toolsGateHint}${judgmentHint}\n`;
             let fullResponse = '';
             // v3 新增: 流式 token 节流推给 B — 让 B 看到过程
             let lastFlushAt = 0;
@@ -610,6 +662,26 @@ async function handleV3P2PMessage(parsed, conn, comm) {
                         comm.sendToConnection(conn.id, msg).catch(() => { });
                     }
                 }
+                // 2026-08-02 fix: 远端路径转发 step 事件 (工具调用过程) — 之前只转 token,
+                //   B 端 P2P 对话看不到工具调用步骤. 复用 agent.chat.thinking 的 phase=step 通道.
+                else if (event.type === 'step_start' || event.type === 'step_done' || event.type === 'step_error') {
+                    const msg = JSON.stringify({
+                        v: 3, op: 'agent.chat.thinking',
+                        payload: {
+                            channelId,
+                            phase: 'step',
+                            stepType: event.type,
+                            tool: event.tool,
+                            content: event.content,
+                            success: event.success,
+                            output: event.output,
+                            error: event.error,
+                            args: event.args,
+                            fromPublicKey: v3P2PRef?.getPublicKey() || ''
+                        }
+                    });
+                    comm.sendToConnection(conn.id, msg).catch(() => { });
+                }
             };
             const agent = await getAgentForChannel(channelId, ch.did || '', ch.name, ch.didDocRef);
             fullResponse = await agent.promptStream(fullPrompt, streamCallback, undefined, channelId);
@@ -1499,7 +1571,11 @@ export async function createWebServer(port = 3000, options = {}) {
                         if (parsed.op === 'agent.heartbeat') {
                             agentHeartbeat?.handleIncoming('agent.heartbeat', parsed.payload, evt.fromPublicKey);
                             // 2026-07-29: 收到心跳也记录交互 (Dunbar 自动归类)
-                            recordInteraction(evt.fromPublicKey).catch(() => { });
+                            // 2026-08-02 fix: 之前不传 text → inferOpponentMove('') = defect,
+                            //   heartbeat 被误判为背叛 → trustScore 持续下跌 → peer 跌入 blocked,
+                            //   导致对端消息被拒 (❌ 您已被本地系统加入通信黑名单)。
+                            //   改为传存活信号文本, 让机器协议消息判为 cooperate (在线维持连接 = 合作)。
+                            recordInteraction(evt.fromPublicKey, 'heartbeat 存活信号(自动)').catch(() => { });
                             return;
                         }
                         // v3 新增: B 端收到 A 的 thinking (开始 + 流式 token)
@@ -1578,11 +1654,27 @@ export async function createWebServer(port = 3000, options = {}) {
                         // v3 新增: 好友申请 RPC — 任何对端可以发, 推到前端 UI 让用户接受
                         if (parsed.op === 'agent.friend.request') {
                             console.log(`[v3-friend] 收到 ${evt.fromPublicKey.substring(0, 12)}... 的好友申请: ${parsed.payload?.name || '(无名字)'}`);
+                            const reqFromName = parsed.payload?.name || ('peer-' + evt.fromPublicKey.substring(0, 8));
+                            const reqMessage = parsed.payload?.message || '想加你为 P2P 好友';
+                            // 2026-08-02: 备注 = 申请消息或显式 note 字段 (自我介绍 / 来源), 存 pending 供智能体工具查询
+                            const reqNote = parsed.payload?.note || reqMessage;
+                            if (parsed.payload?.requestId) {
+                                pendingFriendRequests.set(parsed.payload.requestId, {
+                                    requestId: parsed.payload.requestId,
+                                    fromPublicKey: evt.fromPublicKey,
+                                    fromName: reqFromName,
+                                    message: reqMessage,
+                                    note: reqNote,
+                                    receivedAt: Date.now(),
+                                });
+                                persistPendingFriendRequests(); // 2026-08-02: 落盘, 重启不丢
+                            }
                             broadcast({
                                 type: 'friend-request',
                                 fromPublicKey: evt.fromPublicKey,
-                                fromName: parsed.payload?.name || ('peer-' + evt.fromPublicKey.substring(0, 8)),
-                                message: parsed.payload?.message || '想加你为 P2P 好友',
+                                fromName: reqFromName,
+                                message: reqMessage,
+                                note: reqNote, // 2026-08-02: 透传备注给 UI
                                 requestId: parsed.payload?.requestId, // 2026-06-10: 透传 requestId 给前端
                                 timestamp: Date.now()
                             }, 'p2p-global');
@@ -2278,6 +2370,26 @@ ${goalDesc}
         const identity = await loadOrCreateUserIdentity();
         res.json(identity);
     });
+    // 2026-08-02: 修改左下角用户名 (写回 ~/.bolloon/identity/user.json)
+    app.put('/api/user/identity', async (req, res) => {
+        try {
+            const { name } = req.body || {};
+            const newName = String(name || '').trim().slice(0, 40);
+            if (!newName)
+                return res.status(400).json({ error: 'name 必填' });
+            const identity = await loadOrCreateUserIdentity();
+            identity.name = newName;
+            userIdentityCache = identity;
+            const { mkdirSync, writeFileSync } = await import('fs');
+            mkdirSync(IDENTITY_DIR, { recursive: true });
+            writeFileSync(`${IDENTITY_DIR}/user.json`, JSON.stringify(identity, null, 2), { mode: 0o600 });
+            console.log(`[user-identity] 名字已更新: ${newName}`);
+            res.json(identity);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // 2026-07-01 (v0.2.6): 前后端分离核心 — 后端切 LLM 输出为结构化 segments
     //   - POST /api/segment-reply { reply, knownTools }
     //   - 返回 ChatSegment[] (think / text / env_details / tool_call / final)
@@ -2457,6 +2569,33 @@ ${goalDesc}
         if (!text) {
             return res.status(400).json({ error: 'No text provided' });
         }
+        // 2026-08-02: / 斜杠命令路由 — 用户输入 /plan /todo /task 等快捷命令时,
+        //   直接把命令转成结构化指令注入 contextHint, 引导 LLM 调用对应工具.
+        //   前端 / 菜单插入的是 "/plan 目标; 步骤" 这类文本, 这里解析成提示.
+        let slashCommandHint = '';
+        try {
+            const slashMatch = String(text).match(/^\/([a-z-]+)\s*(.*)$/is);
+            if (slashMatch) {
+                const [, cmdRaw, cmdArgs] = slashMatch;
+                const cmd = cmdRaw.toLowerCase();
+                const argText = String(cmdArgs || '').trim();
+                const hints = {
+                    plan: `用户输入了 /plan 命令, 参数: "${argText}". 请调用 create_plan 工具: goal=参数中 ";" 前的部分 (或整句), steps=";" 后的步骤列表 (逗号分隔). 若参数为空, 先向用户确认目标和步骤.`,
+                    todo: `用户输入了 /todo 命令, 参数: "${argText}". 请调用 update_plan 勾选步骤状态: 格式 "计划ID; 步骤ID; done|blocked". 参数不完整就向用户要.`,
+                    review: `用户输入了 /review 命令, 参数: "${argText}". 请调用 review_plan: 格式 "计划ID; 审查总结". 参数不完整就向用户要.`,
+                    task: `用户输入了 /task 命令, 参数: "${argText}". 请调用 create_task 创建任务.`,
+                    goal: `用户输入了 /goal 命令, 参数: "${argText}". 请调用 park_goal 暂停目标.`,
+                    skill: `用户输入了 /skill 命令, 参数: "${argText}". 请调用 create_skill 沉淀技能.`,
+                    'add-friend': `用户输入了 /add-friend 命令, 参数: "${argText}". 请调用 add_friend_by_id 添加好友 (参数: 64位 hex 公钥 + 可选备注).`,
+                    help: `用户输入了 /help. 请简要列出可用命令: /plan /todo /review /task /goal /skill /add-friend, 各一句话说明.`,
+                };
+                if (hints[cmd]) {
+                    slashCommandHint = `[系统上下文] 快捷命令路由:\n${hints[cmd]}\n\n`;
+                    console.log(`[slash] 命令 /${cmd} 参数="${argText.slice(0, 80)}"`);
+                }
+            }
+        }
+        catch { /* 命令解析失败忽略 */ }
         // 2026-07-15 修 Bug 3: 拖拽附件 — LLM 在 contextHint 里看到文件清单, 用户文本保持可读
         //   替代方案: 把 [attachment:id] 标记塞 text 里, 这里解析回 attachments 数组
         let parsedAttachments = [];
@@ -2501,7 +2640,11 @@ ${goalDesc}
         // 提前捕获 wallet/autoTools 到本地变量, 避免下面 try 块内的 inner const channel
         // (line ~638) 与这里外层的 const channel 形成 shadowing 让 TS 误报"使用前未声明"
         const boundWalletAddress = channel?.walletAddress;
-        const autoToolsEnabled = channel?.autoInvokeTools !== false; // 默认开启
+        // 2026-08-02: 支持 per-message 覆盖 — 前端"发送默认配置"toggle 传 autoInvokeTools,
+        //   有则用消息级设置, 没有则回落到 channel 配置 (默认开启)
+        const autoToolsEnabled = typeof req.body?.autoInvokeTools === 'boolean'
+            ? req.body.autoInvokeTools
+            : channel?.autoInvokeTools !== false;
         // 捕获外层 channel 到独立变量, 避免被 try 块内 (line 740+) 的 const channel 遮蔽
         const channelForJudgment = channel;
         // per-channel queue 检查: 已在跑就入队, 等当前跑完自动接上
@@ -2619,6 +2762,9 @@ ${goalDesc}
             console.log(`[消息处理] 开始处理用户消息, channelId: ${channelId}, sessionId: ${currentSessionId}`);
             // 将真实 DID 作为上下文前缀，让 AI 使用真实的 DID 而不是自己编造的
             let contextHint = '';
+            // 2026-08-02: slash 命令提示 (在 /message 开头解析, 这里注入)
+            if (slashCommandHint)
+                contextHint += slashCommandHint;
             if (realChannelDid)
                 contextHint += `[系统上下文] 当前频道名称: ${realChannelName}, 你的真实 DID: ${realChannelDid}\n`;
             // v3 新增: 标识发送方 — 让 AI 分清内部 owner vs 远端访客
@@ -2712,6 +2858,68 @@ ${goalDesc}
                 }
                 contextHint += '回复时应自然体现这个角色 (不要硬搬原文, 像这个角色说话即可).\n\n';
             }
+            // 2026-08-02: memory 回读 — 把本 channel 的历史记忆摘要注入 contextHint.
+            //   memory-compressor 每次 /message 后把增量摘要 append 到
+            //   ~/.bolloon/memory/<agentId>/sessions/<safe-channel>__<safe-session>.summary.md,
+            //   但之前只写不读, 对话完全无记忆. 这里取尾部最近 3 段增量摘要回灌给 LLM.
+            try {
+                const { getSessionSummaryPath, getMemoryDir, sanitizeAgentId } = await import('../bootstrap/memory-compressor.js');
+                const { readFile, readdir } = await import('fs/promises');
+                const { join } = await import('path');
+                const agentId = channelForJudgment?.agentId;
+                if (agentId) {
+                    // 优先读当前 channel 的 summary (如果有)
+                    const currentSummary = getSessionSummaryPath(agentId, channelId, currentSessionId);
+                    const summariesToRead = [];
+                    try {
+                        const raw = await readFile(currentSummary, 'utf-8');
+                        if (raw.trim())
+                            summariesToRead.push(raw);
+                    }
+                    catch { /* 当前 channel 还没有摘要 */ }
+                    // 再兜底读同 agent 其他 channel 的最近摘要 (跨 channel 记忆)
+                    if (summariesToRead.length === 0) {
+                        try {
+                            const sessionsDir = join(getMemoryDir(agentId), 'sessions');
+                            const files = (await readdir(sessionsDir)).filter(f => f.endsWith('.summary.md'));
+                            // 按文件名排序取最近 2 个 (文件名含时间戳, 近似排序)
+                            const recent = files.sort().slice(-2);
+                            for (const f of recent) {
+                                if (f.includes(sanitizeAgentId(channelId)))
+                                    continue; // 跳过已读的当前 channel
+                                try {
+                                    const raw = await readFile(join(sessionsDir, f), 'utf-8');
+                                    if (raw.trim())
+                                        summariesToRead.push(raw);
+                                }
+                                catch { /* 单个摘要读失败跳过 */ }
+                            }
+                        }
+                        catch { /* 无 sessions 目录 */ }
+                    }
+                    if (summariesToRead.length > 0) {
+                        const memBlock = summariesToRead.map(s => s.trim().slice(-1500)).join('\n\n---\n\n');
+                        contextHint += `[系统上下文] 本 channel 的历史记忆 (来自 memory-compressor 摘要, 帮助你延续之前的对话, 引用而非复述):\n${memBlock.slice(-2500)}\n\n`;
+                    }
+                }
+            }
+            catch (memErr) {
+                // 静默失败 — memory 回读不是核心, 失败不阻塞
+            }
+            // 2026-08-02: plan 回读 — 把进行中的计划注入 contextHint (在 memory 之后)
+            //   配合 create_plan / update_plan / review_plan 工具, 让 LLM 每次对话都能看到
+            //   未完成的计划并继续推进.
+            try {
+                const { listActivePlans, planToContext } = await import('../agents/plan-store.js');
+                const plans = await listActivePlans();
+                if (plans.length > 0) {
+                    const plansBlock = plans.slice(0, 3).map(p => planToContext(p)).join('\n\n');
+                    contextHint += `[系统上下文] 进行中的计划 (来自 plan-store, 执行中每完成一步调 update_plan 勾选):\n${plansBlock}\n\n`;
+                }
+            }
+            catch (planErr) {
+                // 静默失败
+            }
             const linkedIds = channelForJudgment?.linkedDocumentIds;
             if (Array.isArray(linkedIds) && linkedIds.length > 0) {
                 try {
@@ -2974,7 +3182,13 @@ ${goalDesc}
             // 现在改名逻辑挪到 /api/agent-rename 端点, 用户主动触发才跑
             if (channel) {
                 channel.updatedAt = new Date().toISOString();
-                await saveChannels(channels);
+                // 2026-08-02 fix: 原子写入, 防并发覆盖丢 channel
+                await updateChannels((chs) => {
+                    const c = chs.find(x => x.id === channelId);
+                    if (c)
+                        c.updatedAt = channel.updatedAt;
+                    return chs;
+                });
             }
             broadcast({ type: 'done' }, channelId);
             // D 触发: AI 被动捕获判断力 (后台异步, 不阻塞主对话)
@@ -3065,6 +3279,35 @@ ${goalDesc}
                     console.warn(`[web] saveCurrentSession failed (non-fatal): ${saveErr.message?.slice(0, 100)}`);
                 }
             }
+            // 2026-08-02: run-end skill 候选扫描 (fire-and-forget, 不阻塞 finally)
+            //   从本轮 lastSteps 提取连续成功的工具调用模式, 写入 ~/.bolloon/skill-candidates/.
+            //   agent 之后可调 list_skill_candidates / promote_skill 决定是否转正.
+            try {
+                const steps = runState.lastSteps || [];
+                const okTools = steps.filter(s => s.status === 'ok' && s.name && s.name !== 'system');
+                if (okTools.length >= 2) {
+                    setImmediate(async () => {
+                        try {
+                            const { writeSkillCandidate } = await import('../agents/skill-writer.js');
+                            const toolNames = okTools.map(s => s.name).slice(0, 5).join(', ');
+                            const body = `## 背景\n本轮对话连续成功调用了 ${okTools.length} 个工具: ${toolNames}.\n\n## 流程\n${okTools.map(s => `1. 调用 ${s.name}${s.output ? ': ' + String(s.output).slice(0, 120) : ''}`).join('\n')}\n\n## 注意事项\n- 工具名以 list_skills / get_operation_logs 的实际注册名为准\n- 沉淀为正式 skill 前请人工确认流程可复用\n`;
+                            const candName = `auto-${okTools[0].name}-${Date.now().toString(36)}`;
+                            const file = await writeSkillCandidate({
+                                name: candName,
+                                description: `自动候选: ${okTools.length} 个工具连续成功 (${toolNames})`,
+                                body,
+                                source: `channel:${channelId}`,
+                                timestamp: new Date().toISOString(),
+                            });
+                            console.log(`[skill-candidates] 写入候选 ${file} (${okTools.length} tools)`);
+                        }
+                        catch (candErr) {
+                            console.warn('[skill-candidates] 写入失败 (non-fatal):', candErr?.message?.slice(0, 150));
+                        }
+                    });
+                }
+            }
+            catch { /* 非致命 */ }
         }
     });
     // ---------- 频道元数据后台修复队列 ----------
@@ -3271,7 +3514,19 @@ ${goalDesc}
         catch {
             // IPFS 不可用, 跳过 — 下次再试
         }
-        await saveChannels(channels);
+        // 2026-08-02 fix: 原子写入 — DID 修复是异步队列, 与创建/改名的裸 saveChannels
+        //   并发时用旧数组覆盖 (lost update), 这是"重启后 channel 消失"的根因之一.
+        await updateChannels((chs) => {
+            const c = chs.find(x => x.id === channelId);
+            if (c) {
+                c.did = channel.did;
+                c.publicKey = channel.publicKey;
+                c.cid = channel.cid;
+                c.didDocRef = channel.didDocRef;
+                c.updatedAt = new Date().toISOString();
+            }
+            return chs;
+        });
     }
     // 频道列表响应缓存: 短时间内重复请求走缓存, 避免每次重读 + 重序列化 channels.json
     // 跨作用域 (saveChannels 在模块顶层, 本函数在 createWebServer 内) 用 lastChannelsWriteAt 协调失效
@@ -3508,8 +3763,13 @@ ${goalDesc}
                     }]
             };
             console.log(`[创建频道] 先保存频道 ID: ${id}`);
-            channels.push(channel);
-            await saveChannels(channels);
+            // 2026-08-02 fix: 用 updateChannels 原子写入 — 之前 channels.push + saveChannels(channels)
+            //   是裸 read-modify-write, 与 /message updatedAt 保存等并发时会互相覆盖 (lost update),
+            //   新 channel 可能被旧数组冲掉 → 重启后只剩一个 channel 的 bug.
+            await updateChannels((chs) => {
+                chs.push(channel);
+                return chs;
+            });
             await saveSession({ channelId: id, sessionId: 'default', messages: [], lastUpdated: new Date().toISOString() });
             // 2026-07-15 修 Bug 6: 同步把 agent 定义写进 ~/.bolloon/agents/agents.json
             //   之前 channel 只落 channels.json, 不会出现在 agents.json 里.
@@ -3578,7 +3838,18 @@ ${goalDesc}
             channel.sessions.push(session);
             channel.currentSessionId = sessionId;
             channel.updatedAt = new Date().toISOString();
-            await saveChannels(channels);
+            // 2026-08-02 fix: 原子写入
+            await updateChannels((chs) => {
+                const c = chs.find(x => x.id === channelId);
+                if (c) {
+                    if (!c.sessions)
+                        c.sessions = [];
+                    c.sessions.push(session);
+                    c.currentSessionId = sessionId;
+                    c.updatedAt = new Date().toISOString();
+                }
+                return chs;
+            });
             await saveSession({ channelId, sessionId, messages: [], lastUpdated: new Date().toISOString() });
             res.json({ session, currentSessionId: sessionId });
         }
@@ -3617,7 +3888,15 @@ ${goalDesc}
             }
             channel.currentSessionId = sessionId;
             channel.updatedAt = new Date().toISOString();
-            await saveChannels(channels);
+            // 2026-08-02 fix: 原子写入
+            await updateChannels((chs) => {
+                const c = chs.find(x => x.id === channelId);
+                if (c) {
+                    c.currentSessionId = sessionId;
+                    c.updatedAt = new Date().toISOString();
+                }
+                return chs;
+            });
             res.json({ ok: true, currentSessionId: sessionId });
         }
         catch (err) {
@@ -3649,7 +3928,20 @@ ${goalDesc}
                 channel.currentSessionId = nextSession.id;
             }
             channel.updatedAt = new Date().toISOString();
-            await saveChannels(channels);
+            // 2026-08-02 fix: 原子写入
+            await updateChannels((chs) => {
+                const c = chs.find(x => x.id === channelId);
+                if (c && c.sessions) {
+                    const idx = c.sessions.findIndex(s => s.id === sessionId);
+                    if (idx >= 0)
+                        c.sessions.splice(idx, 1);
+                    if (c.currentSessionId === sessionId && c.sessions[0]) {
+                        c.currentSessionId = c.sessions[0].id;
+                    }
+                    c.updatedAt = new Date().toISOString();
+                }
+                return chs;
+            });
             // 删除 session 文件
             try {
                 await fs.unlink(path.join(SESSION_CACHE_PATH, `${channelId}:${sessionId}.json`));
@@ -3671,8 +3963,13 @@ ${goalDesc}
                 return res.status(404).json({ error: 'Channel not found' });
             }
             const channel = channels[index];
-            channels.splice(index, 1);
-            await saveChannels(channels);
+            // 2026-08-02 fix: 原子写入
+            await updateChannels((chs) => {
+                const idx = chs.findIndex(c => c.id === channelId);
+                if (idx >= 0)
+                    chs.splice(idx, 1);
+                return chs;
+            });
             // 清理该 channel 名下所有的 session 文件 + 默认 session 文件
             const candidates = new Set([`${channelId}.json`]);
             if (channel.sessions) {
@@ -3799,7 +4096,18 @@ ${goalDesc}
                 console.log(`[Channel ${channelId}] 自动生成 share_id: ${channel.share_id}`);
             }
             channel.updatedAt = new Date().toISOString();
-            await saveChannels(channels);
+            // 2026-08-02 fix: 原子写入
+            await updateChannels((chs) => {
+                const c = chs.find(x => x.id === channelId);
+                if (c) {
+                    if (shared_with_peers !== undefined)
+                        c.shared_with_peers = shared_with_peers;
+                    if (!c.share_id)
+                        c.share_id = channel.share_id;
+                    c.updatedAt = new Date().toISOString();
+                }
+                return chs;
+            });
             // v3 修复: 分享变更后立即广播给所有 peer, 不用等对方手动刷新
             if (shared_with_peers !== undefined) {
                 v3BroadcastOwn().catch(err => console.error('[v3] broadcast after share update failed:', err));
@@ -3862,7 +4170,18 @@ ${goalDesc}
                 channel.autoInvokeTools = autoInvokeTools;
             }
             channel.updatedAt = new Date().toISOString();
-            await saveChannels(channels);
+            // 2026-08-02 fix: 原子写入
+            await updateChannels((chs) => {
+                const c = chs.find(x => x.id === channelId);
+                if (c) {
+                    c.walletAddress = walletAddress;
+                    c.walletRegisteredAt = new Date().toISOString();
+                    if (typeof autoInvokeTools === 'boolean')
+                        c.autoInvokeTools = autoInvokeTools;
+                    c.updatedAt = new Date().toISOString();
+                }
+                return chs;
+            });
             console.log(`[Wallet] channel ${channelId} 绑定钱包 ${channel.walletAddress} 到 DID ${did}`);
             res.json(channel);
         }
@@ -3891,7 +4210,18 @@ ${goalDesc}
                 channel.autoPayEnabled = autoPayEnabled;
             }
             channel.updatedAt = new Date().toISOString();
-            await saveChannels(channels);
+            // 2026-08-02 fix: 原子写入
+            await updateChannels((chs) => {
+                const c = chs.find(x => x.id === channelId);
+                if (c) {
+                    c.encryptedPrivateKey = encryptedPrivateKey;
+                    c.encryptedPrivateKeyIv = encryptedPrivateKeyIv;
+                    if (typeof autoPayEnabled === 'boolean')
+                        c.autoPayEnabled = autoPayEnabled;
+                    c.updatedAt = new Date().toISOString();
+                }
+                return chs;
+            });
             console.log(`[Wallet] channel ${channelId} 已存储加密私钥 (autoPay=${channel.autoPayEnabled})`);
             res.json(channel);
         }
@@ -3911,7 +4241,17 @@ ${goalDesc}
             channel.encryptedPrivateKeyIv = undefined;
             channel.autoPayEnabled = false;
             channel.updatedAt = new Date().toISOString();
-            await saveChannels(channels);
+            // 2026-08-02 fix: 原子写入
+            await updateChannels((chs) => {
+                const c = chs.find(x => x.id === channelId);
+                if (c) {
+                    c.encryptedPrivateKey = undefined;
+                    c.encryptedPrivateKeyIv = undefined;
+                    c.autoPayEnabled = false;
+                    c.updatedAt = new Date().toISOString();
+                }
+                return chs;
+            });
             console.log(`[Wallet] channel ${channelId} 已清除加密私钥`);
             res.json(channel);
         }
@@ -3933,7 +4273,15 @@ ${goalDesc}
                 return res.status(404).json({ error: 'Channel not found' });
             channel.autoPayEnabled = autoPayEnabled;
             channel.updatedAt = new Date().toISOString();
-            await saveChannels(channels);
+            // 2026-08-02 fix: 原子写入
+            await updateChannels((chs) => {
+                const c = chs.find(x => x.id === channelId);
+                if (c) {
+                    c.autoPayEnabled = autoPayEnabled;
+                    c.updatedAt = new Date().toISOString();
+                }
+                return chs;
+            });
             console.log(`[Wallet] channel ${channelId} autoPay → ${autoPayEnabled}`);
             res.json(channel);
         }
@@ -4230,8 +4578,65 @@ ${goalDesc}
     });
     app.delete('/api/p2p-peers/:name', async (req, res) => {
         try {
-            const { removePeer } = await import('../network/known-peers.js');
-            await removePeer(req.params.name);
+            const { removePeer, listPeers } = await import('../network/known-peers.js');
+            // 2026-08-02: 删除好友时同时撤回分享 — 从所有 channel 的 shared_with_peers 移除该 peer
+            // 参数支持 name 或 publicKey (陌生 peer 只有 publicKey, 不在 known_peers)
+            const peers = await listPeers();
+            const param = req.params.name;
+            const target = peers.find(p => p.name === param) || peers.find(p => p.publicKey === param);
+            if (target) {
+                const { readFile, writeFile } = await import('fs/promises');
+                const channelsPath = `${process.env.HOME || '/tmp'}/.bolloon/sessions/channels.json`;
+                try {
+                    const raw = await readFile(channelsPath, 'utf-8');
+                    const chData = JSON.parse(raw);
+                    const chs = Array.isArray(chData) ? chData : (chData.channels || []);
+                    let changed = 0;
+                    for (const ch of chs) {
+                        if (Array.isArray(ch.shared_with_peers) && ch.shared_with_peers.includes(target.publicKey)) {
+                            ch.shared_with_peers = ch.shared_with_peers.filter((pk) => pk !== target.publicKey);
+                            changed++;
+                        }
+                    }
+                    if (changed > 0) {
+                        if (Array.isArray(chData))
+                            await writeFile(channelsPath, JSON.stringify(chs, null, 2), 'utf-8');
+                        else {
+                            chData.channels = chs;
+                            await writeFile(channelsPath, JSON.stringify(chData, null, 2), 'utf-8');
+                        }
+                        console.log(`[p2p-peers] 删除好友 ${param}: 撤回 ${changed} 个 channel 的分享`);
+                    }
+                }
+                catch (e) {
+                    console.warn('[p2p-peers] 撤回 channel 分享失败 (non-fatal):', e?.message?.slice(0, 120));
+                }
+            }
+            // 2026-08-02: 同时清掉 remote channel cache (内存 + 磁盘) — 否则 topic 在线节点
+            //   删除后仍以 "陌生 peer" (peer-xxx) 出现在 UI, 无法真正删除
+            try {
+                const targetPk = target?.publicKey || (param.length === 64 ? param : null);
+                if (targetPk)
+                    remoteChannelCache.delete(targetPk);
+                const { existsSync } = await import('fs');
+                if (existsSync(REMOTE_CACHE_FILE)) {
+                    const { readFile, writeFile } = await import('fs/promises');
+                    const cacheObj = JSON.parse(await readFile(REMOTE_CACHE_FILE, 'utf-8'));
+                    if (cacheObj && typeof cacheObj === 'object') {
+                        const pkToDel = targetPk || Object.keys(cacheObj).find((k) => k === param);
+                        if (pkToDel && cacheObj[pkToDel]) {
+                            delete cacheObj[pkToDel];
+                            await writeFile(REMOTE_CACHE_FILE, JSON.stringify(cacheObj, null, 2), 'utf-8');
+                            console.log(`[p2p-peers] 已清 remote cache: ${pkToDel.substring(0, 12)}...`);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                console.warn('[p2p-peers] 清 remote cache 失败 (non-fatal):', e?.message?.slice(0, 120));
+            }
+            // 陌生 peer (只有 publicKey) 不在 known_peers, removePeer 无操作也 ok
+            await removePeer(target?.name || param);
             res.json({ ok: true });
         }
         catch (err) {
@@ -4316,7 +4721,7 @@ ${goalDesc}
             if (!v3P2PRef) {
                 return res.status(503).json({ ok: false, code: 'P2P_NOT_STARTED', error: 'P2PDirect not started' });
             }
-            const { targetPublicKey, name, message } = req.body || {};
+            const { targetPublicKey, name, message, note } = req.body || {};
             if (!targetPublicKey || typeof targetPublicKey !== 'string' || targetPublicKey.length !== 64) {
                 return res.status(400).json({ ok: false, code: 'BAD_REQUEST', error: 'targetPublicKey (64 hex) required' });
             }
@@ -4343,7 +4748,8 @@ ${goalDesc}
                     requestId, // 2026-06-10: 加 requestId, ack 时回带
                     fromPublicKey: myPk,
                     name: peerName,
-                    message: message || '想加你为 P2P 好友, 共享 channel 协作'
+                    message: message || '想加你为 P2P 好友, 共享 channel 协作',
+                    note: note || message || undefined, // 2026-08-02: 备注 (自我介绍/来源), 优先显式 note
                 }
             });
             // 2026-06-10: 用 sendToWithWait, 等 conn 真就绪后再发, 默认 5s 超时
@@ -4366,17 +4772,53 @@ ${goalDesc}
             res.status(500).json({ ok: false, code: 'EXCEPTION', error: err.message });
         }
     });
+    // v3: 待处理好友申请查询 (智能体工具 list_pending_friend_requests 用)
+    // 用法: GET /api/friend-requests
+    app.get('/api/friend-requests', async (_req, res) => {
+        const list = Array.from(pendingFriendRequests.values()).map(r => ({
+            requestId: r.requestId,
+            fromPublicKey: r.fromPublicKey,
+            fromName: r.fromName,
+            message: r.message,
+            note: r.note || '',
+            receivedAt: r.receivedAt,
+        }));
+        res.json({ count: list.length, requests: list });
+    });
+    // v3: 忽略/拒绝一个待处理好友申请 (智能体工具 ignore_friend_request 用)
+    // 用法: POST /api/friend-requests/ignore { requestId }
+    app.post('/api/friend-requests/ignore', async (req, res) => {
+        try {
+            const { requestId } = req.body || {};
+            if (!requestId || !pendingFriendRequests.has(requestId)) {
+                return res.status(404).json({ error: `未找到 requestId=${requestId} 的申请` });
+            }
+            const r = pendingFriendRequests.get(requestId);
+            pendingFriendRequests.delete(requestId);
+            persistPendingFriendRequests(); // 2026-08-02: 落盘
+            console.log(`[v3-friend] 忽略好友申请: ${r.fromName} (${r.fromPublicKey.substring(0, 12)}...)`);
+            res.json({ ok: true, ignored: r.fromName });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // v3: 接受对方的好友申请 — 把对方加为 known_peers, 立即推我的 channel 列表给 ta
-    // 用法: POST /api/friend-accept { fromPublicKey, name }
+    // 用法: POST /api/friend-accept { fromPublicKey, name, requestId? }
     app.post('/api/friend-accept', async (req, res) => {
         try {
             if (!v3P2PRef) {
                 return res.status(503).json({ error: 'P2PDirect not started' });
             }
-            const { fromPublicKey, name } = req.body || {};
+            const { fromPublicKey, name, requestId } = req.body || {};
             if (!fromPublicKey || typeof fromPublicKey !== 'string' || fromPublicKey.length !== 64) {
                 return res.status(400).json({ error: 'fromPublicKey (64 hex) required' });
             }
+            // 2026-08-02: 接受后清掉 pending 条目 (若带了 requestId)
+            if (requestId) {
+                pendingFriendRequests.delete(requestId);
+                persistPendingFriendRequests();
+            }
             // 持久化
             const { addOrUpdatePeer, findNameByPublicKey } = await import('../network/known-peers.js');
             const existing = await findNameByPublicKey(fromPublicKey);
@@ -4409,7 +4851,7 @@ ${goalDesc}
             if (!v3P2PRef) {
                 return res.status(503).json({ error: 'P2PDirect not started' });
             }
-            const { targetPublicKey, channelId, text } = req.body || {};
+            const { targetPublicKey, channelId, text, autoInvokeTools } = req.body || {};
             if (!targetPublicKey || !channelId || !text) {
                 return res.status(400).json({ error: 'targetPublicKey, channelId, text required' });
             }
@@ -4418,8 +4860,12 @@ ${goalDesc}
             }
             const fromPk = v3P2PRef.getPublicKey();
             // 2026-07-27: 改用 sendOrQueue (先尝试直发, 失败则入队, 不断线不丢)
+            // 2026-08-02: 透传 autoInvokeTools (发送方工具开关设置, 只对本次远端消息生效)
             const { sendOrQueue } = await import('../network/p2p-outbox.js');
-            const r = await sendOrQueue(targetPublicKey, 'agent.chat.send', { channelId, text, fromPublicKey: fromPk }, v3P2PRef);
+            const r = await sendOrQueue(targetPublicKey, 'agent.chat.send', {
+                channelId, text, fromPublicKey: fromPk,
+                ...(typeof autoInvokeTools === 'boolean' ? { autoInvokeTools } : {}),
+            }, v3P2PRef);
             if (r === 'FAILED') {
                 return res.status(502).json({ error: 'send failed: peer not reachable' });
             }
@@ -5043,6 +5489,12 @@ ${goalDesc}
             if (s?.abortController) {
                 s.abortController.abort();
                 console.log(`[abort] user aborted channel=${channelId}`);
+                // 2026-08-02 fix: abort 后立即广播 done — 之前前端靠 1.5s 兜底 setTimeout 切回 idle,
+                //   视觉上"点了没反应". 这里主动推 done, 前端 finalizeTimelineAsMessage + setSendMode('idle') 立刻生效.
+                try {
+                    broadcast({ type: 'done' }, channelId);
+                }
+                catch { /* 广播失败不影响 abort 主流程 */ }
                 return res.json({ ok: true, aborted: true });
             }
             res.json({ ok: true, aborted: false });