@bolloon/bolloon-agent 0.1.23 → 0.1.25

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);
@@ -254,6 +256,54 @@ async function executeTask(task, channelId) {
 let sseClients = new Set();
 let channelSessions = new Map(); // key: channelId
 let sessionMessages = new Map(); // key: channelId + sessionId
+/**
+ * v3 重做: 构造 channel 的两路 judgment prompt 片段
+ *   路 1: 用户在盾牌里手动绑定的 judgment (channel.bound_judgment_ids)
+ *   路 2: 全局 judgment 列表 (供 LLM 在主调用中按需挑选, 写入回复)
+ * 返回 "" 表示完全没数据; 否则返回完整 "[系统上下文] ..." 块 (含尾部换行)
+ * 失败非致命 — 任何异常都返回空串, 保证 LLM 调用不被阻塞
+ */
+async function buildJudgmentHint(channel, channelIdForLog) {
+    try {
+        const { loadAllJudgments, initializeValueStore } = await import('../pi-ecosystem-judgment/human-value-store.js');
+        await initializeValueStore();
+        const allJudgments = await loadAllJudgments();
+        if (allJudgments.length === 0)
+            return '';
+        const boundIds = new Set(channel && Array.isArray(channel.bound_judgment_ids) ? channel.bound_judgment_ids : []);
+        const bound = allJudgments.filter(j => j.id !== undefined && boundIds.has(j.id));
+        const others = allJudgments.filter(j => j.id !== undefined && !boundIds.has(j.id));
+        let hint = '';
+        // 路 1: 用户手动绑定的 judgment — 硬约束, 必须遵循
+        if (bound.length > 0) {
+            hint += `[系统上下文] 此 channel 用户绑定了 ${bound.length} 条判断力, 必须严格遵循:\n`;
+            for (const j of bound) {
+                const decision = (j.decision || '').toString().slice(0, 200);
+                const reasonList = Array.isArray(j.reasons) ? j.reasons : [];
+                const reasonText = reasonList.length > 0
+                    ? ` (理由: ${reasonList.join('; ').slice(0, 100)})`
+                    : '';
+                hint += `- ${decision}${reasonText}\n`;
+            }
+            hint += '\n';
+        }
+        // 路 2: 全局 judgment 候选池 — 软参考, LLM 自己挑
+        if (others.length > 0) {
+            hint += `[系统上下文] 候选判断力 (用户未明确绑定, 你可以按相关性自主选择参考):\n`;
+            for (const j of others) {
+                const decision = (j.decision || '').toString().slice(0, 120);
+                hint += `- [id=${j.id}] ${decision}\n`;
+            }
+            hint += `\n[系统上下文] 如果你的回复参考了某条候选判断力, 请在回复中自然提及 "我参考了你的判断: <decision 简述>" 即可, 无需复述 id.\n\n`;
+        }
+        console.log(`[v3] channel ${channelIdForLog} 注入: 绑定 ${bound.length} 条, 候选 ${others.length} 条`);
+        return hint;
+    }
+    catch (err) {
+        console.error(`[v3] 加载判断力失败 (非致命):`, err.message);
+        return '';
+    }
+}
 async function getAgentForChannel(channelId, channelDid, channelName, channelDidDoc) {
     // 获取当前 channel 的 currentSessionId
     const channels = await loadChannels();
@@ -310,7 +360,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);
@@ -464,6 +516,8 @@ export async function createWebServer(port = 3000) {
         // (line ~638) 与这里外层的 const channel 形成 shadowing 让 TS 误报"使用前未声明"
         const boundWalletAddress = channel?.walletAddress;
         const autoToolsEnabled = channel?.autoInvokeTools !== false; // 默认开启
+        // 捕获外层 channel 到独立变量, 避免被 try 块内 (line 740+) 的 const channel 遮蔽
+        const channelForJudgment = channel;
         try {
             const agent = await getAgentForChannel(channelId, realChannelDid, realChannelName, realChannelDidDoc);
             let fullResponse = '';
@@ -499,6 +553,11 @@ export async function createWebServer(port = 3000) {
             else {
                 contextHint += `[系统上下文] 自动工具调用已关闭: 每次执行工具前必须先与用户确认。\n`;
             }
+            // v3: 注入 channel 绑定的判断力 (judgment_ids)
+            // 这是 v3 的核心 — channel 跑 LLM 时, 它的判断力 = 绑定的 judgment 列表
+            const judgmentHint = await buildJudgmentHint(channelForJudgment, channelId);
+            if (judgmentHint)
+                contextHint += judgmentHint;
             if (contextHint)
                 contextHint += '\n';
             fullResponse = await agent.promptStream(contextHint + text, streamCallback);
@@ -657,8 +716,8 @@ export async function createWebServer(port = 3000) {
     });
     app.post('/channels', async (req, res) => {
         try {
-            const { name, agentId, walletAddress, autoInvokeTools } = req.body;
-            console.log(`[创建频道] 收到请求: name=${name}, agentId=${agentId}, wallet=${walletAddress ? 'yes' : 'no'}`);
+            const { name, agentId, walletAddress, autoInvokeTools, bound_judgment_ids } = 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' });
             }
@@ -666,6 +725,10 @@ export async function createWebServer(port = 3000) {
             const id = `ch_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
             // 校验钱包地址格式 (粗校验: 0x + 40 hex / Solana base58 / Sui 0x+64)
             const validWallet = isValidWalletAddress(walletAddress);
+            // 过滤 bound_judgment_ids: 只保留 string
+            const safeBoundIds = Array.isArray(bound_judgment_ids)
+                ? bound_judgment_ids.filter((x) => typeof x === 'string' && x.length > 0)
+                : [];
             // 先创建频道（不阻塞等待 DID 生成）
             const channel = {
                 id,
@@ -677,6 +740,7 @@ export async function createWebServer(port = 3000) {
                 walletAddress: validWallet || undefined,
                 walletRegisteredAt: validWallet ? new Date().toISOString() : undefined,
                 autoInvokeTools: autoInvokeTools !== false, // 默认 true
+                bound_judgment_ids: safeBoundIds,
                 sessions: [{
                         id: `sess_${Date.now()}`,
                         createdAt: new Date().toISOString(),
@@ -835,7 +899,7 @@ export async function createWebServer(port = 3000) {
     app.patch('/channels/:channelId', async (req, res) => {
         try {
             const { channelId } = req.params;
-            const { name, walletAddress, autoInvokeTools } = req.body;
+            const { name, walletAddress, autoInvokeTools, bound_judgment_ids } = req.body;
             const channels = await loadChannels();
             const channel = channels.find(c => c.id === channelId);
             if (!channel) {
@@ -862,6 +926,19 @@ export async function createWebServer(port = 3000) {
             if (typeof autoInvokeTools === 'boolean') {
                 channel.autoInvokeTools = autoInvokeTools;
             }
+            // bound_judgment_ids: 允许数组(替换)/null(清空)/undefined(不改)
+            if (bound_judgment_ids !== undefined) {
+                if (bound_judgment_ids === null) {
+                    channel.bound_judgment_ids = [];
+                }
+                else if (Array.isArray(bound_judgment_ids)) {
+                    channel.bound_judgment_ids = bound_judgment_ids.filter((x) => typeof x === 'string' && x.length > 0);
+                }
+                else {
+                    return res.status(400).json({ error: 'bound_judgment_ids must be array or null' });
+                }
+                console.log(`[Channel ${channelId}] 绑定判断力: ${channel.bound_judgment_ids.length} 条`);
+            }
             channel.updatedAt = new Date().toISOString();
             await saveChannels(channels);
             res.json(channel);
@@ -1023,8 +1100,9 @@ export async function createWebServer(port = 3000) {
                     broadcast({ type: 'error', content: event.content }, channelId);
                 }
             };
-            // 重新生成时只发送用户消息
-            fullResponse = await agent.promptStream(userMessage, streamCallback);
+            // 重新生成时只发送用户消息 (v3: 同时注入 channel 绑定的判断力)
+            const regenHint = await buildJudgmentHint(channel, channelId);
+            fullResponse = await agent.promptStream(regenHint + userMessage, streamCallback);
             broadcast({ type: 'ai', content: fullResponse }, channelId);
             // 更新 session
             const existingSession = await loadSession(channelId, currentSessionId);
@@ -1489,6 +1567,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);
@@ -2125,7 +2214,8 @@ export async function createWebServer(port = 3000) {
     try {
         const { createHealthMonitor, createWatchdog } = await import('../heartbeat/index.js');
         healthMonitor = createHealthMonitor();
-        watchdog = createWatchdog();
+        // 把 watchdog 静默阈值拉到 30 分钟, 避免开发期 / 用户空闲时被误杀
+        watchdog = createWatchdog({ silentThresholdMs: 30 * 60 * 1000 });
         console.log('[24h] Heartbeat modules loaded');
     }
     catch (err) {
@@ -2177,6 +2267,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.25",
   "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`);
+}