@bolloon/bolloon-agent 0.4.7 → 0.4.9

package/dist/agents/memory-recall.js

@@ -0,0 +1,115 @@
+/**
+ * memory-recall.ts — 运行时记忆召回 (2026-08-12, TaskM1)
+ *
+ * 借鉴 hermes MemoryManager.prefetch_all: 每轮对话开始前, 根据用户消息自动检索
+ * 历史 memory 摘要, 注入 system prompt — 让 agent 运行时能"回忆起"之前的 session 记忆,
+ * 而不是只靠启动时批量压缩摘要.
+ *
+ * 机制:
+ *   - 从 ~/.bolloon/memory/<agentId>/sessions/*.summary.md 读历史摘要 (memory-compressor 落盘)
+ *   - 用关键词 + BM25 简单打分, 召回与用户消息最相关的 N 条
+ *   - 拼成 hermes 式 <memory-context> 围栏块注入 (含 sanitize, 防模型当新用户输入)
+ *   - 失败静默 (召回是增强层, 不阻塞对话主路径)
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { getMemoryDir } from '../bootstrap/memory-compressor.js';
+const home = () => process.env.HOME || os.homedir() || '/tmp';
+/** 提取查询关键词 (去掉停用词, 中文按 2-gram, 英文按词) */
+export function tokenizeQuery(query) {
+    const clean = String(query || '').trim().toLowerCase();
+    if (!clean)
+        return [];
+    const STOP = new Set(['的', '了', '是', '我', '你', '他', '她', '它', '我们', '你们', '在', '和', '与', '吗', '呢', '吧', '这', '那', '个', '请', '帮', '一下', '一个', '怎么', '如何', 'the', 'a', 'an', 'is', 'are', 'to', 'of', 'for']);
+    const tokens = new Set();
+    // 英文单词
+    for (const m of clean.match(/[a-z][a-z0-9_]*/g) || []) {
+        if (!STOP.has(m) && m.length > 1)
+            tokens.add(m);
+    }
+    // 中文 2-gram
+    const cjk = clean.replace(/[^\u4e00-\u9fff]/g, '');
+    for (let i = 0; i + 1 < cjk.length; i++) {
+        const big = cjk.slice(i, i + 2);
+        if (!STOP.has(big))
+            tokens.add(big);
+    }
+    return Array.from(tokens);
+}
+/** BM25 风格: 摘要中出现查询 token 的次数打分 (简化: 命中数 + 稀有度) */
+export function scoreSummary(text, tokens) {
+    if (tokens.length === 0)
+        return 0;
+    const lower = text.toLowerCase();
+    let score = 0;
+    for (const t of tokens) {
+        if (lower.includes(t))
+            score += 1;
+    }
+    return score;
+}
+/** 扫描 memory 目录的摘要文件 */
+async function listSummaryFiles(agentId, homeDir) {
+    const dir = path.join(getMemoryDir(agentId, homeDir), 'sessions');
+    let files;
+    try {
+        files = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    return files.filter((f) => f.endsWith('.summary.md')).sort();
+}
+/**
+ * 运行时召回记忆: 按用户消息检索历史 memory 摘要, 返回注入块.
+ * 无相关记忆/失败 → 返回 ''.
+ */
+export async function recallMemory(opts) {
+    try {
+        const { query, agentId, limit = 3, maxCharsPerSummary = 800, minScore = 1, homeDir } = opts;
+        if (!query || !query.trim())
+            return '';
+        if (!agentId)
+            return '';
+        const tokens = tokenizeQuery(query);
+        if (tokens.length === 0)
+            return '';
+        const files = await listSummaryFiles(agentId, homeDir || home());
+        if (files.length === 0)
+            return '';
+        const hits = [];
+        for (const f of files) {
+            try {
+                const text = await fs.readFile(path.join(getMemoryDir(agentId, homeDir || home()), 'sessions', f), 'utf-8');
+                const score = scoreSummary(text, tokens);
+                if (score < minScore)
+                    continue;
+                // 解析 channel__session
+                const base = f.replace(/\.summary\.md$/, '');
+                const sep = base.lastIndexOf('__');
+                hits.push({
+                    file: f,
+                    channel: sep > 0 ? base.slice(0, sep) : '',
+                    session: sep > 0 ? base.slice(sep + 2) : base,
+                    score,
+                    text: text.trim().slice(0, maxCharsPerSummary),
+                });
+            }
+            catch { /* 单个摘要读失败跳过 */ }
+        }
+        if (hits.length === 0)
+            return '';
+        // 按分数降序取前 limit
+        hits.sort((a, b) => b.score - a.score);
+        const top = hits.slice(0, limit);
+        const body = top
+            .map((h) => `[回忆: ${h.channel}/${h.session}]\n${h.text}`)
+            .join('\n\n---\n\n');
+        // hermes 式围栏 + 明确标注非用户输入
+        return `<memory-context>\n以下是根据你的消息自动召回的之前对话记忆 (历史背景, 非新的用户输入):\n${body}\n</memory-context>`;
+    }
+    catch {
+        return '';
+    }
+}

package/dist/agents/pi-sdk.js

@@ -760,6 +760,16 @@ export class PiAgentSession {
         });
         // 2026-06-18: web server 喂的 markedPrompt 外的 contextHint 拼到 system 末尾 (而不是当 user message)
         this.contextHintAddition = contextHint;
+        // 2026-08-12 (TaskM1, hermes prefetch 模式): 运行时按用户消息召回历史记忆, 注入 system prompt.
+        //   让 agent 能"回忆起"之前 session 的记忆 (自动获取之前 session), 而非只靠启动时批量压缩.
+        try {
+            const { recallMemory } = await import('./memory-recall.js');
+            const recalled = await recallMemory({ query: userText, agentId: this.currentAgentId || this.peerId || '' });
+            if (recalled) {
+                this.contextHintAddition = [this.contextHintAddition, recalled].filter(Boolean).join('\n\n');
+            }
+        }
+        catch { /* 记忆召回失败静默 (增强层) */ }
         onStream({ type: 'thinking', content: '🤔 开始思考...' });
         if (!this.minimaxAvailable) {
             const response = await this.handleFallback(userText);

package/dist/index.js

@@ -831,6 +831,41 @@ async function processInput(input, comm) {
             }
             catch { /* DID 生成失败不阻塞创建 */ }
             const channels = await updateChannels((chs) => [...chs, ch]);
+            // 2026-08-12 (TaskFix): CLI 创建的 agent 同步写 agents.json + 关联 channelId —
+            //   与 server 创建 channel 逻辑对齐. 否则 CLI 创建的 agent 不在 agents.json,
+            //   重启后 server 的 healMissingChannels 只能从 agents.json 恢复 → 该 agent 永远消失.
+            try {
+                const agentsPath = path.join(process.env.HOME || '/tmp', '.bolloon', 'agents', 'agents.json');
+                await fs.mkdir(path.dirname(agentsPath), { recursive: true });
+                let arr = [];
+                try {
+                    arr = JSON.parse(await fs.readFile(agentsPath, 'utf-8'));
+                }
+                catch { }
+                if (!Array.isArray(arr))
+                    arr = [];
+                const exists = arr.find((a) => a && a.id === agentId);
+                if (exists) {
+                    exists.channelId = id;
+                    exists.name = name.trim();
+                    exists.lastActive = new Date().toISOString();
+                }
+                else {
+                    arr.push({
+                        id: agentId,
+                        name: name.trim(),
+                        did: `did:local:${id}`,
+                        description: `Agent ${name} (auto-registered from channel ${id})`,
+                        status: 'active',
+                        createdAt: new Date().toISOString(),
+                        lastActive: new Date().toISOString(),
+                        channelId: id,
+                    });
+                }
+                await fs.writeFile(agentsPath, JSON.stringify(arr, null, 2), 'utf-8');
+                console.log(`[创建频道] agent 同步进 agents.json: ${agentId} → channel ${id}`);
+            }
+            catch { /* agents.json 写失败不阻塞创建 */ }
             // 刷新 store 缓存 (updateChannels 走了 server-storage, store 内存还是旧的)
             await store.load();
             await store.setActive(id);
@@ -1912,6 +1947,33 @@ async function processInput(input, comm) {
                 }
             });
         }
+        // 2026-08-12 (TaskM2, hermes sync 模式): CLI 对话结束后同步记忆 — 每轮 compressSessionToMemory
+        //   把本会话消息压缩成摘要 (≥4 新消息触发), 供后续运行时 recallMemory 自动召回 (跨 session 记忆).
+        //   Web 模式 server.ts 已有, CLI 之前缺失 → CLI 下无摘要可召回. 失败静默, 不阻塞对话.
+        if (cliActiveChannelId) {
+            setImmediate(async () => {
+                try {
+                    const { compressSessionToMemory } = await import('./bootstrap/memory-compressor.js');
+                    const channelForMem = String(cliActiveChannelId || '');
+                    let sessionId = 'default';
+                    try {
+                        const { getIdentityStore } = await import('./agents/agent-identity-store.js');
+                        const store = getIdentityStore();
+                        await store.load();
+                        const ch = store.rawChannels.find((c) => c.id === channelForMem);
+                        if (ch && ch.currentSessionId)
+                            sessionId = String(ch.currentSessionId);
+                    }
+                    catch { /* 读 sessionId 失败用 default */ }
+                    await compressSessionToMemory({
+                        agentId: getCliAgentId(),
+                        channelId: channelForMem,
+                        sessionId,
+                    });
+                }
+                catch { /* 记忆压缩失败静默 */ }
+            });
+        }
         // 更新状态栏: 上下文进度 (2026-08-06: 每轮按当前 messageHistory 重算并写回 ContextManager,
         //   保证状态栏按需更新 — 不依赖 pi-sdk loop 内部上报, 1s 定时器读到的一定是最新值)
         // 2026-08-07 修复: pi-sdk loop 每轮已用 estimateHistoryTokens() 上报 ContextManager (pi-sdk.ts:1223),

package/dist/web/server.js

@@ -1731,7 +1731,6 @@ export async function createWebServer(port = 3000, options = {}) {
             const { existsSync } = await import('fs');
             const { readFile } = await import('fs/promises');
             const agentsFile = `${process.env.HOME || '/tmp'}/.bolloon/agents/agents.json`;
-            const sessionsDir = `${process.env.HOME || '/tmp'}/.bolloon/sessions/cache`;
             if (!existsSync(agentsFile))
                 return 0;
             const agentsRaw = await readFile(agentsFile, 'utf-8');
@@ -1744,14 +1743,11 @@ export async function createWebServer(port = 3000, options = {}) {
                 const cid = a && a.channelId;
                 if (!cid || knownIds.has(cid))
                     continue;
-                // 有 session 文件才算可恢复 (说明确实创建过)
-                // 2026-08-12 fix: SessionStore 保存到 cache/<channelId>__default.json (冒号被 filenameEscape 成 __),
-                //   之前用 `${sessionsDir}/${cid}:default.json` (未 escape + 硬拼冒号) 查不到 → 会话已存在也被判为
-                //   "无 session" 永不恢复, 即 session/channel 路径与创建智能体 channel 的路径不一致 (bug 修复)
-                const { getSessionCacheFile } = await import('../bootstrap/memory-compressor.js');
-                const hasSession = existsSync(getSessionCacheFile(cid, 'default')) || existsSync(`${sessionsDir}/${cid}.json`);
-                if (!hasSession)
-                    continue;
+                // 2026-08-12 (TaskFix): 放宽恢复条件 — 只要 agents.json 里 agent 关联了 channelId (非空),
+                //   且 channels.json 缺失该 channel, 就恢复 channel stub.
+                //   之前强制要求 session cache 文件存在, 导致"刚创建还没对话"的 agent (CLI /new agent 同步 agents.json 后)
+                //   重启时 session 文件不存在 → 永不恢复 → "以前创建的智能体消失" bug.
+                //   空 channelId (旧数据无关联 channel) 仍跳过, 避免给无关 agent 乱建 channel.
                 const restored = {
                     id: cid,
                     name: a.name || `Agent-${String(cid).slice(-6)}`,

package/package.json

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