@bolloon/bolloon-agent 0.3.46 → 0.3.48

package/dist/index.js

@@ -16,7 +16,7 @@ import { getGlobalSharedContext } from './social/global-shared-context.js';
 import { createBollharnessIntegration } from './bollharness-integration/index.js';
 import * as readline from 'readline';
 import { printBanner, renderDialog, renderUserMessage, renderAgentMessage, renderMessageBox, renderToolCallListItem, termWidth } from './cli/loading-tui.js';
-import { startInk, stopInk, inkAppendLine as appendLine, inkSetStatus, inkSetThinking } from './cli/ink-app.js';
+import { startInk, stopInk, inkAppendLine as appendLine, inkSetStatus, inkSetThinking, inkSetTransient } from './cli/ink-app.js';
 // 启动自动检查更新：后台、节流、检测到新版本自动安装（可被 --no-update / BOLLOON_SKIP_UPDATE 关闭）
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
@@ -271,12 +271,44 @@ async function bootstrapIroh(keypair, name) {
 // Agent 懒加载
 // ---------------------------------------------------------------------------
 let agent = null;
+/** 2026-08-09: agent 当前绑定的 channel id (null = 默认 harness 身份) — 切换时据此重建 */
+let agentBoundChannelId = null;
 let harness = null;
 let hybridMessenger = null;
 let agentIdentity = null;
 async function getAgent() {
-    if (!agent) {
-        const identityDoc = agentIdentity ? {
+    // 2026-08-09: agent 身份绑定当前 active channel — 切换 / 新建 channel 后重建.
+    //   旧实现: agent 全局单例 + peerId:'harness' 固定, 切 channel 身份不变 (bug).
+    //   新实现: channel 有 agentId/did/publicKey/persona 时按 channel 建 session,
+    //   agentIdentity 同步更新, loadSessionKey 回灌该 channel 的历史.
+    const targetChannelId = cliActiveChannelId || null;
+    if (agent && agentBoundChannelId === targetChannelId)
+        return agent;
+    // 读取当前 active channel 的持久身份
+    let chIdentity = null;
+    if (targetChannelId) {
+        try {
+            const { getIdentityStore } = await import('./agents/agent-identity-store.js');
+            const store = getIdentityStore();
+            await store.load();
+            const ch = store.rawChannels.find((c) => c.id === targetChannelId);
+            if (ch)
+                chIdentity = ch;
+        }
+        catch { /* 读不到就退默认 */ }
+    }
+    let identityDoc;
+    if (chIdentity?.did && chIdentity.publicKey) {
+        // channel 已有持久 DID → 用 channel 身份
+        identityDoc = {
+            did: chIdentity.did,
+            name: chIdentity.persona?.name || chIdentity.name || 'agent',
+            publicKey: chIdentity.publicKey,
+            createdAt: Date.now(),
+        };
+    }
+    else if (agentIdentity) {
+        identityDoc = {
             did: agentIdentity.did,
             name: agentIdentity.name,
             publicKey: agentIdentity.publicKey,
@@ -285,15 +317,39 @@ async function getAgent() {
             p2pChannel: agentIdentity.p2pChannel,
             cid: agentIdentity.cid,
             ipnsName: agentIdentity.ipnsName
-        } : undefined;
-        agent = await createAgentSession({
-            cwd: process.cwd(),
-            peerId: 'harness',
-            identityDoc
-        });
+        };
+    }
+    else {
+        identityDoc = undefined;
+    }
+    const loadSessionKey = targetChannelId
+        ? `${targetChannelId}:${chIdentity?.currentSessionId || 'default'}`
+        : undefined;
+    agent = await createAgentSession({
+        cwd: process.cwd(),
+        peerId: targetChannelId ?? 'harness',
+        identityDoc,
+        // 2026-08-09: 透传 channel.agentId → persona docs 按 agent 加载 (身份真正变化)
+        agentId: chIdentity?.agentId || (targetChannelId ? undefined : agentIdentity?.name),
+        loadSessionKey,
+    });
+    agentBoundChannelId = targetChannelId;
+    // 同步 agentIdentity (状态栏 / 身份引用)
+    if (chIdentity) {
+        agentIdentity = {
+            did: chIdentity.did || agentIdentity?.did || '',
+            name: chIdentity.persona?.name || chIdentity.name || 'agent',
+            publicKey: chIdentity.publicKey || agentIdentity?.publicKey || '',
+            peerId: targetChannelId ?? undefined,
+        };
     }
     return agent;
 }
+/** 强制重建 agent (切 channel / 新建 agent 后调用) */
+function invalidateAgent() {
+    agent = null;
+    agentBoundChannelId = null;
+}
 // ---------------------------------------------------------------------------
 // Dispatch
 // ---------------------------------------------------------------------------
@@ -367,6 +423,8 @@ let cliStartTime = 0;
 let cliModelName = '…';
 let cliAgentName = '…';
 let cliActiveChannelId = null;
+// 2026-08-10: CLI 自动整理心跳 (与社交心跳并列, 独立于 server) — 退出时 stop
+let cliOrganizeHeartbeat = null;
 function fmtDuration(ms) {
     const s = Math.floor(ms / 1000);
     if (s < 60)
@@ -503,6 +561,59 @@ async function startCLI(comm) {
     catch { /* 降级: getCliCtxUsage 返回 0/1M */ }
     const initialStatus = `${C_ACCENT}${cliModelName}${RESET}${C_DIM}  │${RESET} ${cliAgentName} ${C_DIM}│${RESET} ⏱ 0s${C_DIM} │${RESET} ${buildContextBar(getCliCtxUsage())}`;
     startInk((text) => { processInput(text, comm); }, initialStatus, getStatus);
+    // 2026-08-10: 自动整理心跳 (CLI 侧, 与社交心跳并列) — 启动后立即"固定看一下 skills view"
+    //   (扫描遗留 skills), 之后按周期 (默认 30min, env BOLLOON_ORGANIZE_HEARTBEAT_MS) 完整进化经验.
+    //   显示走 transient 颜文字行: 触发时显示, 结束后清空 (显示为空).
+    try {
+        const { startOrganizeHeartbeat } = await import('./agents/skill-organizer.js');
+        let firstOrganizeScan = true; // 启动第一轮只做快速遗留扫描 (无 LLM), 不阻塞启动
+        cliOrganizeHeartbeat = startOrganizeHeartbeat({
+            intervalMs: Number(process.env.BOLLOON_ORGANIZE_HEARTBEAT_MS) || 30 * 60_000,
+            onStart: () => inkSetTransient(`${C_DIM}(｀・ω・´) 自动整理经验中...${RESET}`),
+            onEnd: (r) => {
+                inkSetTransient(null); // 结束后去除显示效果 (显示为空)
+                if (r && r.leftovers.length > 0) {
+                    appendLine(`${C_DIM}🧹 发现 ${r.leftovers.length} 个遗留 skills: ${r.leftovers.slice(0, 5).map(l => l.name).join(', ')}${RESET}`);
+                }
+                if (r && r.evolved.length > 0) {
+                    appendLine(`${C_OK}✨ 经验进化: ${r.evolved.join(', ')}${RESET}`);
+                }
+                // 2026-08-10: 知识层整理汇总 (Context OS/社交/智能体/judgeness/项目/画像/日志/目标)
+                const kSections = (r?.knowledge?.sections || []).filter(s => s.handled > 0 || s.error);
+                if (kSections.length > 0) {
+                    appendLine(`${C_DIM}🧠 知识整理: ${kSections.map(s => s.error ? `${s.label}✗` : `${s.label}✓`).join(' ')}${RESET}`);
+                }
+            },
+            onError: () => inkSetTransient(null),
+            run: async () => {
+                // 启动第一轮 (firstOrganizeScan=true) 只做快速扫描 — 不拿 LLM, 立即执行.
+                // 后续周期轮才取 agent LLM 做完整经验进化 (2026-08-10: getAgent 在无 LLM 环境可能
+                //   长时间挂起 → 8s 超时降级为仅扫描)
+                let llm;
+                const needEvolve = !firstOrganizeScan;
+                if (needEvolve) {
+                    try {
+                        const a = await Promise.race([
+                            getAgent().catch(() => null),
+                            new Promise((res) => setTimeout(() => res(null), 8000)),
+                        ]);
+                        if (a && typeof a.promptStream === 'function') {
+                            llm = (p) => a.promptStream(p, () => { }, undefined, cliActiveChannelId || undefined);
+                        }
+                    }
+                    catch { /* 无 agent → 仅扫描 */ }
+                }
+                const { runAutoOrganize } = await import('./agents/skill-organizer.js');
+                const evolve = needEvolve && !!llm;
+                firstOrganizeScan = false;
+                return runAutoOrganize({ llm, source: 'cli:organize-heartbeat', evolve });
+            },
+        });
+        // 启动即跑一轮: 每次打开后固定看一下 skills view (遗留扫描, 快, 不阻塞)
+        // 延迟 3s 等 Ink 挂载完成 (global __inkAppend/__inkSetTransient 注册) — 否则首轮显示丢失
+        setTimeout(() => { cliOrganizeHeartbeat?.runOnce().catch(() => { }); }, 3000);
+    }
+    catch { /* 自动整理启动失败不阻塞 CLI */ }
     // Wait on a promise that resolves on Ctrl+C / 双击 Esc
     // (ink-app 的 requestExit 调 __inkRequestExit → resolve, 清理后 process.exit)
     let cliExitResolve = () => { };
@@ -512,6 +623,10 @@ async function startCLI(comm) {
     delete globalThis.__inkRequestExit;
     stopInk();
     appendLine(`\n${CYAN}👋 再见！${RESET}`);
+    try {
+        cliOrganizeHeartbeat?.stop();
+    }
+    catch { /* 非致命 */ }
     comm.stop();
     process.exit(0);
 }
@@ -575,6 +690,13 @@ async function processInput(input, comm) {
             await store.setActive(r.channel.id);
             cliAgentName = r.identity.name;
             cliActiveChannelId = r.channel.id;
+            // 2026-08-09: 切 channel 必须重建 agent session — 否则身份/记忆停留在旧 channel (bug 修复)
+            invalidateAgent();
+            // 立即重建 (提前建好, 避免下次输入才卡顿; 失败不阻塞切换)
+            try {
+                await getAgent();
+            }
+            catch { /* 非致命, 下次输入时再试 */ }
             inkSetStatus(getStatus()); // 触发状态栏立即重绘 (无需等 1s 定时器)
             const extra = prev && prev.name !== r.identity.name ? ` (从 ${prev.name} 切换)` : '';
             appendLine(`${C_ACCENT}→ 当前智能体: ${r.identity.name}${RESET}${extra}`);
@@ -599,38 +721,47 @@ async function processInput(input, comm) {
             const { getIdentityStore } = await import('./agents/agent-identity-store.js');
             const store = getIdentityStore();
             await store.load();
-            const { readFile, writeFile, mkdir } = await import('fs/promises');
-            const { join } = await import('path');
-            const home = process.env.HOME || '/tmp';
-            const channelsPath = join(home, '.bolloon', 'sessions', 'channels.json');
-            let channels = [];
-            try {
-                const parsed = JSON.parse(await readFile(channelsPath, 'utf-8'));
-                channels = Array.isArray(parsed) ? parsed : parsed?.channels || [];
-            }
-            catch { /* 首次无文件 */ }
-            const dupName = channels.find((c) => c.name === name.trim());
+            // 2026-08-09: 复用 server-storage updateChannels 原子写 (互斥锁) — 旧实现裸 readFile→push→writeFile
+            //   与 Web server 并发写 channels.json 互相覆盖 → 创建的 agent 重启后丢失 (bug 修复)
+            const { updateChannels } = await import('./web/server-storage.js');
+            const dupName = store.rawChannels.find((c) => c.name === name.trim());
             if (dupName) {
                 appendLine(`${C_ERROR}同名智能体已存在: '${dupName.name}' (id=${dupName.id})${RESET}`);
                 return;
             }
             const id = `ch_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+            const agentId = `agent-${name.trim().toLowerCase().replace(/\s+/g, '-')}`;
             const ch = {
                 id,
                 name: name.trim(),
-                agentId: `agent-${name.trim().toLowerCase().replace(/\s+/g, '-')}`,
+                agentId,
                 createdAt: new Date().toISOString(),
                 updatedAt: new Date().toISOString(),
                 currentSessionId: 'default',
             };
             if (personaHint)
                 ch.persona = { name: name.trim(), description: personaHint };
-            channels.push(ch);
-            await mkdir(join(home, '.bolloon', 'sessions'), { recursive: true });
-            await writeFile(channelsPath, JSON.stringify(channels, null, 2), 'utf-8');
+            // 2026-08-09: 立即生成该 agent 的持久 DID 身份 (agent-keys/<agentId>.json) —
+            //   与 server fixOneChannelDID 对齐, 保证 CLI 新建的 agent 身份稳定且归属用户 DID
+            try {
+                const { loadOrCreateAgentIdentity } = await import('./agents/agent-identity.js');
+                const idt = loadOrCreateAgentIdentity(agentId);
+                ch.did = idt.did;
+                ch.publicKey = idt.publicKey;
+            }
+            catch { /* DID 生成失败不阻塞创建 */ }
+            const channels = await updateChannels((chs) => [...chs, ch]);
+            // 刷新 store 缓存 (updateChannels 走了 server-storage, store 内存还是旧的)
+            await store.load();
             await store.setActive(id);
             cliAgentName = name.trim();
             cliActiveChannelId = id;
+            // 2026-08-09: 新建 agent 后立即重建 session — 否则新 agent 身份不加载 (bug 修复)
+            invalidateAgent();
+            try {
+                await getAgent();
+            }
+            catch { /* 非致命 */ }
             inkSetStatus(getStatus());
             appendLine(`${C_OK}✓ 已创建智能体 channel: ${name.trim()}${RESET} (${C_DIM}${id}${RESET})${personaHint ? `\n  ${C_DIM}persona: ${personaHint}${RESET}` : ''}`);
         }
@@ -1544,18 +1675,20 @@ async function processInput(input, comm) {
         appendLine(renderAgentMessage(response));
         // 停止思考动画
         inkSetThinking(false);
-        // 2026-08-04: run-end 经验整理 — 连续成功工具 ≥2 自动写 skill 候选 (颜文字加载)
+        // 2026-08-04: run-end 经验整理 — 连续成功工具 ≥2 自动写 skill 候选
+        // 2026-08-10: 显示改走 transient 行 (颜文字位置): 开始时显示, 结束后清空 (显示为空),
+        //   不再追加 ✨ 消息行 → 不残留显示效果
         if (runEndOkSteps.length >= 2) {
-            appendLine(`${C_DIM}(｀・ω・´) 整理本轮经验中... ${runEndOkSteps.length} 个工具调用${RESET}`);
+            inkSetTransient(`${C_DIM}(｀・ω・´) 整理本轮经验中... ${runEndOkSteps.length} 个工具调用${RESET}`);
             setImmediate(async () => {
                 try {
                     const { writeRunEndSkillCandidates } = await import('./agents/skill-writer.js');
-                    const r = await writeRunEndSkillCandidates(runEndOkSteps, 'cli:interactive');
-                    if (r.wrote) {
-                        appendLine(`${C_OK}✨ (◕‿◕) 经验候选已写入: ${r.names}${RESET}`);
-                    }
+                    await writeRunEndSkillCandidates(runEndOkSteps, 'cli:interactive');
                 }
                 catch { /* 非致命, 静默 */ }
+                finally {
+                    inkSetTransient(null); // 结束后去除显示效果 (显示为空)
+                }
             });
         }
         // 更新状态栏: 上下文进度 (2026-08-06: 每轮按当前 messageHistory 重算并写回 ContextManager,

package/dist/social/agent-heartbeat.js

@@ -50,6 +50,8 @@ const DEFAULTS = {
     backoffFactor: 2,
     maxSocialIntervalMs: 30 * 60_000,
     goalReevalMs: 60 * 60_000,
+    // 2026-08-10: 自动整理心跳
+    organizeIntervalMs: 30 * 60_000,
 };
 const MAX_BACKOFF_LEVEL = 6;
 export class AgentHeartbeat {
@@ -58,6 +60,9 @@ export class AgentHeartbeat {
     lastInitiated = new Map();
     beaconTimer = null;
     socialTimer = null;
+    // 2026-08-10: 自动整理心跳 timer + 重入锁 (上一轮没跑完不重复触发)
+    organizeTimer = null;
+    organizeRunning = false;
     started = false;
     // === 生命周期状态 ===
     phase = 'BOOTSTRAP';
@@ -78,6 +83,10 @@ export class AgentHeartbeat {
             onPeerAlive: options.onPeerAlive,
             onActivity: options.onActivity,
             onLifecycleChange: options.onLifecycleChange,
+            organizeEnabled: options.organizeEnabled ?? true,
+            organizeIntervalMs: options.organizeIntervalMs ?? DEFAULTS.organizeIntervalMs,
+            organize: options.organize,
+            onOrganizeEvent: options.onOrganizeEvent,
             beaconIntervalMs: options.beaconIntervalMs ?? DEFAULTS.beaconIntervalMs,
             socialIntervalMs: options.socialIntervalMs ?? DEFAULTS.socialIntervalMs,
             cooldownMs: options.cooldownMs ?? DEFAULTS.cooldownMs,
@@ -110,10 +119,15 @@ export class AgentHeartbeat {
         if (this.isSocialEnabled()) {
             this.scheduleSocial();
         }
+        // 2026-08-10: 自动整理心跳 — 与社交独立, 社交关闭也照跑
+        if (this.opts.organizeEnabled && this.opts.organize) {
+            this.scheduleOrganize();
+        }
         // 立即发一次 beacon, 让对端尽快看到自己
         this.tickBeacon().catch(() => { });
         console.log(`[heartbeat] 社交心跳已启动 (beacon=${this.opts.beaconIntervalMs}ms` +
-            `${this.isSocialEnabled() ? `, social=${this.opts.socialIntervalMs}ms, cooldown=${this.opts.cooldownMs}ms` : ', social=关闭'} )`);
+            `${this.isSocialEnabled() ? `, social=${this.opts.socialIntervalMs}ms, cooldown=${this.opts.cooldownMs}ms` : ', social=关闭'}` +
+            `${this.opts.organizeEnabled && this.opts.organize ? `, organize=${this.opts.organizeIntervalMs}ms` : ', organize=关闭'} )`);
     }
     /** 优雅停止: 清理全部定时器 (供全局 runtime 的 SIGTERM/SIGINT 清理调用) */
     stop() {
@@ -121,8 +135,11 @@ export class AgentHeartbeat {
             clearInterval(this.beaconTimer);
         if (this.socialTimer)
             clearTimeout(this.socialTimer);
+        if (this.organizeTimer)
+            clearTimeout(this.organizeTimer);
         this.beaconTimer = null;
         this.socialTimer = null;
+        this.organizeTimer = null;
         this.started = false;
         this.setPhase('PAUSED');
         console.log('[heartbeat] 社交心跳已停止 (定时器已清理)');
@@ -192,6 +209,50 @@ export class AgentHeartbeat {
             });
         }, this.currentSocialInterval());
     }
+    // ===================== 自动整理心跳 (2026-08-10) =====================
+    // 与社交心跳并列的第三条心跳: 周期性整理 skills 经验 (候选进化) + 扫描遗留 skills.
+    // 与社交生命周期完全独立 — 社交关闭/退避 RESTING 不影响整理照跑.
+    /** 是否启用了自动整理 */
+    isOrganizeEnabled() {
+        return this.opts.enabled && this.opts.organizeEnabled && !!this.opts.organize;
+    }
+    scheduleOrganize() {
+        if (!this.started || !this.isOrganizeEnabled()) {
+            this.organizeTimer = null;
+            return;
+        }
+        this.organizeTimer = setTimeout(() => {
+            this.tickOrganize()
+                .catch((e) => console.warn('[heartbeat] organize tick 失败:', e?.message))
+                .finally(() => {
+                if (this.started && this.isOrganizeEnabled())
+                    this.scheduleOrganize();
+            });
+        }, this.opts.organizeIntervalMs);
+    }
+    /** 跑一轮自动整理 (导出供测试/启动即跑: 每次打开后固定看一下 skills view) */
+    async tickOrganize() {
+        if (!this.isOrganizeEnabled() || this.organizeRunning)
+            return;
+        this.organizeRunning = true;
+        this.opts.onOrganizeEvent?.({ phase: 'start' });
+        try {
+            const self = await this.opts.self();
+            const r = await this.opts.organize({ self });
+            this.opts.onOrganizeEvent?.({
+                phase: 'end',
+                summary: r?.summary || (r?.done ? '完成' : ''),
+            });
+            return r;
+        }
+        catch (e) {
+            this.opts.onOrganizeEvent?.({ phase: 'error', error: e?.message || String(e) });
+            throw e;
+        }
+        finally {
+            this.organizeRunning = false;
+        }
+    }
     /** 社交决策 tick: 先评估生命周期, 再决定是否对存活 peer 发起对话 */
     async tickSocial() {
         this.opts.onActivity?.();

package/dist/web/server.js

@@ -2332,6 +2332,49 @@ export async function createWebServer(port = 3000, options = {}) {
                             ts: Date.now(),
                         }, 'p2p-global');
                     },
+                    // === 2026-08-10: 自动整理心跳 (与社交并列) ===
+                    // 周期性: ① 扫描 skills view 找遗留 skills ② 候选经验 LLM 完整进化 (不再只是记录工具).
+                    // 与社交生命周期独立 — 社交关闭 (BOLLOON_AGENT_HEARTBEAT_SOCIAL=0) 整理仍照跑.
+                    organizeEnabled: true,
+                    organizeIntervalMs: Number(process.env.BOLLOON_ORGANIZE_HEARTBEAT_MS) || 30 * 60_000,
+                    organize: async () => {
+                        try {
+                            watchdogRef?.recordActivity?.('agent-organize');
+                        }
+                        catch { }
+                        const { runAutoOrganize } = await import('../agents/skill-organizer.js');
+                        // 用第一个本地 channel 的 agent 做 LLM 完整经验进化 (拿不到则仅扫描)
+                        // 2026-08-10: getAgentForChannel 初始化可能挂起 → 8s 超时降级
+                        let llm;
+                        try {
+                            const channels = await loadChannels();
+                            const local = channels[0];
+                            if (local) {
+                                const agent = await Promise.race([
+                                    getAgentForChannel(local.id, local.did || '', local.name, local.didDocRef).catch(() => null),
+                                    new Promise((res) => setTimeout(() => res(null), 8000)),
+                                ]);
+                                if (agent && typeof agent.promptStream === 'function') {
+                                    llm = (p) => agent.promptStream(p, () => { }, undefined, local.id);
+                                }
+                            }
+                        }
+                        catch { /* 无 agent → 仅扫描 */ }
+                        const r = await runAutoOrganize({ llm, source: 'server:organize-heartbeat', evolve: !!llm });
+                        const kTotal = r.knowledge?.totalHandled ?? 0;
+                        return { done: true, summary: `进化 ${r.evolved.length} 个 skill, 遗留 ${r.leftovers.length} 个, 知识层 ${kTotal} 项` };
+                    },
+                    onOrganizeEvent: (evt) => {
+                        if (evt?.phase === 'start') {
+                            console.log('[heartbeat] 自动整理开始 (skills 遗留扫描 + 经验进化)');
+                        }
+                        else if (evt?.phase === 'end') {
+                            console.log(`[heartbeat] 自动整理完成${evt.summary ? `: ${evt.summary}` : ''}`);
+                        }
+                        else if (evt?.phase === 'error') {
+                            console.warn(`[heartbeat] 自动整理失败 (non-fatal): ${evt?.error || ''}`);
+                        }
+                    },
                 });
                 agentHeartbeat.start();
                 // 注册到全局, 让 24h HealthMonitor.checkHeartbeat 能观测到本智能体 (getDiscoveredAgents/isAntColonyEnabled)

package/package.json

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