@bolloon/bolloon-agent 0.1.33 → 0.1.35

package/src/web/server.ts

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'url';
 import * as fs from 'fs/promises';
 import * as fsSync from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 import {
   HyperswarmCommunicator,
   createHyperswarmCommunicator,
@@ -73,6 +74,17 @@ interface Channel {
   name: string;
   agentId: string;
   did?: string;
+  // 2026-06-11: channel 级 persona + 关联文档 (从 ~/.bolloon/persona.json 复制或独立覆盖)
+  persona?: {
+    name?: string;
+    description?: string;
+    personality?: string;
+    greeting?: string;
+    capabilities?: string[];
+    interests?: string[];
+  };
+  // 关联的文档 ID 列表 (启动 LLM 时自动加载到 context)
+  linkedDocumentIds?: string[];
   publicKey?: string;
   cid?: string;
   /** 轻量引用：从 didDocument 只挑出 cid/ipnsName, 不存整份文档 */
@@ -419,8 +431,52 @@ let sseClients: Set<SSEClient> = new Set();
 // v3: 远端 channel UI 元数据缓存 — key: peerId, value: sanitize 过的 channel 列表
 // in-memory only, 进程重启清空 (judgment 内容永远不在这里)
 let remoteChannelCache: Map<string, Array<Record<string, unknown>>> = 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(): Promise<void> {
+  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 as Array<Record<string, unknown>>);
+        }
+      }
+      console.log(`[v3-meta] 从磁盘恢复 ${remoteChannelCache.size} 个 peer 的 channel cache`);
+    }
+  } catch (err) {
+    console.warn('[v3-meta] 恢复 remote channel cache 失败 (非致命):', (err as Error).message);
+  }
+}
+async function persistRemoteChannelCache(): Promise<void> {
+  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: Record<string, unknown> = {};
+    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 as Error).message);
+  }
+}
+// 启动时立即同步读一次 (异步, 不阻塞)
+loadRemoteChannelCacheFromDisk();
 // v3: P2PDirect 引用 (Hyperswarm 薄包装) - 模块级, 因为 web server 闭包里不可用
 let v3P2PRef: import('../network/p2p-direct.js').P2PDirect | null = null;
+// 2026-06-10: watchdog 提升到 module-level, 让 broadcast() / 模块级业务函数能埋点喂活动
+// 之前在 createWebServer 闭包内, 闭包外的 broadcast() 拿不到 → 误判 30min 无活动 → 自杀.
+let watchdogRef: any = null;
 // v3: 等待中的 history RPC (B 端 chat-history endpoint 用) — rpcId → { resolve, reject }
 const v3PendingHistoryGets: Map<string, { resolve: (data: any) => void; reject: (err: Error) => void }> = new Map();
 let channelSessions: Map<string, AgentSession> = new Map(); // key: channelId
@@ -461,7 +517,6 @@ function sanitizeChannelForPeer(
     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
   };
@@ -706,6 +761,15 @@ async function handleV3P2PMessage(parsed: any, conn: P2PConnection, comm: Hypers
         console.warn(`[v3] 存 user 消息失败 (不影响 chat):`, (saveErr as Error).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);
@@ -753,7 +817,13 @@ async function handleV3P2PMessage(parsed: any, conn: P2PConnection, comm: Hypers
       let fullResponse = '';
       // v3 新增: 流式 token 节流推给 B — 让 B 看到过程
       let lastFlushAt = 0;
+      let usedJudgmentIds: string[] = [];
       const streamCallback: any = (event: any) => {
+        // P0.5: 注入门回传
+        if (event?.type === 'used_judgments' && Array.isArray(event.usedIds)) {
+          usedJudgmentIds = event.usedIds;
+          return;
+        }
         if (event.type === 'token') {
           fullResponse += event.content;
           if (fullResponse.length - lastFlushAt >= 20) {
@@ -767,7 +837,7 @@ async function handleV3P2PMessage(parsed: any, conn: P2PConnection, comm: Hypers
         }
       };
       const agent = await getAgentForChannel(channelId, ch.did || '', ch.name, ch.didDocRef);
-      fullResponse = await agent.promptStream(fullPrompt, streamCallback);
+      fullResponse = await agent.promptStream(fullPrompt, streamCallback, undefined, channelId);
 
       // v3 新增: 存 A 的 assistant 消息到 session — B 拉历史时能看到完整对话
       try {
@@ -779,6 +849,7 @@ async function handleV3P2PMessage(parsed: any, conn: P2PConnection, comm: Hypers
           id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
           type: 'ai',
           content: fullResponse,
+          ...(usedJudgmentIds.length > 0 ? { metadata: { usedJudgmentIds } } : {}),
           timestamp: new Date().toISOString()
         });
         session.lastUpdated = new Date().toISOString();
@@ -788,6 +859,13 @@ async function handleV3P2PMessage(parsed: any, conn: P2PConnection, comm: Hypers
         console.warn(`[v3] 存 assistant 消息失败 (不影响):`, (saveErr as Error).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',
@@ -1100,6 +1178,18 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
     console.error('[警告] 未处理的 Promise 拒绝:', reason);
   });
 
+  // Bolloon Bootstrap (幂等, 重复调不会重复挂定时器)
+  // 这里独立调一次以保证 CLI-only 模式 (无 index.ts 引导) 也能 bootstrap
+  try {
+    const { bootstrapBolloon } = await import(
+      '../pi-ecosystem-judgment/human-value-pipeline.js'
+    );
+    const bs = await bootstrapBolloon({ cwd: process.cwd() });
+    console.log(`[createWebServer] bootstrap 完成 (${bs.durationMs}ms)`);
+  } catch (err) {
+    console.warn('[createWebServer] bootstrap 失败 (非致命):', err);
+  }
+
   // 重置旧的 agent session，确保使用新的 LLM 配置
   const { resetAgentSession } = await import('../agents/pi-sdk.js');
   resetAgentSession();
@@ -1116,6 +1206,47 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
   };
   let p2pCommunicator: HyperswarmCommunicator | null = 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 is Record<string, unknown> => 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 身份...');
 
@@ -1218,6 +1349,83 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
                 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 as Error).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 as Error).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 is Record<string, unknown> => 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 as Error).message));
+              return;
+            }
             handleV3P2PMessage(parsed, { id: evt.fromPublicKey, publicKey: evt.fromPublicKey } as any, commShim as any);
           }
         } catch (err) {
@@ -1227,6 +1435,8 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
 
       // 新连接进来 → 主动发我分享给 ta 的 channel 列表
       v3P2PRef.on('connection', (evt: any) => {
+        // 2026-06-10: 喂 watchdog —— 新连接到来是真实业务活动
+        watchdogRef?.recordActivity?.();
         setTimeout(async () => {
           try {
             const channels = await loadChannels();
@@ -1266,38 +1476,46 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
           }
           // 触发一次 broadcast 推送给所有重连的 peer
           setTimeout(() => v3BroadcastOwn(), 2000);
+          // 2026-06-10: 同时主动请求每个 known peer 把 ta 的 channel 列表推过来
+          // 避免对面 publicKey 没变但 cache 丢了(本机重启) → 一直空
+          setTimeout(() => requestChannelsFromAllPeers(), 3500);
         } catch (err) {
           console.error('[v3] 自动重连失败:', (err as Error).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 as Error).message);
+        }
+      }
+      // 立即跑一次 + 每 30s 兜底 (跟 v3BroadcastOwn 一样的节奏)
+      setTimeout(requestChannelsFromAllPeers, 4000);
+      setInterval(requestChannelsFromAllPeers, 30000);
     } catch (err) {
       console.error('[v3] P2PDirect 启动失败:', (err as Error).message);
       v3P2PRef = null;
     }
 
-    // v3: 定期 broadcast — 每个 peer 只收到分享给他的 channel (按 peer 个性化)
-    const v3BroadcastOwn = () => {
-      if (!v3P2PRef) return;
-      loadChannels().then(channels => {
-        const conns = (v3P2PRef as any).conns as Map<string, any>;
-        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 is Record<string, unknown> => 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 as Error).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 {
@@ -1378,7 +1596,10 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
     const channelId = req.query.channelId as string;
     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();
@@ -1414,6 +1635,14 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
 
     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;
@@ -1421,11 +1650,42 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
     // 捕获外层 channel 到独立变量, 避免被 try 块内 (line 740+) 的 const channel 遮蔽
     const channelForJudgment = channel;
 
+    // per-channel queue 检查: 已在跑就入队, 等当前跑完自动接上
+    const runState = getOrCreateRunState(channelId);
+    if (runState.running) {
+      runState.queue.push({ channelId, text, boundWalletAddress, autoToolsEnabled });
+      broadcastQueueUpdate(channelId);
+      console.log(`[queue] /message 入队 channel=${channelId}, queue len=${runState.queue.length}`);
+      return;
+    }
+    runState.running = true;
+    runState.abortController = new AbortController();
+    broadcastQueueUpdate(channelId);
+
     try {
       const agent = await getAgentForChannel(channelId, realChannelDid, realChannelName, realChannelDidDoc);
       let fullResponse = '';
+      // P0.5: 注入门回传的 usedIds, 落 session message metadata, UI 可查
+      let usedJudgmentIds: string[] = [];
 
       const streamCallback: StreamCallback = (event: StreamEvent) => {
+        // P0.5: 捕获注入门回传
+        if ((event as any).type === 'used_judgments' && Array.isArray((event as any).usedIds)) {
+          usedJudgmentIds = (event as any).usedIds;
+          // 同步推给前端 (用于 finalizeTimelineAsMessage 时给 addMessage 传 usedIds)
+          broadcast({ type: 'used_judgments', usedIds: usedJudgmentIds }, channelId);
+          return;
+        }
+        // 阶段事件 (注入门 / D 触发)
+        if ((event as any).type === 'phase') {
+          broadcast({
+            type: 'phase',
+            phase: (event as any).phase,
+            detail: (event as any).detail,
+            usedCount: (event as any).usedCount,
+          }, channelId);
+          return;
+        }
         // 同时发送给流式显示和工作流显示
         if (event.type === 'token' || event.type === 'thinking') {
           broadcast({ type: 'stream', streamType: event.type, content: event.content }, channelId);
@@ -1463,6 +1723,101 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
       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 as Error).message);
+        }
+      }
+
       // v3 新增: 注入"可用渠道"目录, 让 LLM 知道可以 @-mention 哪些 channel
       // - 本地 channels (除了自己)
       // - 远端 channels (remoteChannelCache 缓存的)
@@ -1481,11 +1836,31 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
         for (const c of remoteChannels) {
           contextHint += `  - [远端, owner=${(c._ownerPublicKey || '').substring(0,8)}…] @${c.name} (id=${c.id})\n`;
         }
-        contextHint += '语法: 当你想给其他渠道发消息, 在回复中写 "@渠道名 我要说的话" 即可. 消息会持久化到目标 channel 的 session, 你之后能看到"自己"在那里说的话.\n\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);
+      try {
+        fullResponse = await agent.promptStream(contextHint + text, streamCallback, runState.abortController?.signal, channelId);
+      } catch (err: any) {
+        // abort 抛错: 保留已输出的部分 (fullResponse 可能是空字符串)
+        if (runState.abortController?.signal.aborted || err?.name === 'AbortError') {
+          console.log(`[chat] aborted channel=${channelId}`);
+        } else {
+          throw err;
+        }
+      }
+      // abort 模式: 给 partial 拼后缀
+      if (runState.abortController?.signal.aborted && fullResponse.trim().length > 0) {
+        fullResponse = fullResponse + '\n\n_[生成已中断]_';
+      }
 
       // v3 新增: 解析 LLM 回复里的 @-mentions, 转发到目标 channel
       await routeMentionsInReply(channelId, fullResponse, localChannels, remoteChannels);
@@ -1497,31 +1872,85 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
       session.sessionId = currentSessionId;
       // v3: 加 source 标记 (local = 内部 owner, remote = 远端访客)
       session.messages.push({ id: crypto.randomUUID(), type: 'user' as const, content: text, timestamp: new Date().toISOString(), source: 'local' as any });
-      session.messages.push({ id: crypto.randomUUID(), type: 'ai' as const, content: fullResponse, timestamp: new Date().toISOString(), source: 'local' as any });
+      session.messages.push({
+        id: crypto.randomUUID(),
+        type: 'ai' as const,
+        content: fullResponse,
+        timestamp: new Date().toISOString(),
+        source: 'local' as any,
+        // P0.5: 这条 AI 回复引用了哪些 judgment (注入门回传)
+        ...(usedJudgmentIds.length > 0 ? { metadata: { usedJudgmentIds } } : {}),
+      });
       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 });
+
+      // D 触发: AI 被动捕获判断力 (后台异步, 不阻塞主对话)
+      setImmediate(() => {
+        try {
+          const lastTurns = session.messages.slice(-6).map((m) => ({
+            role: (m.type === 'user' ? 'human' : 'agent') as 'human' | 'agent',
+            content: m.content,
+          }));
+          if (lastTurns.length < 2) return;
+          broadcast({ type: 'phase', phase: 'd_detect', detail: '监测对话...' }, channelId);
+          import('../pi-ecosystem-judgment/human-value-pipeline.js')
+            .then(async ({ detectAndDistillFromChannel, throttleDHook }) => {
+              // channel 维度 5min 节流, 防对话卡顿时 LLM 反复触发
+              if (!throttleDHook(channelId, 5 * 60_000)) {
+                console.log(`[D-hook ${channelId}] throttled (within 5min)`);
+                broadcast({ type: 'phase', phase: 'd_skip', detail: 'throttled' }, channelId);
+                return null;
+              }
+              broadcast({ type: 'phase', phase: 'd_distill', detail: '蒸馏判断力...' }, channelId);
+              return detectAndDistillFromChannel(lastTurns, { channelId });
+            })
+            .then((result) => {
+              if (result && result.triggered) {
+                console.log(
+                  `[D-hook ${channelId}] stored: ${result.reason}`,
+                  result.evolved
+                );
+                broadcast({ type: 'phase', phase: 'd_done', detail: result.reason }, channelId);
+              } else if (result && result.reason) {
+                console.log(`[D-hook ${channelId}] skipped: ${result.reason}`);
+                broadcast({ type: 'phase', phase: 'd_skip', detail: result.reason }, channelId);
+              }
+            })
+            .catch((err) => {
+              console.warn(`[D-hook ${channelId}] failed:`, err);
+              broadcast({ type: 'phase', phase: 'd_error', detail: String(err) }, channelId);
+            });
+        } catch (err) {
+          console.warn(`[D-hook ${channelId}] sync error:`, err);
+        }
+      });
+
+      // 2026-06-11: 202 已发的话, 不要重复 res.json (会抛 ERR_HTTP_HEADERS_SENT)
+      if (!res.headersSent) res.json({ ok: true });
     } catch (err: any) {
       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 });
+    } finally {
+      // queue dequeue: 跑完或失败都要清状态
+      // 当前实现: 自动接下一条需要把 ~200 行 try 块抽函数, 暂不抽.
+      // 替代: 用户点 [队列 +N] 按钮时, 客户端发起一个特殊的 HTTP 请求触发下一条
+      // (在 client.js 实现). 这里只清状态 + 广播.
+      runState.running = false;
+      runState.abortController = null;
+      broadcastQueueUpdate(channelId);
     }
   });
 
@@ -1533,6 +1962,36 @@ export async function createWebServer(port: number = 3000, options: CreateWebSer
   let didFixRunning = false;
   let didFixTimer: NodeJS.Timeout | null = null;
 
+  // ---------- per-channel 消息 queue + abort 状态 ----------
+  // 同 channel 串行 (避免 LLM 调用互踩上下文), 跨 channel 互不干扰
+  interface PendingMessage {
+    channelId: string;
+    text: string;
+    boundWalletAddress?: string;
+    autoToolsEnabled?: boolean;
+    // (req, res 已经在 /message 里 res.status(202) 返回, 入队的只是要重跑的内容参数)
+  }
+  interface ChannelRunState {
+    running: boolean;
+    queue: PendingMessage[];
+    abortController: AbortController | null;
+  }
+  const channelRunState: Map<string, ChannelRunState> = new Map();
+  function getOrCreateRunState(channelId: string): ChannelRunState {
+    let s = channelRunState.get(channelId);
+    if (!s) {
+      s = { running: false, queue: [], abortController: null };
+      channelRunState.set(channelId, s);
+    }
+    return s;
+  }
+  function broadcastQueueUpdate(channelId: string): void {
+    const s = channelRunState.get(channelId);
+    const queueLength = s ? s.queue.length : 0;
+    const running = s ? s.running : false;
+    try { broadcast({ type: 'queue_update', channelId, queueLength, running }, channelId); } catch { /* */ }
+  }
+
   function scheduleDidFix(channelId: string) {
     didFixQueue.add(channelId);
     if (didFixTimer) return;
@@ -1649,9 +2108,21 @@ app.get('/channels', async (_req, res) => {
   // v3: 列出本节点缓存的远端 channel (按 peerId 分组)
   app.get('/api/remote-channels', async (_req, res) => {
     try {
-      const out: Array<{ peerId: string; channels: Array<Record<string, unknown>> }> = [];
+      const out: Array<{ peerId: string; channels: Array<Record<string, unknown>>; peerName?: string }> = [];
+      // 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<string, { name?: string }>();
+      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 });
     } catch (err: any) {
@@ -1659,6 +2130,27 @@ app.get('/channels', async (_req, res) => {
     }
   });
 
+  // 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: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   // v3: 主动向所有已连接 P2P peer 拉 channel 列表
   // 用法: B 端用户点 "刷新远端智能体" → 触发本 endpoint
   app.post('/api/remote-channels/refresh', async (_req, res) => {
@@ -1738,7 +2230,7 @@ app.get('/channels', async (_req, res) => {
 
   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' });
@@ -1754,6 +2246,42 @@ app.get('/channels', async (_req, res) => {
         ? bound_judgment_ids.filter((x: unknown) => typeof x === 'string' && (x as string).length > 0)
         : [];
 
+      // 2026-06-11: persona 加载 — 优先用 personaOverride, 否则从 ~/.bolloon/persona.json 读全局默认
+      let channelPersona: Channel['persona'];
+      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 as Error).message);
+        }
+      }
+
+      // 过滤 linkedDocumentIds: 只保留 string
+      const safeLinkedDocIds = Array.isArray(linkedDocumentIds)
+        ? linkedDocumentIds.filter((x: unknown) => typeof x === 'string' && (x as string).length > 0).slice(0, 50)
+        : [];
+
       // 先创建频道（不阻塞等待 DID 生成）
       const channel: Channel = {
         id,
@@ -1766,6 +2294,8 @@ app.get('/channels', async (_req, res) => {
         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(),
@@ -1944,7 +2474,7 @@ app.get('/channels', async (_req, res) => {
   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) {
@@ -1953,6 +2483,25 @@ app.get('/channels', async (_req, res) => {
       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: unknown) => typeof x === 'string' && (x as string).length > 0).slice(0, 50);
+      }
       // walletAddress 允许 null/'' 来解绑
       if (walletAddress !== undefined) {
         if (walletAddress === null || walletAddress === '') {
@@ -2003,6 +2552,10 @@ app.get('/channels', async (_req, res) => {
       }
       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: any) {
       res.status(500).json({ error: err.message });
@@ -2154,8 +2707,14 @@ app.get('/channels', async (_req, res) => {
 
       const agent = await getAgentForChannel(channelId, realChannelDid, realChannelName, realChannelDidDoc);
       let fullResponse = '';
+      let usedJudgmentIds: string[] = [];
 
       const streamCallback: StreamCallback = (event: StreamEvent) => {
+        // P0.5: 注入门回传
+        if ((event as any).type === 'used_judgments' && Array.isArray((event as any).usedIds)) {
+          usedJudgmentIds = (event as any).usedIds;
+          return;
+        }
         if (event.type === 'token' || event.type === 'thinking') {
           broadcast({ type: 'stream', streamType: event.type, content: event.content }, channelId);
         } else if (event.type === 'status' || event.type === 'tool') {
@@ -2167,7 +2726,7 @@ app.get('/channels', async (_req, res) => {
 
       // 重新生成时只发送用户消息 (v3: 同时注入 channel 绑定的判断力)
       const regenHint = await buildJudgmentHint(channel, channelId);
-      fullResponse = await agent.promptStream(regenHint + userMessage, streamCallback);
+      fullResponse = await agent.promptStream(regenHint + userMessage, streamCallback, undefined, channelId);
 
       broadcast({ type: 'ai', content: fullResponse }, channelId);
 
@@ -2183,7 +2742,8 @@ app.get('/channels', async (_req, res) => {
           id: crypto.randomUUID(),
           type: 'ai' as const,
           content: fullResponse,
-          timestamp: new Date().toISOString()
+          timestamp: new Date().toISOString(),
+          ...(usedJudgmentIds.length > 0 ? { metadata: { usedJudgmentIds } } : {}),
         });
         existingSession.lastUpdated = new Date().toISOString();
         await saveSession(existingSession);
@@ -2728,13 +3288,24 @@ app.get('/channels', async (_req, res) => {
     }
   });
 
-  // 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: any) {
       res.status(500).json({ error: err.message });
     }
@@ -2774,6 +3345,37 @@ app.get('/channels', async (_req, res) => {
       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: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
 
   // v3: 主动 connect 到对端的 P2PDirect publicKey
   // 用法: POST /api/remote-channels/p2p-connect { targetPublicKey: "<hex>" }
@@ -2812,6 +3414,93 @@ app.get('/channels', async (_req, res) => {
     }
   });
 
+  // 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 as any).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: any) {
+      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 as any).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: any) {
+      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 }
@@ -2839,6 +3528,8 @@ app.get('/channels', async (_req, res) => {
           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 });
     } catch (err: any) {
@@ -3470,6 +4161,23 @@ app.get('/channels', async (_req, res) => {
     }
   });
 
+  // 终止当前 channel 的 LLM 流 (UI 终止按钮)
+  app.post('/api/chat/abort', async (req, res) => {
+    try {
+      const { channelId } = req.body as { channelId?: string };
+      if (!channelId) return res.status(400).json({ error: 'channelId required' });
+      const s = channelRunState.get(channelId);
+      if (s?.abortController) {
+        s.abortController.abort();
+        console.log(`[abort] user aborted channel=${channelId}`);
+        return res.json({ ok: true, aborted: true });
+      }
+      res.json({ ok: true, aborted: false });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   // 主人审阅: 批准 draft
   app.post('/api/chat/approve', async (req, res) => {
     try {
@@ -3785,6 +4493,8 @@ app.get('/channels', async (_req, res) => {
     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) {
@@ -3883,22 +4593,432 @@ app.get('/channels', async (_req, res) => {
     }
   });
 
-  app.get('/api/judgments', async (_req, res) => {
+  app.get('/api/judgments', async (req, res) => {
     try {
-      const { loadAllJudgments, initializeValueStore } = await import(
+      const { listJudgmentsByStatus, initializeValueStore } = await import(
         '../pi-ecosystem-judgment/human-value-store.js'
       );
       await initializeValueStore();
-      const all = await loadAllJudgments();
-      // 新的在前
+      const status = (typeof req.query.status === 'string' ? req.query.status : 'all') as
+        | 'active'
+        | 'pending'
+        | 'superseded'
+        | 'rejected'
+        | 'all';
+      const all = await listJudgmentsByStatus(status);
       all.sort((a, b) => (b.timestamp || '').localeCompare(a.timestamp || ''));
-      res.json({ count: all.length, judgments: all });
+      res.json({ count: all.length, status, judgments: all });
     } catch (err: any) {
       console.error('[judgments] GET failed:', err);
       res.status(500).json({ error: err.message });
     }
   });
 
+  // 蒸馏 B 触发 (人类点按钮) — 同步执行演化对齐
+  app.post('/api/judgments/distill-from-conversation', async (req, res) => {
+    try {
+      const { channelId, messageId, recentTurns } = req.body as {
+        channelId?: string;
+        messageId?: string;
+        recentTurns?: number;
+      };
+      if (!channelId) {
+        return res.status(400).json({ error: 'channelId required' });
+      }
+
+      // 取 channel 最近的对话
+      const channels = await loadChannels();
+      const channel = channels.find((c) => c.id === channelId);
+      if (!channel) return res.status(404).json({ error: 'channel not found' });
+
+      const currentSessionId = channel.currentSessionId;
+      if (!currentSessionId) {
+        return res.status(400).json({ error: 'no active session in channel' });
+      }
+      const session = await loadSession(channelId, currentSessionId);
+      if (!session) return res.status(404).json({ error: 'session not found' });
+
+      // 取最近 N 轮 (默认 10), 转成 DistillTurn 格式
+      const limit = Math.min(Math.max(recentTurns ?? 10, 2), 30);
+      const turns = session.messages.slice(-limit).map((m) => ({
+        role: (m.type === 'user' ? 'human' : 'agent') as 'human' | 'agent',
+        content: m.content,
+      }));
+
+      const { distillAndStoreFromChannel } = await import(
+        '../pi-ecosystem-judgment/human-value-pipeline.js'
+      );
+      const result = await distillAndStoreFromChannel(turns, { channelId });
+
+      res.json({
+        ok: true,
+        triggered: result.triggered,
+        reason: result.reason,
+        judgment: result.judgment,
+        evolved: result.evolved,
+      });
+    } catch (err: any) {
+      console.error('[judgments] distill-from-conversation failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 蒸馏 D 触发 (AI 被动) — 后台异步,不阻塞 HTTP 响应
+  app.post('/api/judgments/detect-and-distill', async (req, res) => {
+    try {
+      const { channelId, turns } = req.body as {
+        channelId?: string;
+        turns?: Array<{ role: 'human' | 'agent'; content: string }>;
+      };
+
+      // 先立即返回 202, 不等 LLM
+      res.status(202).json({ ok: true, queued: true });
+
+      if (!channelId || !Array.isArray(turns) || turns.length === 0) {
+        return;
+      }
+
+      // 异步处理 (不 await, 不阻塞响应)
+      setImmediate(async () => {
+        try {
+          const { detectAndDistillFromChannel } = await import(
+            '../pi-ecosystem-judgment/human-value-pipeline.js'
+          );
+          const result = await detectAndDistillFromChannel(turns, { channelId });
+          if (result.triggered) {
+            console.log(`[D-hook] ${channelId}: ${result.reason}`, result.evolved);
+          }
+        } catch (err) {
+          console.warn('[D-hook] background failed:', err);
+        }
+      });
+    } catch (err: any) {
+      console.error('[judgments] detect-and-distill failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 判断力使用回溯 (P0.5): 给定 judgmentIds, 反查对应的 decision 文本
+  // 用途: UI 上"这条 AI 回复引用了哪些原则"
+  app.post('/api/judgments/resolve-usage', async (req, res) => {
+    try {
+      const { ids } = req.body as { ids?: string[] };
+      if (!Array.isArray(ids) || ids.length === 0) {
+        return res.json({ items: [] });
+      }
+      const { loadAllJudgments } = await import(
+        '../pi-ecosystem-judgment/human-value-store.js'
+      );
+      const all = await loadAllJudgments();
+      const byId = new Map(all.map((j) => [j.id, j]));
+      const items = ids
+        .map((id) => byId.get(id))
+        .filter((j): j is NonNullable<typeof j> => Boolean(j))
+        .map((j) => ({
+          id: j.id,
+          decision: j.decision,
+          status: j.status ?? 'active',
+          timestamp: j.timestamp,
+        }));
+      res.json({ items });
+    } catch (err: any) {
+      console.error('[judgments] resolve-usage failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 判断力违规日志 (P3 UI): 读 violations.jsonl
+  app.get('/api/judgments/violations', async (req, res) => {
+    try {
+      const { getRecentViolations } = await import(
+        '../pi-ecosystem-judgment/monitor-gate.js'
+      );
+      const limit = Math.min(Math.max(parseInt(String(req.query.limit ?? '20'), 10) || 20, 1), 200);
+      const items = await getRecentViolations(limit);
+      res.json({ count: items.length, items });
+    } catch (err: any) {
+      console.error('[judgments] violations failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 类 B 自适应扫描: 读 judgments.json + usage.jsonl, 给出 stale/rising/unused 建议
+  // ?force=1 跳过 24h 缓存
+  app.get('/api/judgments/adaptive-suggestions', async (req, res) => {
+    try {
+      const { getCachedScan } = await import(
+        '../pi-ecosystem-judgment/adaptive-scan.js'
+      );
+      const force = String(req.query.force ?? '') === '1';
+      const result = await getCachedScan(force);
+      res.json(result);
+    } catch (err: any) {
+      console.error('[judgments] adaptive-scan failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // Bootstrap Context 调试视图: 返出完整 BolloonContext
+  app.get('/api/bolloon/context', async (req, res) => {
+    try {
+      const { getCachedBolloonContext } = await import(
+        '../pi-ecosystem-judgment/human-value-pipeline.js'
+      );
+      const force = String(req.query.force ?? '') === '1';
+      const ctx = await getCachedBolloonContext({ cwd: process.cwd() }, force);
+      res.json(ctx);
+    } catch (err: any) {
+      console.error('[bolloon] context failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 阶段 B: 周报 (weekly-report.ts 产物) — 仅 API 读取, 不做 UI tab
+  // GET /api/reports           → { files: ['2026-W24.md', ...] }
+  // GET /api/reports/2026-W24  → { week, content }
+  app.get('/api/reports', async (_req, res) => {
+    try {
+      const dir = path.join(os.homedir(), '.bolloon', 'reports');
+      try {
+        const entries = await fs.readdir(dir);
+        const files = entries
+          .filter((f) => f.endsWith('.md'))
+          .sort()
+          .reverse(); // 新的在前
+        res.json({ dir, files });
+      } catch {
+        res.json({ dir, files: [] });
+      }
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/reports/:week', async (req, res) => {
+    try {
+      const week = req.params.week;
+      // 严格校验, 防路径穿越
+      if (!/^\d{4}-W\d{1,2}$/.test(week)) {
+        return res.status(400).json({ error: 'week must match YYYY-Www' });
+      }
+      const file = path.join(os.homedir(), '.bolloon', 'reports', `${week}.md`);
+      try {
+        const content = await fs.readFile(file, 'utf-8');
+        res.json({ week, content, length: content.length });
+      } catch {
+        res.status(404).json({ error: 'not found', week });
+      }
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 阶段 C 护栏 5: auto-evolve baseline 管理 (无 UI, 仅 API)
+  // GET    /api/auto-evolve/baselines             → 列出所有 baseline tag
+  // GET    /api/auto-evolve/baselines/:tag/diff  → 看某 baseline 的 diff 摘要
+  // POST   /api/auto-evolve/rollback {tag}       → 回滚到指定 baseline
+  app.get('/api/auto-evolve/baselines', async (_req, res) => {
+    try {
+      const { execFile } = await import('child_process');
+      const { promisify } = await import('util');
+      const pExec = promisify(execFile);
+      const { stdout } = await pExec('git', [
+        'tag', '-l', 'auto-evolve-baseline-*', '--format=%(refname:short)|%(contents)|%(objectname:short)|%(taggerdate:iso)',
+      ], { cwd: process.cwd() });
+      const tags = stdout.trim().split('\n').filter(Boolean).map((line) => {
+        const [tag, msg, sha, date] = line.split('|');
+        return { tag, message: msg || '', sha, date };
+      });
+      res.json({ tags, count: tags.length });
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/auto-evolve/baselines/:tag/diff', async (req, res) => {
+    try {
+      const { execFile } = await import('child_process');
+      const { promisify } = await import('util');
+      const pExec = promisify(execFile);
+      const tag = req.params.tag;
+      if (!/^auto-evolve-baseline-[\w-]+$/.test(tag)) {
+        return res.status(400).json({ error: 'tag must match auto-evolve-baseline-*' });
+      }
+      const { stdout } = await pExec('git', ['show', '--stat', '--no-color', tag], { cwd: process.cwd() });
+      res.json({ tag, diff: stdout.slice(0, 5000) }); // 限长 5KB
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // Bootstrap Context → 拼好的 system prompt 片段 (供调试看注入效果)
+  app.get('/api/bolloon/context/system-prompt', async (req, res) => {
+    try {
+      const { getCachedBolloonContext } = await import(
+        '../pi-ecosystem-judgment/human-value-pipeline.js'
+      );
+      const { formatContextForSystemPrompt } = await import(
+        '../bootstrap/project-context.js'
+      );
+      const ctx = await getCachedBolloonContext({ cwd: process.cwd() });
+      const systemAddition = formatContextForSystemPrompt(ctx, {
+        maxChars: parseInt(String(req.query.max ?? '4000'), 10) || 4000,
+      });
+      res.json({ systemAddition, length: systemAddition.length, truncated: systemAddition.includes('截断模式') });
+    } catch (err: any) {
+      console.error('[bolloon] context/system-prompt failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 自适应接受/拒绝: 写 evolution.jsonl 留痕, 接受时同时 patch judgments.json
+  // body: { action: 'accept'|'reject'|'revert', suggestion, appliedPatch? }
+  // query: ?auto=1  → 类 B 自动路径, 受 auto-evolve-policy 网关保护
+  //         缺省    → 用户在 UI 手动触发, 不查开关 (避免阻塞用户)
+  app.post('/api/judgments/adaptive-apply', async (req, res) => {
+    try {
+      const isAuto = req.query.auto === '1' || req.query.auto === 'true';
+      const { action, suggestion, appliedPatch } = req.body as {
+        action: 'accept' | 'reject' | 'revert';
+        suggestion: { judgmentId: string; kind: string; decision: string; reason: string; action: string; metrics: unknown; scannedAt: string; key: string };
+        appliedPatch?: Record<string, unknown>;
+      };
+      if (!action || !suggestion?.judgmentId) {
+        return res.status(400).json({ error: 'action and suggestion.judgmentId required' });
+      }
+      const { updateJudgmentStatus } = await import(
+        '../pi-ecosystem-judgment/human-value-store.js'
+      );
+      const { logEvolution } = await import(
+        '../pi-ecosystem-judgment/adaptive-scan.js'
+      );
+      // accept 时: 真正改库
+      if (action === 'accept') {
+        // 阶段 A: 自动路径需先过 auto-evolve-policy 网关
+        if (isAuto) {
+          const { requireDataLayerAutoEvolve } = await import(
+            '../utils/auto-evolve-policy.js'
+          );
+          try {
+            await requireDataLayerAutoEvolve('adaptive-apply.auto.deprecate');
+          } catch (err: any) {
+            return res.status(423).json({
+              error: 'data-layer-auto-evolve-disabled',
+              message: err.message,
+              hint: '设 BOLLOON_AUTO_EVOLVE_DATA=1 或在 self-improve-policy.json 加 dataLayerAutoEvolve: true',
+            });
+          }
+        }
+        if (suggestion.action === 'deprecate') {
+          // 标记 superseded (语义: 不再用, 但保留可回滚)
+          await updateJudgmentStatus(suggestion.judgmentId, 'superseded', {
+            evolutionReason: 'merged', // 借 merged 字段表达"被自适应废弃"
+          });
+        } else if (suggestion.action === 'boost') {
+          // boost: 用户手动接受后, 不改库本身 (weight 在 getRelevantValues 里动态算),
+          // 但写 evolution 留痕, 未来可以基于此调整算法
+          // 当前不直接改库, 仅留痕
+        }
+        // 'review' 类不需要自动改库, 仅 log 接受
+      }
+      await logEvolution({
+        ts: new Date().toISOString(),
+        action,
+        suggestion: suggestion as any,
+        appliedPatch,
+      });
+      res.json({ ok: true });
+    } catch (err: any) {
+      console.error('[judgments] adaptive-apply failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 演化日志 (audit / 一键回滚源)
+  app.get('/api/judgments/evolution-log', async (req, res) => {
+    try {
+      const { readEvolutionLog } = await import(
+        '../pi-ecosystem-judgment/adaptive-scan.js'
+      );
+      const limit = Math.min(Math.max(parseInt(String(req.query.limit ?? '50'), 10) || 50, 1), 200);
+      const items = await readEvolutionLog(limit);
+      res.json({ count: items.length, items });
+    } catch (err: any) {
+      console.error('[judgments] evolution-log failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // 阶段 2: Causal-judge 4 个 endpoint
+  app.get('/api/judgments/causal/correlation', async (req, res) => {
+    try {
+      const { runCorrelationAnalysis } = await import(
+        '../pi-ecosystem-judgment/human-value-pipeline.js'
+      );
+      const topN = Math.min(Math.max(parseInt(String(req.query.topN ?? '5'), 10) || 5, 1), 50);
+      const useLLM = String(req.query.useLLM ?? '1') !== '0';
+      const items = await runCorrelationAnalysis({ topN, useLLM });
+      res.json({ count: items.length, items });
+    } catch (err: any) {
+      console.error('[causal] correlation failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/judgments/causal/intervention', async (req, res) => {
+    try {
+      const { runIntervention } = await import(
+        '../pi-ecosystem-judgment/human-value-pipeline.js'
+      );
+      const { judgmentId, scenario } = req.query as { judgmentId?: string; scenario?: string };
+      if (!judgmentId) return res.status(400).json({ error: 'judgmentId required' });
+      const result = await runIntervention(judgmentId, { scenarioContext: scenario });
+      res.json(result);
+    } catch (err: any) {
+      console.error('[causal] intervention failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/judgments/causal/counterfactual', async (req, res) => {
+    try {
+      const { runCounterfactualAudit } = await import(
+        '../pi-ecosystem-judgment/human-value-pipeline.js'
+      );
+      const { userInput, aiReply, violatedPrinciples } = req.body as {
+        userInput?: string;
+        aiReply?: string;
+        violatedPrinciples?: Array<{ principle: string; reason: string }>;
+      };
+      if (!userInput || !aiReply) {
+        return res.status(400).json({ error: 'userInput and aiReply required' });
+      }
+      const audit = await runCounterfactualAudit({
+        userInput,
+        aiReply,
+        violatedPrinciples: violatedPrinciples ?? [],
+      });
+      res.json(audit);
+    } catch (err: any) {
+      console.error('[causal] counterfactual failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/judgments/causal/audit-log', async (req, res) => {
+    try {
+      const { readCounterfactualLog } = await import(
+        '../pi-ecosystem-judgment/human-value-pipeline.js'
+      );
+      const limit = Math.min(Math.max(parseInt(String(req.query.limit ?? '20'), 10) || 20, 1), 200);
+      const items = await readCounterfactualLog(limit);
+      res.json({ count: items.length, items });
+    } catch (err: any) {
+      console.error('[causal] audit-log failed:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   // 导入判断: 接受 { filename, content (base64), context }.
   // 支持 .json / .yaml / .yml / .md / .txt / .html. 完全离线解析, 不调 LLM.
   // 解析规则:
@@ -4138,8 +5258,12 @@ app.get('/channels', async (_req, res) => {
     // 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');
@@ -4299,6 +5423,8 @@ app.get('/channels', async (_req, res) => {
 }
 
 function broadcast(data: { type: string; [key: string]: unknown }, channelId?: string) {
+  // 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}`);