@morningljn/mnemo 0.1.4 → 0.2.1

package/openspec/changes/memory-self-learning/tasks.md

@@ -0,0 +1,56 @@
+## 1. 存储层：schema 迁移
+
+- [ ] 1.1 `src/store.ts` — 新增 `retrieval_log` 表创建（id, query, results JSON, timestamp）
+- [ ] 1.2 `src/store.ts` — `facts` 表 `ALTER TABLE ADD COLUMN summary TEXT DEFAULT NULL`（兼容已有库）
+- [ ] 1.3 `src/store.ts` — `facts` 表 `ALTER TABLE ADD COLUMN last_retrieved_at TEXT DEFAULT NULL`
+- [ ] 1.4 `src/store.ts` — 重建 FTS5 虚拟表以包含 summary 列
+- [ ] 1.5 `src/store.ts` — 新增 `logRetrieval(query, results: [{id, score}])` 方法，写入 retrieval_log + 更新各 fact 的 last_retrieved_at
+- [ ] 1.6 `src/store.ts` — 新增 `pruneRetrievalLog(maxEntries=5000)` 方法，超出上限删除最旧记录
+- [ ] 1.7 `src/types.ts` — 新增 `RetrievalLogEntry` 类型、`FactStoreArgs` 增加 `summary` 字段、Fact 类型增加 `summary` 和 `last_retrieved_at`
+
+## 2. 检索层：回退 + length penalty + summary
+
+- [ ] 2.1 `src/retriever.ts` — 回退动态权重为静态 `ftsWeight=0.5, jaccardWeight=0.5`
+- [ ] 2.2 `src/retriever.ts` — 移除 relevance gate（`RELEVANCE_THRESHOLD` 相关代码）
+- [ ] 2.3 `src/retriever.ts` — 评分公式末尾新增 length penalty：`score *= min(1.0, 300 / matchText.length)`，matchText = summary（非空时）或 content
+- [ ] 2.4 `src/retriever.ts` — FTS5 候选查询改为优先匹配 summary（非空时用 summary，空时用 content）
+- [ ] 2.5 `src/retriever.ts` — Jaccard tokenization 同样优先使用 summary
+- [ ] 2.6 `src/retriever.ts` — search() 方法末尾调用 `store.logRetrieval(query, results)` 记录检索日志
+- [ ] 2.7 保留 `src/refine.ts` 的 refineQuery（过滤纯操作指令的功能与权重策略无关）
+
+## 3. 自学习层：learn + audit
+
+- [ ] 3.1 `src/store.ts` — 新增 `runLearning()` 方法：遍历所有 fact，按 rate 规则调整 trust_score
+  - `retrieval_count > 30 && rate < 0.05` → `trust_score *= 0.9`
+  - `retrieval_count > 30 && rate > 0.3` → `trust_score = min(1.0, trust_score + 0.05)`
+  - `last_retrieved_at` 超过 60 天 → `trust_score *= 0.95`
+  - `last_retrieved_at` 为 NULL（新 fact）→ 不老化
+- [ ] 3.2 `src/store.ts` — `runLearning()` 返回 `{promoted, demoted, aged, unchanged, long_facts: [{id, content_length, penalty, has_summary}]}`
+- [ ] 3.3 `src/store.ts` — 新增 `runAudit()` 方法：返回数据质量报告（超长无 summary、低 helpful 率、老化候选），不修改数据
+- [ ] 3.4 `src/server.ts` — 新增 `fact_store(action="learn")` handler，调用 `store.runLearning()`
+- [ ] 3.5 `src/server.ts` — 新增 `fact_store(action="audit")` handler，调用 `store.runAudit()`
+- [ ] 3.6 `src/server.ts` — server 启动时通过 `process.nextTick()` 延迟调用 `store.runLearning()`，输出摘要到 stderr
+
+## 4. 写入端：质量控制
+
+- [ ] 4.1 `src/server.ts` — add handler 支持 `summary` 参数，存入 summary 列
+- [ ] 4.2 `src/server.ts` — add/update 时 content 长度 > 500 且无 summary → 返回 warnings 提示
+- [ ] 4.3 `src/server.ts` — add/update 写操作后调用 `store.pruneRetrievalLog()` 保持日志上限
+- [ ] 4.4 `src/server.ts` — update handler 支持 `summary` 参数更新
+
+## 5. 清理：移除 v3 遗留代码
+
+- [ ] 5.1 `src/retriever.ts` — 移除动态权重计算逻辑（`tokenCount <= 3` 判断分支）
+- [ ] 5.2 `src/retriever.ts` — 移除 content dedup（Jaccard > 0.7 去重），改为仅 score 排序
+- [ ] 5.3 `src/refine.ts` — 保留 refineQuery（过滤纯操作指令），但移除与动态权重的耦合
+
+## 6. 测试 + 验证
+
+- [ ] 6.1 `tests/store.test.ts` — 新增 retrieval_log CRUD 测试（写入、查询、自动清理）
+- [ ] 6.2 `tests/store.test.ts` — 新增 summary 列读写测试
+- [ ] 6.3 `tests/store.test.ts` — 新增 `runLearning()` 信任调整测试（promote/demote/aging/新 fact 保护）
+- [ ] 6.4 `tests/store.test.ts` — 新增 `runAudit()` 测试（返回报告不修改数据）
+- [ ] 6.5 `tests/retriever.test.ts` — 新增 length penalty 测试（有/无 summary 两种场景）
+- [ ] 6.6 `tests/retriever.test.ts` — 新增 summary 匹配测试（FTS5 + Jaccard 用 summary）
+- [ ] 6.7 `tests/retriever.test.ts` — 验证静态权重（不再随查询长度变化）
+- [ ] 6.8 端到端验证：`npm run build && npx vitest run`

package/openspec/specs/compact-search/spec.md

@@ -0,0 +1,16 @@
+## ADDED Requirements
+
+### Requirement: 搜索结果精简格式
+搜索返回结果 SHALL 优先返回 summary 而非完整 content，减少 token 消耗。
+
+#### Scenario: 有 summary 的 fact
+- **WHEN** 搜索结果中的 fact 有 summary 字段且非空
+- **THEN** 返回 summary 作为 display 字段，不返回完整 content
+
+#### Scenario: 无 summary 的 fact
+- **WHEN** 搜索结果中的 fact 的 summary 为 NULL
+- **THEN** 返回 content 前 100 字 + "..." 作为 display 字段
+
+#### Scenario: 返回字段精简
+- **WHEN** 搜索结果返回给调用方
+- **THEN** 每条结果包含 factId、display（精简内容）、category、trustScore、score，不包含完整 content、keywords、tags 等冗余字段

package/openspec/specs/dream-cycle/spec.md

@@ -0,0 +1,38 @@
+## ADDED Requirements
+
+### Requirement: Dream action 整理记忆库
+系统 SHALL 提供 `fact_store(action="dream")` 操作，执行三阶段整理：Collect → Consolidate → Evaluate。
+
+#### Scenario: 合并重叠 fact
+- **WHEN** 同 category 内两条 fact 的 Jaccard 相似度 > 0.6
+- **THEN** 系统保留 content 更长的 fact，将另一条标记删除，并在 dream report 中记录合并对
+
+#### Scenario: 压缩长 fact
+- **WHEN** fact 的 content 长度 > 200 字且 summary 为 NULL
+- **THEN** 系统从 content 提取前 2 个完整句子（总长 ≤ 150 字）写入 summary 字段
+
+#### Scenario: 分类修正
+- **WHEN** fact 的 category 与内容不匹配（如 identity 类 fact 内容包含"编码规范"）
+- **THEN** 系统根据关键词规则表将 fact 挪到正确 category
+
+#### Scenario: Dream 前备份
+- **WHEN** dream action 被触发
+- **THEN** 系统在执行任何修改前，自动将数据库备份到 `~/.mnemo/backup/dream-<timestamp>.db`
+
+#### Scenario: 输出 dream report
+- **WHEN** dream 整理完成
+- **THEN** 系统返回 JSON 报告，包含 merged、compressed、reclassified、deleted 计数和 health 统计
+
+### Requirement: CLI dream 命令
+系统 SHALL 提供 `mnemo dream` CLI 命令，手动触发 dream 整理。
+
+#### Scenario: 手动执行 dream
+- **WHEN** 用户运行 `npx mnemo dream` 或 `mnemo dream`
+- **THEN** 系统执行完整 dream cycle 并输出 report 到 stdout
+
+### Requirement: 高频 fact 保护
+Dream 整理 SHALL 保护检索次数 > 100 的 fact 不被删除。
+
+#### Scenario: 高频 fact 不被合并删除
+- **WHEN** 两条 fact 满足合并条件，但其中一条 retrieval_count > 100
+- **THEN** 系统保留高频 fact，仅删除另一条低频 fact

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@morningljn/mnemo",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "Structured fact memory MCP server — SQLite + FTS5, trust scoring, entity graph, bilingual retrieval for Claude Code & Codex",
   "type": "module",
   "main": "dist/server.js",
   "bin": {
     "mnemo": "dist/server.js",
-    "mnemo-init": "dist/init.js"
+    "mnemo-init": "dist/init.js",
+    "mnemo-dream": "dist/dream.js"
   },
   "publishConfig": {
     "access": "public"

package/src/dream.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import { MemoryStore } from './store.js'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+const dbPath = join(homedir(), '.mnemo', 'facts.db')
+const store = new MemoryStore(dbPath)
+
+try {
+  console.log('[mnemo dream] 开始整理记忆库...\n')
+  const report = await store.runDream()
+  console.log(JSON.stringify(report, null, 2))
+  console.log(`\n[mnemo dream] 完成: merged=${report.merged} compressed=${report.compressed} reclassified=${report.reclassified} deleted=${report.deleted}`)
+} catch (err) {
+  console.error('[mnemo dream] error:', err)
+  process.exit(1)
+} finally {
+  store.close()
+}

package/src/init.ts

@@ -19,32 +19,12 @@ const CLAUDE_MD_PATH = join(CLAUDE_DIR, 'CLAUDE.md')
 const SETTINGS_PATH = join(CLAUDE_DIR, 'settings.json')
 
 const MEMORY_RULES = `
-# 记忆系统使用规则
 
-你有 mnemo 记忆工具（fact_store / fact_feedback），必须按以下规则使用：
+# mnemo 记忆系统
 
-## 规则 1：会话预热（自动）
-会话启动时，mnemo-mcp 的 MCP Resource 会自动注入全局记忆到 system context。
-你不需要主动调用 fact_store(search) 来获取高频记忆。
-
-## 规则 2：按需补充查询
-仅在以下情况调用 \`fact_store(action="search")\`：
-- 用户消息涉及个人偏好/习惯/工具选择且预热中未覆盖
-- 用户明确查询记忆（"我之前说过什么""按我的习惯"）
-- 技术选型时需要确认用户偏好
-
-不触发查询的情况：
-- 纯操作指令（"运行测试""git commit"）
-- 通用技术问题（"Promise 怎么用"）
-- 代码审查/解释请求
-
-## 规则 3：写入记忆
-用户说"记住"、"记下来"时，调用 \`fact_store(action="add", content="...", category="...")\`。
-- 先 search 检查是否已有相似事实，有则 update
-- category：identity / coding_style / tool_pref / workflow / general
-
-## 规则 4：反馈强化
-成功使用某条记忆时，调用 \`fact_feedback(action="helpful", fact_id=...)\`。
+- 身份问题（"你是谁"等）→ 先 fact_store(search, query="角色设定")，按设定回答
+- 用户说"记住"→ fact_store(add)，先 search 去重
+- 成功使用记忆 → fact_feedback(helpful, fact_id)
 `
 
 const MCP_TOOLS = [

package/src/resources.ts

@@ -1,6 +1,9 @@
 /**
  * MCP Resource manager for mnemo-mcp.
- * Exposes per-category memory summaries as MCP Resources for session warmup injection.
+ * Exposes per-category memory as MCP Resources for session warmup injection.
+ *
+ * identity → 指令格式（Claude 应遵循的行为设定）
+ * 其他     → 参考格式（供 Claude 查阅的用户偏好）
  */
 
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
@@ -8,7 +11,7 @@ import type { MemoryStore } from './store.js'
 import type { FactCategory } from './types.js'
 
 const CATEGORIES: FactCategory[] = ['identity', 'coding_style', 'tool_pref', 'workflow', 'general']
-const RESOURCE_LIMIT = 10
+const RESOURCE_LIMIT = 15
 
 export interface ResourceFact {
   fact_id: number
@@ -17,13 +20,12 @@ export interface ResourceFact {
 }
 
 export class ResourceManager {
-  private cache = new Map<FactCategory, ResourceFact[]>()
+  private cache = new Map<FactCategory, string>()
 
   constructor(
     private store: MemoryStore,
   ) {}
 
-  /** Register all category resources with the MCP server */
   registerResources(server: McpServer): void {
     for (const category of CATEGORIES) {
       const uri = `mnemo://global/${category}`
@@ -32,46 +34,100 @@ export class ResourceManager {
         uri,
         {
           description: `${category} category global facts (top ${RESOURCE_LIMIT} by trust)`,
-          mimeType: 'application/json',
+          mimeType: 'text/markdown',
         },
         async () => this.readCategory(category),
       )
     }
   }
 
-  /** Read handler for a specific category */
-  private readCategory(category: FactCategory): { contents: Array<{ uri: string; mimeType: string; text: string }> } {
-    const facts = this.getFacts(category)
+  /** Read handler for a specific category (public for server instructions) */
+  readCategory(category: FactCategory): { contents: Array<{ uri: string; mimeType: string; text: string }> } {
+    const text = this.getFormattedFacts(category)
     return {
       contents: [{
         uri: `mnemo://global/${category}`,
-        mimeType: 'application/json',
-        text: JSON.stringify(facts, null, 2),
+        mimeType: 'text/markdown',
+        text,
       }],
     }
   }
 
-  /** Get facts for a category — with caching */
-  getFacts(category: FactCategory): ResourceFact[] {
+  private getFormattedFacts(category: FactCategory): string {
     const cached = this.cache.get(category)
     if (cached) return cached
 
-    const facts = this.store.listFacts(category, 0.0, RESOURCE_LIMIT).map(f => ({
-      fact_id: f.factId,
-      content: f.content,
-      trust_score: f.trustScore,
-    }))
+    const facts = this.store.listFacts(category, 0.0, RESOURCE_LIMIT)
+    const text = category === 'identity'
+      ? this.formatAsInstructions(facts)
+      : this.formatAsReference(facts, category)
 
-    this.cache.set(category, facts)
-    return facts
+    this.cache.set(category, text)
+    return text
+  }
+
+  /**
+   * identity 类事实格式化为指令——Claude 应直接遵循这些设定。
+   * 角色设定排在最前面，用祈使句。
+   */
+  private formatAsInstructions(facts: ReturnType<MemoryStore['listFacts']>): string {
+    const lines: string[] = ['# 身份与行为设定', '', '以下是你的身份设定和用户偏好，请直接遵循：', '']
+
+    // 角色/身份相关的 fact 排在最前面
+    const roleFacts = facts.filter(f =>
+      f.content.includes('角色设定') ||
+      f.content.includes('你是') ||
+      f.content.includes('身份是') ||
+      f.content.includes('女朋友')
+    )
+    const otherFacts = facts.filter(f => !roleFacts.includes(f))
+
+    if (roleFacts.length > 0) {
+      lines.push('## 你的身份')
+      for (const f of roleFacts) {
+        // 把描述性语句转为指令
+        const content = f.content
+          .replace(/^AI角色设定[：:]/, '')
+          .replace(/^你是/, '')
+          .trim()
+        lines.push(`- ${content}`)
+      }
+      lines.push('')
+    }
+
+    if (otherFacts.length > 0) {
+      lines.push('## 用户信息')
+      for (const f of otherFacts) {
+        lines.push(`- ${f.content}`)
+      }
+    }
+
+    return lines.join('\n')
+  }
+
+  /**
+   * 非 identity 类事实格式化为参考——供 Claude 查阅但不强制遵循。
+   */
+  private formatAsReference(facts: ReturnType<MemoryStore['listFacts']>, category: string): string {
+    const title: Record<string, string> = {
+      coding_style: '编码风格偏好',
+      tool_pref: '工具偏好',
+      workflow: '工作流偏好',
+      general: '通用知识',
+    }
+    const lines: string[] = [`# ${title[category] ?? category}`, '']
+
+    for (const f of facts) {
+      lines.push(`- ${f.content}`)
+    }
+
+    return lines.join('\n')
   }
 
-  /** Invalidate all caches — call after any write operation */
   invalidate(): void {
     this.cache.clear()
   }
 
-  /** Get cache entry count for debugging */
   cacheSize(): number {
     return this.cache.size
   }

package/src/retriever.ts

@@ -106,38 +106,32 @@ export class FactRetriever {
         const inferred = this.categoryInferFallback(searchQuery, minTrust, limit)
         if (inferred.length > 0) return inferred
       }
-      // 个人/身份相关的短查询触发 trust fallback
-      if (this.isPersonalQuery(searchQuery)) {
+      // 个人/身份相关的短查询触发 trust fallback（用原始 query，避免 refineQuery 拆词导致正则失配）
+      if (this.isPersonalQuery(query)) {
         return this.trustFallback(category, minTrust, limit)
       }
       return []
     }
 
-    // Stage 2-4: Jaccard 重排序 + 信任评分 + 时间衰减
-    // 动态权重：短查询偏 FTS，长查询偏 Jaccard
+    // Stage 2-4: Jaccard 重排序 + 信任评分 + 时间衰减 + length penalty
     const queryTokens = this.tokenize(searchQuery)
-    const tokenCount = queryTokens.size
-    const ftsWeight = tokenCount <= 3 ? 0.7 : 0.3
-    const jaccardWeight = tokenCount <= 3 ? 0.3 : 0.7
 
     const scored: ScoredFact[] = []
 
     for (const fact of candidates) {
-      const contentTokens = this.tokenize(fact.content)
+      // summary 优先用于匹配
+      const matchText = fact.summary ?? fact.content
+      const matchTokens = this.tokenize(matchText)
       const tagTokens = this.tokenize(fact.tags)
-      const allTokens = new Set([...contentTokens, ...tagTokens])
+      const allTokens = new Set([...matchTokens, ...tagTokens])
 
       const jaccard = this.jaccardSimilarity(queryTokens, allTokens)
-      // Containment: 查询 token 在事实 token 中的覆盖率
       const qInF = this.containmentScore(queryTokens, allTokens)
-
-      // 混合相似度：Jaccard + Containment（简化版，移除 keywordScore）
       const similarity = 0.3 * jaccard + 0.7 * qInF
       const ftsScore = fact.ftsRank
 
-      // 综合评分
-      const relevance = ftsWeight * ftsScore + jaccardWeight * similarity
-
+      // 静态权重 0.5/0.5（回退 v3 动态权重）
+      const relevance = 0.5 * ftsScore + 0.5 * similarity
       let score = relevance * fact.trustScore
 
       // 时间衰减
@@ -145,37 +139,22 @@ export class FactRetriever {
         score *= this.temporalDecay(fact.updatedAt || fact.createdAt)
       }
 
+      // Length penalty：基于 matchText 长度
+      score *= Math.min(1.0, 300 / matchText.length)
+
       scored.push({ ...fact, score })
     }
 
     scored.sort((a, b) => b.score - a.score)
 
-    // 相关性门控：过滤低相关性结果
-    const RELEVANCE_THRESHOLD = 0.15
-    const gated = scored.filter(s => s.score >= RELEVANCE_THRESHOLD)
-    const pool = gated.length > 0 ? gated : scored
-
-    // 内容去重：Jaccard > 0.7 的只保留高分
-    const results: ScoredFact[] = []
-    for (const candidate of pool) {
-      let isDuplicate = false
-      const candidateTokens = this.tokenize(candidate.content)
-      for (const kept of results) {
-        const keptTokens = this.tokenize(kept.content)
-        if (this.jaccardSimilarity(candidateTokens, keptTokens) > 0.7) {
-          isDuplicate = true
-          break
-        }
-      }
-      if (!isDuplicate) {
-        results.push(candidate)
-        if (results.length >= limit) break
-      }
-    }
+    // 取 limit 条（不再做 relevance gate 和 content dedup）
+    const results = scored.slice(0, limit)
 
     // 检索追踪：递增 retrieval_count + top3 信任刷新
     if (results.length > 0) {
       this.trackRetrieval(results)
+      // 记录检索日志
+      this.store.logRetrieval(searchQuery, results.map(r => ({ id: r.factId, score: Math.round(r.score * 1000) / 1000 })))
     }
 
     // 缓存存储 + 指标记录
@@ -295,9 +274,11 @@ export class FactRetriever {
       category: r.category as FactCategory,
       tags: r.tags,
       keywords: r.keywords ?? '[]',
+      summary: (r as any).summary ?? null,
       trustScore: r.trust_score,
       retrievalCount: r.retrieval_count,
       helpfulCount: r.helpful_count,
+      lastRetrievedAt: (r as any).last_retrieved_at ?? null,
       createdAt: r.created_at,
       updatedAt: r.updated_at,
       score: r.trust_score * (1 - i * 0.05),
@@ -409,9 +390,11 @@ export class FactRetriever {
             category: r.category as FactCategory,
             tags: r.tags,
             keywords: r.keywords ?? '[]',
+            summary: (r as any).summary ?? null,
             trustScore: r.trust_score,
             retrievalCount: 0,
             helpfulCount: 0,
+            lastRetrievedAt: (r as any).last_retrieved_at ?? null,
             createdAt: r.created_at,
             updatedAt: r.updated_at,
           })
@@ -454,15 +437,19 @@ export class FactRetriever {
     const ftsParts: string[] = []
 
     for (const word of parts) {
-      ftsParts.push(`"${word}"`)
-      // 对中文部分追加 bigram
-      const cnChars = word.match(/[\u4e00-\u9fff]+/g)
+      const cnChars = word.match(/[一-鿿]+/g)
       if (cnChars) {
+        // 中文部分：trigram tokenizer 需要至少 3 字符
         for (const seg of cnChars) {
-          for (let i = 0; i < seg.length - 1; i++) {
-            ftsParts.push(seg.slice(i, i + 2))
+          if (seg.length >= 3) ftsParts.push(seg)
+          // 提取 trigram（3 字符子串）
+          for (let i = 0; i <= seg.length - 3; i++) {
+            ftsParts.push(seg.slice(i, i + 3))
           }
         }
+      } else {
+        // 非中文部分：用引号包裹（短语匹配），至少 1 字符
+        if (word.length >= 1) ftsParts.push(`"${word}"`)
       }
     }
 
@@ -509,9 +496,11 @@ export class FactRetriever {
       category: String(row.category) as FactCategory,
       tags: String(row.tags),
       keywords: String(row.keywords ?? '[]'),
+      summary: row.summary != null ? String(row.summary) : null,
       trustScore: Number(row.trust_score),
       retrievalCount: Number(row.retrieval_count),
       helpfulCount: Number(row.helpful_count),
+      lastRetrievedAt: row.last_retrieved_at != null ? String(row.last_retrieved_at) : null,
       createdAt: String(row.created_at),
       updatedAt: String(row.updated_at),
       ftsRank: rawRanks[i] / maxRank,
@@ -619,8 +608,8 @@ export class FactRetriever {
     const conditions: string[] = []
     const params: unknown[] = []
     for (const word of words) {
-      conditions.push('(f.content LIKE ? OR f.tags LIKE ?)')
-      params.push(`%${word}%`, `%${word}%`)
+      conditions.push('(f.content LIKE ? OR f.tags LIKE ? OR f.summary LIKE ?)')
+      params.push(`%${word}%`, `%${word}%`, `%${word}%`)
     }
 
     // 中文子串分解：将中文查询拆为 2~3 字滑动窗口，追加 LIKE 条件
@@ -632,14 +621,14 @@ export class FactRetriever {
         // 2-gram
         for (let i = 0; i < seg.length - 1; i++) {
           const bigram = seg.slice(i, i + 2)
-          conditions.push('(f.content LIKE ? OR f.tags LIKE ?)')
-          params.push(`%${bigram}%`, `%${bigram}%`)
+          conditions.push('(f.content LIKE ? OR f.tags LIKE ? OR f.summary LIKE ?)')
+          params.push(`%${bigram}%`, `%${bigram}%`, `%${bigram}%`)
         }
         // 3-gram（覆盖更长的短语匹配）
         for (let i = 0; i < seg.length - 2; i++) {
           const trigram = seg.slice(i, i + 3)
-          conditions.push('(f.content LIKE ? OR f.tags LIKE ?)')
-          params.push(`%${trigram}%`, `%${trigram}%`)
+          conditions.push('(f.content LIKE ? OR f.tags LIKE ? OR f.summary LIKE ?)')
+          params.push(`%${trigram}%`, `%${trigram}%`, `%${trigram}%`)
         }
       }
     }
@@ -656,7 +645,7 @@ export class FactRetriever {
 
     const sql = `
       SELECT f.fact_id, f.content, f.category, f.tags, f.keywords,
-             f.trust_score, f.retrieval_count, f.helpful_count,
+             f.summary, f.trust_score, f.retrieval_count, f.helpful_count,
              f.created_at, f.updated_at
       FROM facts f
       WHERE (${conditionsSql})
@@ -668,6 +657,7 @@ export class FactRetriever {
 
     const rows = this.db.prepare(sql).all(...params) as Array<{
       fact_id: number; content: string; category: string; tags: string; keywords: string;
+      summary: string | null;
       trust_score: number; retrieval_count: number; helpful_count: number;
       created_at: string; updated_at: string;
     }>
@@ -679,9 +669,11 @@ export class FactRetriever {
       category: r.category as FactCategory,
       tags: r.tags,
       keywords: r.keywords ?? '[]',
+      summary: r.summary ?? null,
       trustScore: r.trust_score,
       retrievalCount: r.retrieval_count,
       helpfulCount: r.helpful_count,
+      lastRetrievedAt: (r as any).last_retrieved_at ?? null,
       createdAt: r.created_at,
       updatedAt: r.updated_at,
       ftsRank: 0.5,

package/src/schema.ts

@@ -6,9 +6,11 @@ CREATE TABLE IF NOT EXISTS facts (
   category        TEXT DEFAULT 'general',
   tags            TEXT DEFAULT '',
   keywords        TEXT DEFAULT '[]',
+  summary         TEXT DEFAULT NULL,
   trust_score     REAL DEFAULT 0.5,
   retrieval_count INTEGER DEFAULT 0,
   helpful_count   INTEGER DEFAULT 0,
+  last_retrieved_at TEXT DEFAULT NULL,
   created_at      TEXT DEFAULT (datetime('now', 'localtime')),
   updated_at      TEXT DEFAULT (datetime('now', 'localtime'))
 );
@@ -29,33 +31,42 @@ CREATE TABLE IF NOT EXISTS fact_entities (
   PRIMARY KEY (fact_id, entity_id)
 );
 
+-- 检索日志表
+CREATE TABLE IF NOT EXISTS retrieval_log (
+  id        INTEGER PRIMARY KEY AUTOINCREMENT,
+  query     TEXT NOT NULL,
+  results   TEXT DEFAULT NULL,
+  timestamp TEXT DEFAULT (datetime('now', 'localtime'))
+);
+
 -- 索引
 CREATE INDEX IF NOT EXISTS idx_facts_trust    ON facts(trust_score DESC);
 CREATE INDEX IF NOT EXISTS idx_facts_category ON facts(category);
 CREATE INDEX IF NOT EXISTS idx_entities_name  ON entities(name);
 CREATE INDEX IF NOT EXISTS idx_fact_entities_entity ON fact_entities(entity_id);
+CREATE INDEX IF NOT EXISTS idx_retrieval_log_ts ON retrieval_log(timestamp);
 
--- FTS5 全文索引
+-- FTS5 全文索引（trigram tokenizer 支持中文子串匹配）
 CREATE VIRTUAL TABLE IF NOT EXISTS facts_fts
-  USING fts5(content, tags, content=facts, content_rowid=fact_id);
+  USING fts5(content, tags, summary, content=facts, content_rowid=fact_id, tokenize='trigram');
 
 -- FTS5 同步触发器：插入
 CREATE TRIGGER IF NOT EXISTS facts_ai AFTER INSERT ON facts BEGIN
-  INSERT INTO facts_fts(rowid, content, tags)
-    VALUES (new.fact_id, new.content, new.tags);
+  INSERT INTO facts_fts(rowid, content, tags, summary)
+    VALUES (new.fact_id, new.content, new.tags, COALESCE(new.summary, ''));
 END;
 
 -- FTS5 同步触发器：删除
 CREATE TRIGGER IF NOT EXISTS facts_ad AFTER DELETE ON facts BEGIN
-  INSERT INTO facts_fts(facts_fts, rowid, content, tags)
-    VALUES ('delete', old.fact_id, old.content, old.tags);
+  INSERT INTO facts_fts(facts_fts, rowid, content, tags, summary)
+    VALUES ('delete', old.fact_id, old.content, old.tags, COALESCE(old.summary, ''));
 END;
 
 -- FTS5 同步触发器：更新
 CREATE TRIGGER IF NOT EXISTS facts_au AFTER UPDATE ON facts BEGIN
-  INSERT INTO facts_fts(facts_fts, rowid, content, tags)
-    VALUES ('delete', old.fact_id, old.content, old.tags);
-  INSERT INTO facts_fts(rowid, content, tags)
-    VALUES (new.fact_id, new.content, new.tags);
+  INSERT INTO facts_fts(facts_fts, rowid, content, tags, summary)
+    VALUES ('delete', old.fact_id, old.content, old.tags, COALESCE(old.summary, ''));
+  INSERT INTO facts_fts(rowid, content, tags, summary)
+    VALUES (new.fact_id, new.content, new.tags, COALESCE(new.summary, ''));
 END;
 `