@bolloon/bolloon-agent 0.6.4 → 0.6.6

package/dist/agents/opportunity-web-search.js

@@ -0,0 +1,222 @@
+/**
+ * opportunity-web-search.ts — AI 主动上网搜机会 (2026-10-05, leo: 系统要主动搜索展示)
+ *
+ * 设计: 世界观察器 (world-watcher) 每轮 tick 时, 若有 active intent / 用户画像,
+ *   自动用 DuckDuckGo 搜索「<意图> + 合作/机会/招募/开放」类关键词, 把真搜索结果
+ *   结构化落盘 `~/.bolloon/world/search/<id>.json`, 并进世界流 (reason=search, 带来源 URL)。
+ *
+ * 真实可信: 每条 = 真 URL + 真摘要 (来自搜索返回), 可点开核实, 不是本机编造。
+ * 无 TAVILY_API_KEY 时走 DuckDuckGo HTML 端点 (免费无需 key, 与本仓 fetch_url 同源 curl 模式)。
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as crypto from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { worldDir } from './intent-store.js';
+const pExecFile = promisify(execFile);
+const searchDir = () => path.join(worldDir(), 'search');
+function safeId(s) {
+    return s.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+}
+/** DuckDuckGo HTML 搜索 → 结构化结果 (标题/URL/摘要) */
+async function searchDuckDuckGo(query, limit = 8) {
+    try {
+        const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36';
+        const { stdout } = await pExecFile('curl', [
+            '-sL', '--max-time', '20', '-A', UA,
+            '-H', 'Accept-Language: zh-CN,zh;q=0.9,en;q=0.8',
+            `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`,
+        ], { maxBuffer: 2 * 1024 * 1024, timeout: 25_000 });
+        if (!stdout)
+            return [];
+        // 解析 result__a (标题+URL) + result__snippet (摘要)
+        const out = [];
+        const itemRe = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>(.*?)<\/a>/g;
+        let m;
+        let guard = 0;
+        while ((m = itemRe.exec(stdout)) !== null && guard++ < 30) {
+            const rawHref = m[1];
+            // DDG 的 href 是重定向包装 (//duckduckgo.com/l/?uddg=<encoded>)
+            let url = rawHref;
+            const uddg = rawHref.match(/uddg=([^&]+)/);
+            if (uddg) {
+                try {
+                    url = decodeURIComponent(uddg[1]);
+                }
+                catch {
+                    url = rawHref;
+                }
+            }
+            if (!/^https?:\/\//i.test(url))
+                continue;
+            const title = m[2].replace(/<[^>]+>/g, '').trim();
+            const summary = m[3].replace(/<[^>]+>/g, '').replace(/&[a-z]+;/g, ' ').replace(/\s+/g, ' ').trim();
+            if (title)
+                out.push({ title, url, summary: summary.slice(0, 200) });
+            if (out.length >= limit)
+                break;
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+/** Tavily 搜索 (配置了 TAVILY_API_KEY 时用, 更完整) */
+async function searchTavily(query, limit = 8) {
+    const key = process.env.TAVILY_API_KEY || '';
+    if (!key)
+        return [];
+    try {
+        const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36';
+        const { stdout } = await pExecFile('curl', [
+            '-s', '--max-time', '20', '-A', UA,
+            '-X', 'POST', 'https://api.tavily.com/search',
+            '-H', 'Content-Type: application/json',
+            '-d', JSON.stringify({ api_key: key, query, max_results: limit, include_answer: false }),
+        ], { maxBuffer: 2 * 1024 * 1024, timeout: 25_000 });
+        const d = JSON.parse(stdout);
+        return (d.results || []).slice(0, limit).map((x) => ({
+            title: String(x.title || '').trim(),
+            url: String(x.url || '').trim(),
+            summary: String(x.content || '').replace(/\s+/g, ' ').slice(0, 200),
+        })).filter((x) => x.title && /^https?:/.test(x.url));
+    }
+    catch {
+        return [];
+    }
+}
+/** 搜索查询构造: 意图/画像 + 机会类词 (真搜索, 关键词可配) */
+const OPPORTUNITY_HINTS = ['合作', '机会', '招募', 'open call', 'partnership', 'looking for', 'call for'];
+function buildQueries(topic) {
+    const base = String(topic || '').trim().slice(0, 60);
+    if (!base)
+        return [];
+    return OPPORTUNITY_HINTS.map((h) => `${base} ${h}`);
+}
+/**
+ * 主动搜索一轮: 按 topic (意图/画像文本) 搜机会, 结构化落盘。
+ * 返回本轮新增条数 (已有同 URL 的不重复落盘 — 幂等)。
+ */
+export async function searchOpportunitiesForTopic(topic, opts = {}) {
+    const limit = opts.limit ?? 6;
+    const queries = buildQueries(topic);
+    if (!queries.length)
+        return { ok: false, added: 0, total: 0, results: [], error: '空 topic' };
+    // 合并引擎结果 (Tavily 优先, 无 key 走 DDG)
+    const engine = process.env.TAVILY_API_KEY ? searchTavily : searchDuckDuckGo;
+    const raw = [];
+    for (const q of queries.slice(0, 3)) {
+        const hits = await engine(q, limit);
+        for (const h of hits)
+            raw.push({ ...h, query: q });
+    }
+    // 已有 URL 集合 (幂等)
+    const seen = new Set();
+    try {
+        const files = await fs.readdir(searchDir());
+        for (const f of files) {
+            if (!f.endsWith('.json'))
+                continue;
+            try {
+                const p = JSON.parse(await fs.readFile(path.join(searchDir(), f), 'utf-8'));
+                if (p && p.url)
+                    seen.add(String(p.url));
+            }
+            catch { /* 坏文件跳过 */ }
+        }
+    }
+    catch { /* 目录不存在 = 首次 */ }
+    const now = Date.now();
+    const results = [];
+    let added = 0;
+    try {
+        await fs.mkdir(searchDir(), { recursive: true });
+    }
+    catch { /* 落盘失败不阻断 */ }
+    for (const r of raw) {
+        if (seen.has(r.url))
+            continue; // 已有, 不重复
+        const id = `search_${safeId(crypto.createHash('sha256').update(r.url).digest('hex').slice(0, 14))}`;
+        const opp = {
+            id,
+            query: r.query,
+            title: r.title.slice(0, 80),
+            url: r.url,
+            summary: r.summary,
+            source: process.env.TAVILY_API_KEY ? 'tavily' : 'duckduckgo',
+            searchedAt: now,
+        };
+        try {
+            await fs.writeFile(path.join(searchDir(), `${id}.json`), JSON.stringify(opp, null, 2) + '\n', { mode: 0o600 });
+            seen.add(r.url);
+            results.push(opp);
+            added += 1;
+        }
+        catch { /* 单条失败跳过 */ }
+        if (added >= limit)
+            break;
+    }
+    // 2026-10-05 降级 (leo: 输入后要足够多机会): 引擎被限流/返回空时,
+    // 从已有搜索库按关键词相关度返回匹配旧结果 — 保证输入后总有内容 (不假装, 都是真 URL)。
+    if (added === 0) {
+        try {
+            const existing = await listSearchOpportunities();
+            const topicTags = buildTags(topic);
+            const related = existing
+                .map((o) => {
+                const tags = buildTags(`${o.title} ${o.summary} ${o.query || ''}`);
+                const hit = topicTags.filter((t) => tags.includes(t)).length;
+                return { o, hit };
+            })
+                .filter((x) => x.hit > 0)
+                .sort((a, b) => b.hit - a.hit)
+                .slice(0, limit);
+            for (const { o } of related) {
+                results.push({ ...o, query: `${topic} (相关)` });
+            }
+            if (results.length > 0) {
+                return { ok: true, added: 0, total: results.length, results, error: '引擎限流, 已返回相关旧结果' };
+            }
+        }
+        catch { /* 降级失败不影响 */ }
+    }
+    return { ok: true, added, total: results.length, results };
+}
+/** 提取关键词标签 (分词: ASCII 词 + CJK 二元片) — 用于相关度匹配 (导出供测试) */
+export function buildTags(text) {
+    const src = String(text || '').toLowerCase();
+    const words = src.match(/[a-z][a-z0-9_-]{2,}/g) || [];
+    const cjk = src.match(/[\u4e00-\u9fff]+/g) || [];
+    const cjkBigrams = cjk.flatMap((s) => {
+        if (s.length <= 2)
+            return [s];
+        const out = [];
+        for (let i = 0; i + 1 < s.length; i += 1)
+            out.push(s.slice(i, i + 2));
+        return out;
+    });
+    return Array.from(new Set([...words, ...cjkBigrams]));
+}
+/** 列出已搜索到的机会 (最近在前) */
+export async function listSearchOpportunities() {
+    try {
+        const files = await fs.readdir(searchDir());
+        const out = [];
+        for (const f of files) {
+            if (!f.endsWith('.json'))
+                continue;
+            try {
+                const p = JSON.parse(await fs.readFile(path.join(searchDir(), f), 'utf-8'));
+                if (p && p.id && p.url)
+                    out.push(p);
+            }
+            catch { /* 坏文件跳过 */ }
+        }
+        return out.sort((a, b) => b.searchedAt - a.searchedAt);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/agents/p2p-chat-tools.js

@@ -23,7 +23,7 @@ import * as path from 'path';
 import * as os from 'os';
 import { EventEmitter } from 'events';
 import { irohTransport as defaultIrohTransport } from '../network/iroh-transport.js';
-import { getRelevantValues, getValueProfile, loadAllJudgments } from '../pi-ecosystem-judgment/human-value-store.js';
+import { getValueProfile, loadAllJudgments } from '../pi-ecosystem-judgment/human-value-store.js';
 function homeDir() {
     return process.env.HOME || process.env.USERPROFILE || os.homedir();
 }
@@ -189,7 +189,6 @@ export async function getInbox(peerDID) {
 async function buildValueHint(text) {
     try {
         const allJudgments = await loadAllJudgments();
-        const relevant = await getRelevantValues(text, undefined);
         const profile = await getValueProfile('me');
         const profileHint = [
             `quality_focus=${profile.quality_focus.toFixed(2)}`,

package/dist/agents/parse-tool-call.js

@@ -522,21 +522,19 @@ export function parseToolCall(content, ctx) {
     return null;
 }
 /**
- * isFinalResponse — 临时判断 LLM 是否已完结 (含 <final gen>)
- * 2026-06-19/06-30 修: 先剥离 think, 避免思考块中提及 <final gen> 误杀
- *                       含可解析 tool_call 则优先执行工具, 不算 final
+ * isFinalResponse — 判断 LLM 是否已完结。
+ * 2026-10-12 (leo 拍板: 全项目去掉 <final gen> 截止符): 旧实现只有在回复里找到
+ *   `<final gen>` 标记才返回 true —— 模型中间轮次 echo 该文本就误判提前截止。
+ *   现在: 剥掉 think 块后**没有可执行工具调用** = 这一轮就是最终答复。
+ *   (工具调用优先: 含可解析 tool_call 不算 final, 先执行工具。)
  */
 export function isFinalResponse(content, ctx) {
-    const stripped = content.replace(/<think[\s\S]*?<\/think/g, '');
-    if (!stripped.includes('<final gen>'))
-        return false;
-    // 用默认 ctx (无需 tool 名解析, 只看能否 parse 出来) - 但 isFinalResponse 不需要 tools 列表上下文.
-    // 如果没有传 ctx, 使用 empty set (只解析不 resolve).
+    const stripped = content.replace(/<think[\s\S]*?<\/think>/g, '');
+    // 与 react-loop 的判定链一致: 有可解析的工具调用 → 优先执行工具, 不算 final
     if (ctx && parseToolCall(stripped, ctx))
         return false;
     if (!ctx) {
         // 试探性 parse (不 resolve name) — 如果至少能提取 name+args 模式, 就不是 final.
-        // 这里粗略检测: stripped 中含 json "name": 或 <invoke name= 或 <function_calls> 任一
         if (/\{[\s\S]*?"name"\s*:/.test(stripped))
             return false;
         if (/<invoke\s+name=/.test(stripped))
@@ -546,23 +544,12 @@ export function isFinalResponse(content, ctx) {
     }
     return true;
 }
-/** extractFinalAnswer: 去除 <final gen> 标记 + tool call 噪声. */
+/** extractFinalAnswer: 去除 tool call 噪声. (2026-10-12: <final gen> 标记移除, 不再剥除) */
 export function extractFinalAnswer(content) {
-    const marker = '<final gen>';
-    const markerIndex = content.indexOf(marker);
-    if (markerIndex !== -1) {
-        const after = content.substring(markerIndex + marker.length).trim();
-        if (after) {
-            content = after;
-        }
-        else {
-            content = content.substring(0, markerIndex).trim();
-        }
-    }
     let cleaned = content
         .replace(/调用工具[：:]\s*\w+\s*\([^)]*\)/g, '')
         .replace(/使用工具[：:]\s*\w+\s*\([^)]*\)/g, '')
-        .replace(/tool[_\w]*[：:]\s*\w+\s*\([^)]*\)/gi, '')
+        .replace(/tool[_\\w]*[：:]\s*\w+\s*\([^)]*\)/gi, '')
         .trim();
     return cleaned;
 }

package/dist/agents/pi-harness.js

@@ -29,7 +29,6 @@ export class PiAgentHarness {
     deps;
     failClosed;
     modelCalls = 0;
-    degradedOnce = new Set();
     constructor(deps) {
         this.deps = deps;
         this.failClosed = deps.failClosed !== false;
@@ -256,7 +255,7 @@ export class PiAgentHarness {
             this.emit({ event: 'review', kind: 'error', failureKind: 'goal_review', reason: `审查器失效: ${err?.message}`, runId: state.runId, goalId: state.goalId });
             return {
                 kind: 'continue-review',
-                hint: `[目标审查降级] 审查器执行失败 (${String(err?.message || err).slice(0, 120)}), 按"未确认完成"处理: 请再次核对用户需求是否真的全部满足, 并列出证据。确认完成后再加 <final gen>。`,
+                hint: `[目标审查降级] 审查器执行失败 (${String(err?.message || err).slice(0, 120)}), 按"未确认完成"处理: 请再次核对用户需求是否真的全部满足, 并列出证据。确认完成后再给出最终回答。`,
             };
         }
     }

package/dist/agents/pi-sdk-tools.js

@@ -13,6 +13,7 @@ import { checkWritePath } from './shell-guard.js';
 import { p2pDocumentTools } from './p2p-document-tools.js';
 import { runSelfImproveLoop } from './pi-sdk-session-factory.js';
 import { getMinimax } from '../constraints/index.js';
+import { llmConfigStore } from '../llm/config-store.js';
 import { delegateToEngine, buildDelegateCommand } from '../external-engines/delegate.js';
 import { spawnBackground } from './process-runner.js';
 import { DELEGATE_ENV_MARK } from './background-notices.js';
@@ -858,11 +859,9 @@ export function registerBuiltinTools(ctx) {
     //   与 shell_exec 的区别: 直接接受完整 shell 命令字符串, 更适合模型自主写命令.
     // 2026-10-01 (优化 #2 v1): **工具发现** —— 125 个工具不可能都记住, 给一个"按关键词找工具"的入口。
     // 空关键词只回**分类索引**(名称清单), 有关键词才回"名称+用途摘要" ⇒ 不刷屏。
-    // 2026-10-01 (用户: 「skills 教训学习, bolloon 有吗, 从 hermes 触发的方法是什么, 学一下」):
-    //   **实测缺口**: `skill-loader` 把 1300 个技能**注册**进注册表 ✓, 但 `describeSkill` 只 import 从没调用 ✗
-    //   ⇒ 技能**描述从不进提示** ⇒ 模型不知道它们存在 ⇒ 技能触发链**断在这里** ✗。
-    //   她那边的做法: 启动自动装载 + 按**描述**在提示里露面 + 需要时用 `skill_view` 读全文 ✓。
-    //   bolloon 有 1300 个(她百来号) ⇒ 全量注入会撑爆提示 ✗ ⇒ 改成**两个发现工具**(和 `list_tools` 同一思路 ✓)。
+    // 2026-10-01 (用户: 「skills 教训学习, bolloon 有吗」): 技能发现 = 两个工具而非全量注入 —
+    //   技能库上千个, 全量注入会撑爆提示 (历史: 19 个 skill 曾把 systemPrompt 顶到 22K 导致模型不输出)。
+    //   做法同 `list_tools`: 按关键词找 (`list_skills`) → 读全文 (`read_skill`)。
     ctx.tools.set('list_skills', {
         name: 'list_skills',
         description: '用于**找技能**: 给关键词(中文/英文都行)⇒ 返回已装载技能的名字+说明(≤20 条); 不给关键词 ⇒ 先给总数与前若干条. 找到后用 read_skill 读全文再照做.',
@@ -4445,6 +4444,182 @@ export function registerWalletTools(ctx) {
             }
         }
     });
+    // 2026-10-14 (leo: 「需要向量记忆和去中心化记忆」, P0): 结构化记忆工具
+    //  —— MemoryEntry 本地 JSONL 持久化; embedding 向量 (P1) / OrbitDB 复制 (P3) 后续接
+    const memoryAgentId = () => ctx.identity?.did || String(ctx.cwd || '');
+    /**
+     * P1: 记忆 embedding 配置。读 llm-config 的 `embedding` 段:
+     *   { embedding: { provider, model, baseUrl?, apiKey?, groupId? } }
+     * 未配置 / provider 不可用 → { provider: 'none' } (记忆层回退关键词, 行为不变)。
+     * 诚实边界: 本仓现有 provider (glm 中转 / minimax 订阅 key) 实测无可用 embedding,
+     * 故默认 none; 将来任一供应商 key 就绪, 在此配置段填上即可, 记忆层零改动。
+     */
+    const getMemoryEmbeddingConfig = () => {
+        try {
+            const cfg = llmConfigStore?.config;
+            const emb = cfg?.embedding;
+            if (emb && typeof emb === 'object' && emb.provider && emb.provider !== 'none') {
+                return {
+                    provider: String(emb.provider),
+                    model: emb.model ? String(emb.model) : undefined,
+                    baseUrl: emb.baseUrl ? String(emb.baseUrl) : undefined,
+                    apiKey: emb.apiKey ? String(emb.apiKey) : undefined,
+                    groupId: emb.groupId ? String(emb.groupId) : undefined,
+                };
+            }
+        }
+        catch { /* 配置读取失败 → none */ }
+        return { provider: 'none' };
+    };
+    ctx.tools.set('memory_save', {
+        name: 'memory_save',
+        description: '保存一条**结构化长期记忆** (事实/偏好/洞察/事件/关系/技能反馈)。用于: 用户明确说"记住 X"、反复出现的偏好、值得跨会话保留的事实。自动去重 (同内容不重复), 自动打分重要性。',
+        parameters: {
+            content: '记忆内容 (必填, ≥2 字符)',
+            kind: '类型: fact | insight | preference | event | relationship | skill-feedback (默认 fact)',
+            importance: '手动重要性 0-1 (可选, 缺省自动启发式打分)',
+            refs: '关联证据 JSON 数组 (可选, 如 goalId/runId)',
+        },
+        execute: async (args) => {
+            try {
+                const { getMemoryStore } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                // P1: 有 embedding adapter 时 save 顺便向量化 (存 vec, 供语义召回)
+                let adapter;
+                try {
+                    const { createEmbeddingAdapter } = await import('../llm/embedding-adapter.js');
+                    const a = createEmbeddingAdapter(getMemoryEmbeddingConfig());
+                    if (a.provider !== 'none')
+                        adapter = a;
+                }
+                catch { /* 无向量能力 → 只存文本 */ }
+                const entry = await store.save({
+                    content: String(args.content || '').trim(),
+                    kind: args.kind || 'fact',
+                    importance: args.importance !== undefined ? Number(args.importance) : undefined,
+                    refs: Array.isArray(args.refs) ? args.refs.map(String) : undefined,
+                    source: 'tool',
+                }, adapter);
+                // P3: 条目级 OrbitDB 同步 (失败静默 — 本地记忆仍权威)
+                try {
+                    const { syncMemoryEntryToOrbit } = await import('../orbitdb/memory-sync.js');
+                    await syncMemoryEntryToOrbit(entry);
+                }
+                catch { /* 同步失败不阻塞保存 */ }
+                return { success: true, output: `✅ 已保存记忆 #${entry.id.slice(0, 8)} (${entry.kind}, 重要性 ${entry.importance.toFixed(2)})` };
+            }
+            catch (e) {
+                return { success: false, error: `memory_save 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    ctx.tools.set('memory_recall', {
+        name: 'memory_recall',
+        description: '按查询关键词**召回长期记忆** (事实/偏好/洞察)。每轮对话已自动做记忆召回, 这里用于显式深挖: 用户说"你还记得我之前说的 X"、或当前任务需要历史上下文时调用。',
+        parameters: {
+            query: '查询内容 (必填, 用关键词)',
+            limit: '返回条数 (默认 3)',
+        },
+        execute: async (args) => {
+            try {
+                const { getMemoryStore, formatRecallBlock } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                await store.load();
+                // P3: 召回前先拉远端条目合并 (LWW, updatedAt 大者胜; 网络不可用静默)
+                try {
+                    const { fetchRemoteEntries } = await import('../orbitdb/memory-sync.js');
+                    const remote = await fetchRemoteEntries(memoryAgentId());
+                    if (remote.length > 0)
+                        await store.mergeRemote(remote);
+                }
+                catch { /* 远端拉取失败 → 只用本地 */ }
+                const query = String(args.query || '');
+                // P1: 有 embedding adapter 时走向量召回; 无 → 关键词回退 (P0 行为不变)
+                let queryVec;
+                try {
+                    const { createEmbeddingAdapter } = await import('../llm/embedding-adapter.js');
+                    const adapter = createEmbeddingAdapter(getMemoryEmbeddingConfig());
+                    if (adapter.provider !== 'none' && query.trim()) {
+                        queryVec = await adapter.embed(query);
+                    }
+                }
+                catch { /* vector 不可用 → 关键词回退 */ }
+                const hits = await store.recall({
+                    query,
+                    limit: args.limit ? Number(args.limit) : 3,
+                    queryVec,
+                });
+                if (!hits.length)
+                    return { success: true, output: '📭 没有找到相关记忆 (可能是新话题或记忆未保存)' };
+                return { success: true, output: formatRecallBlock(hits) };
+            }
+            catch (e) {
+                return { success: false, error: `memory_recall 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    // P2: 价值分层工具 — 固化 / 遗忘 / 统计 (2026-10-11, decentralized-memory-design §2.7)
+    ctx.tools.set('memory_crystallize', {
+        name: 'memory_crystallize',
+        description: '固化一条记忆 (crystallize): 标记为「重要, 不淡忘」+ importance 加成。用于: 用户明确说"这个要记住"、反复确认的重要约定、多次命中的核心事实。返回固化后的条目。',
+        parameters: {
+            entryId: '记忆 ID (从 memory_recall 的返回里拿, 形如 #xxxxxxxx)',
+        },
+        execute: async (args) => {
+            try {
+                const { getMemoryStore } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                await store.load();
+                const id = String(args.entryId || '').replace(/^#/, '');
+                const e = await store.crystallize(id);
+                if (!e)
+                    return { success: false, error: `未找到记忆 #${id}` };
+                return { success: true, output: `✅ 已固化记忆 #${e.id.slice(0, 8)} (${e.kind}, importance ${e.importance.toFixed(2)}, 不再淡忘)` };
+            }
+            catch (e) {
+                return { success: false, error: `memory_crystallize 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    ctx.tools.set('memory_forget', {
+        name: 'memory_forget',
+        description: '删除一条记忆 (entryId 从 memory_recall 返回拿)。用于: 用户说"忘掉这个/删掉这条记忆"、记忆过时/错误。删除不可恢复。',
+        parameters: {
+            entryId: '记忆 ID (形如 #xxxxxxxx)',
+        },
+        execute: async (args) => {
+            try {
+                const { getMemoryStore } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                await store.load();
+                const id = String(args.entryId || '').replace(/^#/, '');
+                const ok = await store.remove(id);
+                if (!ok)
+                    return { success: false, error: `未找到记忆 #${id}` };
+                return { success: true, output: `🗑️ 已删除记忆 #${id.slice(0, 8)}` };
+            }
+            catch (e) {
+                return { success: false, error: `memory_forget 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    ctx.tools.set('memory_stats', {
+        name: 'memory_stats',
+        description: '查看记忆库统计: 总条数 / 已固化 / 已淡化 (decay)。用于: 用户问"我存了多少记忆"、诊断记忆衰减是否生效。',
+        parameters: {},
+        execute: async () => {
+            try {
+                const { getMemoryStore } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                await store.load();
+                const s = store.stats();
+                return { success: true, output: `📊 记忆统计: 共 ${s.total} 条 · 已固化 ${s.crystallized} · 已淡化 ${s.decayed}` };
+            }
+            catch (e) {
+                return { success: false, error: `memory_stats 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
     // 2026-07-28: 注册 LSP 工具 (代码智能)
     // registerBuiltinTools 不是 async, 用同步 import 兜底
     try {