@bolloon/bolloon-agent 0.1.27 → 0.1.29

package/dist/web/server.js

@@ -257,6 +257,10 @@ let sseClients = new Set();
 // v3: 远端 channel UI 元数据缓存 — key: peerId, value: sanitize 过的 channel 列表
 // in-memory only, 进程重启清空 (judgment 内容永远不在这里)
 let remoteChannelCache = new Map();
+// v3: P2PDirect 引用 (Hyperswarm 薄包装) - 模块级, 因为 web server 闭包里不可用
+let v3P2PRef = null;
+// v3: 等待中的 history RPC (B 端 chat-history endpoint 用) — rpcId → { resolve, reject }
+const v3PendingHistoryGets = new Map();
 let channelSessions = new Map(); // key: channelId
 let sessionMessages = new Map(); // key: channelId + sessionId
 /**
@@ -270,8 +274,18 @@ let sessionMessages = new Map(); // key: channelId + sessionId
  * v3: 过滤 channel 元数据, 只返回对远端 peer 安全的字段.
  * 关键: bound_judgment_ids / walletBinding / autoInvokeTools 内部状态不外传.
  * judgment 内容永远不会出现在 RPC 响应里 (judgment 始终在 A 节点内存, 由 A 跑 LLM).
+ *
+ * Phase 3 分享模式: 加 peerPublicKey 参数 — 只有 shared_with_peers 包含此 peer 的 channel 才返回.
+ * peerPublicKey 不传 = admin 路径, 返回所有 channel (老行为).
  */
-function sanitizeChannelForPeer(ch) {
+function sanitizeChannelForPeer(ch, peerPublicKey) {
+    // Phase 3 核心: 分享过滤
+    if (peerPublicKey) {
+        const shared = Array.isArray(ch.shared_with_peers) ? ch.shared_with_peers : [];
+        if (!shared.includes(peerPublicKey)) {
+            return null; // 没分享给这个 peer, 不返回
+        }
+    }
     return {
         id: ch.id,
         name: ch.name,
@@ -279,11 +293,281 @@ function sanitizeChannelForPeer(ch) {
         publicKey: ch.publicKey,
         createdAt: ch.createdAt,
         updatedAt: ch.updatedAt,
-        hasWallet: !!ch.walletAddress, // 只告诉 B "有没有钱包", 不传地址
+        hasWallet: !!ch.walletAddress,
         boundJudgmentCount: Array.isArray(ch.bound_judgment_ids) ? ch.bound_judgment_ids.length : 0,
-        // 🔒 不返回: bound_judgment_ids, walletAddress, walletBinding, autoInvokeTools, sessions
+        share_id: ch.share_id,
+        // 🔒 不返回: bound_judgment_ids, walletAddress, walletBinding, autoInvokeTools, sessions, shared_with_peers
     };
 }
+/** v3 新增: 判断 channel 是否分享给 peerPublicKey */
+function isSharedWith(ch, peerPublicKey) {
+    const shared = Array.isArray(ch.shared_with_peers) ? ch.shared_with_peers : [];
+    return shared.includes(peerPublicKey);
+}
+/**
+ * v3: 处理 Hyperswarm 通道收到的 v3 RPC 消息
+ * 设计: 用 HyperswarmCommunicator (DHT topic 自动发现) 取代 iroh 直接 connect
+ *   - A 启动 → broadcast(agent.meta.list.reply) → 所有已连接 peer 缓存 A 的 channel
+ *   - B 启动 → 同样 broadcast
+ *   - 任何节点收到 list 请求 → 回 list.reply
+ */
+async function handleV3P2PMessage(parsed, conn, comm) {
+    const op = parsed.op;
+    const peerKey = conn.publicKey;
+    if (op === 'agent.meta.list') {
+        // 对方问我的 channel 列表 — 只返回分享给他的
+        try {
+            const channels = await loadChannels();
+            const publicMeta = channels
+                .map(ch => sanitizeChannelForPeer(ch, peerKey))
+                .filter((x) => x !== null);
+            const reply = JSON.stringify({ v: 3, op: 'agent.meta.list.reply', payload: { channels: publicMeta } });
+            await comm.sendToConnection(conn.id, reply);
+            console.log(`[v3] 回 ${peerKey.substring(0, 12)}... list.reply (${publicMeta.length} 个分享给 ta)`);
+        }
+        catch (err) {
+            console.error('[v3] 处理 agent.meta.list 失败:', err.message);
+        }
+        return;
+    }
+    if (op === 'agent.meta.list.reply') {
+        // 对方把他自己的 channel 列表推给我 — 缓存
+        const list = parsed.payload?.channels || [];
+        remoteChannelCache.set(peerKey, list);
+        console.log(`[v3] 收到 ${peerKey.substring(0, 12)}... 的 ${list.length} 个 channel, 已缓存`);
+        broadcast({
+            type: 'remote-channel-update',
+            peerId: peerKey,
+            channels: list
+        }, 'p2p-global');
+        return;
+    }
+    if (op === 'agent.meta.get') {
+        // 对方问单条 channel — 回
+        const channelId = parsed.payload?.channelId;
+        if (channelId) {
+            const channels = await loadChannels();
+            const ch = channels.find(c => c.id === channelId);
+            if (ch) {
+                // Phase 3: 分享过滤 — 必须分享给该 peer
+                const sanitized = sanitizeChannelForPeer(ch, peerKey);
+                if (sanitized) {
+                    const reply = JSON.stringify({ v: 3, op: 'agent.meta.get.reply', payload: { channel: sanitized } });
+                    await comm.sendToConnection(conn.id, reply);
+                }
+                else {
+                    const reply = JSON.stringify({ v: 3, op: 'agent.meta.get.reply', payload: { error: 'not shared with you' } });
+                    await comm.sendToConnection(conn.id, reply);
+                }
+            }
+        }
+        return;
+    }
+    if (op === 'agent.meta.get.reply') {
+        const ch = parsed.payload?.channel;
+        if (ch && ch.id) {
+            const list = remoteChannelCache.get(peerKey) || [];
+            const idx = list.findIndex((c) => c.id === ch.id);
+            if (idx >= 0)
+                list[idx] = ch;
+            else
+                list.push(ch);
+            remoteChannelCache.set(peerKey, list);
+            broadcast({
+                type: 'remote-channel-update',
+                peerId: peerKey,
+                channels: list
+            }, 'p2p-global');
+        }
+        return;
+    }
+    if (op === 'agent.chat.send') {
+        // B 端发来: 在 A 节点上对 channelId 跑 LLM, 结果回 B
+        // judgment 永远在 A 节点 (buildJudgmentHint 已经用 bound_judgment_ids)
+        const { channelId, text, fromPublicKey } = parsed.payload || {};
+        if (!channelId || !text) {
+            console.warn(`[v3] agent.chat.send 缺少 channelId/text`);
+            return;
+        }
+        const senderKey = fromPublicKey || peerKey;
+        console.log(`[v3] 收到 ${senderKey.substring(0, 12)}... 对 channel ${channelId} 的 chat: "${text.substring(0, 40)}..."`);
+        try {
+            // 1. 找到 channel
+            const channels = await loadChannels();
+            const ch = channels.find(c => c.id === channelId);
+            if (!ch) {
+                const reply = JSON.stringify({
+                    v: 3, op: 'agent.chat.reply',
+                    payload: { channelId, fromPublicKey: v3P2PRef?.getPublicKey() || '', error: 'channel not found', text: '' }
+                });
+                await comm.sendToConnection(conn.id, reply);
+                return;
+            }
+            // v3 新增: 持久化 B 的 user 消息到 A 的 session — 让历史可拉
+            try {
+                const existing = await loadSession(channelId, 'default');
+                const session = existing || {
+                    channelId, sessionId: 'default', messages: [], lastUpdated: new Date().toISOString()
+                };
+                session.messages.push({
+                    id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                    type: 'user',
+                    content: text,
+                    timestamp: new Date().toISOString()
+                });
+                session.lastUpdated = new Date().toISOString();
+                await saveSession(session);
+                console.log(`[v3] (${channelId}) 存 user 消息 (${text.length} chars) 到 A 的 session`);
+            }
+            catch (saveErr) {
+                console.warn(`[v3] 存 user 消息失败 (不影响 chat):`, saveErr.message);
+            }
+            // v3 新增: 告诉 B "我开始想了, 用了哪些 judgment" — 让 B 看到决策依据
+            const judgmentHint = await buildJudgmentHint(ch, channelId);
+            const usedJudgments = await extractJudgmentsFromHint(ch);
+            try {
+                const thinkingStart = JSON.stringify({
+                    v: 3, op: 'agent.chat.thinking',
+                    payload: {
+                        channelId,
+                        phase: 'start',
+                        fromPublicKey: v3P2PRef?.getPublicKey() || '',
+                        hint: judgmentHint,
+                        usedJudgments,
+                        userText: text
+                    }
+                });
+                await comm.sendToConnection(conn.id, thinkingStart);
+            }
+            catch { }
+            // 2. 跑 LLM (复用 Phase 1 的 buildJudgmentHint — 注入 channel 的 judgment)
+            const { getMinimax } = await import('../constraints/index.js');
+            const llm = getMinimax();
+            const fullPrompt = `${judgmentHint}${text}`;
+            let fullResponse = '';
+            // v3 新增: 流式 token 节流推给 B — 让 B 看到过程
+            let lastFlushAt = 0;
+            const streamCallback = (event) => {
+                if (event.type === 'token') {
+                    fullResponse += event.content;
+                    if (fullResponse.length - lastFlushAt >= 20) {
+                        lastFlushAt = fullResponse.length;
+                        const msg = JSON.stringify({
+                            v: 3, op: 'agent.chat.thinking',
+                            payload: { channelId, phase: 'token', partial: fullResponse, fromPublicKey: v3P2PRef?.getPublicKey() || '' }
+                        });
+                        comm.sendToConnection(conn.id, msg).catch(() => { });
+                    }
+                }
+            };
+            const agent = await getAgentForChannel(channelId, ch.did || '', ch.name, ch.didDocRef);
+            fullResponse = await agent.promptStream(fullPrompt, streamCallback);
+            // v3 新增: 存 A 的 assistant 消息到 session — B 拉历史时能看到完整对话
+            try {
+                const existing = await loadSession(channelId, 'default');
+                const session = existing || {
+                    channelId, sessionId: 'default', messages: [], lastUpdated: new Date().toISOString()
+                };
+                session.messages.push({
+                    id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                    type: 'ai',
+                    content: fullResponse,
+                    timestamp: new Date().toISOString()
+                });
+                session.lastUpdated = new Date().toISOString();
+                await saveSession(session);
+                console.log(`[v3] (${channelId}) 存 assistant 回复 (${fullResponse.length} chars) 到 A 的 session`);
+            }
+            catch (saveErr) {
+                console.warn(`[v3] 存 assistant 消息失败 (不影响):`, saveErr.message);
+            }
+            // 3. 把完整回复发给 B
+            const reply = JSON.stringify({
+                v: 3, op: 'agent.chat.reply',
+                payload: {
+                    channelId,
+                    fromPublicKey: v3P2PRef?.getPublicKey() || '',
+                    text: fullResponse
+                }
+            });
+            await comm.sendToConnection(conn.id, reply);
+            console.log(`[v3] 回 chat.reply 给 ${senderKey.substring(0, 12)}... (${fullResponse.length} chars)`);
+        }
+        catch (err) {
+            console.error(`[v3] agent.chat.send 处理失败:`, err.message);
+            try {
+                const reply = JSON.stringify({
+                    v: 3, op: 'agent.chat.reply',
+                    payload: { channelId, fromPublicKey: v3P2PRef?.getPublicKey() || '', error: err.message, text: '' }
+                });
+                await comm.sendToConnection(conn.id, reply);
+            }
+            catch { }
+        }
+        return;
+    }
+    if (op === 'agent.history.get') {
+        // v3 新增: B 拉 A 的 channel 历史 (含所有 message + judgment hint)
+        // 共享过滤: 只返回 B 可见的 channel + 包含的 judgment
+        const { channelId, rpcId, fromPublicKey } = parsed.payload || {};
+        if (!channelId || !rpcId) {
+            console.warn(`[v3] agent.history.get 缺少 channelId/rpcId`);
+            return;
+        }
+        try {
+            const channels = await loadChannels();
+            const ch = channels.find(c => c.id === channelId);
+            if (!ch) {
+                const err = JSON.stringify({
+                    v: 3, op: 'agent.history.get.reply',
+                    payload: { rpcId, error: 'channel not found', messages: [], judgments: { bound: [], candidates: [] } }
+                });
+                await comm.sendToConnection(conn.id, err);
+                return;
+            }
+            // 共享过滤: 必须 peerKey 在 shared_with_peers 里 (避免泄露未分享的 channel)
+            const peerKey = fromPublicKey;
+            if (!peerKey || !isSharedWith(ch, peerKey)) {
+                const err = JSON.stringify({
+                    v: 3, op: 'agent.history.get.reply',
+                    payload: { rpcId, error: 'channel not shared with you', messages: [], judgments: { bound: [], candidates: [] } }
+                });
+                await comm.sendToConnection(conn.id, err);
+                return;
+            }
+            // 加载 A 端 session
+            const session = await loadSession(channelId, 'default');
+            // 加载 channel 用到的 judgment
+            const judgments = await extractJudgmentsFromHint(ch);
+            const reply = JSON.stringify({
+                v: 3, op: 'agent.history.get.reply',
+                payload: {
+                    rpcId,
+                    channelId,
+                    messages: session?.messages || [],
+                    lastUpdated: session?.lastUpdated,
+                    judgments,
+                    channelName: ch.name
+                }
+            });
+            await comm.sendToConnection(conn.id, reply);
+            console.log(`[v3] 回 history.reply 给 ${peerKey.substring(0, 12)}... (channelId=${channelId}, ${session?.messages?.length || 0} messages)`);
+        }
+        catch (err) {
+            console.error(`[v3] agent.history.get 处理失败:`, err.message);
+            try {
+                const errMsg = JSON.stringify({
+                    v: 3, op: 'agent.history.get.reply',
+                    payload: { rpcId, error: err.message, messages: [], judgments: { bound: [], candidates: [] } }
+                });
+                await comm.sendToConnection(conn.id, errMsg);
+            }
+            catch { }
+        }
+        return;
+    }
+    console.log(`[v3] 收到未知 op: ${op}`);
+}
 async function buildJudgmentHint(channel, channelIdForLog) {
     try {
         const { loadAllJudgments, initializeValueStore } = await import('../pi-ecosystem-judgment/human-value-store.js');
@@ -325,6 +609,38 @@ async function buildJudgmentHint(channel, channelIdForLog) {
         return '';
     }
 }
+/**
+ * v3 新增: 把 channel 当前用到的 judgment 提取成结构化数据, 给 B 端 UI 显示.
+ * 返回 { bound: [...], candidates: [...] } — bound 是硬绑定, candidates 是参考池.
+ */
+async function extractJudgmentsFromHint(channel) {
+    try {
+        const { loadAllJudgments, initializeValueStore } = await import('../pi-ecosystem-judgment/human-value-store.js');
+        await initializeValueStore();
+        const allJudgments = await loadAllJudgments();
+        if (allJudgments.length === 0)
+            return { bound: [], candidates: [] };
+        const boundIds = new Set(channel && Array.isArray(channel.bound_judgment_ids) ? channel.bound_judgment_ids : []);
+        const summarize = (j) => ({
+            id: j.id,
+            decision: (j.decision || '').toString().slice(0, 200),
+            reasons: Array.isArray(j.reasons) ? j.reasons : [],
+            domain: j.domain,
+            stakes: j.stakes
+        });
+        const bound = allJudgments
+            .filter((j) => j.id !== undefined && boundIds.has(j.id))
+            .map(summarize);
+        const candidates = allJudgments
+            .filter((j) => j.id !== undefined && !boundIds.has(j.id))
+            .map(summarize);
+        return { bound, candidates };
+    }
+    catch (err) {
+        console.warn(`[v3] extractJudgmentsFromHint 失败:`, err.message);
+        return { bound: [], candidates: [] };
+    }
+}
 async function getAgentForChannel(channelId, channelDid, channelName, channelDidDoc) {
     // 获取当前 channel 的 currentSessionId
     const channels = await loadChannels();
@@ -428,7 +744,164 @@ export async function createWebServer(port = 3000, options = {}) {
         catch (e) {
             console.log('P2P DID 本地模式运行');
         }
-        // 初始化 P2P 通信器
+        // v3: 完全用 P2PDirect 取代 @diap/sdk 的 HyperswarmCommunicator
+        // 原因: @diap/sdk 的 sendToConnection 是 stub, 不真发数据
+        // 这里故意不启动 p2pCommunicator (保持 null), 让 P2PDirect 独占 hyperswarm 通道
+        try {
+            const { P2PDirect } = await import('../network/p2p-direct.js');
+            v3P2PRef = new P2PDirect({ name: 'v3' });
+            await v3P2PRef.start();
+            await v3P2PRef.joinTopic(Buffer.from('bolloon-agent-harness'));
+            v3P2PRef.on('data', (evt) => {
+                try {
+                    const parsed = JSON.parse(evt.data.toString('utf-8'));
+                    if (parsed && parsed.v === 3 && parsed.op) {
+                        // v3 跨用户 chat: B 端收到 A 的 chat.reply, 直接 SSE 推给前端
+                        if (parsed.op === 'agent.chat.reply') {
+                            console.log(`[v3] 收到来自 ${evt.fromPublicKey.substring(0, 12)}... 的 chat.reply (${(parsed.payload?.text || '').length} chars)`);
+                            broadcast({
+                                type: 'remote-chat-reply',
+                                fromPublicKey: evt.fromPublicKey,
+                                channelId: parsed.payload?.channelId,
+                                text: parsed.payload?.text || '',
+                                error: parsed.payload?.error
+                            }, 'p2p-global');
+                            return;
+                        }
+                        // v3 新增: B 端收到 A 的 thinking (开始 + 流式 token)
+                        if (parsed.op === 'agent.chat.thinking') {
+                            const phase = parsed.payload?.phase;
+                            if (phase === 'start') {
+                                console.log(`[v3] 收到来自 ${evt.fromPublicKey.substring(0, 12)}... 的 thinking start (judgments: bound=${(parsed.payload?.usedJudgments?.bound || []).length}, candidates=${(parsed.payload?.usedJudgments?.candidates || []).length})`);
+                            }
+                            broadcast({
+                                type: 'remote-chat-thinking',
+                                fromPublicKey: evt.fromPublicKey,
+                                channelId: parsed.payload?.channelId,
+                                phase: parsed.payload?.phase,
+                                partial: parsed.payload?.partial,
+                                hint: parsed.payload?.hint,
+                                usedJudgments: parsed.payload?.usedJudgments,
+                                userText: parsed.payload?.userText
+                            }, 'p2p-global');
+                            return;
+                        }
+                        // v3 新增: B 端收到 A 的 history reply → resolve pending promise
+                        if (parsed.op === 'agent.history.get.reply') {
+                            const rpcId = parsed.payload?.rpcId;
+                            if (rpcId && v3PendingHistoryGets.has(rpcId)) {
+                                const pending = v3PendingHistoryGets.get(rpcId);
+                                v3PendingHistoryGets.delete(rpcId);
+                                if (parsed.payload?.error) {
+                                    pending.reject(new Error(parsed.payload.error));
+                                }
+                                else {
+                                    pending.resolve({
+                                        channelId: parsed.payload.channelId,
+                                        messages: parsed.payload.messages || [],
+                                        lastUpdated: parsed.payload.lastUpdated,
+                                        judgments: parsed.payload.judgments || { bound: [], candidates: [] },
+                                        channelName: parsed.payload.channelName
+                                    });
+                                }
+                            }
+                            return;
+                        }
+                        const commShim = {
+                            sendToConnection: (_id, data) => {
+                                v3P2PRef.sendTo(evt.fromPublicKey, data);
+                                return Promise.resolve();
+                            }
+                        };
+                        handleV3P2PMessage(parsed, { id: evt.fromPublicKey, publicKey: evt.fromPublicKey }, commShim);
+                    }
+                }
+                catch (err) {
+                    console.error('[v3-P2PDirect] 解析/处理消息失败:', err.message);
+                }
+            });
+            // 新连接进来 → 主动发我分享给 ta 的 channel 列表
+            v3P2PRef.on('connection', (evt) => {
+                setTimeout(async () => {
+                    try {
+                        const channels = await loadChannels();
+                        const publicMeta = channels
+                            .map(ch => sanitizeChannelForPeer(ch, evt.remotePublicKey))
+                            .filter((x) => x !== null);
+                        const msg = JSON.stringify({ v: 3, op: 'agent.meta.list.reply', payload: { channels: publicMeta } });
+                        v3P2PRef.sendTo(evt.remotePublicKey, msg);
+                        console.log(`[v3] 新连接 ${evt.remotePublicKey.substring(0, 12)}... → 发 ${publicMeta.length} 个分享给 ta`);
+                    }
+                    catch (err) {
+                        console.error('[v3] 新连接发 list.reply 失败:', err.message);
+                    }
+                }, 500);
+            });
+            console.log(`[v3] P2PDirect 已启动, role=${v3P2PRef.getRole()}, publicKey=${v3P2PRef.getPublicKey().substring(0, 12)}...`);
+            // v3: 启动后自动重连 known peers — 让"启动就互联"成为现实
+            setTimeout(async () => {
+                try {
+                    const { listPeers, markConnected } = await import('../network/known-peers.js');
+                    const peers = await listPeers();
+                    if (peers.length === 0) {
+                        console.log(`[v3] 没有 known peers, 跳过自动重连`);
+                        return;
+                    }
+                    const swarm = v3P2PRef.swarm;
+                    if (!swarm)
+                        return;
+                    for (const peer of peers) {
+                        try {
+                            await swarm.joinPeer(Buffer.from(peer.publicKey, 'hex'));
+                            await markConnected(peer.name || '');
+                            console.log(`[v3] 自动重连 ${peer.name} (${peer.publicKey.substring(0, 12)}...) ✓`);
+                        }
+                        catch (err) {
+                            console.warn(`[v3] 自动重连 ${peer.name} 失败:`, err.message);
+                        }
+                    }
+                    // 触发一次 broadcast 推送给所有重连的 peer
+                    setTimeout(() => v3BroadcastOwn(), 2000);
+                }
+                catch (err) {
+                    console.error('[v3] 自动重连失败:', err.message);
+                }
+            }, 5000); // 5s 后再重连, 让 swarm 充分 bootstrap
+        }
+        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));
+        };
+        setTimeout(v3BroadcastOwn, 3000);
+        setTimeout(v3BroadcastOwn, 10000);
+        setTimeout(v3BroadcastOwn, 20000);
+        setTimeout(v3BroadcastOwn, 40000);
+        // 保留 @diap/sdk 的旧实例 (它的 Hyperswarm 实例能帮 P2PDirect 做 DHT bootstrap)
         try {
             const rawSeed = crypto.getRandomValues(new Uint8Array(32));
             p2pCommunicator = createHyperswarmCommunicator({
@@ -438,22 +911,20 @@ export async function createWebServer(port = 3000, options = {}) {
                 maxConnections: 50,
                 seed: rawSeed
             });
-            p2pCommunicator.on('connection', (conn) => {
-                console.log(`P2P 连接: ${conn.publicKey.substring(0, 8)}...`);
-            });
             p2pCommunicator.on('message', async (msg, conn) => {
+                // 旧 p2p_message 路径 (非 v3)
                 const content = new TextDecoder().decode(msg.content);
-                console.log(`P2P 收到消息: ${content.substring(0, 50)}...`);
-                // 可以在这里处理接收到的消息
                 broadcast({ type: 'p2p_message', from: conn.publicKey.substring(0, 8), content }, undefined);
             });
             await p2pCommunicator.start();
-            const topic = createTopic('bolloon-agent-harness');
-            await p2pCommunicator.joinTopic(topic);
-            console.log(`P2P 网络已就绪`);
+            // @diap/sdk 也 join topic — 它的 Hyperswarm 实例帮 P2PDirect 做 DHT 引导
+            // @diap/sdk 收到的数据是 mock (不真发), 但 DHT 发现 + 节点连接是 OK 的
+            const oldTopic = createTopic('bolloon-agent-harness');
+            await p2pCommunicator.joinTopic(oldTopic);
+            console.log(`P2P 老通道已就绪 (DHT bootstrap 帮 P2PDirect, 实际数据走 P2PDirect)`);
         }
         catch (e) {
-            console.log(`P2P 网络初始化失败: ${e.message}`);
+            console.log(`P2P 老通道初始化失败: ${e.message}`);
         }
     }
     catch (e) {
@@ -752,6 +1223,26 @@ export async function createWebServer(port = 3000, options = {}) {
     // 用法: B 端用户点 "刷新远端智能体" → 触发本 endpoint
     app.post('/api/remote-channels/refresh', async (_req, res) => {
         try {
+            // Phase 3: 优先用 P2PDirect conns (Phase 2/3 的真实通道)
+            if (v3P2PRef) {
+                const conns = v3P2PRef.conns;
+                const peerIds = Array.from(conns.keys()).filter(pk => {
+                    const c = conns.get(pk);
+                    return c && !c.destroyed;
+                });
+                if (peerIds.length === 0) {
+                    return res.json({ ok: true, sent: 0, note: 'no connected peers (P2PDirect)' });
+                }
+                // 让每个 peer 拉 list — Phase 3 个性化分享过滤
+                let sent = 0;
+                for (const peerPk of peerIds) {
+                    const ok = await v3P2PRef.sendTo(peerPk, JSON.stringify({ v: 3, op: 'agent.meta.list', payload: {} }));
+                    if (ok)
+                        sent++;
+                }
+                return res.json({ ok: true, sent, total: peerIds.length });
+            }
+            // Fallback: 老 iroh 路径
             const peers = irohTransport.getPeers ? irohTransport.getPeers() : [];
             const peerIds = Array.isArray(peers) ? peers.map((p) => p.nodeId || p) : [];
             if (peerIds.length === 0) {
@@ -769,6 +1260,36 @@ export async function createWebServer(port = 3000, options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
+    // ===== v3: 主动 connect 到对端, 再发 agent.meta.list =====
+    // 用法: POST /api/remote-channels/connect { targetAddr: "<完整 EndpointAddr 含 relay URL>" }
+    // targetAddr 应来自对端 GET /api/iroh-addr (完整字符串, 不只是 nodeId)
+    // 兼容旧用法: 也接受 targetNodeId, 但只有 nodeId 不一定能 connect 成功
+    app.post('/api/remote-channels/connect', async (req, res) => {
+        try {
+            const { targetAddr, targetNodeId } = req.body || {};
+            const target = targetAddr || targetNodeId;
+            if (!target || typeof target !== 'string') {
+                return res.status(400).json({ error: 'targetAddr (or targetNodeId) required' });
+            }
+            console.log(`[v3] 主动 connect 到 ${target.substring(0, 32)}...`);
+            // iroh connect 接受 nodeId 或完整 addr 字符串 — 用完整 addr 才会成功
+            const ok = await irohTransport.connect(target);
+            if (!ok) {
+                return res.status(502).json({
+                    error: 'connect failed',
+                    hint: '传 targetAddr (完整 EndpointAddr 字符串, 含 relay URL) 而非仅 nodeId'
+                });
+            }
+            // 立即发 agent.meta.list 请求对端返回元数据
+            const sent = await irohTransport.sendMessage(target, 'agent.meta.list', new TextEncoder().encode('{}'));
+            console.log(`[v3] connect+list 发送结果: connect=ok, list=${sent}`);
+            res.json({ ok: true, connected: true, sent, target });
+        }
+        catch (err) {
+            console.error('[v3] /api/remote-channels/connect 失败:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
     app.post('/channels', async (req, res) => {
         try {
             const { name, agentId, walletAddress, autoInvokeTools, bound_judgment_ids } = req.body;
@@ -954,7 +1475,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 } = req.body;
+            const { name, walletAddress, autoInvokeTools, bound_judgment_ids, shared_with_peers } = req.body;
             const channels = await loadChannels();
             const channel = channels.find(c => c.id === channelId);
             if (!channel) {
@@ -994,6 +1515,25 @@ export async function createWebServer(port = 3000, options = {}) {
                 }
                 console.log(`[Channel ${channelId}] 绑定判断力: ${channel.bound_judgment_ids.length} 条`);
             }
+            // Phase 3: shared_with_peers (显式分享给指定 peerPublicKey 列表)
+            if (shared_with_peers !== undefined) {
+                if (shared_with_peers === null) {
+                    channel.shared_with_peers = [];
+                }
+                else if (Array.isArray(shared_with_peers)) {
+                    channel.shared_with_peers = shared_with_peers.filter((x) => typeof x === 'string' && x.length === 64 // iroh/hyperswarm pubkey 32 字节 = 64 hex
+                    );
+                }
+                else {
+                    return res.status(400).json({ error: 'shared_with_peers must be array of publicKey hex' });
+                }
+                console.log(`[Channel ${channelId}] 分享给 ${channel.shared_with_peers.length} 个 peer`);
+            }
+            // 首次保存时自动生成 share_id (短字符串, 方便粘贴)
+            if (!channel.share_id) {
+                channel.share_id = `shr_${channelId.slice(3, 12)}_${Math.random().toString(36).substring(2, 8)}`;
+                console.log(`[Channel ${channelId}] 自动生成 share_id: ${channel.share_id}`);
+            }
             channel.updatedAt = new Date().toISOString();
             await saveChannels(channels);
             res.json(channel);
@@ -1534,6 +2074,183 @@ export async function createWebServer(port = 3000, options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
+    // v3 测试: 返回 iroh endpoint 完整地址 (含 relay URL), 这才是 connect() 真正需要的
+    app.get('/api/iroh-addr', async (_req, res) => {
+        try {
+            const addr = irohTransport.getEndpointAddr
+                ? irohTransport.getEndpointAddr()
+                : irohTransport.getNodeId();
+            res.json({ addr });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 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() });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // v3: known peers CRUD (持久化到 ~/.bolloon/known_peers.json)
+    // GET 列表, POST 加/更新, DELETE 删, PATCH 重命名
+    app.get('/api/p2p-peers', async (_req, res) => {
+        try {
+            const { listPeers } = await import('../network/known-peers.js');
+            const peers = await listPeers();
+            res.json({ count: peers.length, peers });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/p2p-peers', async (req, res) => {
+        try {
+            const { name, publicKey, notes } = req.body || {};
+            if (!name || !publicKey)
+                return res.status(400).json({ error: 'name and publicKey required' });
+            if (typeof publicKey !== 'string' || publicKey.length !== 64) {
+                return res.status(400).json({ error: 'publicKey must be 64-char hex (32 bytes)' });
+            }
+            const { addOrUpdatePeer } = await import('../network/known-peers.js');
+            await addOrUpdatePeer(name, publicKey, notes);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/api/p2p-peers/:name', async (req, res) => {
+        try {
+            const { removePeer } = await import('../network/known-peers.js');
+            await removePeer(req.params.name);
+            res.json({ ok: true });
+        }
+        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) => {
+        try {
+            if (!v3P2PRef) {
+                return res.status(503).json({ error: 'P2PDirect not started' });
+            }
+            const { targetPublicKey, name, persist } = req.body || {};
+            if (!targetPublicKey || typeof targetPublicKey !== 'string') {
+                return res.status(400).json({ error: 'targetPublicKey required (hex)' });
+            }
+            // v3P2PRef 直接连到目标 publicKey (用 hyperswarm 的 joinPeer API)
+            const swarm = v3P2PRef.swarm;
+            if (!swarm)
+                return res.status(503).json({ error: 'swarm not available' });
+            const conn = await swarm.joinPeer(Buffer.from(targetPublicKey, 'hex'));
+            console.log(`[v3] 已主动 joinPeer ${targetPublicKey.substring(0, 12)}...`);
+            // 自动持久化 (默认开启) — 之后启动自动重连
+            let persistedAs = null;
+            if (persist !== false) {
+                const { addOrUpdatePeer, findNameByPublicKey } = await import('../network/known-peers.js');
+                // 优先用客户端传的 name, 否则用 publicKey 前 8 位
+                const peerName = name || `peer-${targetPublicKey.substring(0, 8)}`;
+                // 如果 publicKey 已被别的 name 占用, 用现有 name
+                const existingName = await findNameByPublicKey(targetPublicKey);
+                persistedAs = existingName ?? peerName ?? `peer-${targetPublicKey.substring(0, 8)}`;
+                await addOrUpdatePeer(persistedAs, targetPublicKey);
+                console.log(`[v3] 自动持久化 peer: ${persistedAs}`);
+            }
+            res.json({ ok: true, target: targetPublicKey, persistedAs });
+        }
+        catch (err) {
+            console.error('[v3] p2p-connect 失败:', 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 }
+    app.post('/api/remote-channels/chat-send', async (req, res) => {
+        try {
+            if (!v3P2PRef) {
+                return res.status(503).json({ error: 'P2PDirect not started' });
+            }
+            const { targetPublicKey, channelId, text } = req.body || {};
+            if (!targetPublicKey || !channelId || !text) {
+                return res.status(400).json({ error: 'targetPublicKey, channelId, text required' });
+            }
+            if (typeof text !== 'string' || text.length === 0 || text.length > 8000) {
+                return res.status(400).json({ error: 'text length must be 1-8000' });
+            }
+            const fromPk = v3P2PRef.getPublicKey();
+            const msg = JSON.stringify({
+                v: 3,
+                op: 'agent.chat.send',
+                payload: { channelId, text, fromPublicKey: fromPk }
+            });
+            const ok = v3P2PRef.sendTo(targetPublicKey, msg);
+            if (!ok) {
+                return res.status(502).json({
+                    error: 'peer not connected. POST /api/remote-channels/p2p-connect first.'
+                });
+            }
+            console.log(`[v3] chat-send 转发到 ${targetPublicKey.substring(0, 12)}... (channelId=${channelId})`);
+            res.json({ ok: true, sent: true });
+        }
+        catch (err) {
+            console.error('[v3] chat-send 失败:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // v3 新增: B 拉 A 的 channel 历史 + 用了哪些 judgment
+    // GET /api/remote-channels/chat-history?targetPublicKey=...&channelId=...
+    // 实现: 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); }
+                });
+            });
+            console.log(`[v3] chat-history 从 ${targetPublicKey.substring(0, 12)}... 拉到 ${(result.messages || []).length} 条`);
+            res.json(result);
+        }
+        catch (err) {
+            console.error('[v3] chat-history 失败:', err.message);
+            res.status(504).json({ error: err.message });
+        }
+    });
     // 获取已连接的节点
     app.get('/api/peers', async (_req, res) => {
         try {
@@ -1699,7 +2416,8 @@ export async function createWebServer(port = 3000, options = {}) {
                 console.log(`[v3] 收到 agent.meta.list from ${msg.from.substring(0, 12)}...`);
                 try {
                     const channels = await loadChannels();
-                    const publicMeta = channels.map(sanitizeChannelForPeer);
+                    // iroh 路径保留 (admin / debug 用, 不走分享过滤)
+                    const publicMeta = channels.map((ch) => sanitizeChannelForPeer(ch));
                     const response = JSON.stringify({ ok: true, channels: publicMeta });
                     const encoded = new TextEncoder().encode(response);
                     // 沿用 msg.from 路由回去