@bolloon/bolloon-agent 0.3.26 → 0.3.28

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);
@@ -1402,11 +1614,112 @@ export async function createWebServer(port = 3000, options = {}) {
     catch (err) {
         console.warn('[createWebServer] bootstrap 失败 (非致命):', err);
     }
+    // 2026-08-03 (Context OS P5): 初始化资产层 12+3 目录 (幂等, 每层 README 声明职责边界)
+    try {
+        const { ensureContextOsDirs } = await import('../bootstrap/context-os.js');
+        await ensureContextOsDirs();
+        console.log('[createWebServer] Context OS 资产层就绪 (~/.bolloon/context-os/, 12+3 层)');
+    }
+    catch (err) {
+        console.warn('[createWebServer] Context OS 资产层初始化失败 (非致命):', err);
+    }
+    // 2026-08-03: 后台自动安装/启动本地 Kubo (IPFS+IPNS 发布用, 全自动零手动).
+    //   fire-and-forget, 不阻塞 server 启动; 首次下载 ~100MB 需 1-2 分钟.
+    //   装好后 publish_did / DID 发布自动走 IPFS+IPNS; 没装好则降级本地模式.
+    (async () => {
+        try {
+            const sdk = await import('@diap/sdk');
+            const checkKuboSetup = sdk.checkKuboSetup;
+            if (typeof checkKuboSetup !== 'function')
+                return;
+            const setup = await checkKuboSetup(true, true);
+            if (setup?.ready && setup?.daemonRunning) {
+                console.log('[ipfs] 本地 Kubo 就绪 (自动安装/启动) → DID 发布支持 IPFS+IPNS');
+            }
+            else {
+                console.log('[ipfs] Kubo 不可用, DID 发布降级本地模式 (可用 publish_did 工具重试)');
+            }
+        }
+        catch (e) {
+            console.warn('[ipfs] Kubo 自动安装失败 (非致命):', e?.message?.slice(0, 120));
+        }
+    })();
+    // 2026-08-03: 初始化 MCP 适配器 (读 ~/.mcp.json, 自动握手发现工具).
+    //   后台异步: 不阻塞启动, 失败静默 (agent 调 mcp_list_tools 时再触发).
+    (async () => {
+        try {
+            const { initializeMcpAdapter } = await import('../pi-ecosystem-mcp/index.js');
+            await initializeMcpAdapter();
+        }
+        catch (e) {
+            console.warn('[mcp] 初始化失败 (非致命):', e?.message?.slice(0, 120));
+        }
+    })();
     // 重置旧的 agent session，确保使用新的 LLM 配置
     const { resetAgentSession } = await import('../agents/pi-sdk.js');
     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 +1872,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 +3080,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 +3109,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 +3152,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 +3196,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);
@@ -2899,7 +3344,7 @@ ${goalDesc}
                     }
                     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`;
+                        contextHint += `[系统上下文] 动态状态层 · chat-worksite (上次做到哪 — 本 channel 历史记忆, 来自 memory-compressor 摘要, 引用而非复述):\n${memBlock.slice(-2500)}\n\n`;
                     }
                 }
             }
@@ -2914,12 +3359,25 @@ ${goalDesc}
                 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`;
+                    contextHint += `[系统上下文] 动态状态层 · focus (此刻优先级与时间边界 — 进行中的计划, 来自 plan-store, 执行中每完成一步调 update_plan 勾选):\n${plansBlock}\n\n`;
                 }
             }
             catch (planErr) {
                 // 静默失败
             }
+            // 2026-08-03 (Context OS P5): 资产层目录注入 — LLM 知道有 12+3 层资产,
+            //   需要细节时用 read_context_assets 按层路由读取, 不全仓扫描 (Context OS §4).
+            try {
+                const { readContextAssets, formatLayerListing } = await import('../bootstrap/context-os.js');
+                const listings = await readContextAssets();
+                const total = listings.reduce((s, l) => s + l.fileCount, 0);
+                if (total > 0) {
+                    contextHint += `[系统上下文] 资产层 (Context OS 12+3 层, ${total} 篇资产 — 任务需要细节时用 read_context_assets 按层读取, 不要假装知道没读过的内容):\n${formatLayerListing(listings)}`;
+                }
+            }
+            catch (ctxErr) {
+                // 静默失败
+            }
             const linkedIds = channelForJudgment?.linkedDocumentIds;
             if (Array.isArray(linkedIds) && linkedIds.length > 0) {
                 try {
@@ -3317,7 +3775,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 +4015,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;
@@ -3810,6 +4276,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));
@@ -3993,6 +4482,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(() => '');
@@ -4004,11 +4496,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})`);
                     }
                 }
             }
@@ -4911,43 +5417,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 });
         }
     });
     // 获取已连接的节点
@@ -6312,7 +6842,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) {