cortico-world-memory 0.1.0 → 0.1.2

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "cortico-world-memory",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
-  "description": "Cortico World 扩展：三级记忆 + Hybrid Recall 向量记忆（移植自 E:/qq_bot 的 memory 系统与 memory_server 向量记忆 sidecar，qq_bot 源码零改动）。",
+  "description": "Cortico World 扩展：五层记忆（事实库/知识库/反思/人格/档案）+ 三级记忆底座 + Hybrid Recall 向量混合检索（移植自 E:/qq_bot 的记忆系统与 memory_server 向量 sidecar，qq_bot 源码零改动）。",
   "license": "MIT",
   "keywords": [
     "cortico-world",

package/src/ENV_PROMPT.md

@@ -1,4 +1,4 @@
-你带有一套自己的记忆(三级记忆 + 混合检索记忆库)。
+你带有一套自己的记忆(五层记忆:事实库/知识库/反思/人格/档案 + 三级记忆底座 + 混合检索记忆库)。
 
 ## 记忆机制
 - {{memoryContext}}

package/src/config.ts

@@ -18,6 +18,16 @@ export interface MemoryConfig {
   vectorTopK: number;
   /** 环境提示词里常驻注入的「重要信息」条数上限。 */
   notesInPrompt: number;
+  /**
+   * 自动捕获:开启后周期扫描事件流,把外部入站用户消息自动沉淀进事实库/向量库。
+   * world 无关——只认 `origin:'external'` 的入站事件,QQ 没开也能抓其它 world 的对话,
+   * QQ 开了就自动沉淀 QQ 聊天(无需 bot 手动调 mem_remember)。
+   */
+  autoCapture: boolean;
+  /** 自动捕获的轮询间隔(毫秒)。 */
+  captureIntervalMs: number;
+  /** 短于此长度的入站消息不沉淀(过滤表情/口令噪声)。 */
+  captureMinLength: number;
   /**
    * 向量来源:
    *  - `off`     纯 BM25 关键词检索(零依赖,永远可用);
@@ -43,6 +53,9 @@ export const MEMORY_DEFAULTS: MemoryConfig = {
   observeIntervalMs: 30000,
   vectorTopK: 5,
   notesInPrompt: 10,
+  autoCapture: true,
+  captureIntervalMs: 20000,
+  captureMinLength: 2,
   embeddingProvider: 'off',
   embeddingEndpoint: '',
   embeddingModel: '',
@@ -57,13 +70,16 @@ export const MEMORY_CONFIG_GROUP: ConfigGroup = {
   schema: {
     type: 'object',
     title: '记忆系统',
-    description: '三级记忆(短期/摘要/话题)与 Hybrid Recall 向量记忆(移植自 qq_bot)。',
+    description: '五层记忆(事实库/知识库/反思/人格/档案)+ 三级记忆底座(短期/摘要/话题)与 Hybrid Recall 向量混合检索(移植自 qq_bot)。',
     properties: {
       'worlds.memory.maxHistory': { type: 'number', title: '短期窗口(条)', description: '每个 scope 保留的最近对话条数。' },
       'worlds.memory.maxVectorsPerScope': { type: 'number', title: '向量上限(条/scope)', description: '超出截掉最旧的。' },
       'worlds.memory.observeIntervalMs': { type: 'number', title: '记忆推送周期(ms)', description: '把话题/摘要/要点推给人格的周期。', 'x-hot': true },
       'worlds.memory.vectorTopK': { type: 'number', title: '检索条数', description: 'mem_recall 默认返回条数。' },
       'worlds.memory.notesInPrompt': { type: 'number', title: '要点注入条数', description: '环境提示词常驻的「重要信息」上限。' },
+      'worlds.memory.autoCapture': { type: 'boolean', title: '自动捕获对话', description: '周期扫描事件流,把外部入站用户消息自动沉淀进记忆(world 无关,QQ 没开也能用)。', 'x-hot': true },
+      'worlds.memory.captureIntervalMs': { type: 'number', title: '捕获扫描周期(ms)', description: '自动捕获的轮询间隔,默认 20s。', 'x-hot': true },
+      'worlds.memory.captureMinLength': { type: 'number', title: '捕获最小长度', description: '短于此长度的入站消息不沉淀。' },
       'worlds.memory.embeddingProvider': {
         type: 'string', title: '向量来源', enum: ['off', 'http', 'sidecar'],
         description: 'off=纯 BM25;http=OpenAI 兼容 /embeddings;sidecar=qq_bot memory_server。失败自动降级 BM25。',

package/src/fact-store.ts

@@ -111,4 +111,33 @@ export class FactStore {
     if (!scope) return Object.values(this.data).reduce((s, l) => s + l.length, 0);
     return (this.data[scope] ?? []).length;
   }
+
+  /**
+   * 跨 scope 召回:扫描全部 scope 的事实,按词频打分、按 hash 去重、取 top_k。
+   * 用于「自动捕获的对话」与显式事实共存的场景——scope 留空时也能搜到对话域。
+   */
+  recallAll(query: string, limit = 5): Fact[] {
+    const q = query.trim().toLowerCase();
+    if (!q) return [];
+    const terms = q.split(/\s+/).filter(Boolean);
+    const scored: Array<{ f: Fact; score: number }> = [];
+    for (const list of Object.values(this.data)) {
+      for (const f of list) {
+        const text = f.text.toLowerCase();
+        let score = 0;
+        for (const term of terms) if (text.includes(term)) score += 1;
+        if (score > 0) scored.push({ f, score });
+      }
+    }
+    // 同一事实可能命中多 scope(文本相同 hash 不同),按 hash 去重保留最高分
+    const best = new Map<string, { f: Fact; score: number }>();
+    for (const x of scored) {
+      const cur = best.get(x.f.hash);
+      if (!cur || x.score > cur.score) best.set(x.f.hash, x);
+    }
+    return [...best.values()]
+      .sort((a, b) => b.score - a.score)
+      .slice(0, Math.max(1, limit))
+      .map((x) => x.f);
+  }
 }

package/src/vector-store.ts

@@ -288,6 +288,76 @@ export class VectorStore {
       }));
   }
 
+  /** BM25 检索(全局条目池),返回 [下标, 分数] 降序(>0)。 */
+  private bm25SearchAll(items: VectorItem[], query: string, topK: number): Array<{ idx: number; score: number }> {
+    if (!items.length) return [];
+    const queryTokens = tokenizeCjkNgram(query);
+    if (!queryTokens.length) return [];
+    const docTokens = items.map((it) => tokenizeCjkNgram(it.text));
+    const scores = bm25Score(queryTokens, docTokens);
+    return scores
+      .map((score, idx) => ({ idx, score }))
+      .filter((x) => x.score > 0)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, topK);
+  }
+
+  /** 点积检索(全局条目池,逐条解码构建矩阵),返回 [下标, 分数] 降序(>0.3)。 */
+  private cosineSearchAll(items: VectorItem[], queryVector: readonly number[], topK: number): Array<{ idx: number; score: number }> {
+    let dim = 0;
+    const rows: number[] = [];
+    const chunks: Float32Array[] = [];
+    for (let i = 0; i < items.length; i++) {
+      const enc = items[i]!.vector;
+      if (!enc) continue;
+      const v = l2Normalize(decodeVectorFp16(enc));
+      if (dim === 0) dim = v.length;
+      if (v.length !== dim) continue; // 维度不齐(换过模型)跳过
+      chunks.push(v);
+      rows.push(i);
+    }
+    if (!rows.length || queryVector.length !== dim) return [];
+    const q = l2Normalize(Float32Array.from(queryVector));
+    const matrix = new Float32Array(rows.length * dim);
+    chunks.forEach((v, r) => matrix.set(v, r * dim));
+    const scores = new Float32Array(rows.length);
+    for (let r = 0; r < rows.length; r++) {
+      let dot = 0;
+      const base = r * dim;
+      for (let d = 0; d < dim; d++) dot += matrix[base + d]! * q[d]!;
+      scores[r] = dot;
+    }
+    return [...Array(rows.length).keys()]
+      .filter((r) => scores[r]! > 0.3)
+      .sort((a, b) => scores[b]! - scores[a]!)
+      .slice(0, topK)
+      .map((r) => ({ idx: rows[r]!, score: scores[r]! }));
+  }
+
+  /**
+   * 跨 scope Hybrid Recall:把所有 scope 的条目汇总成一个全局池,跑 BM25 + Cosine + RRF。
+   * 用于「自动捕获的对话」与显式事实共存时,scope 留空也能搜到对话域。
+   */
+  hybridSearchAll(query: string, queryVector: readonly number[] | null, topK: number): SearchHit[] {
+    const all: VectorItem[] = [];
+    for (const list of Object.values(this.data.vectors)) for (const it of list) all.push(it);
+    if (!all.length) return [];
+    const bm25 = this.bm25SearchAll(all, query, topK * 2);
+    const cosine = queryVector ? this.cosineSearchAll(all, queryVector, topK * 2) : [];
+    if (!bm25.length && !cosine.length) return [];
+    const fused = rrfFusion([bm25, cosine]);
+    const viaVector = new Set(cosine.map((c) => c.idx));
+    const viaBm25 = new Set(bm25.map((c) => c.idx));
+    return [...fused.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, topK)
+      .map(([idx, score]) => ({
+        text: all[idx]!.text,
+        score: +score.toFixed(4),
+        via: viaBm25.has(idx) && viaVector.has(idx) ? 'both' : viaVector.has(idx) ? 'vector' : 'bm25',
+      }));
+  }
+
   /** 统计信息,对齐 `get_vector_stats`。 */
   stats(): { scopes: number; total: number; indexed: number; model: string } {
     const vectors = this.data.vectors;

package/src/world.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import type { World, WorldHost, ToolDef, ToolTag } from 'cortico/core/types.ts';
+import type { World, WorldHost, ToolDef, ToolTag, EventEnvelope } from 'cortico/core/types.ts';
 import type { WorldContext } from 'cortico/world.ts';
 import type { MemoryConfig } from './config.ts';
 import { MemoryBase } from './memory.ts';
@@ -15,6 +15,22 @@ import { buildEventText, buildView, promptVars } from './observe.ts';
 
 const ENV_PROMPT_FILE = fileURLToPath(new URL('./ENV_PROMPT.md', import.meta.url));
 
+/** 清理自动捕获的入站文本:去掉 QQ 的「【QQ群 ...】」前缀(对其它 world 无前缀,无副作用),压缩空白。 */
+function cleanCaptureText(t: string): string {
+  return (t ?? '')
+    .replace(/^【[^】]*】\s*/u, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+/** 自动捕获时判断事件是否为「真人入站消息」(world 无关:只认 origin='external' + 非 bot 自言)。 */
+function isInboundUser(e: EventEnvelope): boolean {
+  if (e.origin !== 'external') return false; // 排除 internal 回灌 / 记忆自身推送
+  const role = (e.meta?.role as string) ?? '';
+  if (role === 'assistant' || role === 'bot' || e.meta?.self === true) return false; // 排除 bot 自己
+  return true;
+}
+
 export class MemoryWorld implements World {
   readonly id = 'memory';
   private host: WorldHost | null = null;
@@ -28,6 +44,8 @@ export class MemoryWorld implements World {
   private persona: PersonaStore | null = null;
   private profile: ProfileStore | null = null;
   private embedder: EmbeddingClient | null = null;
+  private lastCursor = 0; // 自动捕获已扫到的事件游标(启动=当前尾,不回灌历史)
+  private captureTimer: ReturnType<typeof setInterval> | null = null;
 
   constructor(private readonly ctx: WorldContext<MemoryConfig>) {}
 
@@ -94,12 +112,17 @@ export class MemoryWorld implements World {
     }, Math.max(10_000, this.cfg.observeIntervalMs));
 
     this.push('memory.context', buildEventText(this.view()));
+
+    // 自动捕获:从当前事件尾开始(不回灌历史),周期扫描外部入站消息沉淀进记忆。
+    try { this.lastCursor = (host.store?.latestCursor?.() ?? 0) || 0; } catch { this.lastCursor = 0; }
+    if (this.cfg.autoCapture) this.startCapture();
   }
 
   /** stop 必须 async 返回 Promise(框架 withDeadline 直接 work.then)。 */
   async stop(): Promise<void> {
     if (this.timer) clearInterval(this.timer);
     this.timer = null;
+    if (this.captureTimer) { clearInterval(this.captureTimer); this.captureTimer = null; }
     this.mem?.flush();
     this.vectors?.flush(); // 防抖写盘强制落盘
     this.facts?.flush();
@@ -109,6 +132,48 @@ export class MemoryWorld implements World {
     this.profile?.flush();
   }
 
+  /** 启动自动捕获轮询(尊重暂停开关)。 */
+  private startCapture(): void {
+    const ms = Math.max(5000, Number(this.cfg.captureIntervalMs) || 20000);
+    if (this.captureTimer) clearInterval(this.captureTimer);
+    this.captureTimer = setInterval(() => { void this.captureIncoming(); }, ms);
+    this.captureTimer.unref?.();
+  }
+
+  /**
+   * 扫描事件流、把外部入站用户消息自动沉淀进事实库/向量库。
+   * world 无关:只认 `origin:'external'` + 非 bot 自言——QQ 没开时抓其它 world,QQ 开了就自动沉淀 QQ 聊天。
+   * 记忆自身的 internal 推送不在此列(被 origin 过滤),不会自我循环捕获。
+   * 返回本次新增条数。
+   */
+  private async captureIncoming(): Promise<number> {
+    const host = this.host;
+    if (!host) return 0;
+    if (host.isPaused?.() === true) return 0; // 与框架暂停语义一致
+    const store = host.store;
+    if (!store || !store.range) return 0;
+    const to = (store.latestCursor?.() ?? this.lastCursor) || 0;
+    if (!Number.isFinite(to) || to <= this.lastCursor) return 0;
+    const events = (store.range({ fromCursor: this.lastCursor + 1, toCursor: to }) ?? []) as EventEnvelope[];
+    let captured = 0;
+    for (const e of events) {
+      if (!isInboundUser(e)) continue;
+      const text = cleanCaptureText(e.text ?? '');
+      if (text.length < (this.cfg.captureMinLength ?? 2)) continue;
+      // scope 取对话地址(senderKey,如群号/私聊号);没有则按来源(source)分域——QQ 没开也不报错。
+      const scope = (typeof e.senderKey === 'string' && e.senderKey.trim())
+        ? e.senderKey.trim()
+        : (typeof e.source === 'string' && e.source ? e.source : 'main');
+      this.facts!.add(scope, [text]);
+      const vec = this.cfg.embeddingProvider === 'off' ? null : await this.embedder!.embed(text);
+      this.vectors!.add(scope, text, vec, this.cfg.maxVectorsPerScope);
+      captured++;
+    }
+    this.lastCursor = to;
+    if (captured > 0) { this.facts!.flush(); this.vectors!.flush(); }
+    return captured;
+  }
+
   private view() {
     return buildView(this.mem!, this.vectors!, 'main', this.cfg.notesInPrompt, this.profile);
   }
@@ -160,20 +225,23 @@ export class MemoryWorld implements World {
           this.vectors!.add(scope, text, this.cfg.embeddingProvider === 'off' ? null : await this.embedder!.embed(text), this.cfg.maxVectorsPerScope);
           return added ? `OK 已记住(${scope}): ${text.slice(0, 80)}` : `OK 已存在,跳过重复(${scope})`;
         }),
-      mem_recall: mk('mem_recall', '按语义+关键词混合检索长期记忆(事实库全文 + BM25+向量+RRF 融合),找旧账/回忆约定时用。', { query: str('查询'), top_k: num('条数'), scope: str('记忆域') }, ['query'], ['read'],
+      mem_recall: mk('mem_recall', '按语义+关键词混合检索长期记忆(事实库全文 + BM25+向量+RRF 融合),找旧账/回忆约定时用。scope 留空或填 main = 跨全部记忆域(含自动捕获的对话);填具体 scope 只搜该域。', { query: str('查询'), top_k: num('条数'), scope: str('记忆域(留空=全部)') }, ['query'], ['read'],
         async (a) => {
           const scope = scopeOf(a);
           const topK = Math.min(20, Number(a.top_k) || this.cfg.vectorTopK);
           const query = String(a.query);
           const vector = this.cfg.embeddingProvider === 'off' ? null : await this.embedder!.embed(query);
-          const hits = this.vectors!.hybridSearch(scope, query, vector, topK);
-          const facts = this.facts!.recall(scope, query, topK);
+          const global = scope === 'main'; // main = 搜全部域(对话域也含)
+          const hits = global
+            ? this.vectors!.hybridSearchAll(query, vector, topK)
+            : this.vectors!.hybridSearch(scope, query, vector, topK);
+          const facts = global ? this.facts!.recallAll(query, topK) : this.facts!.recall(scope, query, topK);
           // 合并两路结果,按 text 去重,事实库命中的优先(更精确)。
           const seen = new Set<string>();
           const out: string[] = [];
           for (const f of facts) if (!seen.has(f.text)) { seen.add(f.text); out.push(f.text); }
           for (const h of hits) if (!seen.has(h.text)) { seen.add(h.text); out.push(h.text); }
-          if (!out.length) return `OK ${scope} 里没有匹配「${query}」的记忆`;
+          if (!out.length) return `OK ${global ? '全部域' : scope} 里没有匹配「${query}」的记忆`;
           return `OK ${out.slice(0, topK).map((t, i) => `${i + 1}. ${t}`).join('\n')}`;
         }),
       mem_recent: mk('mem_recent', '回看本域最近的短期对话(最多 maxHistory 条)。', { n: num('条数'), scope: str('记忆域') }, [], ['read', 'snapshot'],
@@ -329,6 +397,11 @@ export class MemoryWorld implements World {
             maxHistory: this.cfg.maxHistory,
           })}`;
         }),
+      mem_capture_now: mk('mem_capture_now', '立刻扫描事件流,把自上次扫描以来的外部入站用户消息沉淀进记忆(自动捕获的手动触发,无需等轮询周期)。QQ 没开时也可抓其它 world 的对话。', {}, [], ['act'],
+        async () => {
+          const captured = await this.captureIncoming();
+          return `OK 本次捕获 ${captured} 条;当前游标 ${this.lastCursor}`;
+        }),
       mem_flush: mk('mem_flush', '把记忆立即落盘(平时自动防抖落盘,一般不用调)。', {}, [], ['act'],
         async () => { this.mem?.flush(); this.vectors?.flush(); this.facts?.flush(); this.kb?.flush(); this.reflect?.flush(); this.persona?.flush(); this.profile?.flush(); return 'OK 已落盘'; }),
     };