@bolloon/bolloon-agent 0.6.4 → 0.6.6

package/dist/agents/memory-store.js

@@ -0,0 +1,359 @@
+/**
+ * memory-store.ts — 结构化记忆条目 (P0, 2026-10-14, decentralized-memory-design §2)
+ *
+ * 与 memory-recall.ts (会话摘要召回) 互补: 摘要文件是「整段会话的压缩」,
+ * 这里是「结构化单条记忆」—— kind / importance / refs 证据链, 可单独召回/删除/固化。
+ *
+ * P0 范围 (小步, 零新依赖):
+ *   - MemoryEntry 模型 + 原子 JSONL 持久化 (~/.bolloon/memory/<agentId>/entries.jsonl)
+ *   - save (自动 importance 启发式打分) / recall (关键词 + importance 加权) / remove
+ *   - 无 embedding (P1 接), 无 OrbitDB 复制 (P3 接)
+ *
+ * 借鉴 Hermes (decentralized-memory-design §1.5):
+ *   - 写入落盘, prompt 注入走「每轮召回」快照, 不实时重建 (冻结快照 ≠ 实时写)
+ *   - 条目摘要进上下文, 全文按需拉取 (progressive disclosure)
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { createHash } from 'node:crypto';
+import { cosineSimilarity } from '../llm/embedding-adapter.js';
+const home = () => process.env.HOME || os.homedir() || '/tmp';
+export function memoryEntriesPath(agentId, homeDir) {
+    const base = homeDir || home();
+    return path.join(base, '.bolloon', 'memory', agentId, 'entries.jsonl');
+}
+/** 空内容/纯空白 → 拒绝存 (与 evaluateQuality 同口径: 空串不是记忆) */
+function validContent(content) {
+    return String(content || '').trim().length >= 2;
+}
+/** importance 启发式: 长度 + 特定信号词 (P0 无 LLM 打分, 不引依赖) */
+export function heuristicImportance(content, kind = 'fact', manual) {
+    if (typeof manual === 'number')
+        return Math.min(1, Math.max(0, manual));
+    const t = String(content || '');
+    let score = 0.3; // 基线
+    if (t.length > 100)
+        score += 0.2; // 长记忆 = 更可能是重要细节
+    if (/喜欢|偏好|讨厌|禁止|必须|永远|从不|重要|注意|记住|约定/.test(t))
+        score += 0.25; // 用户强语义
+    if (kind === 'preference' || kind === 'relationship')
+        score += 0.2;
+    if (kind === 'skill-feedback')
+        score += 0.15;
+    return Math.min(1, score);
+}
+/**
+ * P2: 价值衰减 (decay) — 长期未被召回的条目降权标记, 不删除。
+ * 规则:
+ *   - 固化条目 (crystallized) 豁免 (用户确认过/多次命中, 不淡忘)
+ *   - 从 lastRecalledAt (未召回过 = createdAt) 起算, 超过 days 天 → decayed=true + importance×factor
+ *   - 被召回 → decayed 撤销 (recall 里已处理)
+ * 纯函数: 不改 entry, 返回更新后的副本 (无变化返回原引用)。
+ */
+export function applyDecay(entry, nowIso, opts = {}) {
+    if (entry.crystallized)
+        return entry; // 固化豁免
+    const days = opts.days ?? 30;
+    const factor = opts.factor ?? 0.5;
+    const base = entry.lastRecalledAt || entry.createdAt;
+    const ms = Date.parse(nowIso) - Date.parse(base);
+    if (!Number.isFinite(ms) || ms < 0)
+        return entry;
+    const elapsedDays = ms / 86_400_000;
+    if (elapsedDays < days)
+        return entry;
+    // 幂等: 已淡化过就不再重复降 (decayed 标记本身是终态)
+    if (entry.decayed)
+        return entry;
+    return {
+        ...entry,
+        importance: Math.max(0.05, entry.importance * factor),
+        decayed: true,
+        updatedAt: nowIso,
+    };
+}
+/** P2: 全库跑一次 decay, 返回被淡化条数 (未调用过 save/recall 的旧条目也会被标) */
+export function decayAll(entries, nowIso, opts = {}) {
+    let n = 0;
+    for (const [id, e] of entries) {
+        const after = applyDecay(e, nowIso, opts);
+        if (after !== e) {
+            entries.set(id, after);
+            n++;
+        }
+    }
+    return n;
+}
+/** 关键词提取 (与 memory-recall.tokenizeQuery 同口径: 中文 2-gram + 英文分词) */
+function tokenize(text) {
+    const clean = String(text || '').toLowerCase().trim();
+    if (!clean)
+        return [];
+    const STOP = new Set(['的', '了', '是', '我', '你', '他', '她', '它', '我们', '你们', '在', '和', '与', '吗', '呢', '吧', '这', '那', '个', '请', '帮', '一下', '一个', '怎么', '如何', 'the', 'a', 'an', 'is', 'are', 'to', 'of', 'for', 'and']);
+    const out = [];
+    // 英文词
+    for (const w of clean.match(/[a-z][a-z0-9_]+/g) || []) {
+        if (!STOP.has(w))
+            out.push(w);
+    }
+    // 中文 2-gram
+    const cjk = (clean.match(/[\u4e00-\u9fff]+/g) || []).join('');
+    for (let i = 0; i < cjk.length - 1; i++) {
+        const g = cjk.slice(i, i + 2);
+        if (!STOP.has(g))
+            out.push(g);
+    }
+    return out;
+}
+/** 词 → 分数 (词面命中 1 + 干净长词加权, 不引 TF-IDF, P1 换向量) */
+function scoreText(text, tokens) {
+    const t = String(text || '').toLowerCase();
+    let score = 0;
+    for (const tok of tokens) {
+        if (t.includes(tok))
+            score += tok.length >= 4 ? 1.2 : 1;
+    }
+    return score;
+}
+/**
+ * MemoryStore — 单 agent 的结构化记忆 (每实例对应一个 agentId, 不跨 agent)
+ *
+ * 文件锁: fcntl 不可用 (Windows) 时退化为无锁 (与 Hermes 同思路, 原子 rename 兜底)。
+ * 防并发写坏: 写入 → tmp 文件 → rename 原子替换。
+ */
+export class MemoryStore {
+    agentId;
+    file;
+    entries = new Map();
+    constructor(agentId, homeDir) {
+        this.agentId = agentId;
+        this.file = memoryEntriesPath(agentId, homeDir);
+    }
+    async load() {
+        try {
+            const raw = await fs.readFile(this.file, 'utf8');
+            this.entries.clear();
+            for (const line of raw.split('\n')) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const e = JSON.parse(line);
+                    if (e?.id)
+                        this.entries.set(e.id, e);
+                }
+                catch { /* 单行损坏跳过 (append-only, 不整文件作废) */ }
+            }
+        }
+        catch { /* 文件不存在 = 空记忆 */ }
+    }
+    async persist() {
+        const dir = path.dirname(this.file);
+        await fs.mkdir(dir, { recursive: true });
+        const tmp = `${this.file}.tmp-${process.pid}`;
+        const lines = [...this.entries.values()].map((e) => JSON.stringify(e));
+        await fs.writeFile(tmp, lines.join('\n') + (lines.length ? '\n' : ''));
+        await fs.rename(tmp, this.file); // 原子替换, 并发读不碰半截文件
+    }
+    async save(input, adapter) {
+        const content = String(input.content || '').trim();
+        if (!validContent(content))
+            throw new Error('记忆内容太短 (至少 2 个字符)');
+        const now = new Date().toISOString();
+        const id = createHash('sha256').update(`${this.agentId}|${content}`).digest('hex').slice(0, 32);
+        const existing = this.entries.get(id);
+        let vec = existing?.vec;
+        if (adapter && adapter.provider !== 'none') {
+            try {
+                vec = await adapter.embed(content); // 内容变 → 重算; 内容同 → 复用旧向量
+            }
+            catch {
+                // 向量化失败不阻塞保存 (记忆仍存, 召回走关键词)
+            }
+        }
+        const entry = {
+            id,
+            agentId: this.agentId,
+            content,
+            kind: input.kind || existing?.kind || 'fact',
+            importance: heuristicImportance(content, input.kind || existing?.kind, input.importance),
+            createdAt: existing?.createdAt || now,
+            updatedAt: now,
+            source: input.source || existing?.source || 'manual',
+            refs: input.refs || existing?.refs || [],
+            crystallized: existing?.crystallized || false,
+            recallCount: existing?.recallCount || 0,
+            lastRecalledAt: existing?.lastRecalledAt,
+            decayed: existing?.decayed,
+            vec,
+        };
+        this.entries.set(id, entry);
+        await this.persist();
+        return entry;
+    }
+    /**
+     * 召回:
+     *   - queryVec 提供 且 条目有 vec → cosine 相似度 (语义召回), 按 importance 加权
+     *   - 否则 → 关键词命中 (P0 行为), 完全兼容旧调用
+     * 命中后 recallCount++ 并落盘 (动态升权)
+     */
+    async recall(opts) {
+        if (this.entries.size === 0)
+            return [];
+        const limit = opts.limit || 3;
+        const hits = [];
+        const qv = opts.queryVec;
+        const useVec = !!qv && qv.length > 0;
+        if (useVec) {
+            const minCosine = opts.minCosine ?? 0;
+            for (const e of this.entries.values()) {
+                if (!e.vec || e.vec.length !== qv.length)
+                    continue; // 无向量的旧条目跳过
+                const c = cosineSimilarity(qv, e.vec);
+                if (c < minCosine)
+                    continue;
+                const weighted = c * (0.4 + 0.6 * e.importance); // importance 加权
+                if (weighted > 0)
+                    hits.push({ entry: e, score: weighted });
+            }
+        }
+        else {
+            const tokens = tokenize(opts.query);
+            if (tokens.length === 0)
+                return [];
+            const minScore = opts.minScore ?? 0;
+            for (const e of this.entries.values()) {
+                const s = scoreText(e.content, tokens);
+                if (s <= minScore)
+                    continue;
+                const weighted = Math.min(5, s) * (0.4 + 0.6 * e.importance); // importance 加权
+                hits.push({ entry: e, score: weighted });
+            }
+        }
+        hits.sort((a, b) => b.score - a.score);
+        const top = hits.slice(0, limit);
+        // 命中 → recallCount++ + lastRecalledAt 刷新 (动态升权 / decay 重置), 每 10 次 importance +0.05
+        if (top.length > 0) {
+            const nowIso = new Date().toISOString();
+            let changed = false;
+            for (const h of top) {
+                h.entry.recallCount++;
+                h.entry.lastRecalledAt = nowIso;
+                if (h.entry.decayed)
+                    h.entry.decayed = false; // 被召回 → 淡化撤销
+                if (h.entry.recallCount % 10 === 0 && h.entry.importance < 1) {
+                    h.entry.importance = Math.min(1, h.entry.importance + 0.05);
+                }
+                changed = true;
+            }
+            if (changed)
+                await this.persist().catch(() => { });
+        }
+        return top;
+    }
+    /** P2: 固化 — 多次召回或用户确认后调用; crystallized=true (进 08-Insights 由调用方负责) */
+    async crystallize(id) {
+        const e = this.entries.get(id);
+        if (!e)
+            return null;
+        const changed = !e.crystallized;
+        e.crystallized = true;
+        e.importance = Math.min(1, e.importance + 0.1); // 固化 → importance 加成
+        e.updatedAt = new Date().toISOString();
+        if (changed)
+            await this.persist();
+        return e;
+    }
+    /** P2: 自动固化阈值 — 召回 ≥ 5 次且 importance ≥ 0.6 的条目 (recall 后可调用, 返回新固化条数) */
+    async autoCrystallize() {
+        let n = 0;
+        for (const e of this.entries.values()) {
+            if (!e.crystallized && e.recallCount >= 5 && e.importance >= 0.6) {
+                e.crystallized = true;
+                e.importance = Math.min(1, e.importance + 0.1);
+                e.updatedAt = new Date().toISOString();
+                n++;
+            }
+        }
+        if (n > 0)
+            await this.persist();
+        return n;
+    }
+    /** P2: 统计 (decay 标定 / 审计用) */
+    stats() {
+        let crystallized = 0;
+        let decayed = 0;
+        for (const e of this.entries.values()) {
+            if (e.crystallized)
+                crystallized++;
+            if (e.decayed)
+                decayed++;
+        }
+        return { total: this.entries.size, crystallized, decayed };
+    }
+    /**
+     * P3: 合并远端条目 (OrbitDB 拉回的) 到本地, LWW (updatedAt 大者胜)。
+     * 返回被采纳的远端条数; 有采纳则落盘。同步前本地必须先 load()。
+     */
+    async mergeRemote(remote) {
+        let n = 0;
+        for (const r of remote) {
+            if (!r || !r.id || r.agentId !== this.agentId)
+                continue; // 归属校验: 只合并本 agent
+            const l = this.entries.get(r.id);
+            if (!l) {
+                this.entries.set(r.id, r);
+                n++;
+            }
+            else if (r.updatedAt > l.updatedAt) {
+                this.entries.set(r.id, r);
+                n++;
+            }
+            // 平手 / 本地更新 → 本地胜 (LWW)
+        }
+        if (n > 0)
+            await this.persist();
+        return n;
+    }
+    /** P3: 导出一份「可在其他节点重建」的条目快照 (不含运行时计数, 只含持久事实) */
+    exportEntries() {
+        return [...this.entries.values()].map((e) => ({ ...e, vec: undefined })); // vec 不跨节点 (维度依赖 adapter)
+    }
+    async remove(id) {
+        const existed = this.entries.delete(id);
+        if (existed)
+            await this.persist();
+        return existed;
+    }
+    async list(limit = 50) {
+        return [...this.entries.values()]
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+            .slice(0, limit);
+    }
+}
+/** 单例 (per-agent 分桶, 与 getContextStore 同模式); 测试可传 homeDir */
+const stores = new Map();
+export function getMemoryStore(agentId, homeDir) {
+    const key = `${homeDir || home()}|${agentId}`;
+    let s = stores.get(key);
+    if (!s) {
+        s = new MemoryStore(agentId, homeDir);
+        stores.set(key, s);
+    }
+    return s;
+}
+/** 召回 → 拼注入文本 (progressive disclosure: 只带摘要级内容 + id, 全文按需 load) */
+export function formatRecallBlock(hits) {
+    if (!hits.length)
+        return '';
+    const lines = hits.map((h, i) => {
+        const e = h.entry;
+        const tag = `${e.kind}${e.crystallized ? '★' : ''}`;
+        return `[${i + 1}] (${tag}, 权重 ${e.importance.toFixed(2)}) ${e.content.slice(0, 200)}`;
+    });
+    return `<memory-context>\n${lines.join('\n')}\n</memory-context>`;
+}
+/** 测试辅助: 清空分桶 (隔离 HOME 时用) */
+export function resetMemoryStores() {
+    stores.clear();
+}

package/dist/agents/opportunity-inbox.js

@@ -0,0 +1,147 @@
+/**
+ * opportunity-inbox.ts — 机会信箱 (2026-10-05, leo: 别人主动投来的机会)
+ *
+ * 设计: 外部 agent 用 DIAP Ed25519 身份签名投递机会声明到本机信箱,
+ *   验签通过才入库 (~/.bolloon/world/inbox/<id>.json) 并进入世界流。
+ *   来源可验: 每条机会带 provider DID + 验签状态, 不再是「本机自产」的虚拟感。
+ *
+ * 协议: bolloon-opportunity-inbox/1
+ *   POST payload = { title, summary, refs[], provider: {did}, issuedAt }
+ *   signature  = ed25519Sign(privateKey, canonicalize(payload))
+ *   验证 = ed25519Verify(providerPublicKey, canonicalize(payload), signature)
+ *
+ * 未来: 群复制 (OrbitDB 公共群 announce) 是信箱的另一条投递通道, 需要第二节点 (诚实边界)。
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as crypto from 'node:crypto';
+import { worldDir } from './intent-store.js';
+import { canonicalize, ed25519Verify } from './x402/paid-info-protocol.js';
+export const INBOX_PROTOCOL = 'bolloon-opportunity-inbox/1';
+const inboxDir = () => path.join(worldDir(), 'inbox');
+function safeId(s) {
+    return s.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+}
+/** 把投递载荷按签名标准序列化 (必须与签名时完全一致) */
+export function canonicalPayload(p) {
+    return canonicalize({
+        protocol: p.protocol,
+        title: p.title,
+        summary: p.summary,
+        refs: p.refs,
+        provider: p.provider,
+        issuedAt: p.issuedAt,
+    });
+}
+/** 投递方 DID 的 Ed25519 公钥解析 (did:key 格式 → 32 字节 hex) */
+export async function resolveDidPublicKey(did) {
+    try {
+        // did:key:z6Mk... — multibase base58btc 编码: [multicodec 0xed01(2B) + 32B 公钥] = 34 字节
+        const m = String(did || '').match(/^did:key:z([1-9A-HJ-NP-Za-km-z]+)$/);
+        if (!m)
+            return null;
+        const decoded = Buffer.from(importB58(m[1]));
+        if (decoded.length === 34 && decoded[0] === 0xed && decoded[1] === 0x01) {
+            return decoded.subarray(2).toString('hex'); // 剥 multicodec, 取 32 字节公钥
+        }
+        if (decoded.length === 32)
+            return decoded.toString('hex'); // 裸 32 字节兜底
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** base58btc 解码 (multibase 'z' 前缀 = base58btc) — 只依赖 Node crypto 的 b58 简易实现 */
+function importB58(s) {
+    const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+    const base = BigInt(58);
+    let num = BigInt(0);
+    for (const ch of s) {
+        const idx = ALPHABET.indexOf(ch);
+        if (idx < 0)
+            throw new Error('bad base58 char');
+        num = num * base + BigInt(idx);
+    }
+    const bytes = [];
+    while (num > 0n) {
+        bytes.unshift(Number(num & 0xffn));
+        num >>= 8n;
+    }
+    // 前导 '1' → 前导 0x00
+    let leading = 0;
+    for (const ch of s) {
+        if (ch === '1')
+            leading++;
+        else
+            break;
+    }
+    return Uint8Array.from([...new Array(leading).fill(0), ...bytes]);
+}
+/** 投递机会到信箱 (验签通过才入库) */
+export async function deliverOpportunity(payload, signatureB64) {
+    if (payload.protocol !== INBOX_PROTOCOL)
+        return { ok: false, error: `协议不匹配: ${payload.protocol}` };
+    const title = String(payload.title || '').trim();
+    if (!title)
+        return { ok: false, error: '缺 title' };
+    const did = String(payload.provider?.did || '').trim();
+    if (!did)
+        return { ok: false, error: '缺 provider.did' };
+    // 1. 验签 (能解析公钥才可能 verified)
+    const pub = await resolveDidPublicKey(did);
+    let verification;
+    if (!pub) {
+        verification = 'unverified'; // 公钥解析不了 → 不入库 (不可信来源不污染世界流)
+        return { ok: false, error: '无法解析 provider DID 公钥 (拒绝不可信来源)' };
+    }
+    const okSig = await ed25519Verify(pub, canonicalPayload(payload), signatureB64);
+    if (!okSig) {
+        verification = 'signature-invalid';
+        return { ok: false, error: '签名无效 (拒绝伪造投递)' };
+    }
+    verification = 'verified';
+    // 2. 入库 (一机会一文件)
+    const id = `inbox_${safeId(crypto.createHash('sha256').update(canonicalPayload(payload)).digest('hex').slice(0, 16))}`;
+    const opp = {
+        protocol: payload.protocol,
+        id,
+        title,
+        summary: String(payload.summary || '').trim(),
+        refs: Array.isArray(payload.refs) ? payload.refs.map(String).filter(Boolean) : [],
+        provider: { did, name: payload.provider?.name },
+        issuedAt: payload.issuedAt,
+        verification,
+        receivedAt: Date.now(),
+    };
+    try {
+        await fs.mkdir(inboxDir(), { recursive: true });
+        await fs.writeFile(path.join(inboxDir(), `${id}.json`), JSON.stringify(opp, null, 2) + '\n', { mode: 0o600 });
+    }
+    catch (err) {
+        return { ok: false, error: `入库失败: ${err instanceof Error ? err.message : err}` };
+    }
+    return { ok: true, opportunity: opp };
+}
+/** 列出信箱机会 (verified 优先, 最近在前) */
+export async function listInboxOpportunities() {
+    try {
+        const files = await fs.readdir(inboxDir());
+        const out = [];
+        for (const f of files) {
+            if (!f.endsWith('.json'))
+                continue;
+            try {
+                const raw = await fs.readFile(path.join(inboxDir(), f), 'utf-8');
+                const p = JSON.parse(raw);
+                if (p && p.id)
+                    out.push(p);
+            }
+            catch { /* 坏文件跳过 */ }
+        }
+        return out.sort((a, b) => b.receivedAt - a.receivedAt);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/agents/opportunity-match.js

@@ -134,7 +134,52 @@ function candidateOf(entry, intentId, score, reason, matchTags) {
  *   · 无意图: 流入最近 open 公告 (新鲜度优先) —— 打开即有内容
  *   · 有意图: 匹配(`match`)优先浮上来, 其余世界变化按新鲜度垫底 (世界不停)
  *   · 已忽略的同源公告不流入 (随交互越来越准)
+ *   · 机会信箱 (外部 agent 投递, 验签通过) 恒优先 —— 真实可信来源
  */
+async function mergeInboxOnTop(all) {
+    const { listInboxOpportunities } = await import('./opportunity-inbox.js');
+    const inboxOpps = await listInboxOpportunities();
+    const inboxCards = inboxOpps
+        .filter((o) => o.verification === 'verified') // 只放行验签通过的
+        .map((o) => ({
+        id: o.id,
+        intentId: null,
+        source: 'inbox',
+        sourceId: o.id,
+        score: 0.9,
+        reason: 'inbox',
+        title: o.title,
+        summary: o.summary,
+        budget: null,
+        matchTags: [],
+        createdAt: o.receivedAt,
+        inbox: { providerDid: o.provider.did, providerName: o.provider.name, verification: o.verification, refs: o.refs },
+    }));
+    for (const c of inboxCards.slice(0, 10)) {
+        void noteObservation({ ts: Date.now(), kind: 'opportunity-seen', sourceId: c.sourceId, title: c.title, score: c.score, reason: 'inbox' });
+    }
+    // 2026-10-05: AI 主动上网搜到的机会 (真 URL, 可点开核实) — 排信箱后、本地源前
+    const { listSearchOpportunities } = await import('./opportunity-web-search.js');
+    const searchOpps = await listSearchOpportunities();
+    const searchCards = searchOpps.map((o) => ({
+        id: o.id,
+        intentId: null,
+        source: 'search',
+        sourceId: o.id,
+        score: 0.8,
+        reason: 'search',
+        title: o.title,
+        summary: o.summary,
+        budget: null,
+        matchTags: [],
+        createdAt: o.searchedAt,
+        search: { url: o.url, source: o.source, query: o.query },
+    }));
+    for (const c of searchCards.slice(0, 10)) {
+        void noteObservation({ ts: Date.now(), kind: 'opportunity-seen', sourceId: c.sourceId, title: c.title, score: c.score, reason: 'search' });
+    }
+    return [...inboxCards, ...searchCards, ...all]; // 信箱 > 搜索 > 本地
+}
 export async function scanOpportunities(opts = {}) {
     const limit = opts.limit ?? 50;
     const minScore = opts.minScore ?? 0.2;
@@ -184,7 +229,7 @@ export async function scanOpportunities(opts = {}) {
             for (const c of all.filter((x) => x.reason === 'match').slice(0, 10)) {
                 void noteObservation({ ts: Date.now(), kind: 'opportunity-seen', sourceId: c.sourceId, title: c.title, score: c.score, reason: 'match' });
             }
-            return { ok: true, results: all.slice(0, limit) };
+            return { ok: true, results: (await mergeInboxOnTop(all)).slice(0, limit) };
         }
         // 默认世界流: 新鲜度优先
         const sorted = [...openEntries].sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
@@ -198,7 +243,7 @@ export async function scanOpportunities(opts = {}) {
         for (const c of out.slice(0, 10)) {
             void noteObservation({ ts: Date.now(), kind: 'world-change', sourceId: c.sourceId, title: c.title, score: c.score, reason: 'world' });
         }
-        return { ok: true, results: out.slice(0, limit) };
+        return { ok: true, results: (await mergeInboxOnTop(out)).slice(0, limit) };
     }
     // 有意图: 匹配打分, match 优先; 世界变化不消失
     const matches = [];
@@ -229,11 +274,7 @@ export async function scanOpportunities(opts = {}) {
             return rank(a.reason) - rank(b.reason);
         return b.score - a.score;
     });
-    // 世界观察: 高分匹配 = AI 主动看到的机会 (自动记 memory)
-    for (const c of all.filter((x) => x.reason === 'match').slice(0, 10)) {
-        void noteObservation({ ts: Date.now(), kind: 'opportunity-seen', sourceId: c.sourceId, title: c.title, score: c.score, reason: 'match' });
-    }
-    return { ok: true, results: all.slice(0, limit) };
+    return { ok: true, results: (await mergeInboxOnTop(all)).slice(0, limit) };
 }
 /** 对单个意图即时匹配 (list --intent 用; 不走反馈过滤) */
 export async function matchOneIntentText(text, tags, budget, opts = {}) {