@bolloon/bolloon-agent 0.3.25 → 0.3.27

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

@@ -394,6 +394,81 @@ export function registerBuiltinTools(ctx) {
             }
         }
     });
+    // 2026-08-02: 远端 channel 工具 — 让本地智能体能获取远端 channel 列表 + 发送消息到远端
+    //   (之前本地智能体看不到远端 channel, 无法 @ 远程智能体交流 — "工具没有给到位")
+    ctx.tools.set('list_remote_channels', {
+        name: 'list_remote_channels',
+        description: '列出 P2P 好友节点分享给你的远端 channel (远程智能体会话). 每个远端 channel 属于某个 peer, 你可以在回复中写 "@渠道名 消息内容" 或调用 send_to_remote_channel 给它们发消息.',
+        parameters: {},
+        execute: async () => {
+            try {
+                const port = process.env.PORT || '54188';
+                const res = await fetch(`http://127.0.0.1:${port}/api/remote-channels`);
+                if (!res.ok)
+                    return { success: false, error: `HTTP ${res.status}` };
+                const data = await res.json();
+                const peers = data?.peers || [];
+                const lines = [];
+                let total = 0;
+                for (const p of peers) {
+                    const chs = p.channels || [];
+                    total += chs.length;
+                    if (chs.length === 0)
+                        continue;
+                    lines.push(`👤 ${p.peerName || ('peer-' + String(p.peerId).substring(0, 8))} (${String(p.peerId).substring(0, 16)}…):`);
+                    for (const c of chs) {
+                        lines.push(`  - @${c.name} (id=${c.id})`);
+                    }
+                }
+                if (total === 0) {
+                    return { success: true, output: '📭 当前没有远端 channel (没有好友分享 channel 给你, 或对方不在线). 可先用 add_friend_by_id 添加好友.' };
+                }
+                return { success: true, output: `🌐 ${total} 个远端 channel:\n${lines.join('\n')}\n\n在回复中写 "@渠道名 消息内容" 即可发送 (系统自动转发到对方节点).` };
+            }
+            catch (e) {
+                return { success: false, error: `获取远端 channel 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    ctx.tools.set('send_to_remote_channel', {
+        name: 'send_to_remote_channel',
+        description: '发送消息到远端 channel (远程智能体会话, 属于某个 P2P 好友节点). 对方节点会在该 channel 上跑 LLM 处理你的消息并回复. 用 list_remote_channels 查看可用 channel 和 owner.',
+        parameters: {
+            targetPublicKey: '远端节点 publicKey (64 hex, 用 list_remote_channels 看 owner)',
+            channelId: '远端 channel id (用 list_remote_channels 查看)',
+            text: '消息内容 (必填)',
+            autoInvokeTools: '可选, 是否允许对方调用工具 (true/false, 默认 true)'
+        },
+        execute: async (args) => {
+            const targetPublicKey = String(args.targetPublicKey || '').trim();
+            const channelId = String(args.channelId || '').trim();
+            const text = String(args.text || '').trim();
+            if (!targetPublicKey || !channelId || !text) {
+                return { success: false, error: 'targetPublicKey, channelId, text 必填 (用 list_remote_channels 查)' };
+            }
+            try {
+                const port = process.env.PORT || '54188';
+                const res = await fetch(`http://127.0.0.1:${port}/api/remote-channels/chat-send`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        targetPublicKey,
+                        channelId,
+                        text,
+                        ...(typeof args.autoInvokeTools === 'boolean' ? { autoInvokeTools: args.autoInvokeTools } : {}),
+                    })
+                });
+                const data = await res.json();
+                if (!res.ok) {
+                    return { success: false, error: `发送失败: ${data.error || `HTTP ${res.status}`}` };
+                }
+                return { success: true, output: `📨 消息已发送到远端 channel ${channelId} (${data.sent ? '已送达' : data.queued ? '对方不在线, 已入队, 上线后自动送达' : '未知状态'}). 对方智能体会回复, 可用 check_inbox 或稍后查看.` };
+            }
+            catch (e) {
+                return { success: false, error: `发送失败: ${String(e.message || e)}` };
+            }
+        }
+    });
     // delegate_to_engine — 把编码任务委派给本机已安装的其他 AI 编码智能体 CLI
     // (codex / claude-code / opencode / openclaw / hermes). 它们必须已安装且可达 PATH.
     // 实验 API 引擎 (experiment:xxx) 是供应商不是 CLI, 不支持委派, 工具会提示改用 import.

package/dist/security/tool-gate.js

@@ -46,6 +46,8 @@ const TOOL_WHITELIST = new Set([
     'create_skill', 'update_skill', 'list_skill_candidates', 'promote_skill',
     // 2026-08-02: plan/todo/review 工具 (plan-store.ts)
     'create_plan', 'update_plan', 'review_plan', 'list_plans',
+    // 2026-08-02: 远端 channel 工具 (本地智能体 @ 远程交流)
+    'list_remote_channels', 'send_to_remote_channel',
 ]);
 export const gateWhitelist = { gate: 'whitelist', allowed: true };
 /**

package/dist/web/client.js

@@ -1689,7 +1689,72 @@
       v3GlobalEventSource.onmessage = (e) => {
         try {
           const msg = JSON.parse(e.data);
-          if (msg.type === "remote-chat-reply") {
+          if (msg.type === "remote-chat-sent") {
+            console.log("[v3] \u6536\u5230 remote-chat-sent:", msg.channelId, "|", String(msg.text || "").slice(0, 30));
+            try {
+              const pk = msg.fromPublicKey;
+              const cid = msg.channelId;
+              if (pk && cid && msg.text) {
+                const key = `bolloon.rcmCache.${pk}.${cid}`;
+                let arr = [];
+                try {
+                  const raw = localStorage.getItem(key);
+                  if (raw) arr = JSON.parse(raw);
+                } catch {
+                  arr = [];
+                }
+                if (!Array.isArray(arr)) arr = [];
+                const entry = { type: "user", content: msg.text, timestamp: (/* @__PURE__ */ new Date()).toISOString(), source: "local-sent" };
+                const dup = arr.some((m) => m.type === "user" && m.content === entry.content && m.source === "local-sent");
+                if (!dup) {
+                  arr.push(entry);
+                  try {
+                    localStorage.setItem(key, JSON.stringify(arr.slice(-200)));
+                  } catch {
+                  }
+                }
+              }
+            } catch {
+            }
+            const log = document.getElementById("rcm-log");
+            if (!log) return;
+            const modal = document.getElementById("remote-chat-modal");
+            const openChannelId = modal ? modal.dataset.channelId : null;
+            if (openChannelId && openChannelId !== msg.channelId) return;
+            const prefix = `\u{1F464} \u6211 \u2192 \u8FDC\u7AEF${msg.peerName ? ` ${msg.peerName}` : ""}
+
+`;
+            addMessage2(prefix + (msg.text || ""), "user", false, log);
+            if (msg.queued) {
+              const qEl = document.createElement("div");
+              qEl.className = "remote-chat-sysmsg remote-chat-sysmsg-info";
+              qEl.textContent = "\u{1F4E4} \u5BF9\u65B9\u4E0D\u5728\u7EBF, \u6D88\u606F\u5DF2\u5165\u961F, \u4E0A\u7EBF\u540E\u81EA\u52A8\u9001\u8FBE";
+              log.appendChild(qEl);
+            }
+            log.scrollTop = log.scrollHeight;
+          } else if (msg.type === "remote-chat-step") {
+            const log = document.getElementById("rcm-log");
+            if (!log) return;
+            const modal = document.getElementById("remote-chat-modal");
+            const openChannelId = modal ? modal.dataset.channelId : null;
+            if (openChannelId && openChannelId !== msg.channelId) return;
+            let liveEl = document.getElementById("rcm-thinking-live-local");
+            if (!liveEl) {
+              liveEl = document.createElement("div");
+              liveEl.id = "rcm-thinking-live-local";
+              liveEl.className = "remote-chat-sysmsg remote-chat-sysmsg-info";
+              log.appendChild(liveEl);
+            }
+            if (msg.stepType === "step_start") {
+              liveEl.textContent = `\u{1F527} \u672C\u5730\u667A\u80FD\u4F53\u6B63\u5728\u8C03\u7528\u5DE5\u5177: ${msg.tool || "..."}`;
+            } else if (msg.stepType === "step_done") {
+              liveEl.textContent = `\u2705 \u672C\u5730\u5DE5\u5177\u8C03\u7528\u5B8C\u6210: ${msg.tool || ""}`;
+            } else if (msg.stepType === "step_error") {
+              liveEl.textContent = `\u274C \u672C\u5730\u5DE5\u5177\u8C03\u7528\u5931\u8D25: ${msg.tool || ""}`;
+              liveEl.className = "remote-chat-sysmsg remote-chat-sysmsg-error";
+            }
+            log.scrollTop = log.scrollHeight;
+          } else if (msg.type === "remote-chat-reply") {
             const log = document.getElementById("rcm-log");
             const thinkingEl = document.getElementById("rcm-thinking");
             if (thinkingEl) thinkingEl.style.display = "none";
@@ -1793,15 +1858,25 @@
               }
             }
           } else if (msg.type === "cross-mention-received") {
+            const log = document.getElementById("rcm-log");
+            const rcmModal = document.getElementById("remote-chat-modal");
+            const rcmOpenId = rcmModal ? rcmModal.dataset.channelId : null;
+            if (log && (!msg.targetChannelId || !rcmOpenId || rcmOpenId === msg.targetChannelId)) {
+              const fromTxt = msg.source === "ai-mention-remote" ? `\u8FDC\u7AEF\u667A\u80FD\u4F53 ${msg.originChannelName ? `(${msg.originChannelName})` : ""}` : `${msg.originChannelName} (\u672C\u5730)`;
+              addMessage2(`\u{1F4E1} ${fromTxt}
+
+${msg.text || ""}`, "ai", false, log);
+              log.scrollTop = log.scrollHeight;
+            }
             const allModals = document.querySelectorAll('.rcm-mention-toast, [id^="rcm-log"]');
-            for (const log of allModals) {
-              if (!log.id) continue;
+            for (const logEl of allModals) {
+              if (!logEl.id) continue;
               const toast = document.createElement("div");
               toast.style.cssText = "margin:6px 0;padding:8px 10px;background:#fce7f3;border-left:3px solid #ec4899;border-radius:4px;font-size:12px;color:#831843;";
               const fromTxt = msg.source === "ai-mention-remote" ? `\u8FDC\u7AEF\u8282\u70B9 ${(msg.fromPublicKey || "").substring(0, 8)}\u2026 \u7684 ${msg.originChannelName}` : `${msg.originChannelName} (\u672C\u5730)`;
               toast.innerHTML = `\u{1F4E1} <b>${fromTxt}</b> @-mention \u2192 \u5F53\u524D channel: <i>${escapeHtml2((msg.text || "").slice(0, 100))}</i>${msg.text && msg.text.length > 100 ? "\u2026" : ""}`;
-              log.appendChild(toast);
-              log.scrollTop = log.scrollHeight;
+              logEl.appendChild(toast);
+              logEl.scrollTop = logEl.scrollHeight;
             }
           } else if (msg.type === "remote-channel-update") {
             const peerId = msg.peerId;
@@ -4971,7 +5046,7 @@ ${data.error || "channel not found"}`, "error");
   function openRemoteChannelChat(peerPublicKey, channelId, channelName) {
     document.getElementById("remote-chat-modal")?.remove();
     const html = `
-    <div id="remote-chat-modal" class="remote-chat-overlay">
+    <div id="remote-chat-modal" class="remote-chat-overlay" data-channel-id="${escapeHtml2(channelId)}" data-peer-id="${escapeHtml2(peerPublicKey)}">
       <div class="remote-chat-shell">
         <div class="remote-chat-header">
           <div style="flex:1;min-width:0;">
@@ -5093,7 +5168,11 @@ ${data.error || "channel not found"}`, "error");
           const type = m.type === "user" ? "user" : "ai";
           let prefix = "";
           if (m.type === "user") {
-            if (m.source === "remote") {
+            if (m.source === "local-sent") {
+              prefix = `\u{1F464} \u6211 \u2192 \u8FDC\u7AEF
+
+`;
+            } else if (m.source === "remote") {
               prefix = `\u{1F310} \u8FDC\u7AEF\u8BBF\u5BA2${m.fromPublicKey ? " (" + m.fromPublicKey.substring(0, 8) + "\u2026)" : ""}
 
 `;
@@ -5103,9 +5182,19 @@ ${data.error || "channel not found"}`, "error");
 `;
             }
           } else {
-            prefix = `\u{1F916} A \u7684 LLM
+            if (m.source === "remote-reply") {
+              prefix = `\u{1F916} \u8FDC\u7AEF\u56DE\u590D
+
+`;
+            } else if (m.source === "ai-mention-remote") {
+              prefix = `\u{1F4E1} \u8FDC\u7AEF\u667A\u80FD\u4F53 ${m.originChannelName ? `(${m.originChannelName})` : ""}
+
+`;
+            } else {
+              prefix = `\u{1F916} A \u7684 LLM
 
 `;
+            }
           }
           addMessage2(prefix + (m.content || ""), type, false, log);
         }
@@ -5123,12 +5212,33 @@ ${data.error || "channel not found"}`, "error");
         writeRcmCache(cacheMsgs);
       } catch {
       }
+      try {
+        const cachedAll = readRcmCache();
+        const localSent = cachedAll.filter((m) => m.source === "local-sent");
+        if (localSent.length > 0) {
+          const remoteContents = new Set(msgs.map((m) => m.content));
+          for (const m of localSent) {
+            if (remoteContents.has(m.content)) continue;
+            const dup = Array.from(log.querySelectorAll(".message-user")).some(
+              (el) => (el.textContent || "").includes(m.content)
+            );
+            if (dup) continue;
+            addMessage2(`\u{1F464} \u6211 \u2192 \u8FDC\u7AEF
+
+${m.content}`, "user", false, log);
+          }
+          setTimeout(() => {
+            log.scrollTop = log.scrollHeight;
+          }, 50);
+        }
+      } catch {
+      }
     }
     const doSend = async () => {
       const text = inputEl.value.trim();
       if (!text) return;
       append(text, "user");
-      cacheRemoteMessage(peerPublicKey, channelId, { type: "user", content: text, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      cacheRemoteMessage(peerPublicKey, channelId, { type: "user", content: text, timestamp: (/* @__PURE__ */ new Date()).toISOString(), source: "local-sent" });
       inputEl.value = "";
       sendBtn2.disabled = true;
       sendBtn2.textContent = "...";
@@ -6046,7 +6156,10 @@ ${data.error || "channel not found"}`, "error");
               autoInvokeTools
             })
           });
-          if (!res.ok) throw new Error("create failed");
+          if (!res.ok) {
+            const errData = await res.json().catch(() => ({}));
+            throw new Error(errData.error || `HTTP ${res.status}`);
+          }
           const channel = await res.json();
           channels.push(channel);
           renderChannels();

package/dist/web/server-storage.js

@@ -24,13 +24,20 @@ export function getLastChannelsWriteAt() {
 }
 /** 对 channels 执行原子化的 read-modify-write, 自带互斥锁 */
 export async function updateChannels(fn) {
-    channelsLock = channelsLock.then(async () => {
+    const run = channelsLock.then(async () => {
         const chs = await rawLoadChannels();
         const result = fn(chs);
         await rawSaveChannels(result);
         return result;
     });
-    return channelsLock;
+    // 2026-08-02 fix: 失败不毒化锁链 — 之前 channelsLock = channelsLock.then(...),
+    //   某次 fn 抛错 → 整个链变 rejected → 之后所有 updateChannels 直接 reject,
+    //   fn 不再执行 → UI 创建 channel 偶发"不落盘" (静默丢失).
+    channelsLock = run.catch((e) => {
+        console.error('[updateChannels] 失败 (已隔离, 不影响后续操作):', e?.message || e);
+        return undefined;
+    });
+    return run;
 }
 async function rawLoadChannels() {
     try {

package/dist/web/server.js

@@ -151,6 +151,9 @@ let sseClients = new Set();
 // v3: 远端 channel UI 元数据缓存 — key: peerId, value: sanitize 过的 channel 列表
 // in-memory only, 进程重启清空 (judgment 内容永远不在这里)
 let remoteChannelCache = new Map();
+// 2026-08-02: channel 运行状态 (running/queue/abort/续看) — 模块级提升,
+//   triggerRemoteFollowup (模块级) 也要访问. createWebServer 启动时 clear.
+let channelRunState = 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 / 备注)
@@ -274,6 +277,49 @@ let watchdogRef = null;
 const v3PendingHistoryGets = new Map();
 let channelSessions = new Map(); // key: channelId
 let sessionMessages = new Map(); // key: channelId + sessionId
+// ============ 2026-08-02: 远端对话本地镜像 (替代 localStorage 缓存) ============
+// 问题: localStorage 5MB 上限 + 同步阻塞 + 每浏览器独立; 且对方离线时 chat-history RPC 拉不到.
+// 方案: 服务端磁盘镜像 ~/.bolloon/remote-chat-logs/<peerPk>__<channelId>.json —
+//   · 本地 @ 发出 (remote-chat-sent) → 写镜像 (source: local-sent)
+//   · 收到回复 (chat.reply) → 写镜像 (source: remote-reply)
+//   · chat-history API 先读镜像 (立即返回, 离线可读), 后台 RPC 增量合并对端历史
+const REMOTE_CHAT_LOG_DIR = `${process.env.HOME || '/tmp'}/.bolloon/remote-chat-logs`;
+async function readRemoteChatLog(peerPk, channelId) {
+    try {
+        const { readFile } = await import('fs/promises');
+        const p = `${REMOTE_CHAT_LOG_DIR}/${peerPk}__${channelId}.json`;
+        const raw = await readFile(p, 'utf-8');
+        const arr = JSON.parse(raw);
+        return Array.isArray(arr) ? arr : [];
+    }
+    catch {
+        return [];
+    }
+}
+async function appendRemoteChatLog(peerPk, channelId, entry) {
+    try {
+        const { mkdir, readFile, writeFile } = await import('fs/promises');
+        await mkdir(REMOTE_CHAT_LOG_DIR, { recursive: true });
+        const p = `${REMOTE_CHAT_LOG_DIR}/${peerPk}__${channelId}.json`;
+        let arr = [];
+        try {
+            arr = JSON.parse(await readFile(p, 'utf-8'));
+        }
+        catch { }
+        if (!Array.isArray(arr))
+            arr = [];
+        // 去重: 同 source + content + timestamp 跳过
+        const dup = arr.some(m => m.source === entry.source && m.content === entry.content && m.timestamp === entry.timestamp);
+        if (!dup) {
+            arr.push(entry);
+            // 防无限增长: 保留最近 500 条
+            if (arr.length > 500)
+                arr = arr.slice(-500);
+            await writeFile(p, JSON.stringify(arr, null, 2), 'utf-8');
+        }
+    }
+    catch { /* 镜像失败不阻塞 */ }
+}
 /**
  * v3 重做: 构造 channel 的两路 judgment prompt 片段
  *   路 1: 用户在盾牌里手动绑定的 judgment (channel.bound_judgment_ids)
@@ -325,9 +371,12 @@ function isSharedWith(ch, peerPublicKey) {
  */
 async function routeMentionsInReply(originChannelId, replyText, localChannels, remoteChannels) {
     const results = [];
-    // 解析: 匹配 @渠道名 后面跟一段文字 (到下一个 @ 或 行尾)
+    // 解析: 匹配 @渠道名 后面跟一段文字 (到行尾 / 下一个 @ / 结束)
     // 渠道名: 中文/英文/数字/下划线/连字符, 1-30 字符
-    const regex = /@([一-龥A-Za-z0-9_\-]{1,30})\s+([^\n@]+?)(?=(?:\s*@[一-龥A-Za-z0-9_\-]{1,30}\s)|$)/g;
+    // 2026-08-02 fix: 文字部分 [^\n]+? 不跨行 + lookahead 支持 \n 边界 —
+    //   原来 lookahead 只认 @ 或 $, AI 回复里 "@渠道名 消息\n\n（解释...）" 尾随说明行
+    //   会导致匹配失败, @ 转发静默失效
+    const regex = /@([一-龥A-Za-z0-9_\-]{1,30})\s+([^\n]+?)(?=\n|\s*@[一-龥A-Za-z0-9_\-]{1,30}\s|$)/g;
     const matches = [...replyText.matchAll(regex)];
     if (matches.length === 0)
         return results;
@@ -404,10 +453,56 @@ async function routeMentionsInReply(originChannelId, replyText, localChannels, r
                 const r = await sendOrQueue(ownerPk, 'agent.cross.post', rpcPayload, v3P2PRef);
                 if (r === 'SENT') {
                     console.log(`[v3-cross] (${originChannelName}) @${targetName} → 远端 peer ${ownerPk.substring(0, 12)}... (channelId=${remoteTarget.id})`);
+                    // 2026-08-02: 激活远端协作续看 — 本地智能体 @ 远端后, 收到对方回复时多看一次
+                    //   (Validator: 判断完成 or 继续), remoteChannelId 用于 reply 事件匹配, maxRounds=3 防死循环
+                    const rs = channelRunState.get(originChannelId);
+                    if (rs && !rs.remoteFollowup) {
+                        rs.remoteFollowup = { rounds: 0, maxRounds: 3, remoteChannelId: remoteTarget.id };
+                        console.log(`[v3-followup] ${originChannelId} 激活远端协作续看 → ${remoteTarget.id} (maxRounds=3)`);
+                    }
+                    // 2026-08-02: @ 消息也要显示在 P2P 对话框 — broadcast remote-chat-sent,
+                    //   前端 rcm-log 打开且匹配 channelId 时显示"我 → 远端"这条消息
+                    //   注意: 不能传 'p2p-global' 第二参 — broadcast 会用第二参覆盖 payload.channelId
+                    broadcast({
+                        type: 'remote-chat-sent',
+                        channelId: remoteTarget.id,
+                        fromPublicKey: ownerPk,
+                        text,
+                        originChannelId,
+                        originChannelName,
+                        peerName: remoteTarget.name,
+                        sent: true,
+                    });
+                    // 写本地镜像 (替代 localStorage) — 对方离线时对话记录也可读
+                    appendRemoteChatLog(ownerPk, remoteTarget.id, {
+                        type: 'user', content: text, timestamp: new Date().toISOString(), source: 'local-sent',
+                    }).catch(() => { });
                     results.push({ targetName, targetId: remoteTarget.id, source: 'remote', text, status: 'sent' });
                 }
                 else if (r === 'QUEUED') {
                     console.log(`[v3-cross] (${originChannelName}) @${targetName} → 远端 peer ${ownerPk.substring(0, 12)}... 已入队 (对方不在线)`);
+                    // 入队也激活 — 对方上线后会回复, 同样续看
+                    const rs = channelRunState.get(originChannelId);
+                    if (rs && !rs.remoteFollowup) {
+                        rs.remoteFollowup = { rounds: 0, maxRounds: 3, remoteChannelId: remoteTarget.id };
+                        console.log(`[v3-followup] ${originChannelId} 激活远端协作续看 (入队 → ${remoteTarget.id})`);
+                    }
+                    // 入队也广播 (对方不在线, 显示"已入队")
+                    broadcast({
+                        type: 'remote-chat-sent',
+                        channelId: remoteTarget.id,
+                        fromPublicKey: ownerPk,
+                        text,
+                        originChannelId,
+                        originChannelName,
+                        peerName: remoteTarget.name,
+                        sent: false,
+                        queued: true,
+                    });
+                    // 写本地镜像 (入队也记录)
+                    appendRemoteChatLog(ownerPk, remoteTarget.id, {
+                        type: 'user', content: text, timestamp: new Date().toISOString(), source: 'local-sent',
+                    }).catch(() => { });
                     results.push({ targetName, targetId: remoteTarget.id, source: 'remote', text, status: 'queued' });
                 }
                 else {
@@ -425,6 +520,121 @@ async function routeMentionsInReply(originChannelId, replyText, localChannels, r
     }
     return results;
 }
+/**
+ * 2026-08-02: 远端协作续看 — 收到远端回复后, 本地智能体"多看一次回复".
+ * 流程 (与 /message 一致): 构建 context (注入远端回复 + 渠道目录) → promptStream →
+ *   routeMentionsInReply (LLM 若 @ 则继续转发) → broadcast 显示.
+ * LLM 判断: 任务未完成 → 回复里 @ 继续 (下次回复再续看); 完成 → 总结, 协作结束.
+ * 防死循环: roundsLeft 由调用方控制 (triggerRemoteFollowup 结束时若还有轮次, 保留
+ *   remoteFollowup; 否则清除).
+ */
+async function triggerRemoteFollowup(channelId, remoteReply, fromPublicKey, roundsLeft) {
+    try {
+        const channels = await loadChannels();
+        const ch = channels.find((c) => c.id === channelId);
+        if (!ch)
+            return;
+        const agent = await getAgentForChannel(channelId, ch.did || '', ch.name, ch.didDocRef);
+        if (!agent)
+            return;
+        // 构建 context: 远端回复 + 渠道目录 (让 LLM 知道可以 @ 谁继续)
+        let contextHint = `[系统上下文] 当前频道名称: ${ch.name}\n`;
+        contextHint += `[系统上下文] 你通过 P2P 给远端智能体发了消息, 对方回复如下. 请判断协作是否可以继续:\n`;
+        contextHint += `  对方回复: ${remoteReply.slice(0, 1500)}\n\n`;
+        contextHint += `[系统上下文] 协作规则 (本轮为自动续看, 非用户直接消息):\n`;
+        contextHint += `  1. 如果对方回复解决了问题/任务完成 → 给用户总结结果, 不要继续发消息.\n`;
+        contextHint += `  2. 如果对方回复不完整/需要进一步协作 → 在回复中写 "@渠道名 继续的内容" 继续协作 (剩余续看轮次: ${Math.max(0, roundsLeft)}).\n`;
+        contextHint += `  3. 最多再继续 ${Math.max(0, roundsLeft)} 轮, 之后必须总结收尾.\n\n`;
+        // 渠道目录 (本地跳过自己 + 远端)
+        try {
+            const localChs = await loadChannels();
+            const remoteForDir = [];
+            for (const [peerPk, list] of remoteChannelCache.entries()) {
+                for (const rc of list)
+                    remoteForDir.push({ ...rc, _ownerPublicKey: peerPk });
+            }
+            if (localChs.length > 0 || remoteForDir.length > 0) {
+                contextHint += '[系统上下文] 可用渠道 (回复中写 "@渠道名 消息内容" 可给它们发消息):\n';
+                for (const c of localChs) {
+                    if (c.id === channelId)
+                        continue;
+                    contextHint += `  - [本地] @${c.name} (id=${c.id})\n`;
+                }
+                for (const c of remoteForDir) {
+                    contextHint += `  - [远端, owner=${(c._ownerPublicKey || '').substring(0, 8)}…] @${c.name} (id=${c.id})\n`;
+                }
+                contextHint += '\n';
+            }
+        }
+        catch { /* 目录失败不阻塞 */ }
+        const markedPrompt = `【自动续看】远端智能体的回复需要你判断是否继续协作.\n【远端回复】\n${remoteReply.slice(0, 2000)}\n【回复结束】\n\n${contextHint}`;
+        // streamCallback: 广播 thinking/step (让用户看到续看过程), 不广播 token 流
+        const streamCallback = (event) => {
+            if (event?.type === 'used_judgments')
+                return;
+            if (event.type === 'step_start' || event.type === 'step_done' || event.type === 'step_error') {
+                broadcast({ type: 'followup-step', ...event, channelId }, channelId);
+            }
+        };
+        const fullResponse = await agent.promptStream(markedPrompt, streamCallback, undefined, channelId);
+        if (!fullResponse.trim())
+            return;
+        // 广播续看结果给 UI
+        broadcast({
+            type: 'ai',
+            content: `🔄 远端智能体回复 (来自 ${fromPublicKey.substring(0, 10)}…):\n${remoteReply.slice(0, 600)}\n\n---\n\n${fullResponse}`,
+            followup: true,
+        }, channelId);
+        // 存 session (作为 ai 消息)
+        try {
+            const existing = await loadSession(channelId, ch.currentSessionId || 'default');
+            const session = existing || { channelId, sessionId: 'default', messages: [], lastUpdated: '' };
+            session.messages.push({
+                id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                type: 'ai',
+                content: fullResponse,
+                timestamp: new Date().toISOString(),
+                source: 'followup',
+            });
+            session.lastUpdated = new Date().toISOString();
+            await saveSession(session);
+        }
+        catch { /* 存失败不阻塞 */ }
+        // 路由 @ 转发 (LLM 若决定继续, 回复里会有 @渠道名)
+        try {
+            const localChs = await loadChannels();
+            const remoteForRoute = [];
+            for (const [peerPk, list] of remoteChannelCache.entries()) {
+                for (const rc of list)
+                    remoteForRoute.push({ ...rc, _ownerPublicKey: peerPk });
+            }
+            const mentions = await routeMentionsInReply(channelId, fullResponse, localChs, remoteForRoute);
+            const didContinue = mentions.some((m) => m.status === 'sent' || m.status === 'queued');
+            if (!didContinue) {
+                // LLM 决定结束 → 清除续看状态
+                const rs = channelRunState.get(channelId);
+                if (rs)
+                    rs.remoteFollowup = undefined;
+                console.log(`[v3-followup] ${channelId} 本地智能体决定结束协作 (无继续 @)`);
+            }
+            else {
+                console.log(`[v3-followup] ${channelId} 本地智能体继续协作 (${mentions.length} 个 @ 转发)`);
+            }
+        }
+        catch (routeErr) {
+            console.warn('[v3-followup] 路由 @ 失败:', routeErr?.message?.slice(0, 100));
+            const rs = channelRunState.get(channelId);
+            if (rs)
+                rs.remoteFollowup = undefined;
+        }
+    }
+    catch (err) {
+        console.error(`[v3-followup] ${channelId} 续看失败:`, err?.message?.slice(0, 200));
+        const rs = channelRunState.get(channelId);
+        if (rs)
+            rs.remoteFollowup = undefined;
+    }
+}
 /**
  * v3: 处理 Hyperswarm 通道收到的 v3 RPC 消息
  * 设计: 用 HyperswarmCommunicator (DHT topic 自动发现) 取代 iroh 直接 connect
@@ -1383,6 +1593,8 @@ function checkStaleLock(startPort) {
 }
 export async function createWebServer(port = 3000, options = {}) {
     selfImproveEnabled = options.selfImprove ?? false;
+    // 2026-08-02: channelRunState 是模块级 (triggerRemoteFollowup 访问), 每次启动清空避免残留
+    channelRunState.clear();
     // 防止 P2P DHT 超时等错误导致进程崩溃
     process.on('unhandledRejection', (reason, promise) => {
         console.error('[警告] 未处理的 Promise 拒绝:', reason);
@@ -1407,6 +1619,66 @@ export async function createWebServer(port = 3000, options = {}) {
     resetAgentSession();
     // 初始化 LLM（从配置文件读取 MiniMax 配置）
     initMinimax();
+    // 2026-08-02 fix: 启动自愈 — 从 agents.json 恢复 channels.json 缺失的 channel.
+    //   背景: UI 创建 channel 偶发不落盘 / 历史并发覆盖丢 channel, 但 agents.json 里
+    //   agent 的 channelId + name 还在 (session 文件也在) → 启动时自动恢复, 智能体不再"消失".
+    // 2026-08-02 v2: 抽成函数 healMissingChannels() — 启动 + GET /channels 时都调用.
+    //   之前只启动时跑一次: 启动时 channel 还在 → 跳过, 之后运行中丢失 → 永远不恢复
+    //   (用户报告"每次刷新和 build 都会消失" — 刷新后 GET /channels 触发恢复即可自愈).
+    async function healMissingChannels() {
+        try {
+            const { existsSync } = await import('fs');
+            const { readFile } = await import('fs/promises');
+            const agentsFile = `${process.env.HOME || '/tmp'}/.bolloon/agents/agents.json`;
+            const sessionsDir = `${process.env.HOME || '/tmp'}/.bolloon/sessions/cache`;
+            if (!existsSync(agentsFile))
+                return 0;
+            const agentsRaw = await readFile(agentsFile, 'utf-8');
+            const agentsArr = JSON.parse(agentsRaw);
+            const arr = Array.isArray(agentsArr) ? agentsArr : [];
+            const chs = await loadChannels();
+            const knownIds = new Set(chs.map((c) => c.id));
+            let healed = 0;
+            for (const a of arr) {
+                const cid = a && a.channelId;
+                if (!cid || knownIds.has(cid))
+                    continue;
+                // 有 session 文件才算可恢复 (说明确实创建过)
+                const hasSession = existsSync(`${sessionsDir}/${cid}:default.json`) || existsSync(`${sessionsDir}/${cid}.json`);
+                if (!hasSession)
+                    continue;
+                const restored = {
+                    id: cid,
+                    name: a.name || `Agent-${String(cid).slice(-6)}`,
+                    agentId: a.id,
+                    createdAt: a.createdAt || new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                    currentSessionId: 'default',
+                    sessions: [{ id: 'default', name: 'Default', createdAt: new Date().toISOString(), messageCount: 0, preview: '' }],
+                    did: a.did || undefined,
+                };
+                await updateChannels((all) => {
+                    if (!all.some((c) => c.id === cid))
+                        all.push(restored);
+                    return all;
+                });
+                knownIds.add(cid);
+                healed++;
+                console.log(`[自愈] 恢复 channel: ${cid} (${restored.name}, agent=${a.id})`);
+            }
+            if (healed > 0)
+                console.log(`[自愈] 共恢复 ${healed} 个丢失的 channel`);
+            return healed;
+        }
+        catch (healErr) {
+            console.warn('[自愈] channel 恢复失败 (非致命):', healErr?.message?.slice(0, 120));
+            return 0;
+        }
+    }
+    // 启动时自愈一次
+    await healMissingChannels().catch(() => { });
+    // 2026-08-02: GET /channels 运行中自愈的节流时间戳
+    let lastHealAt = 0;
     // ==================== P2P DIAP 身份初始化 ====================
     let p2pIdentity = {
         did: '',
@@ -1559,12 +1831,54 @@ export async function createWebServer(port = 3000, options = {}) {
                                         session.lastUpdated = new Date().toISOString();
                                         await saveSession(session);
                                         console.log(`[v3] chat.reply 已持久化到 session (${replyChannelId}): ${replyText.substring(0, 40)}...`);
+                                        // 2026-08-02: 写本地镜像 (替代 localStorage) — 离线也能看到对方回复
+                                        appendRemoteChatLog(evt.fromPublicKey, replyChannelId, {
+                                            type: 'ai', content: replyText, timestamp: new Date().toISOString(), source: 'remote-reply',
+                                        }).catch(() => { });
                                     }
                                     catch (e) {
                                         console.warn('[v3] chat.reply 持久化失败:', e?.message?.substring(0, 100));
                                     }
                                 }).catch(() => { });
                             }
+                            // 2026-08-02: 远端协作续看 — 用户 @ 过远端 / 智能体发过 send_to_remote 的 channel,
+                            //   收到对方回复时本地智能体"多看一次回复": LLM 判断任务是否完成, 未完成可 @ 继续.
+                            //   防死循环: maxRounds 上限 (默认 3), 达到后结束协作.
+                            //   replyChannelId 是远端 channel id, 需遍历 channelRunState 匹配 remoteFollowup.remoteChannelId
+                            if (replyChannelId && replyText) {
+                                try {
+                                    let matchedLocalId = null;
+                                    let matchedRs = null;
+                                    for (const [cid, rs] of channelRunState.entries()) {
+                                        if (rs?.remoteFollowup?.remoteChannelId === replyChannelId) {
+                                            matchedLocalId = cid;
+                                            matchedRs = rs;
+                                            break;
+                                        }
+                                    }
+                                    // 兜底: 若 replyChannelId 本身是本地 channel (旧协议), 直接用它
+                                    if (!matchedRs && channelRunState.has(replyChannelId) && channelRunState.get(replyChannelId)?.remoteFollowup) {
+                                        matchedLocalId = replyChannelId;
+                                        matchedRs = channelRunState.get(replyChannelId);
+                                    }
+                                    if (matchedRs && matchedRs.remoteFollowup && !matchedRs.running && matchedLocalId) {
+                                        const fu = matchedRs.remoteFollowup;
+                                        fu.rounds += 1;
+                                        if (fu.rounds <= fu.maxRounds) {
+                                            console.log(`[v3-followup] ${matchedLocalId} 收到远端回复 (round ${fu.rounds}/${fu.maxRounds}), 本地智能体续看...`);
+                                            // 异步触发本地智能体处理回复 (不阻塞 data 事件循环)
+                                            void triggerRemoteFollowup(matchedLocalId, replyText, evt.fromPublicKey, fu.maxRounds - fu.rounds);
+                                        }
+                                        else {
+                                            console.log(`[v3-followup] ${matchedLocalId} 达到续看上限 (${fu.maxRounds}), 结束协作`);
+                                            matchedRs.remoteFollowup = undefined;
+                                        }
+                                    }
+                                }
+                                catch (fuErr) {
+                                    console.warn('[v3-followup] 续看调度失败 (非致命):', fuErr?.message?.slice(0, 100));
+                                }
+                            }
                             return;
                         }
                         // 2026-07-21: 社交心跳 beacon — 远端智能体宣告存活/能力, 更新本地 liveness
@@ -2725,6 +3039,23 @@ ${goalDesc}
                     broadcast({ type: 'status', tool: event.tool, content: event.content }, channelId);
                     broadcast({ type: 'workflow_step', step: event.tool || '系统', content: event.content }, channelId);
                     console.log(`[SSE 广播] workflow_step: step=${event.tool}, content="${event.content?.substring(0, 80)}..."`);
+                    // 2026-08-02: 本地 @ 远端时, 工作流步骤也推给 P2P 对话框 (rcm-log)
+                    //   — 用户报告"进程看不到": 本地智能体执行过程 (即使没调工具, 只有 status/tool 事件)
+                    //   也要在 P2P 对话框显示, 让用户看到"进程"
+                    try {
+                        const rs = channelRunState.get(channelId);
+                        if (rs?.remoteFollowup?.remoteChannelId) {
+                            broadcast({
+                                type: 'remote-chat-step',
+                                channelId: rs.remoteFollowup.remoteChannelId,
+                                stepType: 'step_start',
+                                tool: event.tool || '工作流',
+                                content: event.content,
+                                localStep: true,
+                            });
+                        }
+                    }
+                    catch { /* 非致命 */ }
                 }
                 else if (event.type === 'step_start' || event.type === 'step_done' || event.type === 'step_error') {
                     // 2026-06-15: 步骤状态机事件 — 原样转发 (前端 step-timeline 组件订阅)
@@ -2737,6 +3068,26 @@ ${goalDesc}
                         error: event.error,
                         args: event.args,
                     }, channelId);
+                    // 2026-08-02: 对称显示 — 本地智能体 @ 远端时, 本地工具调用过程也推给 P2P 对话框
+                    //   (rcm-log): remote-chat-step 事件带 remoteChannelId, 前端按对话框匹配显示
+                    try {
+                        const rs = channelRunState.get(channelId);
+                        if (rs?.remoteFollowup?.remoteChannelId) {
+                            broadcast({
+                                type: 'remote-chat-step',
+                                channelId: rs.remoteFollowup.remoteChannelId,
+                                stepType: event.type,
+                                tool: event.tool,
+                                content: event.content,
+                                success: event.success,
+                                output: event.output,
+                                error: event.error,
+                                args: event.args,
+                                localStep: true, // 标记: 这是本地智能体的工具过程 (区别于对方转发的)
+                            });
+                        }
+                    }
+                    catch { /* 非致命 */ }
                     // 2026-06-16: 累积 step 到 runState, 供 /api/loop/inspect 读取
                     try {
                         if (event.type === 'step_done' || event.type === 'step_error') {
@@ -2760,6 +3111,32 @@ ${goalDesc}
                 }
             };
             console.log(`[消息处理] 开始处理用户消息, channelId: ${channelId}, sessionId: ${currentSessionId}`);
+            // 2026-08-02 fix: 预激活远端协作续看 — 用户消息含 @远端 时立即激活 remoteFollowup.
+            //   之前只在 routeMentionsInReply (AI 回复后) 激活 → 首次 @ 时本地智能体的工具调用
+            //   (step 事件) 发生在激活前, P2P 对话框看不到本地工具过程 (用户报告"进程看不到").
+            //   现在收到消息即激活 → promptStream 期间的工具 step 也能 broadcast remote-chat-step.
+            try {
+                const mentionMatch = /@([一-龥A-Za-z0-9_\-]{1,30})/.exec(text);
+                if (mentionMatch && remoteChannelCache.size > 0) {
+                    const targetName = mentionMatch[1];
+                    let hitRemoteId = null;
+                    for (const list of remoteChannelCache.values()) {
+                        const rc = list.find((c) => c.name === targetName);
+                        if (rc) {
+                            hitRemoteId = String(rc.id);
+                            break;
+                        }
+                    }
+                    if (hitRemoteId) {
+                        const rs = channelRunState.get(channelId);
+                        if (rs && !rs.remoteFollowup) {
+                            rs.remoteFollowup = { rounds: 0, maxRounds: 3, remoteChannelId: hitRemoteId };
+                            console.log(`[v3-followup] ${channelId} 预激活远端协作续看 → ${hitRemoteId} (消息含 @${targetName})`);
+                        }
+                    }
+                }
+            }
+            catch { /* 预激活失败不阻塞 */ }
             // 将真实 DID 作为上下文前缀，让 AI 使用真实的 DID 而不是自己编造的
             let contextHint = '';
             // 2026-08-02: slash 命令提示 (在 /message 开头解析, 这里注入)
@@ -2778,6 +3155,33 @@ ${goalDesc}
             else {
                 contextHint += `[系统上下文] 自动工具调用已关闭: 每次执行工具前必须先与用户确认。\n`;
             }
+            // 2026-08-02 fix: 本地路径注入远端 channel 目录 (dirHint) — 之前只有远端路径 (agent.chat.send)
+            //   有 dirHint, 本地智能体对话时看不到远端 channel 列表 → 无法 @ 远程智能体交流.
+            //   现在注入: 可用渠道列表 (本地 + 远端), 让 LLM 知道 @ 谁、发什么.
+            try {
+                const localChs = await loadChannels();
+                const remoteForDir = [];
+                for (const [peerPk, list] of remoteChannelCache.entries()) {
+                    for (const ch of list) {
+                        remoteForDir.push({ ...ch, _ownerPublicKey: peerPk });
+                    }
+                }
+                if (localChs.length > 0 || remoteForDir.length > 0) {
+                    contextHint += '[系统上下文] 可用渠道 (你可以在回复中写 "@渠道名 消息内容" 给它们发消息, 消息会持久化到目标 channel 的 session):\n';
+                    for (const c of localChs) {
+                        if (c.id === channelId)
+                            continue; // 跳过自己
+                        contextHint += `  - [本地] @${c.name} (id=${c.id})\n`;
+                    }
+                    for (const c of remoteForDir) {
+                        contextHint += `  - [远端, owner=${(c._ownerPublicKey || '').substring(0, 8)}…] @${c.name} (id=${c.id})\n`;
+                    }
+                    contextHint += '语法: 在回复中写 "@渠道名 我要说的话" 即可, 系统会自动转发。\n\n';
+                }
+            }
+            catch (dirErr) {
+                // 静默 — dirHint 不是核心
+            }
             // v3: 注入 channel 绑定的判断力 (judgment_ids)
             // 这是 v3 的核心 — channel 跑 LLM 时, 它的判断力 = 绑定的 judgment 列表
             const judgmentHint = await buildJudgmentHint(channelForJudgment, channelId);
@@ -3317,7 +3721,7 @@ ${goalDesc}
     const didFixQueue = new Set(); // 待修复的 channelId
     let didFixRunning = false;
     let didFixTimer = null;
-    const channelRunState = new Map();
+    // 2026-08-02: channelRunState 已提升为模块级 (triggerRemoteFollowup 也访问), 这里复用
     function getOrCreateRunState(channelId) {
         let s = channelRunState.get(channelId);
         if (!s) {
@@ -3557,6 +3961,14 @@ ${goalDesc}
     }
     app.get('/channels', async (_req, res) => {
         try {
+            // 2026-08-02 fix: 运行中自愈 — 每次拉取前检查丢失的 channel (从 agents.json 恢复).
+            //   解决"刷新/build 后 channel 消失": 刷新即触发 GET /channels → 丢失的自动回来
+            //   节流: 5s 内只跑一次 (heal 内部有文件 IO)
+            const nowMs = Date.now();
+            if (nowMs - (lastHealAt || 0) > 5000) {
+                lastHealAt = nowMs;
+                await healMissingChannels().catch(() => { });
+            }
             // 2026-06-17: 缓存命中 → 0 行;未命中 → 1 行 summary (上面 console.log proxy 已吃掉 [API] /channels 等旧日志)
             const t0 = Date.now();
             const now = t0;
@@ -3698,6 +4110,14 @@ ${goalDesc}
                 return res.status(400).json({ error: 'name and agentId required' });
             }
             const channels = await loadChannels();
+            // 2026-08-02 fix: 同 agentId 下禁止重名 — 之前用户连点两次"新建智能体"生成两个同名
+            //   "智能体" channel, UI 无法区分 (分享栏名字对不上 id). 同 agentId 同名直接拒绝.
+            const dupName = channels.find(c => c.agentId === agentId && c.name === name.trim());
+            if (dupName) {
+                return res.status(400).json({
+                    error: `同名智能体已存在 (${dupName.name}, id=${dupName.id}), 请换一个名字`
+                });
+            }
             const id = `ch_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
             // 校验钱包地址格式 (粗校验: 0x + 40 hex / Solana base58 / Sui 0x+64)
             const validWallet = isValidWalletAddress(walletAddress);
@@ -3802,6 +4222,29 @@ ${goalDesc}
                     await fs.writeFile(agentsPath, JSON.stringify(arr, null, 2), 'utf-8');
                     console.log(`[创建频道] agent 写进 agents.json: name=${name} id=${agentId}`);
                 }
+                else {
+                    // 2026-08-02 fix: agent 已存在时更新 channelId + name — 之前 exists 直接跳过,
+                    //   用户复用同一 agentId 新建 channel 时, agents.json 的 channelId 仍指向旧 channel
+                    //   (可能已删除), P2P manifest / 恢复逻辑拿到的关联是错的 → "智能体消失"
+                    const existing = arr.find(a => a && a.id === agentId);
+                    const oldCid = existing?.channelId;
+                    let changed = false;
+                    if (existing) {
+                        if (existing.channelId !== id) {
+                            existing.channelId = id;
+                            changed = true;
+                        }
+                        if (existing.name !== name) {
+                            existing.name = name;
+                            changed = true;
+                        }
+                        existing.lastActive = new Date().toISOString();
+                    }
+                    if (changed) {
+                        await fs.writeFile(agentsPath, JSON.stringify(arr, null, 2), 'utf-8');
+                        console.log(`[创建频道] agent ${agentId} channelId 更新: ${oldCid} → ${id} (name=${name})`);
+                    }
+                }
             }
             catch (e) {
                 console.warn('[创建频道] 写 agents.json 失败 (非致命):', e?.message?.slice(0, 120));
@@ -3985,6 +4428,9 @@ ${goalDesc}
             //   之前 v0.3.6 (Bug 6) 创建频道时同步往 agents.json append, 删频道却没删回来
             //   → agents.json 里残留孤儿 agent, 重启后 loadLocalSubAgents 还能读到这些 — 看起来像"删不掉"
             //   修法: 用 channel.agentId 找, 同步从 agents.json 删一条
+            // 2026-08-02 二次修: 只在没有其他 channel 复用该 agentId 时才删 agent —
+            //   之前无条件 filter(a.id === channel.agentId), 多个 channel 共享 agentId (用户复用"智能体" id)
+            //   时, 删一个 channel 把 agent 也清了 → 其他 channel 变孤儿 → "智能体消失"
             try {
                 const agentsPath = path.join(process.env.HOME || '/tmp', '.bolloon', 'agents', 'agents.json');
                 const raw = await fs.readFile(agentsPath, 'utf-8').catch(() => '');
@@ -3996,11 +4442,25 @@ ${goalDesc}
                     catch { }
                     if (!Array.isArray(arr))
                         arr = [];
+                    // 检查是否有其他 channel 还引用这个 agentId (含刚删的这条: 用删除后的 channels 判断)
+                    const remainingChannels = await loadChannels();
+                    const agentIdStillUsed = remainingChannels.some((c) => c.id !== channelId && c.agentId === channel.agentId);
                     const before = arr.length;
-                    arr = arr.filter(a => !(a && (a.id === channel.agentId || a.channelId === channelId)));
+                    // 只删: ① channelId 精确匹配的 agent 条目 ② 该 agentId 无其他 channel 使用时才按 agentId 删
+                    arr = arr.filter(a => {
+                        if (!a)
+                            return false;
+                        if (a.channelId === channelId)
+                            return false; // 精确指向被删 channel
+                        if (a.id === channel.agentId && agentIdStillUsed)
+                            return true; // 共享中, 保留
+                        if (a.id === channel.agentId && !agentIdStillUsed)
+                            return false; // 无引用, 删
+                        return true;
+                    });
                     if (arr.length !== before) {
                         await fs.writeFile(agentsPath, JSON.stringify(arr, null, 2), 'utf-8');
-                        console.log(`[删除频道] agents.json 清掉 ${before - arr.length} 条 orphan agent (channel=${channelId})`);
+                        console.log(`[删除频道] agents.json 清掉 ${before - arr.length} 条 agent (channel=${channelId}, agentId=${channel.agentId}, 仍被使用=${agentIdStillUsed})`);
                     }
                 }
             }
@@ -4096,12 +4556,31 @@ ${goalDesc}
                 console.log(`[Channel ${channelId}] 自动生成 share_id: ${channel.share_id}`);
             }
             channel.updatedAt = new Date().toISOString();
-            // 2026-08-02 fix: 原子写入
+            // 2026-08-02 fix: 原子写入 — 之前回调只写 shared_with_peers/share_id, name 等字段
+            //   只改了外层内存对象, 磁盘没落 → 改名后重启名字回退 / 与 UI 显示不一致 ("改名没修好")
             await updateChannels((chs) => {
                 const c = chs.find(x => x.id === channelId);
                 if (c) {
+                    if (typeof name === 'string' && name.trim())
+                        c.name = name.trim();
+                    if (persona !== undefined) {
+                        if (persona === null)
+                            c.persona = undefined;
+                        else if (typeof persona === 'object')
+                            c.persona = channel.persona;
+                    }
+                    if (Array.isArray(linkedDocumentIds))
+                        c.linkedDocumentIds = channel.linkedDocumentIds;
+                    if (walletAddress !== undefined) {
+                        c.walletAddress = channel.walletAddress;
+                        c.walletRegisteredAt = channel.walletRegisteredAt;
+                    }
+                    if (typeof autoInvokeTools === 'boolean')
+                        c.autoInvokeTools = channel.autoInvokeTools;
+                    if (bound_judgment_ids !== undefined)
+                        c.bound_judgment_ids = channel.bound_judgment_ids;
                     if (shared_with_peers !== undefined)
-                        c.shared_with_peers = shared_with_peers;
+                        c.shared_with_peers = channel.shared_with_peers;
                     if (!c.share_id)
                         c.share_id = channel.share_id;
                     c.updatedAt = new Date().toISOString();
@@ -4884,43 +5363,67 @@ ${goalDesc}
     // 实现: B → POST 给 A 一个 agent.history.get RPC → A 把 session 返回 → B 渲染
     app.get('/api/remote-channels/chat-history', async (req, res) => {
         try {
-            if (!v3P2PRef) {
-                return res.status(503).json({ error: 'P2PDirect not started' });
-            }
             const targetPublicKey = String(req.query.targetPublicKey || '');
             const channelId = String(req.query.channelId || '');
             if (!targetPublicKey || !channelId) {
                 return res.status(400).json({ error: 'targetPublicKey, channelId required' });
             }
-            // 通过 RPC 拉 A 的 session — A 端收到后异步回复
-            const fromPk = v3P2PRef.getPublicKey();
-            const rpcId = `hist-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-            const msg = JSON.stringify({
-                v: 3,
-                op: 'agent.history.get',
-                payload: { rpcId, channelId, fromPublicKey: fromPk }
-            });
-            const ok = v3P2PRef.sendTo(targetPublicKey, msg);
-            if (!ok) {
-                return res.status(502).json({ error: 'peer not connected' });
-            }
-            // 等待 A 异步回复 (15s timeout) — 用一个 Promise 等
-            const result = await new Promise((resolve, reject) => {
-                const timer = setTimeout(() => {
-                    v3PendingHistoryGets.delete(rpcId);
-                    reject(new Error('A 端 15s 内未回复, 可能未分享该 channel'));
-                }, 15000);
-                v3PendingHistoryGets.set(rpcId, {
-                    resolve: (data) => { clearTimeout(timer); resolve(data); },
-                    reject: (err) => { clearTimeout(timer); reject(err); }
+            // 2026-08-02: 本地镜像优先 — 立即返回本地记录 (对方离线也有), 不用等 RPC
+            const mirror = await readRemoteChatLog(targetPublicKey, channelId);
+            if (mirror.length > 0 && !v3P2PRef) {
+                return res.json({ messages: mirror, source: 'mirror', judgments: { bound: [], candidates: [] } });
+            }
+            // 有 P2P: 后台 RPC 拉对端合并 (不阻塞响应 — 镜像先返回, RPC 结果下次刷新拿到)
+            if (v3P2PRef) {
+                const fromPk = v3P2PRef.getPublicKey();
+                const rpcId = `hist-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                const msg = JSON.stringify({
+                    v: 3,
+                    op: 'agent.history.get',
+                    payload: { rpcId, channelId, fromPublicKey: fromPk }
                 });
-            });
-            console.log(`[v3] chat-history 从 ${targetPublicKey.substring(0, 12)}... 拉到 ${(result.messages || []).length} 条`);
-            res.json(result);
+                const ok = v3P2PRef.sendTo(targetPublicKey, msg);
+                if (!ok && mirror.length === 0) {
+                    return res.status(502).json({ error: 'peer not connected (本地也无缓存)' });
+                }
+                if (ok && mirror.length === 0) {
+                    // 无本地镜像 → 等 RPC (15s)
+                    try {
+                        const result = await new Promise((resolve, reject) => {
+                            const timer = setTimeout(() => {
+                                v3PendingHistoryGets.delete(rpcId);
+                                reject(new Error('A 端 15s 内未回复'));
+                            }, 15000);
+                            v3PendingHistoryGets.set(rpcId, {
+                                resolve: (data) => { clearTimeout(timer); resolve(data); },
+                                reject: (err) => { clearTimeout(timer); reject(err); }
+                            });
+                        });
+                        // 把对端历史写进本地镜像 (增量缓存)
+                        const remoteMsgs = result.messages || [];
+                        for (const m of remoteMsgs) {
+                            await appendRemoteChatLog(targetPublicKey, channelId, {
+                                type: m.type === 'user' ? 'user' : 'ai',
+                                content: m.content || '',
+                                timestamp: m.timestamp || new Date().toISOString(),
+                                source: m.source || 'remote',
+                            });
+                        }
+                        return res.json({ ...result, messages: remoteMsgs, source: 'rpc' });
+                    }
+                    catch (err) {
+                        return res.status(504).json({ error: err.message });
+                    }
+                }
+                // 有本地镜像 + 有 P2P: 返回镜像 (RPC 结果由前端 15s 刷新轮询拿)
+                return res.json({ messages: mirror, source: 'mirror', judgments: { bound: [], candidates: [] } });
+            }
+            // 无 P2P
+            return res.json({ messages: mirror, source: 'mirror', judgments: { bound: [], candidates: [] } });
         }
         catch (err) {
             console.error('[v3] chat-history 失败:', err.message);
-            res.status(504).json({ error: err.message });
+            res.status(500).json({ error: err.message });
         }
     });
     // 获取已连接的节点
@@ -6285,7 +6788,11 @@ function broadcast(data, channelId) {
     const msgId = (data.type === 'ai' || data.type === 'user')
         ? nextMsgId(channelId)
         : `evt_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
-    const envelope = { ...data, channelId, seq, msgId };
+    // 2026-08-02 fix: 第二参 channelId 为 undefined 时, 不要用 undefined 覆盖 data.channelId —
+    //   否则 payload 自带的 channelId (如 remote-chat-sent 的远端 channel id) 会丢, 前端无法匹配对话框
+    const envelope = channelId !== undefined
+        ? { ...data, channelId, seq, msgId }
+        : { ...data, seq, msgId };
     const message = `data: ${JSON.stringify(envelope)}\n\n`;
     console.log(`[broadcast] type=${data.type}, channelId=${channelId}, seq=${seq}, msgId=${msgId}, clients=${sseClients.size}`);
     for (const client of sseClients) {

package/package.json

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