@bolloon/bolloon-agent 0.1.23 → 0.1.24

package/dist/web/iroh-delegate-transport.js

@@ -0,0 +1,125 @@
+/**
+ * iroh-delegate-transport — 把 irohTransport 适配成 DelegateTransport 抽象
+ *
+ * 目的: 让 agent-delegate-server 可以挂到 iroh transport 上, 而不是只在 Hyperswarm 测试里跑.
+ *
+ * 注意命名坑:
+ *   - DelegateTransport.sendToNode 用的是 "publicKey" (Hyperswarm 测试用 Hyperswarm 公钥)
+ *   - iroh 路径里我们没有 "publicKey", 只有 nodeId (string)
+ *   - 这里我们把 iroh nodeId 直接当作 publicKey 字段传入. 调用方 (/api/agent/delegate) 的
+ *     toPublicKey 参数实际上对应的就是 iroh 目标 nodeId.
+ *   - DIAP 真实 did:key 与 iroh nodeId 的映射关系另由 agent-manifest 协议承担
+ *     (manifest_payload.ownerPublicKey 字段), 后续在 manifest cache 里维护.
+ */
+import { irohTransport } from '../network/iroh-transport.js';
+import { parseFrame } from '../agents/agent-manifest-protocol.js';
+/**
+ * 构造一个基于 irohTransport 的 DelegateTransport 实现.
+ *
+ * sendToNode: 用 irohTransport.sendMessage 发送 frame, 然后用 requestResponse 等待
+ *             对端 via onIncomingFrame 注册的 handler 写回.
+ *             由于 iroh 1-shot 消息没有 req/resp 关联, 这里用 'agent_request' 类型
+ *             包一层, 在 onMessage('agent_request') 内部复用现有 handler, 拿到 reply
+ *             再用 'agent_response' 单播回原 node.
+ *
+ * onIncomingFrame: 把对方发的 manifest_request / manifest_payload / agent_delegate
+ *             类型消息路由到 agent-delegate-server 注册的 handler.
+ */
+export function createIrohDelegateTransport(opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 30000;
+    const verbose = opts.verbose ?? false;
+    let incomingHandler = null;
+    // 单播回包映射: requestId -> resolver
+    const pendingReplies = new Map();
+    // 启动时挂一次 onMessage 监听 (重复挂也只会换 handler, 不重复触发)
+    irohTransport.onMessage('agent_request', async (msg) => {
+        if (!incomingHandler)
+            return;
+        const f = parseFrame(new TextDecoder().decode(msg.payload));
+        if (!f)
+            return;
+        const fromKey = msg.from;
+        const reply = await incomingHandler(fromKey, new TextDecoder().decode(msg.payload));
+        if (reply) {
+            try {
+                // 把 reply 也用 agent_response 类型发回去, requestId 透传
+                const replyFrame = JSON.parse(reply);
+                const reqId = f._reqId || replyFrame._reqId;
+                const tagged = reqId ? JSON.stringify({ ...replyFrame, _reqId: reqId }) : reply;
+                await irohTransport.sendMessage(fromKey, 'agent_response', new TextEncoder().encode(tagged));
+                if (verbose)
+                    console.log(`[iroh-delegate] 已回包给 ${fromKey.substring(0, 12)}... (${replyFrame.type})`);
+            }
+            catch (e) {
+                if (verbose)
+                    console.warn('[iroh-delegate] 回包失败:', e);
+            }
+        }
+    });
+    irohTransport.onMessage('agent_response', (msg) => {
+        const f = parseFrame(new TextDecoder().decode(msg.payload));
+        if (!f)
+            return;
+        const reqId = f._reqId;
+        if (!reqId)
+            return;
+        const pending = pendingReplies.get(reqId);
+        if (pending) {
+            clearTimeout(pending.timer);
+            pendingReplies.delete(reqId);
+            pending.resolve(JSON.stringify(f));
+        }
+    });
+    return {
+        sendToNode: async (publicKey, frame, timeoutOverrideMs) => {
+            const t = timeoutOverrideMs ?? timeoutMs;
+            const reqId = `req-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const tagged = JSON.stringify({ ...JSON.parse(frame), _reqId: reqId });
+            const payload = new TextEncoder().encode(tagged);
+            return new Promise(async (resolve) => {
+                const timer = setTimeout(() => {
+                    pendingReplies.delete(reqId);
+                    resolve(null);
+                }, t);
+                pendingReplies.set(reqId, { resolve, timer });
+                try {
+                    const ok = await irohTransport.sendMessage(publicKey, 'agent_request', payload);
+                    if (!ok) {
+                        clearTimeout(timer);
+                        pendingReplies.delete(reqId);
+                        resolve(null);
+                    }
+                }
+                catch (e) {
+                    if (verbose)
+                        console.warn('[iroh-delegate] 发送失败:', e);
+                    clearTimeout(timer);
+                    pendingReplies.delete(reqId);
+                    resolve(null);
+                }
+            });
+        },
+        onIncomingFrame: (handler) => {
+            incomingHandler = handler;
+        },
+    };
+}
+/**
+ * 把本地节点 manifest 注册到 agent-manifest 协议, 并写入本地缓存.
+ * 在 iroh 初始化完成时调用一次.
+ */
+export function registerLocalAgents(ownerName, ownerPublicKey, agents) {
+    // 动态导入避免循环引用
+    import('../agents/agent-manifest-protocol.js').then((mod) => {
+        mod.setLocalManifest({
+            ownerName,
+            ownerPublicKey,
+            agents: agents.map((a) => ({
+                id: a.id,
+                name: a.name,
+                capabilities: a.capabilities,
+                status: a.status || 'active',
+            })),
+        });
+    });
+}

package/dist/web/server.js

@@ -11,6 +11,8 @@ import { initMinimax, getMinimax } from '../constraints/index.js';
 import { createAgentSession } from '../agents/pi-sdk.js';
 import { llmConfigStore } from '../llm/config-store.js';
 import { irohTransport } from '../network/iroh-transport.js';
+import { createAgentDelegateApp } from './agent-delegate-server.js';
+import { createIrohDelegateTransport } from './iroh-delegate-transport.js';
 import { verifyMessage, isAddress, getAddress } from 'viem';
 // 前端资源路径：在打包后会通过 CommonJS require 加载，使用 import.meta.url
 const __filename = fileURLToPath(import.meta.url);
@@ -310,7 +312,9 @@ async function getAgentForChannel(channelId, channelDid, channelName, channelDid
     }
     return session;
 }
-export async function createWebServer(port = 3000) {
+let selfImproveEnabled = false;
+export async function createWebServer(port = 3000, options = {}) {
+    selfImproveEnabled = options.selfImprove ?? false;
     // 防止 P2P DHT 超时等错误导致进程崩溃
     process.on('unhandledRejection', (reason, promise) => {
         console.error('[警告] 未处理的 Promise 拒绝:', reason);
@@ -1489,6 +1493,17 @@ export async function createWebServer(port = 3000) {
                 initialized: true
             };
             irohInitialized = true;
+            // 挂载 agent-delegate app (manifest 协议 + agent_delegate)
+            // 必须在 irohInitialized 之后挂, 因为适配器要监听 irohTransport.onMessage
+            try {
+                const delegateTransport = createIrohDelegateTransport({ verbose: true });
+                const delegateApp = createAgentDelegateApp(delegateTransport);
+                app.use('/api/agent', delegateApp);
+                console.log('[iroh API] agent-delegate app 已挂载到 /api/agent');
+            }
+            catch (e) {
+                console.error('[iroh API] 挂载 agent-delegate app 失败:', e);
+            }
             // 设置消息处理
             irohTransport.onMessage('chat', (msg) => {
                 const content = new TextDecoder().decode(msg.payload);
@@ -2177,6 +2192,294 @@ export async function createWebServer(port = 3000) {
             res.status(500).json({ error: err.message });
         }
     });
+    // ==================== Judgments (v1 核心: 让我能记录判断) ====================
+    // POST /api/judgments       — 记录一个判断
+    // GET  /api/judgments       — 列出所有判断 (新→旧)
+    // 存储: ~/.bolloon/human-values/judgments.json (human-value-store)
+    //      极简版: 只记录 decision + reason; 其它字段可选
+    app.post('/api/judgments', async (req, res) => {
+        try {
+            const { decision, reason, context } = req.body;
+            if (!decision || typeof decision !== 'string' || !decision.trim()) {
+                return res.status(400).json({ error: 'decision required' });
+            }
+            const { storeHumanJudgment, initializeValueStore } = await import('../pi-ecosystem-judgment/human-value-store.js');
+            await initializeValueStore();
+            const j = await storeHumanJudgment({
+                decision: decision.trim(),
+                decision_type: 'approve',
+                reasons: reason ? [reason.trim()] : [],
+                values_derived: [],
+                context: {
+                    domain: context?.domain || 'general',
+                    complexity: 'moderate',
+                    stakes: context?.stakes || 'medium',
+                    time_pressure: 'low',
+                },
+                metadata: {
+                    source: 'explicit',
+                    confidence: 0.8,
+                    revisable: true,
+                },
+            });
+            res.json({ ok: true, judgment: j });
+        }
+        catch (err) {
+            console.error('[judgments] POST failed:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/api/judgments', async (_req, res) => {
+        try {
+            const { loadAllJudgments, initializeValueStore } = await import('../pi-ecosystem-judgment/human-value-store.js');
+            await initializeValueStore();
+            const all = await loadAllJudgments();
+            // 新的在前
+            all.sort((a, b) => (b.timestamp || '').localeCompare(a.timestamp || ''));
+            res.json({ count: all.length, judgments: all });
+        }
+        catch (err) {
+            console.error('[judgments] GET failed:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 导入判断: 接受 { filename, content (base64), context }.
+    // 支持 .json / .yaml / .yml / .md / .txt / .html. 完全离线解析, 不调 LLM.
+    // 解析规则:
+    //   - .json: 顶层数组 [{decision, reason?, context?}, ...] 或 {judgments: [...]} 或 {items: [...]}
+    //   - .yaml/.yml: 期望顶层数组 (用 js-yaml); 不支持复杂结构
+    //   - .md/.txt/.html: 每一段 (按空行分隔) 算一条判断, 首行非空 = decision, 整段 = content
+    //                     如果首行是 markdown 标题 (# ...) 则去掉 #, 整段去掉首行后作 reason
+    app.post('/api/judgments/import', async (req, res) => {
+        try {
+            const { filename, content, context } = req.body;
+            if (!filename || !content) {
+                return res.status(400).json({ error: 'filename and content (base64) required' });
+            }
+            let raw;
+            try {
+                raw = Buffer.from(content, 'base64').toString('utf-8');
+            }
+            catch {
+                return res.status(400).json({ error: 'content is not valid base64' });
+            }
+            const lower = filename.toLowerCase();
+            let items = [];
+            if (lower.endsWith('.json')) {
+                try {
+                    const parsed = JSON.parse(raw);
+                    const arr = Array.isArray(parsed) ? parsed
+                        : Array.isArray(parsed?.judgments) ? parsed.judgments
+                            : Array.isArray(parsed?.items) ? parsed.items
+                                : null;
+                    if (!arr)
+                        return res.status(400).json({ error: 'JSON must be an array, or {judgments:[]}/{items:[]}' });
+                    for (const it of arr) {
+                        if (it && typeof it.decision === 'string' && it.decision.trim()) {
+                            items.push({ decision: it.decision.trim(), reason: it.reason, context: it.context });
+                        }
+                    }
+                }
+                catch (e) {
+                    return res.status(400).json({ error: 'JSON parse failed: ' + e.message });
+                }
+            }
+            else if (lower.endsWith('.yaml') || lower.endsWith('.yml')) {
+                try {
+                    const yaml = (await import('js-yaml')).default;
+                    const parsed = yaml.load(raw);
+                    if (!Array.isArray(parsed))
+                        return res.status(400).json({ error: 'YAML must be a top-level array' });
+                    for (const it of parsed) {
+                        if (it && typeof it.decision === 'string' && it.decision.trim()) {
+                            items.push({ decision: it.decision.trim(), reason: it.reason, context: it.context });
+                        }
+                    }
+                }
+                catch (e) {
+                    return res.status(400).json({ error: 'YAML parse failed: ' + e.message });
+                }
+            }
+            else if (lower.endsWith('.md') || lower.endsWith('.txt') || lower.endsWith('.html') || lower.endsWith('.htm')) {
+                // 通用纯文本: 按空行分段, 每段是一条判断
+                // 对 .html 先剥掉标签, 但保留段落分隔
+                let text = raw;
+                if (lower.endsWith('.html') || lower.endsWith('.htm')) {
+                    text = text.replace(/<script[\s\S]*?<\/script>/gi, '')
+                        .replace(/<style[\s\S]*?<\/style>/gi, '')
+                        // 块级标签 -> 双换行 (保留段落分隔)
+                        .replace(/<\/?(p|div|h[1-6]|li|tr|br)[^>]*>/gi, '\n\n')
+                        .replace(/<[^>]+>/g, ' ')
+                        .replace(/&nbsp;/g, ' ').replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>');
+                }
+                const blocks = text.split(/\n\s*\n/).map(b => b.trim()).filter(b => b.length > 0);
+                for (const block of blocks) {
+                    const lines = block.split('\n').map(l => l.trim()).filter(l => l.length > 0);
+                    if (lines.length === 0)
+                        continue;
+                    let decision = lines[0];
+                    // 如果首行是 markdown 标题, 去掉 # 前缀
+                    decision = decision.replace(/^#+\s*/, '');
+                    // 如果整段就是一个短句 (没有换行), 直接当 decision
+                    const reason = lines.length > 1 ? lines.slice(1).join(' ').trim() || undefined : undefined;
+                    if (decision)
+                        items.push({ decision, reason });
+                }
+            }
+            else {
+                return res.status(400).json({ error: 'unsupported file type (use .json .yaml .yml .md .txt .html)' });
+            }
+            if (items.length === 0) {
+                return res.status(400).json({ error: 'no parseable judgments found in file' });
+            }
+            const { storeHumanJudgment, initializeValueStore } = await import('../pi-ecosystem-judgment/human-value-store.js');
+            await initializeValueStore();
+            const imported = [];
+            const errors = [];
+            for (let i = 0; i < items.length; i++) {
+                try {
+                    const it = items[i];
+                    const j = await storeHumanJudgment({
+                        decision: it.decision,
+                        decision_type: 'approve',
+                        reasons: it.reason ? [String(it.reason)] : [],
+                        values_derived: [],
+                        context: {
+                            domain: it.context?.domain || context?.domain || 'general',
+                            complexity: 'moderate',
+                            stakes: it.context?.stakes || context?.stakes || 'medium',
+                            time_pressure: 'low',
+                        },
+                        metadata: {
+                            source: 'explicit',
+                            confidence: 0.8,
+                            revisable: true,
+                        },
+                    });
+                    imported.push(j);
+                }
+                catch (e) {
+                    errors.push(`#${i + 1} (${items[i].decision.substring(0, 30)}): ${e.message}`);
+                }
+            }
+            res.json({ ok: true, imported: imported.length, failed: errors.length, errors: errors.slice(0, 5), judgments: imported });
+        }
+        catch (err) {
+            console.error('[judgments] import failed:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 修改判断 (手动编辑 decision / reasons / context / values_derived)
+    app.patch('/api/judgments/:id', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const { updateJudgment, initializeValueStore } = await import('../pi-ecosystem-judgment/human-value-store.js');
+            await initializeValueStore();
+            const updated = await updateJudgment(id, req.body || {});
+            if (!updated)
+                return res.status(404).json({ error: 'judgment not found' });
+            res.json({ ok: true, judgment: updated });
+        }
+        catch (err) {
+            console.error('[judgments] PATCH failed:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 删除判断
+    app.delete('/api/judgments/:id', async (req, res) => {
+        try {
+            const { id } = req.params;
+            const { deleteJudgment, initializeValueStore } = await import('../pi-ecosystem-judgment/human-value-store.js');
+            await initializeValueStore();
+            const ok = await deleteJudgment(id);
+            if (!ok)
+                return res.status(404).json({ error: 'judgment not found' });
+            res.json({ ok: true });
+        }
+        catch (err) {
+            console.error('[judgments] DELETE failed:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // 批量删除: { ids: ['hv-xxx', ...] } → { ok, deleted, notFound }
+    app.post('/api/judgments/batch-delete', async (req, res) => {
+        try {
+            const ids = (req.body && Array.isArray(req.body.ids)) ? req.body.ids : null;
+            if (!ids)
+                return res.status(400).json({ error: 'ids array required' });
+            const { deleteJudgment, initializeValueStore } = await import('../pi-ecosystem-judgment/human-value-store.js');
+            await initializeValueStore();
+            const idStrs = ids.filter((x) => typeof x === 'string' && x.length > 0);
+            let deleted = 0;
+            const notFound = [];
+            for (const id of idStrs) {
+                const ok = await deleteJudgment(id);
+                if (ok)
+                    deleted++;
+                else
+                    notFound.push(id);
+            }
+            res.json({ ok: true, deleted, notFound });
+        }
+        catch (err) {
+            console.error('[judgments] batch-delete failed:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // AI 自动委派: 根据新判断的 capability / context 找最匹配的远端 agent, 委派任务
+    // 由前端在 POST /api/judgments 成功后调用 (fire-and-forget)
+    // 出参: { matched, targetAgent, response | skipped, reason }
+    app.post('/api/judgments/auto-delegate', async (req, res) => {
+        try {
+            const { judgmentId, capability, instruction } = req.body;
+            if (!judgmentId && !capability) {
+                return res.status(400).json({ error: 'judgmentId or capability required' });
+            }
+            const cap = capability || 'general';
+            // 用 agent-manifest-protocol 里的 pickAgent (内存) — 走本节点已经缓存的远端 manifest
+            const manifestMod = await import('../agents/agent-manifest-protocol.js');
+            const picked = manifestMod.pickAgent(cap);
+            if (!picked) {
+                return res.json({ ok: true, matched: false, reason: 'no remote agent matches capability' });
+            }
+            // 命中后, 用 iroh delegate transport 真正发过去
+            // 注: irohDelegateTransport.sendToNode 走的是 sendToNode(publicKey, frame, timeoutMs)
+            // irohTransport 的 sendMessage 不等回包, 所以委托是 fire-and-forget
+            // 想等回包需要新接口. 这里先把 "找得到目标 + 发送成功" 作为成功.
+            // TODO: 接入 requestResponse 等待远端 agent_response
+            try {
+                const idMod = await import('../network/iroh-integration.js');
+                const integ = idMod.getIrohIntegration();
+                if (!integ || !integ.getNodeId()) {
+                    return res.json({ ok: true, matched: true, targetAgent: picked.agent, sent: false, reason: 'iroh not initialized' });
+                }
+                // 用 pickAgent 选出来的 agent 关联的 irohNodeId (有的话), 没有就跳到本地自处理
+                const targetIrohNodeId = picked.agent.irohNodeId;
+                if (!targetIrohNodeId) {
+                    return res.json({ ok: true, matched: true, targetAgent: picked.agent, sent: false, reason: 'target agent has no irohNodeId (peer identity not bound)' });
+                }
+                const ok = await integ.sendTo(targetIrohNodeId, 'agent_delegate', new TextEncoder().encode(JSON.stringify({
+                    type: 'agent_delegate',
+                    payload: {
+                        capability: cap,
+                        instruction: instruction || `请执行我的判断: ${judgmentId}`,
+                        fromAgentId: 'local-judgment',
+                    },
+                    ts: Date.now(),
+                    fromDid: '',
+                })));
+                res.json({ ok: true, matched: true, targetAgent: picked.agent, sent: ok });
+            }
+            catch (e) {
+                res.json({ ok: true, matched: true, targetAgent: picked.agent, sent: false, error: e.message });
+            }
+        }
+        catch (err) {
+            console.error('[judgments] auto-delegate failed:', err);
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // (判断的 UI 已合并到主页面 header 的盾牌按钮 + modal, 不再走独立路由)
     // 启动看门狗监控
     if (watchdog) {
         // level 1 (内存爆) → 进程自杀, 依赖外层 supervisor / 用户重启 (Windows 任务计划/手动)

package/dist/web/style.css

@@ -575,6 +575,13 @@ body {
   transform: rotate(90deg);
 }
 
+/* ⚡ 自动工具徽章 + 当前会话名: 折叠时不显示, 只在展开时可见.
+   配置 (钱包/工具) 按钮保留在行上, 用户随时能进 modal. */
+.agent-group:not(.expanded) .agent-tools-badge,
+.agent-group:not(.expanded) .agent-current-session {
+  display: none !important;
+}
+
 .agent-new-session {
   /* 已废弃: 新建会话按钮迁移到 session 列表顶部, 见 .session-new-item */
   display: none;

package/package.json

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

package/src/agents/agent-manifest-protocol.ts

@@ -0,0 +1,117 @@
+/**
+ * agent-manifest-protocol - 节点握手后立刻互换"我有哪些 agent + capabilities"
+ *
+ * 核心目的：实现 "建联一次，访问对方所有智能体"。
+ *   - 节点连上 (Hyperswarm 主题 / iroh) 后立刻发 'manifest_request'
+ *   - 对端回 'manifest_payload'，写入本地 agentRegistry
+ *   - 之后任何指令可以 pickAgent(capability, ownerDid) → 直接委派
+ *
+ * 协议消息 (Hyperswarm 字符串帧):
+ *   manifest_request: { }
+ *   manifest_payload: { ownerName, ownerPublicKey, agents:[{id,name,capabilities,status}], publishedAt }
+ *
+ * 本文件不绑定 transport — 只提供 build/parse/dispatch 帮助函数。
+ * 调用方在自己 transport 上挂 onMessage('manifest_request', ...) 和 onMessage('manifest_payload', ...)。
+ */
+
+export interface AgentManifestEntry {
+  id: string;
+  name: string;
+  capabilities: string[];
+  status: 'active' | 'idle' | 'busy' | 'creating' | 'terminated';
+  // 可选 — 若对方把这个 agent 关联到具体子 P2P 端点
+  peerId?: string;
+  irohNodeId?: string;
+  sessionId?: string;
+  cid?: string;
+  ipnsName?: string;
+}
+
+export interface AgentManifest {
+  ownerName: string;
+  ownerPublicKey: string;
+  agents: AgentManifestEntry[];
+  publishedAt: number;
+}
+
+// ============== 帧构造 ==============
+export function buildManifestRequest(): string {
+  return JSON.stringify({ type: 'manifest_request', payload: {}, ts: Date.now(), fromDid: '' });
+}
+
+export function buildManifestPayload(manifest: AgentManifest): string {
+  return JSON.stringify({ type: 'manifest_payload', payload: manifest, ts: Date.now(), fromDid: '' });
+}
+
+export function buildAgentDelegateRequest(opts: {
+  capability: string;
+  docPath?: string;
+  docContent?: string;
+  instruction: string;
+  fromAgentId: string;
+}): string {
+  return JSON.stringify({ type: 'agent_delegate', payload: opts, ts: Date.now(), fromDid: '' });
+}
+
+export function buildAgentResponse(opts: {
+  ok: boolean;
+  delegatedTo: string;
+  resultCid?: string;
+  summary: string;
+  error?: string;
+}): string {
+  return JSON.stringify({ type: 'agent_response', payload: opts, ts: Date.now(), fromDid: '' });
+}
+
+// ============== 帧解析 ==============
+export function parseFrame(text: string): { type: string; payload: any; ts: number; fromDid: string } | null {
+  try { return JSON.parse(text); } catch { return null; }
+}
+
+// ============== 本地 manifest registry ==============
+const localManifest: AgentManifest = {
+  ownerName: '',
+  ownerPublicKey: '',
+  agents: [],
+  publishedAt: 0,
+};
+
+export function setLocalManifest(m: Partial<AgentManifest>) {
+  Object.assign(localManifest, m, { publishedAt: Date.now() });
+  return localManifest;
+}
+
+export function getLocalManifest(): AgentManifest {
+  return localManifest;
+}
+
+export function addLocalAgent(agent: AgentManifestEntry) {
+  const idx = localManifest.agents.findIndex((a) => a.id === agent.id);
+  if (idx >= 0) localManifest.agents[idx] = agent;
+  else localManifest.agents.push(agent);
+  localManifest.publishedAt = Date.now();
+  return localManifest;
+}
+
+// ============== 远端 manifest 缓存 ==============
+const remoteManifests: Map<string, AgentManifest> = new Map();  // key = ownerPublicKey
+
+export function cacheRemoteManifest(m: AgentManifest) {
+  if (m.ownerPublicKey) remoteManifests.set(m.ownerPublicKey, m);
+  return m;
+}
+
+export function getRemoteManifests(): AgentManifest[] {
+  return Array.from(remoteManifests.values());
+}
+
+export function pickAgent(capability: string, ownerPublicKey?: string): { agent: AgentManifestEntry; owner: AgentManifest } | null {
+  const owners = ownerPublicKey
+    ? [remoteManifests.get(ownerPublicKey)].filter(Boolean) as AgentManifest[]
+    : getRemoteManifests();
+  for (const owner of owners) {
+    const a = owner.agents.find((x) => x.capabilities.includes(capability) && x.status === 'active');
+    if (a) return { agent: a, owner };
+  }
+  return null;
+}

package/src/agents/iroh-secret.ts

@@ -0,0 +1,32 @@
+/**
+ * iroh-secret - 把 iroh secretKey 落 ~/.bolloon/iroh-secret.json
+ *
+ * iroh 默认每次启动生成新节点 ID；落盘后可实现"跨重启稳定 nodeId"。
+ * 对应 Issue: "建联一次访问所有智能体"需要稳定标识, 不然对方缓存的 nodeId 失效
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+
+const SECRET_DIR = path.join(os.homedir(), '.bolloon');
+
+export function loadOrCreateIrohSecret(role: string = 'default'): { secretKey: Uint8Array; createdAt: string; reused: boolean } {
+  if (!fs.existsSync(SECRET_DIR)) fs.mkdirSync(SECRET_DIR, { recursive: true });
+  const fp = path.join(SECRET_DIR, `iroh-secret-${role}.json`);
+  if (fs.existsSync(fp)) {
+    const j = JSON.parse(fs.readFileSync(fp, 'utf-8'));
+    return { secretKey: Buffer.from(j.secretKey, 'hex'), createdAt: j.createdAt, reused: true };
+  }
+  const sk = crypto.randomBytes(32);
+  const createdAt = new Date().toISOString();
+  fs.writeFileSync(fp, JSON.stringify({ secretKey: sk.toString('hex'), createdAt }, null, 2), { mode: 0o600 });
+  // chmod in case the file already existed and umask produced looser perms
+  try { fs.chmodSync(fp, 0o600); } catch {}
+  return { secretKey: sk, createdAt, reused: false };
+}
+
+export function irohSecretFilePath(role: string = 'default'): string {
+  return path.join(SECRET_DIR, `iroh-secret-${role}.json`);
+}

package/src/index.ts

@@ -22,7 +22,8 @@ import { createSubAgentManager } from './agents/subagent-manager.js';
 import { getGlobalSharedContext } from './social/global-shared-context.js';
 import { BollharnessIntegration, createBollharnessIntegration } from './bollharness-integration/index.js';
 import * as readline from 'readline';
-import { checkAndUpdate } from './utils/auto-update.js';
+// 启动时自动检查更新已禁用 (改用 --update-check / --update-now 显式触发)
+
 
 const RESET = '\x1b[0m';
 const BOLD = '\x1b[1m';
@@ -1516,13 +1517,10 @@ async function main() {
     process.exit(0);
   }
 
-  // 启动时检查 npm 包更新
-  const updateResult = await checkAndUpdate();
-  if (updateResult.hasUpdate && updateResult.updated) {
-    console.log(`\n${YELLOW}更新完成，请重新启动 bolloon${RESET}\n`);
-    // 更新完成后退出，让用户重新启动
-    process.exit(0);
-  }
+  // 自动更新已禁用: 启动时不再自动检查/安装更新.
+  // 想手动检查: bolloon --update-check
+  // 想手动更新: bolloon --update-now [package]
+  // 想完全屏蔽 (CI / sandbox): BOLLOON_SKIP_UPDATE=true
 
   const mode = args.web ? 'web' : 'cli';
   const isNonInteractive = !!(args.tool || args.prompt);