@bolloon/bolloon-agent 0.1.32 → 0.1.34

package/dist/web/server.js

@@ -11,6 +11,7 @@ import { initMinimax, getMinimax } from '../constraints/index.js';
 import { createAgentSession } from '../agents/pi-sdk.js';
 import { llmConfigStore } from '../llm/config-store.js';
 import { videoConfigStore } from '../llm/video-config-store.js';
+import { audioConfigStore } from '../llm/audio-config-store.js';
 import { irohTransport } from '../network/iroh-transport.js';
 import { createAgentDelegateApp } from './agent-delegate-server.js';
 import { createIrohDelegateTransport } from './iroh-delegate-transport.js';
@@ -280,8 +281,54 @@ let sseClients = new Set();
 // v3: 远端 channel UI 元数据缓存 — key: peerId, value: sanitize 过的 channel 列表
 // in-memory only, 进程重启清空 (judgment 内容永远不在这里)
 let remoteChannelCache = new Map();
+// 2026-06-10: 持久化 remote channel cache 到 ~/.bolloon/remote-channels-cache.json
+// 之前是纯内存 Map, nodeA 重启后所有对端 channel 列表丢失, 需要等对面再推一次
+const REMOTE_CACHE_FILE = `${process.env.HOME || '/tmp'}/.bolloon/remote-channels-cache.json`;
+async function loadRemoteChannelCacheFromDisk() {
+    try {
+        const { readFile, mkdir } = await import('fs/promises');
+        const { existsSync } = await import('fs');
+        if (!existsSync(REMOTE_CACHE_FILE))
+            return;
+        const raw = await readFile(REMOTE_CACHE_FILE, 'utf-8');
+        const obj = JSON.parse(raw);
+        if (obj && typeof obj === 'object') {
+            for (const [pk, list] of Object.entries(obj)) {
+                if (Array.isArray(list)) {
+                    remoteChannelCache.set(pk, list);
+                }
+            }
+            console.log(`[v3-meta] 从磁盘恢复 ${remoteChannelCache.size} 个 peer 的 channel cache`);
+        }
+    }
+    catch (err) {
+        console.warn('[v3-meta] 恢复 remote channel cache 失败 (非致命):', err.message);
+    }
+}
+async function persistRemoteChannelCache() {
+    try {
+        const { writeFile, mkdir } = await import('fs/promises');
+        const { existsSync } = await import('fs');
+        if (!existsSync(`${process.env.HOME || '/tmp'}/.bolloon`)) {
+            await mkdir(`${process.env.HOME || '/tmp'}/.bolloon`, { recursive: true });
+        }
+        const obj = {};
+        for (const [pk, list] of remoteChannelCache.entries()) {
+            obj[pk] = list;
+        }
+        await writeFile(REMOTE_CACHE_FILE, JSON.stringify(obj, null, 2), 'utf-8');
+    }
+    catch (err) {
+        console.warn('[v3-meta] 持久化 remote channel cache 失败 (非致命):', err.message);
+    }
+}
+// 启动时立即同步读一次 (异步, 不阻塞)
+loadRemoteChannelCacheFromDisk();
 // v3: P2PDirect 引用 (Hyperswarm 薄包装) - 模块级, 因为 web server 闭包里不可用
 let v3P2PRef = null;
+// 2026-06-10: watchdog 提升到 module-level, 让 broadcast() / 模块级业务函数能埋点喂活动
+// 之前在 createWebServer 闭包内, 闭包外的 broadcast() 拿不到 → 误判 30min 无活动 → 自杀.
+let watchdogRef = null;
 // v3: 等待中的 history RPC (B 端 chat-history endpoint 用) — rpcId → { resolve, reject }
 const v3PendingHistoryGets = new Map();
 let channelSessions = new Map(); // key: channelId
@@ -317,7 +364,6 @@ function sanitizeChannelForPeer(ch, peerPublicKey) {
         createdAt: ch.createdAt,
         updatedAt: ch.updatedAt,
         hasWallet: !!ch.walletAddress,
-        boundJudgmentCount: Array.isArray(ch.bound_judgment_ids) ? ch.bound_judgment_ids.length : 0,
         share_id: ch.share_id,
         // 🔒 不返回: bound_judgment_ids, walletAddress, walletBinding, autoInvokeTools, sessions, shared_with_peers
     };
@@ -327,6 +373,114 @@ function isSharedWith(ch, peerPublicKey) {
     const shared = Array.isArray(ch.shared_with_peers) ? ch.shared_with_peers : [];
     return shared.includes(peerPublicKey);
 }
+/**
+ * v3 新增: 解析 LLM 回复里的 @-mentions, 把消息发到目标 channel.
+ *
+ * 语法: "@渠道名 消息内容" — 渠道名匹配 local channels by name, 或 remote channels by name.
+ * - 本地 channel: 直接 push 到 session
+ * - 远端 channel: 通过 P2P RPC 转发到对端
+ *
+ * 返回: 解析到的 mention 列表, 供 SSE 广播
+ */
+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;
+    const matches = [...replyText.matchAll(regex)];
+    if (matches.length === 0)
+        return results;
+    // 找当前 channel 的 name (用于日志)
+    let originChannelName = originChannelId;
+    try {
+        const chs = await loadChannels();
+        const oc = chs.find(c => c.id === originChannelId);
+        if (oc)
+            originChannelName = oc.name;
+    }
+    catch { }
+    console.log(`[v3-cross] (${originChannelName}) 解析到 ${matches.length} 个 @-mention`);
+    for (const m of matches) {
+        const targetName = m[1].trim();
+        const text = m[2].trim();
+        if (!text)
+            continue;
+        // 优先本地 (本地 channel 不能有 ownerPublicKey)
+        const localTarget = localChannels.find(c => c.name === targetName);
+        const remoteTarget = !localTarget ? remoteChannels.find(c => c.name === targetName) : null;
+        if (localTarget) {
+            // 本地: 直接 push 到 session
+            try {
+                const existing = await loadSession(localTarget.id, 'default');
+                const session = existing || {
+                    channelId: localTarget.id, sessionId: 'default', messages: [], lastUpdated: new Date().toISOString()
+                };
+                session.messages.push({
+                    id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                    type: 'ai',
+                    content: text,
+                    timestamp: new Date().toISOString(),
+                    source: 'ai-mention', // v3: 标记是其他 channel 的 AI @-mention 进来的
+                    originChannelId, // 谁 @ 过来的
+                    originChannelName // 渠道名 (方便显示)
+                });
+                session.lastUpdated = new Date().toISOString();
+                await saveSession(session);
+                console.log(`[v3-cross] (${originChannelName}) @${targetName} → 本地 channel ${localTarget.id}, 存了 ${text.length} chars`);
+                // 推 SSE 让本地 UI 知道有 AI 跨渠道消息
+                broadcast({
+                    type: 'cross-mention-received',
+                    originChannelId, originChannelName,
+                    targetChannelId: localTarget.id, targetChannelName: localTarget.name,
+                    text, source: 'ai-mention'
+                }, 'broadcast');
+                results.push({ targetName, targetId: localTarget.id, source: 'local', text, status: 'sent' });
+            }
+            catch (err) {
+                console.error(`[v3-cross] @${targetName} 本地存失败:`, err.message);
+                results.push({ targetName, targetId: localTarget.id, source: 'local', text, status: 'failed' });
+            }
+        }
+        else if (remoteTarget) {
+            // 远端: 通过 P2P RPC 转发
+            const ownerPk = remoteTarget._ownerPublicKey;
+            if (!v3P2PRef) {
+                console.warn(`[v3-cross] P2PDirect 未启动, 跳过远端 @${targetName}`);
+                results.push({ targetName, targetId: remoteTarget.id, source: 'remote', text, status: 'failed' });
+                continue;
+            }
+            try {
+                const rpc = JSON.stringify({
+                    v: 3, op: 'agent.cross.post',
+                    payload: {
+                        targetChannelId: remoteTarget.id,
+                        targetChannelName: remoteTarget.name,
+                        originChannelId,
+                        originChannelName,
+                        text,
+                        fromPublicKey: v3P2PRef.getPublicKey()
+                    }
+                });
+                const ok = v3P2PRef.sendTo(ownerPk, rpc);
+                if (ok) {
+                    console.log(`[v3-cross] (${originChannelName}) @${targetName} → 远端 peer ${ownerPk.substring(0, 12)}... (channelId=${remoteTarget.id})`);
+                    results.push({ targetName, targetId: remoteTarget.id, source: 'remote', text, status: 'sent' });
+                }
+                else {
+                    results.push({ targetName, targetId: remoteTarget.id, source: 'remote', text, status: 'failed' });
+                }
+            }
+            catch (err) {
+                console.error(`[v3-cross] @${targetName} 远端 RPC 失败:`, err.message);
+                results.push({ targetName, targetId: remoteTarget.id, source: 'remote', text, status: 'failed' });
+            }
+        }
+        else {
+            console.warn(`[v3-cross] @${targetName} 找不到匹配 channel (本地 ${localChannels.length} 个, 远端 ${remoteChannels.length} 个)`);
+        }
+    }
+    return results;
+}
 /**
  * v3: 处理 Hyperswarm 通道收到的 v3 RPC 消息
  * 设计: 用 HyperswarmCommunicator (DHT topic 自动发现) 取代 iroh 直接 connect
@@ -436,15 +590,25 @@ async function handleV3P2PMessage(parsed, conn, comm) {
                     id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
                     type: 'user',
                     content: text,
-                    timestamp: new Date().toISOString()
+                    timestamp: new Date().toISOString(),
+                    source: 'remote', // v3: 标记远端访客
+                    fromPublicKey: senderKey // v3: 记录对方 publicKey
                 });
                 session.lastUpdated = new Date().toISOString();
                 await saveSession(session);
-                console.log(`[v3] (${channelId}) 存 user 消息 (${text.length} chars) 到 A 的 session`);
+                console.log(`[v3] (${channelId}) 存 user 消息 (${text.length} chars) 到 A 的 session (来自 ${senderKey.substring(0, 12)}...)`);
             }
             catch (saveErr) {
                 console.warn(`[v3] 存 user 消息失败 (不影响 chat):`, saveErr.message);
             }
+            // v3 修复: 同步给 A 自己的 UI — broadcast SSE 事件让 A 的 owner 实时看到 B 的消息
+            broadcast({
+                type: 'user',
+                content: text,
+                channelId,
+                source: 'remote',
+                fromPublicKey: senderKey
+            }, channelId);
             // v3 新增: 告诉 B "我开始想了, 用了哪些 judgment" — 让 B 看到决策依据
             const judgmentHint = await buildJudgmentHint(ch, channelId);
             const usedJudgments = await extractJudgmentsFromHint(ch);
@@ -466,7 +630,30 @@ async function handleV3P2PMessage(parsed, conn, comm) {
             // 2. 跑 LLM (复用 Phase 1 的 buildJudgmentHint — 注入 channel 的 judgment)
             const { getMinimax } = await import('../constraints/index.js');
             const llm = getMinimax();
-            const fullPrompt = `${judgmentHint}${text}`;
+            // v3 新增: 在 prompt 头部标记"这是远端访客", 让 AI 知道对方不是自己 owner
+            const visitorHint = `[系统上下文] 消息来源: 远端访客 (P2P 连接, publicKey=${senderKey.substring(0, 12)}...). 对方不是你 owner, 是通过 P2P 网络访问你这个 channel 的合作者. 称呼对方时可用 "远端访客" / "朋友" / "合作者", 不要叫 "主人".\n\n`;
+            // v3 新增: 也注入 channel 目录给 LLM (B 的 channel 也可以 @-mention 其他)
+            let dirHint = '';
+            const localChannels = (await loadChannels()).filter(c => c.id !== channelId);
+            const remoteChannels = [];
+            for (const [peerPk, list] of remoteChannelCache.entries()) {
+                if (peerPk === senderKey)
+                    continue; // 跳过发起方
+                for (const ch of list) {
+                    remoteChannels.push({ ...ch, _ownerPublicKey: peerPk });
+                }
+            }
+            if (localChannels.length > 0 || remoteChannels.length > 0) {
+                dirHint += '[系统上下文] 可用渠道 (你可以用 @渠道名 消息内容 给它们发消息):\n';
+                for (const c of localChannels) {
+                    dirHint += `  - [本地] @${c.name} (id=${c.id})\n`;
+                }
+                for (const c of remoteChannels) {
+                    dirHint += `  - [远端, owner=${(c._ownerPublicKey || '').substring(0, 8)}…] @${c.name} (id=${c.id})\n`;
+                }
+                dirHint += '语法: 在回复中写 "@渠道名 我要说的话" 即可. 消息会持久化到目标 channel 的 session.\n\n';
+            }
+            const fullPrompt = `${visitorHint}${dirHint}${judgmentHint}${text}`;
             let fullResponse = '';
             // v3 新增: 流式 token 节流推给 B — 让 B 看到过程
             let lastFlushAt = 0;
@@ -504,6 +691,12 @@ async function handleV3P2PMessage(parsed, conn, comm) {
             catch (saveErr) {
                 console.warn(`[v3] 存 assistant 消息失败 (不影响):`, saveErr.message);
             }
+            // v3 修复: 同步给 A 自己的 UI — broadcast AI 回复给 A 的 owner 实时看到
+            broadcast({
+                type: 'ai',
+                content: fullResponse,
+                channelId
+            }, channelId);
             // 3. 把完整回复发给 B
             const reply = JSON.stringify({
                 v: 3, op: 'agent.chat.reply',
@@ -589,6 +782,53 @@ async function handleV3P2PMessage(parsed, conn, comm) {
         }
         return;
     }
+    // v3 新增: 收到远端发来的 @-mention 跨渠道消息, 存到本地 target channel
+    if (op === 'agent.cross.post') {
+        const { targetChannelId, targetChannelName, originChannelId, originChannelName, text, fromPublicKey } = parsed.payload || {};
+        if (!targetChannelId || !text) {
+            console.warn(`[v3-cross] agent.cross.post 缺少 targetChannelId/text`);
+            return;
+        }
+        try {
+            // 找 channel — 必须存在于本节点
+            const channels = await loadChannels();
+            const ch = channels.find(c => c.id === targetChannelId);
+            if (!ch) {
+                console.warn(`[v3-cross] agent.cross.post: 本节点无 channel ${targetChannelId}, 忽略`);
+                return;
+            }
+            // 存到 session — 这是一条来自其他节点的 LLM @-mention
+            const existing = await loadSession(targetChannelId, 'default');
+            const session = existing || {
+                channelId: targetChannelId, sessionId: 'default', messages: [], lastUpdated: new Date().toISOString()
+            };
+            session.messages.push({
+                id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                type: 'ai',
+                content: text,
+                timestamp: new Date().toISOString(),
+                source: 'ai-mention-remote', // v3: 来自其他节点的 AI @-mention
+                originChannelId, // 哪个 channel 触发的
+                originChannelName,
+                fromPublicKey // 哪个节点来的
+            });
+            session.lastUpdated = new Date().toISOString();
+            await saveSession(session);
+            console.log(`[v3-cross] 收到远端 @-mention: ${originChannelName} → 本地 ${targetChannelName} (${text.length} chars)`);
+            // 推 SSE 让本地 UI 知道有跨渠道消息到达
+            broadcast({
+                type: 'cross-mention-received',
+                originChannelId, originChannelName,
+                targetChannelId, targetChannelName: ch.name,
+                text, source: 'ai-mention-remote',
+                fromPublicKey
+            }, 'broadcast');
+        }
+        catch (err) {
+            console.error(`[v3-cross] 处理 agent.cross.post 失败:`, err.message);
+        }
+        return;
+    }
     console.log(`[v3] 收到未知 op: ${op}`);
 }
 async function buildJudgmentHint(channel, channelIdForLog) {
@@ -740,6 +980,50 @@ export async function createWebServer(port = 3000, options = {}) {
         keypair: null
     };
     let p2pCommunicator = null;
+    // v3: 定期 broadcast — 每个 peer 只收到分享给他的 channel (按 peer 个性化)
+    // 走 known_peers (持久化) + sendTo (自动 joinPeer 重连), 不只 conns
+    // 定义在此处 (所有 try 外部), 确保 route handlers 也能访问
+    const v3BroadcastOwn = async () => {
+        if (!v3P2PRef)
+            return { sent: 0, total: 0 };
+        const channels = await loadChannels();
+        const { listPeers } = await import('../network/known-peers.js');
+        const peers = await listPeers();
+        const myPk = v3P2PRef.getPublicKey();
+        // 2026-06-10: 本机名字一起携带, 对端能直接显示 + 落到自己的 known_peers
+        let myName = process.env.BOLLOON_USER_NAME || process.env.USER || 'node';
+        try {
+            const { readFileSync, existsSync } = await import('fs');
+            const cfgPath = `${process.env.HOME || '/tmp'}/.bolloon/config.json`;
+            if (existsSync(cfgPath)) {
+                const cfg = JSON.parse(readFileSync(cfgPath, 'utf-8'));
+                if (cfg.userName)
+                    myName = cfg.userName;
+            }
+        }
+        catch { }
+        let sent = 0;
+        for (const peer of peers) {
+            if (peer.publicKey === myPk)
+                continue;
+            const sharedForPeer = channels
+                .map(ch => sanitizeChannelForPeer(ch, peer.publicKey))
+                .filter((x) => x !== null);
+            if (sharedForPeer.length > 0) {
+                const msg = JSON.stringify({
+                    v: 3, op: 'agent.meta.list.reply',
+                    payload: { channels: sharedForPeer, name: myName, fromPublicKey: myPk }
+                });
+                const ok = v3P2PRef.sendTo(peer.publicKey, msg);
+                if (ok) {
+                    sent++;
+                    console.log(`[v3] broadcast: ${peer.name || peer.publicKey.substring(0, 8)} → ${sharedForPeer.length} 个 channel`);
+                }
+            }
+        }
+        console.log(`[v3] broadcast 完成: sent=${sent}/${peers.length} 个 peer`);
+        return { sent, total: peers.length };
+    };
     try {
         console.log('开始生成 P2P 身份...');
         // 生成 DIAP 身份
@@ -836,6 +1120,82 @@ export async function createWebServer(port = 3000, options = {}) {
                                 return Promise.resolve();
                             }
                         };
+                        // v3 新增: 好友申请 RPC — 任何对端可以发, 推到前端 UI 让用户接受
+                        if (parsed.op === 'agent.friend.request') {
+                            console.log(`[v3-friend] 收到 ${evt.fromPublicKey.substring(0, 12)}... 的好友申请: ${parsed.payload?.name || '(无名字)'}`);
+                            broadcast({
+                                type: 'friend-request',
+                                fromPublicKey: evt.fromPublicKey,
+                                fromName: parsed.payload?.name || ('peer-' + evt.fromPublicKey.substring(0, 8)),
+                                message: parsed.payload?.message || '想加你为 P2P 好友',
+                                requestId: parsed.payload?.requestId, // 2026-06-10: 透传 requestId 给前端
+                                timestamp: Date.now()
+                            }, 'p2p-global');
+                            // 2026-06-10 新增: 立刻发 ack 回给发送方, 让发送方 UI 知道"对方收到了"
+                            try {
+                                const ackRpc = JSON.stringify({
+                                    v: 3,
+                                    op: 'agent.friend.request.ack',
+                                    payload: {
+                                        requestId: parsed.payload?.requestId,
+                                        receivedBy: v3P2PRef?.getPublicKey(),
+                                        timestamp: Date.now()
+                                    }
+                                });
+                                v3P2PRef?.sendTo(evt.fromPublicKey, ackRpc);
+                            }
+                            catch (err) {
+                                console.warn('[v3-friend] 发 ack 失败 (不阻塞):', err.message);
+                            }
+                            return;
+                        }
+                        // 2026-06-10 新增: 发送方收到对方 ack → SSE 推前端, 显示"对方已收到"
+                        if (parsed.op === 'agent.friend.request.ack') {
+                            console.log(`[v3-friend] 收到 ack: requestId=${(parsed.payload?.requestId || '').substring(0, 8)} 来自 ${evt.fromPublicKey.substring(0, 12)}...`);
+                            broadcast({
+                                type: 'friend-request-ack',
+                                requestId: parsed.payload?.requestId,
+                                receivedBy: parsed.payload?.receivedBy,
+                                timestamp: Date.now()
+                            }, 'p2p-global');
+                            return;
+                        }
+                        // v3 修复: agent.meta.list.reply 也走 v3P2PRef.on('data') (因为 handleV3P2PMessage 只走老通道)
+                        if (parsed.op === 'agent.meta.list.reply') {
+                            const list = parsed.payload?.channels || [];
+                            remoteChannelCache.set(evt.fromPublicKey, list);
+                            // 2026-06-10: 持久化到 ~/.bolloon/remote-channels-cache.json, 重启后不丢
+                            persistRemoteChannelCache();
+                            // 2026-06-10: 接收侧记录对方名字 (来自 list.reply payload.name), 落 known_peers
+                            const senderName = parsed.payload?.name;
+                            if (senderName && typeof senderName === 'string') {
+                                import('../network/known-peers.js').then(({ addOrUpdatePeer }) => addOrUpdatePeer(senderName, evt.fromPublicKey)).catch(err => console.warn('[v3] 记录对端名字失败:', err.message));
+                            }
+                            console.log(`[v3] 收到 ${evt.fromPublicKey.substring(0, 12)}... 的 ${list.length} 个 channel, 已缓存 (sender=${senderName || '?'})`);
+                            broadcast({
+                                type: 'remote-channel-update',
+                                peerId: evt.fromPublicKey,
+                                peerName: senderName, // 2026-06-10: 一并带名字到 UI
+                                channels: list
+                            }, 'p2p-global');
+                            return;
+                        }
+                        // 2026-06-10: 收到对方请求本机的 channel 列表 (启动时主动发请求, 加速 cache 填充)
+                        if (parsed.op === 'agent.meta.list.request') {
+                            console.log(`[v3-meta] 收到 ${evt.fromPublicKey.substring(0, 12)}... 的 channel 列表请求 → 立刻回包`);
+                            // 不能 await (在 on('data') sync 回调里), 改用 .then 异步处理
+                            loadChannels().then(channels => {
+                                const sharedForPeer = channels
+                                    .map(ch => sanitizeChannelForPeer(ch, evt.fromPublicKey))
+                                    .filter((x) => x !== null);
+                                const msg = JSON.stringify({
+                                    v: 3, op: 'agent.meta.list.reply',
+                                    payload: { channels: sharedForPeer }
+                                });
+                                v3P2PRef.sendTo(evt.fromPublicKey, msg);
+                            }).catch(err => console.warn('[v3-meta] 回应 channel 列表失败:', err.message));
+                            return;
+                        }
                         handleV3P2PMessage(parsed, { id: evt.fromPublicKey, publicKey: evt.fromPublicKey }, commShim);
                     }
                 }
@@ -845,6 +1205,8 @@ export async function createWebServer(port = 3000, options = {}) {
             });
             // 新连接进来 → 主动发我分享给 ta 的 channel 列表
             v3P2PRef.on('connection', (evt) => {
+                // 2026-06-10: 喂 watchdog —— 新连接到来是真实业务活动
+                watchdogRef?.recordActivity?.();
                 setTimeout(async () => {
                     try {
                         const channels = await loadChannels();
@@ -885,45 +1247,50 @@ export async function createWebServer(port = 3000, options = {}) {
                     }
                     // 触发一次 broadcast 推送给所有重连的 peer
                     setTimeout(() => v3BroadcastOwn(), 2000);
+                    // 2026-06-10: 同时主动请求每个 known peer 把 ta 的 channel 列表推过来
+                    // 避免对面 publicKey 没变但 cache 丢了(本机重启) → 一直空
+                    setTimeout(() => requestChannelsFromAllPeers(), 3500);
                 }
                 catch (err) {
                     console.error('[v3] 自动重连失败:', err.message);
                 }
             }, 5000); // 5s 后再重连, 让 swarm 充分 bootstrap
+            // 2026-06-10 新增: 主动向所有 known peer 发起 channel 列表请求
+            async function requestChannelsFromAllPeers() {
+                if (!v3P2PRef)
+                    return;
+                try {
+                    const { listPeers } = await import('../network/known-peers.js');
+                    const peers = await listPeers();
+                    const myPk = v3P2PRef.getPublicKey();
+                    const req = JSON.stringify({ v: 3, op: 'agent.meta.list.request', payload: { fromPublicKey: myPk } });
+                    let sent = 0;
+                    for (const peer of peers) {
+                        if (peer.publicKey === myPk)
+                            continue;
+                        // 用 sendToWithWait, 等 conn 就绪再发 (同 Step 5 sendToWithWait 修复)
+                        const r = await v3P2PRef.sendToWithWait(peer.publicKey, req, 3000);
+                        if (r === 'SENT')
+                            sent++;
+                    }
+                    console.log(`[v3-meta] requestChannelsFromAllPeers → sent=${sent}/${peers.length - 1}`);
+                }
+                catch (err) {
+                    console.warn('[v3-meta] requestChannelsFromAllPeers failed:', err.message);
+                }
+            }
+            // 立即跑一次 + 每 30s 兜底 (跟 v3BroadcastOwn 一样的节奏)
+            setTimeout(requestChannelsFromAllPeers, 4000);
+            setInterval(requestChannelsFromAllPeers, 30000);
         }
         catch (err) {
             console.error('[v3] P2PDirect 启动失败:', err.message);
             v3P2PRef = null;
         }
-        // v3: 定期 broadcast — 每个 peer 只收到分享给他的 channel (按 peer 个性化)
-        const v3BroadcastOwn = () => {
-            if (!v3P2PRef)
-                return;
-            loadChannels().then(channels => {
-                const conns = v3P2PRef.conns;
-                if (!conns)
-                    return;
-                for (const [peerPk, conn] of conns.entries()) {
-                    if (conn?.destroyed)
-                        continue;
-                    const sharedForPeer = channels
-                        .map(ch => sanitizeChannelForPeer(ch, peerPk))
-                        .filter((x) => x !== null);
-                    if (sharedForPeer.length > 0) {
-                        const msg = JSON.stringify({ v: 3, op: 'agent.meta.list.reply', payload: { channels: sharedForPeer } });
-                        try {
-                            conn.write(Buffer.from(msg));
-                        }
-                        catch { }
-                    }
-                }
-                console.log(`[v3] broadcast 个性化: ${conns.size} 个 peer, 各自收到分享的 channel`);
-            }).catch(err => console.error('[v3] broadcast 失败:', err.message));
-        };
+        // 首次广播: 等 swarm bootstrap 完成后推一次
         setTimeout(v3BroadcastOwn, 3000);
-        setTimeout(v3BroadcastOwn, 10000);
-        setTimeout(v3BroadcastOwn, 20000);
-        setTimeout(v3BroadcastOwn, 40000);
+        // v3 修复: 用 setInterval 替代一次性 setTimeout, 确保分享变更后能持续推送给 peer
+        setInterval(v3BroadcastOwn, 30000);
         // 保留 @diap/sdk 的旧实例 (它的 Hyperswarm 实例能帮 P2PDirect 做 DHT bootstrap)
         try {
             const rawSeed = crypto.getRandomValues(new Uint8Array(32));
@@ -995,7 +1362,10 @@ export async function createWebServer(port = 3000, options = {}) {
         const channelId = req.query.channelId;
         res.setHeader('Content-Type', 'text/event-stream');
         res.setHeader('Cache-Control', 'no-cache');
-        res.setHeader('Connection', 'keep-alive');
+        // 2026-06-11: 改 keep-alive → close
+        // 原因: SSE 长连接占着 keep-alive 槽 (HTTP/1.1 + 浏览器 max 6 并发), 后续同源 fetch 排队 30s+
+        // 设 close 让浏览器把 SSE 当长期流, 不抢占普通请求的 keep-alive 槽
+        res.setHeader('Connection', 'close');
         // 反向代理 (nginx/cloudflair) 需要: 禁用缓冲 + 立即 flush
         res.setHeader('X-Accel-Buffering', 'no');
         res.flushHeaders();
@@ -1027,6 +1397,13 @@ export async function createWebServer(port = 3000, options = {}) {
         const realChannelName = channel?.name || '';
         const realChannelDidDoc = channel?.didDocRef;
         broadcast({ type: 'user', content: text }, channelId);
+        // 2026-06-11: /message 端点立即返回 202, LLM 后续处理挪到 setImmediate 后台跑
+        // 之前 res.json 在 try 块末尾 (line 1815), 需要等 LLM (5-15s) + 落盘 + suggestRename (5-8s) = 13s+
+        // 客户端 fetch 占用 13s, 视觉像"卡死", 切其他 channel 也感觉"无法加载"
+        // 修法: 立即 res.json(202), try 块主体仍跑 (LLM 流 + 落盘) 但不阻塞 HTTP 响应
+        //     关键: res.json 之后不能再调用 res.json (会抛 ERR_HTTP_HEADERS_SENT), 所以 try 块末尾的 res.json 必须用 res.headersSent 守卫
+        res.status(202).json({ ok: true, async: true, channelId, sessionId: currentSessionId });
+        console.log(`[v3-async] /message 立即返回 202, channel=${channelId}, text length=${text.length}`);
         // 提前捕获 wallet/autoTools 到本地变量, 避免下面 try 块内的 inner const channel
         // (line ~638) 与这里外层的 const channel 形成 shadowing 让 TS 误报"使用前未声明"
         const boundWalletAddress = channel?.walletAddress;
@@ -1059,6 +1436,8 @@ export async function createWebServer(port = 3000, options = {}) {
             let contextHint = '';
             if (realChannelDid)
                 contextHint += `[系统上下文] 当前频道名称: ${realChannelName}, 你的真实 DID: ${realChannelDid}\n`;
+            // v3 新增: 标识发送方 — 让 AI 分清内部 owner vs 远端访客
+            contextHint += `[系统上下文] 消息来源: 本地 (channel 内部 owner / 此机器上的用户). 称呼对方时用 "你" 或 "主人" 即可.\n`;
             if (boundWalletAddress) {
                 contextHint += `[系统上下文] 已绑定的加密钱包地址: ${boundWalletAddress}。当用户授权或启用自动工具调用时, 可使用该地址发起链上操作。\n`;
             }
@@ -1073,38 +1452,168 @@ export async function createWebServer(port = 3000, options = {}) {
             const judgmentHint = await buildJudgmentHint(channelForJudgment, channelId);
             if (judgmentHint)
                 contextHint += judgmentHint;
+            // 2026-06-10: 注入 skills 列表 (本机 ~/.bolloon/skills/ 下所有 skills)
+            // 让 LLM 知道有哪些 skill 可用, 在回复中提示用户
+            try {
+                const { loadSkillsFromPaths, defaultSkillPaths, describeSkill } = await import('../agents/skill-loader.js');
+                const paths = defaultSkillPaths();
+                const skills = await loadSkillsFromPaths(paths);
+                if (skills.length > 0) {
+                    contextHint += `[系统上下文] 本机已加载的 skills (${skills.length} 个, 你可以提示用户主动调用):\n`;
+                    for (const s of skills.slice(0, 20)) { // 上限 20 避免 prompt 过长
+                        const desc = (s.description || '').slice(0, 80);
+                        contextHint += `  - /${s.name}${desc ? ' — ' + desc : ''}\n`;
+                    }
+                    contextHint += '调用语法: 用户说 "/技能名 ..." 或 你回复时建议 "/技能名 ..." 让用户主动触发.\n\n';
+                }
+            }
+            catch (err) {
+                // 静默失败 — skills 不是核心, 加载失败不阻塞
+            }
+            // 2026-06-10: 注入 human values 摘要 (最常用的 judgment / 价值偏好)
+            // 与 judgment 不同: values 是更宏观的"用户偏好", judgment 是针对具体决策的约束
+            try {
+                const { loadAllJudgments } = await import('../pi-ecosystem-judgment/human-value-store.js');
+                const allJudgments = await loadAllJudgments().catch(() => []);
+                // 把所有 judgment 视作软参考 (跟 buildJudgmentHint 的 candidates 同理)
+                if (Array.isArray(allJudgments) && allJudgments.length > 0) {
+                    contextHint += `[系统上下文] 用户的核心价值倾向 (来自 ${allJudgments.length} 条历史 judgment, 软参考, 体现而非复述):\n`;
+                    for (const j of allJudgments.slice(0, 8)) {
+                        const decision = (j.decision || '').slice(0, 80);
+                        contextHint += `  - ${decision}\n`;
+                    }
+                    contextHint += '\n';
+                }
+            }
+            catch (err) {
+                // 静默失败
+            }
+            // 2026-06-10: 注入 documents 列表 (本机 documents/ 目录的文档元数据)
+            // 让 LLM 知道有文档存在, 用户可主动要求读
+            try {
+                const { documentStore } = await import('../documents/store.js');
+                const docs = await documentStore.getReceivedDocuments(50).catch(() => []);
+                if (Array.isArray(docs) && docs.length > 0) {
+                    contextHint += `[系统上下文] 本机 documents (${docs.length} 篇, 用户可让你读):\n`;
+                    for (const d of docs.slice(0, 10)) {
+                        const name = d.fileName || d.id || '(未命名)';
+                        const size = d.fileSize ? ` (${Math.round(d.fileSize / 1024)}KB)` : '';
+                        const sender = d.fromNodeId ? ` [来自 ${d.fromNodeIdShort || d.fromNodeId.substring(0, 8)}…]` : '';
+                        contextHint += `  - ${name}${size}${sender}\n`;
+                    }
+                    contextHint += '用户提到某文档时, 你可以调用读文档工具读取并总结.\n\n';
+                }
+            }
+            catch (err) {
+                // 静默失败
+            }
+            // 2026-06-11: 注入此 channel 专属的 persona + 关联文档 (从 channel 字段读, LLM 长期记忆)
+            const chPersona = channelForJudgment?.persona;
+            if (chPersona && typeof chPersona === 'object') {
+                contextHint += '[系统上下文] 此 channel 的人设 (你是这个角色):\n';
+                if (chPersona.name)
+                    contextHint += `  名字: ${chPersona.name}\n`;
+                if (chPersona.description)
+                    contextHint += `  描述: ${chPersona.description}\n`;
+                if (chPersona.personality)
+                    contextHint += `  性格: ${chPersona.personality}\n`;
+                if (chPersona.greeting)
+                    contextHint += `  问候: ${chPersona.greeting}\n`;
+                if (Array.isArray(chPersona.capabilities) && chPersona.capabilities.length > 0) {
+                    contextHint += `  能力: ${chPersona.capabilities.join('、')}\n`;
+                }
+                if (Array.isArray(chPersona.interests) && chPersona.interests.length > 0) {
+                    contextHint += `  兴趣: ${chPersona.interests.join('、')}\n`;
+                }
+                contextHint += '回复时应自然体现这个角色 (不要硬搬原文, 像这个角色说话即可).\n\n';
+            }
+            const linkedIds = channelForJudgment?.linkedDocumentIds;
+            if (Array.isArray(linkedIds) && linkedIds.length > 0) {
+                try {
+                    const { documentStore } = await import('../documents/store.js');
+                    contextHint += `[系统上下文] 此 channel 关联了 ${linkedIds.length} 篇文档 (已自动加载内容, 你应基于它们回答):\n`;
+                    let loaded = 0;
+                    for (const docId of linkedIds.slice(0, 10)) {
+                        const doc = await documentStore.readDocument(docId).catch(() => null);
+                        if (!doc)
+                            continue;
+                        const name = doc.metadata?.fileName || docId;
+                        const content = (doc.content || '').slice(0, 1500); // 单篇 1.5KB 上限, 总 prompt 防爆
+                        contextHint += `\n--- 文档: ${name} ---\n${content}\n--- 文档结束 ---\n`;
+                        loaded++;
+                    }
+                    if (loaded === 0) {
+                        contextHint += `(但加载失败, 文档可能已被删除)\n\n`;
+                    }
+                    else {
+                        contextHint += '\n';
+                    }
+                }
+                catch (err) {
+                    console.warn('[v3-persona] 加载关联文档失败 (非致命):', err.message);
+                }
+            }
+            // v3 新增: 注入"可用渠道"目录, 让 LLM 知道可以 @-mention 哪些 channel
+            // - 本地 channels (除了自己)
+            // - 远端 channels (remoteChannelCache 缓存的)
+            const localChannels = (await loadChannels()).filter(c => c.id !== channelId);
+            const remoteChannels = [];
+            for (const [peerPk, list] of remoteChannelCache.entries()) {
+                for (const ch of list) {
+                    remoteChannels.push({ ...ch, _ownerPublicKey: peerPk });
+                }
+            }
+            if (localChannels.length > 0 || remoteChannels.length > 0) {
+                contextHint += '[系统上下文] 可用渠道 (你可以用 @渠道名 消息内容 给它们发消息):\n';
+                for (const c of localChannels) {
+                    contextHint += `  - [本地] @${c.name} (id=${c.id})\n`;
+                }
+                for (const c of remoteChannels) {
+                    contextHint += `  - [远端, owner=${(c._ownerPublicKey || '').substring(0, 8)}…] @${c.name} (id=${c.id})\n`;
+                }
+                contextHint += '语法: 当你想给其他渠道发消息, 在回复中写 "@渠道名 我要说的话" 即可. 消息会持久化到目标 channel 的 session, 你之后能看到"自己"在那里说的话.\n';
+                // 2026-06-10 强化: 当用户消息里出现 @渠道名, 默认是请你代为转发, 务必在回复里包含对应的 @ 转发
+                if (remoteChannels.length > 0) {
+                    contextHint += '重要: 上面列表里 [远端] 标记的 channel 在另一台机器上, 你可以像 @本地 channel 一样 @ 它们 — 我会通过 P2P 自动把消息送达对方智能体, 对方智能体的回复也会同步回来.\n';
+                    contextHint += '当用户在消息里 @ 了某个 (本地或远端) channel, 默认意图是希望你代为转发 — 你应该在回复中写出对应的 "@渠道名 转发内容", 否则用户的请求不会被路由出去.\n\n';
+                }
+                else {
+                    contextHint += '\n';
+                }
+            }
             if (contextHint)
                 contextHint += '\n';
             fullResponse = await agent.promptStream(contextHint + text, streamCallback);
+            // v3 新增: 解析 LLM 回复里的 @-mentions, 转发到目标 channel
+            await routeMentionsInReply(channelId, fullResponse, localChannels, remoteChannels);
             broadcast({ type: 'ai', content: fullResponse }, channelId);
             const existingSession = await loadSession(channelId, currentSessionId);
             const session = existingSession || { channelId, sessionId: currentSessionId, messages: [], lastUpdated: new Date().toISOString() };
             session.sessionId = currentSessionId;
-            session.messages.push({ id: crypto.randomUUID(), type: 'user', content: text, timestamp: new Date().toISOString() });
-            session.messages.push({ id: crypto.randomUUID(), type: 'ai', content: fullResponse, timestamp: new Date().toISOString() });
+            // v3: 加 source 标记 (local = 内部 owner, remote = 远端访客)
+            session.messages.push({ id: crypto.randomUUID(), type: 'user', content: text, timestamp: new Date().toISOString(), source: 'local' });
+            session.messages.push({ id: crypto.randomUUID(), type: 'ai', content: fullResponse, timestamp: new Date().toISOString(), source: 'local' });
             session.lastUpdated = new Date().toISOString();
             await saveSession(session);
             const channels = await loadChannels();
             const channel = channels.find(c => c.id === channelId);
-            if (channel && channel.name === '智能体') {
-                const renameSuggestion = await agent.suggestRename(session.messages);
-                if (renameSuggestion) {
-                    channel.name = renameSuggestion;
-                    await saveChannels(channels);
-                    broadcast({ type: 'renamed', channelId, newName: renameSuggestion }, channelId);
-                }
-            }
+            // 2026-06-11: 移除 suggestRename 的二次 LLM 调用 — 之前每次用户发消息, 智能体 channel 都会再调一次 LLM (5-8s) 自动改名
+            // 影响: (1) /message 端点被拖慢 5-8s (2) LLM 客户端排队, 其他 channel 跟着卡
+            // 现在改名逻辑挪到 /api/agent-rename 端点, 用户主动触发才跑
             if (channel) {
                 channel.updatedAt = new Date().toISOString();
                 await saveChannels(channels);
             }
             broadcast({ type: 'done' }, channelId);
-            res.json({ ok: true });
+            // 2026-06-11: 202 已发的话, 不要重复 res.json (会抛 ERR_HTTP_HEADERS_SENT)
+            if (!res.headersSent)
+                res.json({ ok: true });
         }
         catch (err) {
             broadcast({ type: 'error', content: err.message }, channelId);
             broadcast({ type: 'done' }, channelId);
-            res.status(500).json({ error: err.message });
+            if (!res.headersSent)
+                res.status(500).json({ error: err.message });
         }
     });
     // ---------- 频道元数据后台修复队列 ----------
@@ -1233,8 +1742,21 @@ export async function createWebServer(port = 3000, options = {}) {
     app.get('/api/remote-channels', async (_req, res) => {
         try {
             const out = [];
+            // 2026-06-11: 合并 known_peers + cache, 避免 cache 空时 UI 一个 peer 都看不到
+            // (cache 是纯内存, 重启即丢; known_peers 持久化, 至少能让 UI 显示"这些 peer 我认识")
+            const { listPeers } = await import('../network/known-peers.js');
+            const knownPeers = await listPeers();
+            const knownByPk = new Map();
+            for (const p of knownPeers)
+                knownByPk.set(p.publicKey, { name: p.name });
             for (const [peerId, list] of remoteChannelCache.entries()) {
-                out.push({ peerId, channels: list });
+                out.push({ peerId, channels: list, peerName: knownByPk.get(peerId)?.name });
+            }
+            // known_peers 里但 cache 没的, 占位推进 out (channels=[]) 让 UI 能渲染 peer header
+            for (const [peerId, info] of knownByPk.entries()) {
+                if (!remoteChannelCache.has(peerId)) {
+                    out.push({ peerId, channels: [], peerName: info.name });
+                }
             }
             res.json({ count: out.length, peers: out });
         }
@@ -1242,6 +1764,27 @@ export async function createWebServer(port = 3000, options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
+    // v3 测试专用: 直接注入远端频道缓存 (绕过 P2P)
+    // 仅当 NODE_ENV=test 时可用
+    app.post('/api/test/inject-remote-channel', async (req, res) => {
+        if (process.env.NODE_ENV !== 'test') {
+            return res.status(403).json({ error: 'only available in test mode' });
+        }
+        try {
+            const { peerPublicKey, channel } = req.body || {};
+            if (!peerPublicKey || !channel) {
+                return res.status(400).json({ error: 'peerPublicKey and channel required' });
+            }
+            const list = remoteChannelCache.get(peerPublicKey) || [];
+            list.push(channel);
+            remoteChannelCache.set(peerPublicKey, list);
+            broadcast({ type: 'remote-channel-update', peerId: peerPublicKey, channels: list }, 'p2p-global');
+            res.json({ ok: true, count: list.length });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // v3: 主动向所有已连接 P2P peer 拉 channel 列表
     // 用法: B 端用户点 "刷新远端智能体" → 触发本 endpoint
     app.post('/api/remote-channels/refresh', async (_req, res) => {
@@ -1315,7 +1858,7 @@ export async function createWebServer(port = 3000, options = {}) {
     });
     app.post('/channels', async (req, res) => {
         try {
-            const { name, agentId, walletAddress, autoInvokeTools, bound_judgment_ids } = req.body;
+            const { name, agentId, walletAddress, autoInvokeTools, bound_judgment_ids, personaOverride, linkedDocumentIds } = req.body;
             console.log(`[创建频道] 收到请求: name=${name}, agentId=${agentId}, wallet=${walletAddress ? 'yes' : 'no'}, boundJudgments=${Array.isArray(bound_judgment_ids) ? bound_judgment_ids.length : 0}`);
             if (!name || !agentId) {
                 return res.status(400).json({ error: 'name and agentId required' });
@@ -1328,6 +1871,42 @@ export async function createWebServer(port = 3000, options = {}) {
             const safeBoundIds = Array.isArray(bound_judgment_ids)
                 ? bound_judgment_ids.filter((x) => typeof x === 'string' && x.length > 0)
                 : [];
+            // 2026-06-11: persona 加载 — 优先用 personaOverride, 否则从 ~/.bolloon/persona.json 读全局默认
+            let channelPersona;
+            if (personaOverride && typeof personaOverride === 'object') {
+                channelPersona = {
+                    name: personaOverride.name,
+                    description: personaOverride.description,
+                    personality: personaOverride.personality,
+                    greeting: personaOverride.greeting,
+                    capabilities: Array.isArray(personaOverride.capabilities) ? personaOverride.capabilities.slice(0, 20) : undefined,
+                    interests: Array.isArray(personaOverride.interests) ? personaOverride.interests.slice(0, 20) : undefined,
+                };
+            }
+            else {
+                try {
+                    const { readFileSync, existsSync } = await import('fs');
+                    const personaPath = `${process.env.HOME || '/tmp'}/.bolloon/persona.json`;
+                    if (existsSync(personaPath)) {
+                        const p = JSON.parse(readFileSync(personaPath, 'utf-8'));
+                        channelPersona = {
+                            name: p.name,
+                            description: p.description,
+                            personality: p.personality,
+                            greeting: p.greeting,
+                            capabilities: Array.isArray(p.capabilities) ? p.capabilities.slice(0, 20) : undefined,
+                            interests: Array.isArray(p.interests) ? p.interests.slice(0, 20) : undefined,
+                        };
+                    }
+                }
+                catch (err) {
+                    console.warn('[创建频道] 加载 persona.json 失败 (非致命):', err.message);
+                }
+            }
+            // 过滤 linkedDocumentIds: 只保留 string
+            const safeLinkedDocIds = Array.isArray(linkedDocumentIds)
+                ? linkedDocumentIds.filter((x) => typeof x === 'string' && x.length > 0).slice(0, 50)
+                : [];
             // 先创建频道（不阻塞等待 DID 生成）
             const channel = {
                 id,
@@ -1340,6 +1919,8 @@ export async function createWebServer(port = 3000, options = {}) {
                 walletRegisteredAt: validWallet ? new Date().toISOString() : undefined,
                 autoInvokeTools: autoInvokeTools !== false, // 默认 true
                 bound_judgment_ids: safeBoundIds,
+                persona: channelPersona,
+                linkedDocumentIds: safeLinkedDocIds,
                 sessions: [{
                         id: `sess_${Date.now()}`,
                         createdAt: new Date().toISOString(),
@@ -1498,7 +2079,7 @@ export async function createWebServer(port = 3000, options = {}) {
     app.patch('/channels/:channelId', async (req, res) => {
         try {
             const { channelId } = req.params;
-            const { name, walletAddress, autoInvokeTools, bound_judgment_ids, shared_with_peers } = req.body;
+            const { name, walletAddress, autoInvokeTools, bound_judgment_ids, shared_with_peers, persona, linkedDocumentIds } = req.body;
             const channels = await loadChannels();
             const channel = channels.find(c => c.id === channelId);
             if (!channel) {
@@ -1507,6 +2088,26 @@ export async function createWebServer(port = 3000, options = {}) {
             if (typeof name === 'string' && name.trim()) {
                 channel.name = name.trim();
             }
+            // 2026-06-11: 改 persona (允许 null 重置回全局默认)
+            if (persona !== undefined) {
+                if (persona === null) {
+                    channel.persona = undefined;
+                }
+                else if (typeof persona === 'object') {
+                    channel.persona = {
+                        name: persona.name,
+                        description: persona.description,
+                        personality: persona.personality,
+                        greeting: persona.greeting,
+                        capabilities: Array.isArray(persona.capabilities) ? persona.capabilities.slice(0, 20) : channel.persona?.capabilities,
+                        interests: Array.isArray(persona.interests) ? persona.interests.slice(0, 20) : channel.persona?.interests,
+                    };
+                }
+            }
+            // 2026-06-11: 改关联文档列表 (数组整体替换, 空数组 = 解绑所有)
+            if (Array.isArray(linkedDocumentIds)) {
+                channel.linkedDocumentIds = linkedDocumentIds.filter((x) => typeof x === 'string' && x.length > 0).slice(0, 50);
+            }
             // walletAddress 允许 null/'' 来解绑
             if (walletAddress !== undefined) {
                 if (walletAddress === null || walletAddress === '') {
@@ -1559,6 +2160,10 @@ export async function createWebServer(port = 3000, options = {}) {
             }
             channel.updatedAt = new Date().toISOString();
             await saveChannels(channels);
+            // v3 修复: 分享变更后立即广播给所有 peer, 不用等对方手动刷新
+            if (shared_with_peers !== undefined) {
+                v3BroadcastOwn().catch(err => console.error('[v3] broadcast after share update failed:', err));
+            }
             res.json(channel);
         }
         catch (err) {
@@ -1953,6 +2558,11 @@ export async function createWebServer(port = 3000, options = {}) {
             if (!provider || !config) {
                 return res.status(400).json({ error: 'provider and config required' });
             }
+            // 如果前端发的是掩码（***xxx），从当前配置里取真实 key
+            const currentConfig = await llmConfigStore.getProvider(provider);
+            if (currentConfig && config.apiKey && config.apiKey.startsWith('***')) {
+                config.apiKey = currentConfig.apiKey;
+            }
             await llmConfigStore.updateProvider(provider, config);
             // 如果是活跃供应商，重新初始化 Pi SDK
             const currentActive = await llmConfigStore.getActiveProvider();
@@ -2065,6 +2675,59 @@ export async function createWebServer(port = 3000, options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
+    // ==================== 音频生成配置 (TTS / Music) ====================
+    // 获取音频配置
+    app.get('/api/audio-config', async (req, res) => {
+        try {
+            const config = await audioConfigStore.getConfig();
+            const providerInfo = audioConfigStore.getAllProviderInfo();
+            const masked = Object.fromEntries(Object.entries(config.providers).map(([key, val]) => [
+                key,
+                { ...val, apiKey: val.apiKey ? '***' + val.apiKey.slice(-4) : '' }
+            ]));
+            res.json({
+                activeProvider: config.activeProvider,
+                providers: masked,
+                providerInfo
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 更新音频供应商配置
+    app.post('/api/audio-config', async (req, res) => {
+        try {
+            const { provider, config } = req.body;
+            if (!provider || !config) {
+                return res.status(400).json({ error: 'provider and config required' });
+            }
+            // 掩码回写真实 key
+            const currentConfig = await audioConfigStore.getProvider(provider);
+            if (currentConfig && config.apiKey && config.apiKey.startsWith('***')) {
+                config.apiKey = currentConfig.apiKey;
+            }
+            await audioConfigStore.updateProvider(provider, config);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 测试音频供应商连接
+    app.post('/api/audio-test', async (req, res) => {
+        try {
+            const { provider } = req.body;
+            if (!provider) {
+                return res.status(400).json({ error: 'provider required' });
+            }
+            const result = await audioConfigStore.testProvider(provider);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // 统一 AI 解析入口：CLI / 接收方节点 调这里完成 LLM + judgment + harness
     // 入参: { text, mimeType, fileName, fromNodeId, source }
     // 出参: { summary, qualityScore, judgmentId?, gateArtifact? }
@@ -2163,13 +2826,26 @@ export async function createWebServer(port = 3000, options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
-    // v3: 暴露 P2PDirect 自己的 publicKey, 对方可用它主动 connect
+    // v3: 暴露 P2PDirect 自己的 publicKey + 本机名字, 对方可用它主动 connect 并自动取名
     app.get('/api/p2p-publickey', async (_req, res) => {
         try {
             if (!v3P2PRef) {
                 return res.status(503).json({ error: 'P2PDirect not started' });
             }
-            res.json({ publicKey: v3P2PRef.getPublicKey() });
+            const publicKey = v3P2PRef.getPublicKey();
+            // 2026-06-10: 把本机 user/agent name 一起返回, 对方拿到后能直接用
+            let name = process.env.BOLLOON_USER_NAME || process.env.USER || 'node';
+            try {
+                const { readFileSync, existsSync } = await import('fs');
+                const cfgPath = `${process.env.HOME || '/tmp'}/.bolloon/config.json`;
+                if (existsSync(cfgPath)) {
+                    const cfg = JSON.parse(readFileSync(cfgPath, 'utf-8'));
+                    if (cfg.userName)
+                        name = cfg.userName;
+                }
+            }
+            catch { }
+            res.json({ publicKey, name, role: v3P2PRef.getRole() });
         }
         catch (err) {
             res.status(500).json({ error: err.message });
@@ -2213,6 +2889,40 @@ export async function createWebServer(port = 3000, options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
+    // 2026-06-10: PATCH 重命名 / 改备注 / 同时影响 publicKey
+    // 用法: PATCH /api/p2p-peers/:name { name?, notes?, publicKey? }
+    app.patch('/api/p2p-peers/:name', async (req, res) => {
+        try {
+            const { addOrUpdatePeer, removePeer } = await import('../network/known-peers.js');
+            const { readFile, writeFile } = await import('fs/promises');
+            const { existsSync } = await import('fs');
+            const filePath = `${process.env.HOME || '/tmp'}/.bolloon/known_peers.json`;
+            if (!existsSync(filePath))
+                return res.status(404).json({ error: 'no known_peers.json' });
+            const data = JSON.parse(await readFile(filePath, 'utf-8'));
+            const oldName = req.params.name;
+            const oldEntry = data.peers[oldName];
+            if (!oldEntry)
+                return res.status(404).json({ error: `peer "${oldName}" not found` });
+            const { name: newName, notes, publicKey: newPk } = req.body || {};
+            const finalName = newName || oldName;
+            const finalPk = newPk || oldEntry.publicKey;
+            if (finalName !== oldName) {
+                delete data.peers[oldName];
+            }
+            data.peers[finalName] = {
+                ...oldEntry,
+                publicKey: finalPk,
+                name: finalName,
+                notes: notes !== undefined ? notes : oldEntry.notes
+            };
+            await writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8');
+            res.json({ ok: true, peer: data.peers[finalName] });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // v3: 主动 connect 到对端的 P2PDirect publicKey
     // 用法: POST /api/remote-channels/p2p-connect { targetPublicKey: "<hex>" }
     app.post('/api/remote-channels/p2p-connect', async (req, res) => {
@@ -2249,6 +2959,99 @@ export async function createWebServer(port = 3000, options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
+    // v3: 主动给对端发好友申请 — 推到对端 UI 让对方接受
+    // 用法: POST /api/friend-request { targetPublicKey, name, message }
+    // 2026-06-10 改: 用 sendToWithWait 等握手完成, 不再 fire-and-forget; 返回结构化 code 让前端知道失败
+    app.post('/api/friend-request', async (req, res) => {
+        try {
+            if (!v3P2PRef) {
+                return res.status(503).json({ ok: false, code: 'P2P_NOT_STARTED', error: 'P2PDirect not started' });
+            }
+            const { targetPublicKey, name, message } = req.body || {};
+            if (!targetPublicKey || typeof targetPublicKey !== 'string' || targetPublicKey.length !== 64) {
+                return res.status(400).json({ ok: false, code: 'BAD_REQUEST', error: 'targetPublicKey (64 hex) required' });
+            }
+            // 先 joinPeer 触发握手 (注意: joinPeer 不阻塞到 conn 就绪)
+            const swarm = v3P2PRef.swarm;
+            if (swarm) {
+                try {
+                    await swarm.joinPeer(Buffer.from(targetPublicKey, 'hex'));
+                }
+                catch { }
+            }
+            // 主动把对方加为本机 known_peers (本地视角认为对方是朋友)
+            const { addOrUpdatePeer, findNameByPublicKey } = await import('../network/known-peers.js');
+            const existing = await findNameByPublicKey(targetPublicKey);
+            const peerName = name || existing || `peer-${targetPublicKey.substring(0, 8)}`;
+            await addOrUpdatePeer(peerName, targetPublicKey);
+            // 构造 RPC, 推到对端 — 对端会 SSE 推 friend-request 到前端
+            const myPk = v3P2PRef.getPublicKey();
+            const requestId = crypto.randomUUID();
+            const rpc = JSON.stringify({
+                v: 3,
+                op: 'agent.friend.request',
+                payload: {
+                    requestId, // 2026-06-10: 加 requestId, ack 时回带
+                    fromPublicKey: myPk,
+                    name: peerName,
+                    message: message || '想加你为 P2P 好友, 共享 channel 协作'
+                }
+            });
+            // 2026-06-10: 用 sendToWithWait, 等 conn 真就绪后再发, 默认 5s 超时
+            const result = await v3P2PRef.sendToWithWait(targetPublicKey, rpc, 5000);
+            console.log(`[v3-friend] ${myPk.substring(0, 12)}... 发送好友申请给 ${targetPublicKey.substring(0, 12)}... (result=${result}, requestId=${requestId.substring(0, 8)})`);
+            if (result !== 'SENT') {
+                return res.status(502).json({
+                    ok: false,
+                    code: result, // NO_CONN / WRITE_FAIL
+                    error: result === 'NO_CONN'
+                        ? '对方未在线, 请确认对方已启动 bolloon 并互联'
+                        : '写入 P2P 通道失败, 请重试',
+                    persistedAs: peerName // 本地仍持久化, 等对方上线再 retry 即可
+                });
+            }
+            res.json({ ok: true, sent: true, code: 'SENT', persistedAs: peerName, requestId });
+        }
+        catch (err) {
+            console.error('[v3-friend] friend-request 失败:', err);
+            res.status(500).json({ ok: false, code: 'EXCEPTION', error: err.message });
+        }
+    });
+    // v3: 接受对方的好友申请 — 把对方加为 known_peers, 立即推我的 channel 列表给 ta
+    // 用法: POST /api/friend-accept { fromPublicKey, name }
+    app.post('/api/friend-accept', async (req, res) => {
+        try {
+            if (!v3P2PRef) {
+                return res.status(503).json({ error: 'P2PDirect not started' });
+            }
+            const { fromPublicKey, name } = req.body || {};
+            if (!fromPublicKey || typeof fromPublicKey !== 'string' || fromPublicKey.length !== 64) {
+                return res.status(400).json({ error: 'fromPublicKey (64 hex) required' });
+            }
+            // 持久化
+            const { addOrUpdatePeer, findNameByPublicKey } = await import('../network/known-peers.js');
+            const existing = await findNameByPublicKey(fromPublicKey);
+            const peerName = name || existing || `peer-${fromPublicKey.substring(0, 8)}`;
+            await addOrUpdatePeer(peerName, fromPublicKey);
+            // joinPeer 确保连接存在 (连接可能已在 friend-request 时建立, 这里可能是 no-op)
+            const swarm = v3P2PRef.swarm;
+            if (swarm) {
+                try {
+                    await swarm.joinPeer(Buffer.from(fromPublicKey, 'hex'));
+                }
+                catch { }
+            }
+            // v3 修复: 主动广播自己的 channel 列表给新好友,
+            // 不能依赖 connection handler, 因为连接在 friend-request 阶段已建立, 不会触发新 connection 事件
+            v3BroadcastOwn().catch(err => console.error('[v3] broadcast after friend-accept failed:', err));
+            console.log(`[v3-friend] 接受好友申请: ${fromPublicKey.substring(0, 12)}... → ${peerName}`);
+            res.json({ ok: true, persistedAs: peerName });
+        }
+        catch (err) {
+            console.error('[v3-friend] friend-accept 失败:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
     // v3: 给远端 channel 发消息 (B 节点) - 通过 P2PDirect 转发到 A, A 跑 LLM, 回 B
     // 用法: POST /api/remote-channels/chat-send
     //   { targetPublicKey, channelId, text }
@@ -2276,6 +3079,8 @@ export async function createWebServer(port = 3000, options = {}) {
                     error: 'peer not connected. POST /api/remote-channels/p2p-connect first.'
                 });
             }
+            // 2026-06-10: 喂 watchdog — chat-send 成功是真实业务活动
+            watchdogRef?.recordActivity?.();
             console.log(`[v3] chat-send 转发到 ${targetPublicKey.substring(0, 12)}... (channelId=${channelId})`);
             res.json({ ok: true, sent: true });
         }
@@ -3151,6 +3956,8 @@ export async function createWebServer(port = 3000, options = {}) {
         healthMonitor = createHealthMonitor();
         // 把 watchdog 静默阈值拉到 30 分钟, 避免开发期 / 用户空闲时被误杀
         watchdog = createWatchdog({ silentThresholdMs: 30 * 60 * 1000 });
+        // 2026-06-10: 同步到 module-level, 让 broadcast() / P2P handler / chat-send 都能喂活动
+        watchdogRef = watchdog;
         console.log('[24h] Heartbeat modules loaded');
     }
     catch (err) {
@@ -3495,8 +4302,12 @@ export async function createWebServer(port = 3000, options = {}) {
         // level 1 (内存爆) → 进程自杀, 依赖外层 supervisor / 用户重启 (Windows 任务计划/手动)
         // 否则 Node.js 高 GC 压力下 HTTP 响应丢失, 客户端 fetch 永远 pending
         watchdog.registerRestartStrategy(1, () => {
-            console.error('[Watchdog] memory critical, 进程退出 (期望外层重启)');
-            setTimeout(() => process.exit(1), 100);
+            // 2026-06-10: 改为不退出, 因为我们直接后台 tsx 启动没有外层 supervisor.
+            // 误判主要因 recordActivity 仅在显式调用时刷新, 而 broadcast/SSE/连接均不触发.
+            // 退出策略原文保留在注释里:
+            //   console.error('[Watchdog] memory critical, 进程退出 (期望外层重启)');
+            //   setTimeout(() => process.exit(1), 100);
+            console.warn('[Watchdog] silentThreshold 触发, 但跳过 process.exit (无 supervisor)');
         });
         watchdog.start();
         console.log('[24h] Watchdog started');
@@ -3655,6 +4466,8 @@ export async function createWebServer(port = 3000, options = {}) {
     });
 }
 function broadcast(data, channelId) {
+    // 2026-06-10: 喂 watchdog, 避免 30min 空闲被误判 (recordActivity 内有 5s 去抖)
+    watchdogRef?.recordActivity?.();
     const envelope = { ...data, channelId };
     const message = `data: ${JSON.stringify(envelope)}\n\n`;
     console.log(`[broadcast] type=${data.type}, channelId=${channelId}, clients=${sseClients.size}`);