@morningljn/mnemo 0.1.4 → 0.2.1

package/src/server.ts

@@ -9,7 +9,7 @@ import { MemoryStore } from './store.js'
 import { FactRetriever } from './retriever.js'
 import { ResourceManager } from './resources.js'
 import { fullSecurityScan } from './security.js'
-import type { FactStoreArgs, FactFeedbackArgs, FactCategory } from './types.js'
+import type { FactStoreArgs, FactFeedbackArgs, FactCategory, ScoredFact, CompactFactResult } from './types.js'
 
 const FACT_STORE_DESCRIPTION = `结构化事实记忆系统（SQLite+FTS5 索引）。支持读写。
 
@@ -27,8 +27,9 @@ const FACT_STORE_DESCRIPTION = `结构化事实记忆系统（SQLite+FTS5 索引
 写入时先 search 检查是否已存在相似事实。identity/coding_style/tool_pref/workflow/general → 全局库，project → 项目库。`
 
 const factStoreSchema = {
-  action: z.enum(['add', 'search', 'probe', 'related', 'reason', 'contradict', 'update', 'remove', 'list']),
+  action: z.enum(['add', 'search', 'probe', 'related', 'reason', 'contradict', 'update', 'remove', 'list', 'learn', 'audit', 'dream']),
   content: z.union([z.string(), z.array(z.string())]).optional().describe("事实内容（'add' 必需，支持批量）"),
+  summary: z.string().optional().describe('超长事实的摘要（检索用 summary 匹配）'),
   query: z.string().optional().describe("搜索查询（'search' 必需）"),
   entity: z.string().optional().describe("实体名（'probe'/'related' 使用）"),
   entities: z.array(z.string()).optional().describe("实体列表（'reason' 使用）"),
@@ -51,6 +52,16 @@ function resolveCategory(category?: string): FactCategory {
   return valid.includes(category as FactCategory) ? (category as FactCategory) : 'general'
 }
 
+function toCompactResult(f: ScoredFact): CompactFactResult {
+  return {
+    factId: f.factId,
+    display: f.summary ?? (f.content.length > 100 ? f.content.slice(0, 100) + '...' : f.content),
+    category: f.category,
+    trustScore: Math.round(f.trustScore * 100) / 100,
+    score: Math.round(f.score * 1000) / 1000,
+  }
+}
+
 const minTrust = 0.3
 
 // -- Initialize store + retriever --
@@ -62,8 +73,38 @@ const retriever = new FactRetriever(store, { temporalDecayHalfLife: 30 })
 store.decayTrustScores()
 store.auditContradictions()
 
+// Auto-learn on startup (non-blocking)
+process.nextTick(() => {
+  try {
+    const result = store.runLearning()
+    if (result.demoted > 0 || result.aged > 0 || result.long_facts.length > 0) {
+      console.error(`[mnemo:auto-learn] promoted=${result.promoted} demoted=${result.demoted} aged=${result.aged} long_facts=${result.long_facts.length}`)
+    }
+  } catch (err) {
+    console.error('[mnemo:auto-learn] error:', err)
+  }
+})
+
 // -- MCP Server --
-const server = new McpServer({ name: 'mnemo-mcp', version: '0.1.0' })
+// 动态生成 instructions：将 identity resource 中的角色设定作为 system prompt 指令注入
+function buildInstructions(): string {
+  try {
+    const rm = new ResourceManager(store)
+    const result = rm.readCategory('identity')
+    const identityText = result.contents[0]?.text ?? ''
+    if (identityText.length > 10) {
+      return identityText
+    }
+  } catch {
+    // fallback：无 identity 数据时不注入
+  }
+  return ''
+}
+
+const server = new McpServer(
+  { name: 'mnemo-mcp', version: '0.1.0' },
+  { instructions: buildInstructions() },
+)
 
 // -- MCP Resources: 会话预热注入 --
 const resourceManager = new ResourceManager(store)
@@ -93,13 +134,22 @@ server.tool(
             let warnings: string[] | undefined
             const scan = fullSecurityScan(content)
             if (scan.warnings.length > 0 || scan.hasPii) warnings = [...scan.warnings]
+            if (content.length > 500 && !a.summary) {
+              warnings = [...(warnings ?? []), 'content 超过 500 字，建议提供 summary 或拆分为多条 fact']
+            }
 
             if (similar) {
               store.updateFact(similar.factId, { content, tags: a.tags, trustDelta: 0.05 })
+              if (a.summary) {
+                store.connection.prepare('UPDATE facts SET summary = ? WHERE fact_id = ?').run(a.summary, similar.factId)
+              }
               const demoted = store.demoteContradictingFacts(similar.factId, content, category)
               results.push({ fact_id: similar.factId, status: 'updated', reason: 'similar_fact_merged', ...(demoted > 0 ? { contradicted_demoted: demoted } : {}), ...(warnings ? { warnings } : {}) })
             } else {
               const factId = store.addFact(content, category, a.tags ?? '')
+              if (a.summary) {
+                store.connection.prepare('UPDATE facts SET summary = ? WHERE fact_id = ?').run(a.summary, factId)
+              }
               const demoted = store.demoteContradictingFacts(factId, content, category)
               results.push({ fact_id: factId, status: 'added', category, ...(demoted > 0 ? { contradicted_demoted: demoted } : {}), ...(warnings ? { warnings } : {}) })
             }
@@ -114,26 +164,30 @@ server.tool(
         case 'search': {
           if (!a.query) return { content: [{ type: 'text' as const, text: JSON.stringify({ error: 'Missing required argument: query' }) }] }
           const results = retriever.search(a.query, { category: a.category ? category : undefined, minTrust: a.min_trust ?? minTrust, limit: a.limit ?? 10 })
-          return { content: [{ type: 'text' as const, text: JSON.stringify({ results, count: results.length }) }] }
+          const compact = results.map(toCompactResult)
+          return { content: [{ type: 'text' as const, text: JSON.stringify({ results: compact, count: compact.length }) }] }
         }
 
         case 'probe': {
           if (!a.entity) return { content: [{ type: 'text' as const, text: JSON.stringify({ error: 'Missing required argument: entity' }) }] }
           const results = retriever.probe(a.entity, { minTrust: a.min_trust ?? minTrust, limit: a.limit ?? 10 })
-          return { content: [{ type: 'text' as const, text: JSON.stringify({ results, count: results.length }) }] }
+          const compact = results.map(toCompactResult)
+          return { content: [{ type: 'text' as const, text: JSON.stringify({ results: compact, count: compact.length }) }] }
         }
 
         case 'related': {
           if (!a.entity) return { content: [{ type: 'text' as const, text: JSON.stringify({ error: 'Missing required argument: entity' }) }] }
           const results = retriever.related(a.entity, { minTrust: a.min_trust ?? minTrust, limit: a.limit ?? 10 })
-          return { content: [{ type: 'text' as const, text: JSON.stringify({ results, count: results.length }) }] }
+          const compact = results.map(toCompactResult)
+          return { content: [{ type: 'text' as const, text: JSON.stringify({ results: compact, count: compact.length }) }] }
         }
 
         case 'reason': {
           const entities = a.entities ?? []
           if (entities.length === 0) return { content: [{ type: 'text' as const, text: JSON.stringify({ error: "reason requires 'entities' list" }) }] }
           const results = retriever.reason(entities, { minTrust: a.min_trust ?? minTrust, limit: a.limit ?? 10 })
-          return { content: [{ type: 'text' as const, text: JSON.stringify({ results, count: results.length }) }] }
+          const compact = results.map(toCompactResult)
+          return { content: [{ type: 'text' as const, text: JSON.stringify({ results: compact, count: compact.length }) }] }
         }
 
         case 'contradict': {
@@ -144,6 +198,9 @@ server.tool(
         case 'update': {
           if (!a.fact_id) return { content: [{ type: 'text' as const, text: JSON.stringify({ error: 'Missing required argument: fact_id' }) }] }
           const updated = store.updateFact(a.fact_id as number, { content: a.content as string | undefined, tags: a.tags, category, trustDelta: a.trust_delta })
+          if (a.summary !== undefined) {
+            store.connection.prepare('UPDATE facts SET summary = ? WHERE fact_id = ?').run(a.summary, a.fact_id as number)
+          }
           retriever.getCache().clear()
           resourceManager.invalidate()
           return { content: [{ type: 'text' as const, text: JSON.stringify({ updated }) }] }
@@ -159,6 +216,23 @@ server.tool(
           return { content: [{ type: 'text' as const, text: JSON.stringify(response) }] }
         }
 
+        case 'learn': {
+          const result = store.runLearning()
+          return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
+        }
+
+        case 'audit': {
+          const report = store.runAudit()
+          return { content: [{ type: 'text' as const, text: JSON.stringify(report) }] }
+        }
+
+        case 'dream': {
+          const report = await store.runDream()
+          retriever.getCache().clear()
+          resourceManager.invalidate()
+          return { content: [{ type: 'text' as const, text: JSON.stringify(report) }] }
+        }
+
         case 'list': {
           const facts = store.listFacts(category, a.min_trust ?? 0.0, a.limit ?? 10)
           return { content: [{ type: 'text' as const, text: JSON.stringify({ facts, count: facts.length }) }] }

package/src/store.ts

@@ -12,9 +12,9 @@
 import Database from 'better-sqlite3'
 import type { Statement } from 'better-sqlite3'
 import { mkdirSync } from 'node:fs'
-import { dirname } from 'node:path'
+import { dirname, join } from 'node:path'
 import { SCHEMA } from './schema.js'
-import type { Fact, FactCategory } from './types.js'
+import type { Fact, FactCategory, DreamReport } from './types.js'
 
 // 信任评分常量
 const HELPFUL_DELTA = 0.05
@@ -63,9 +63,11 @@ interface FactRow {
   category: string
   tags: string
   keywords: string
+  summary?: string | null
   trust_score: number
   retrieval_count: number
   helpful_count: number
+  last_retrieved_at?: string | null
   created_at: string
   updated_at: string
 }
@@ -110,10 +112,58 @@ export class MemoryStore {
 
   /** 增量迁移：添加新列（已存在则跳过） */
   private migrateSchema(): void {
+    const addColumn = (table: string, column: string, def: string): void => {
+      try {
+        this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${def}`)
+      } catch { /* 列已存在 */ }
+    }
+
     // keywords 列（v2）
-    try {
-      this.db.exec('ALTER TABLE facts ADD COLUMN keywords TEXT DEFAULT \'[]\'')
-    } catch { /* 列已存在 */ }
+    addColumn('facts', 'keywords', "TEXT DEFAULT '[]'")
+    // summary 列
+    addColumn('facts', 'summary', 'TEXT DEFAULT NULL')
+    // last_retrieved_at 列
+    addColumn('facts', 'last_retrieved_at', 'TEXT DEFAULT NULL')
+
+    // FTS5 重建：检查 facts_fts 是否包含 summary 列
+    const ftsCols = this.db.pragma('table_info(facts_fts)') as Array<{ name: string }>
+    const hasSummary = ftsCols.some(c => c.name === 'summary')
+    if (!hasSummary) {
+      // DROP 旧 FTS5 表和触发器，重建含 summary 的新版本
+      this.db.exec(`
+        DROP TABLE IF EXISTS facts_fts;
+        DROP TRIGGER IF EXISTS facts_ai;
+        DROP TRIGGER IF EXISTS facts_ad;
+        DROP TRIGGER IF EXISTS facts_au;
+      `)
+      // 重建 FTS5 虚拟表（含 summary，使用 trigram tokenizer 支持中文子串）
+      this.db.exec(`
+        CREATE VIRTUAL TABLE facts_fts
+          USING fts5(content, tags, summary, content=facts, content_rowid=fact_id, tokenize='trigram');
+      `)
+      // 重填充
+      this.db.exec(`
+        INSERT INTO facts_fts(rowid, content, tags, summary)
+          SELECT fact_id, content, tags, COALESCE(summary, '') FROM facts;
+      `)
+      // 重建触发器
+      this.db.exec(`
+        CREATE TRIGGER facts_ai AFTER INSERT ON facts BEGIN
+          INSERT INTO facts_fts(rowid, content, tags, summary)
+            VALUES (new.fact_id, new.content, new.tags, COALESCE(new.summary, ''));
+        END;
+        CREATE TRIGGER facts_ad AFTER DELETE ON facts BEGIN
+          INSERT INTO facts_fts(facts_fts, rowid, content, tags, summary)
+            VALUES ('delete', old.fact_id, old.content, old.tags, COALESCE(old.summary, ''));
+        END;
+        CREATE TRIGGER facts_au AFTER UPDATE ON facts BEGIN
+          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;
+      `)
+    }
   }
 
   private prepareStatements(): void {
@@ -361,8 +411,8 @@ export class MemoryStore {
     params.push(limit)
 
     const sql = `
-      SELECT fact_id, content, category, tags, keywords, trust_score,
-             retrieval_count, helpful_count, created_at, updated_at
+      SELECT fact_id, content, category, tags, keywords, summary, trust_score,
+             retrieval_count, helpful_count, last_retrieved_at, created_at, updated_at
       FROM facts
       WHERE trust_score >= ?
         ${categoryClause}
@@ -410,8 +460,8 @@ export class MemoryStore {
     params.push(limit)
 
     const sql = `
-      SELECT f.fact_id, f.content, f.category, f.tags, f.keywords, f.trust_score,
-             f.retrieval_count, f.helpful_count, f.created_at, f.updated_at
+      SELECT f.fact_id, f.content, f.category, f.tags, f.keywords, f.summary, f.trust_score,
+             f.retrieval_count, f.helpful_count, f.last_retrieved_at, f.created_at, f.updated_at
       FROM facts f
       JOIN fact_entities fe ON f.fact_id = fe.fact_id
       JOIN entities e ON fe.entity_id = e.entity_id
@@ -445,8 +495,8 @@ export class MemoryStore {
     params.push(limit)
 
     const sql = `
-      SELECT f.fact_id, f.content, f.category, f.tags, f.keywords, f.trust_score,
-             f.retrieval_count, f.helpful_count, f.created_at, f.updated_at
+      SELECT f.fact_id, f.content, f.category, f.tags, f.keywords, f.summary, f.trust_score,
+             f.retrieval_count, f.helpful_count, f.last_retrieved_at, f.created_at, f.updated_at
       FROM facts f
       WHERE f.fact_id IN (${intersects})
         ${categoryClause}
@@ -635,6 +685,321 @@ export class MemoryStore {
     return row.count
   }
 
+  /** 记录检索日志并更新 last_retrieved_at */
+  logRetrieval(query: string, results: Array<{ id: number; score: number }>): void {
+    const resultsJson = JSON.stringify(results)
+    this.db.prepare(
+      "INSERT INTO retrieval_log (query, results) VALUES (?, ?)"
+    ).run(query, resultsJson)
+
+    // 更新返回 fact 的 last_retrieved_at
+    if (results.length > 0) {
+      const ids = results.map(r => r.id)
+      const placeholders = ids.map(() => '?').join(',')
+      this.db.prepare(
+        `UPDATE facts SET last_retrieved_at = datetime('now', 'localtime') WHERE fact_id IN (${placeholders})`
+      ).run(...ids)
+    }
+
+    // 自动清理日志
+    this.pruneRetrievalLog(5000)
+  }
+
+  /** 清理检索日志，保留最近 maxEntries 条 */
+  pruneRetrievalLog(maxEntries = 5000): void {
+    this.db.prepare(
+      `DELETE FROM retrieval_log WHERE id NOT IN (
+        SELECT id FROM retrieval_log ORDER BY id DESC LIMIT ?
+      )`
+    ).run(maxEntries)
+  }
+
+  /** 自学习：基于检索统计自动调整 trust_score */
+  runLearning(): {
+    promoted: number
+    demoted: number
+    aged: number
+    unchanged: number
+    long_facts: Array<{ id: number; content_length: number; penalty: number; has_summary: boolean }>
+  } {
+    const rows = this.db.prepare(
+      'SELECT fact_id, content, summary, retrieval_count, helpful_count, trust_score, last_retrieved_at FROM facts'
+    ).all() as Array<{
+      fact_id: number; content: string; summary: string | null;
+      retrieval_count: number; helpful_count: number; trust_score: number; last_retrieved_at: string | null
+    }>
+
+    let promoted = 0
+    let demoted = 0
+    let aged = 0
+    let unchanged = 0
+    const longFacts: Array<{ id: number; content_length: number; penalty: number; has_summary: boolean }> = []
+
+    const now = Date.now()
+
+    for (const row of rows) {
+      let changed = false
+      const rate = row.retrieval_count > 0 ? row.helpful_count / row.retrieval_count : 0
+
+      // Rate-based adjustment (需要 30+ 次检索)
+      if (row.retrieval_count > 30) {
+        // 高频检索保护：检索 >100 次说明被持续需要，feedback 少不代表无用
+        const highFrequencyProtected = row.retrieval_count > 100
+        if (rate < 0.05 && !highFrequencyProtected) {
+          const newTrust = clampTrust(row.trust_score * 0.9)
+          this.db.prepare('UPDATE facts SET trust_score = ? WHERE fact_id = ?').run(newTrust, row.fact_id)
+          demoted++
+          changed = true
+        } else if (rate > 0.3) {
+          const newTrust = clampTrust(row.trust_score + 0.05)
+          this.db.prepare('UPDATE facts SET trust_score = ? WHERE fact_id = ?').run(newTrust, row.fact_id)
+          promoted++
+          changed = true
+        }
+      }
+
+      // Aging (60 天未检索)
+      if (row.last_retrieved_at) {
+        const lastRetrieved = new Date(row.last_retrieved_at + 'Z').getTime()
+        const daysSinceRetrieval = (now - lastRetrieved) / 86_400_000
+        if (daysSinceRetrieval > 60) {
+          const currentTrust = this.db.prepare('SELECT trust_score FROM facts WHERE fact_id = ?').get(row.fact_id) as any
+          const newTrust = clampTrust(currentTrust.trust_score * 0.95)
+          this.db.prepare('UPDATE facts SET trust_score = ? WHERE fact_id = ?').run(newTrust, row.fact_id)
+          aged++
+          changed = true
+        }
+      }
+      // last_retrieved_at 为 NULL = 新 fact，不老化
+
+      if (!changed) unchanged++
+
+      // Long facts report (content > 300 字无 summary)
+      const matchLength = row.summary ? row.summary.length : row.content.length
+      if (matchLength > 300) {
+        longFacts.push({
+          id: row.fact_id,
+          content_length: row.content.length,
+          penalty: Math.min(1.0, 300 / matchLength),
+          has_summary: !!row.summary,
+        })
+      }
+    }
+
+    return { promoted, demoted, aged, unchanged, long_facts: longFacts }
+  }
+
+  /** 数据质量审计（只读，不修改数据） */
+  runAudit(): {
+    total_facts: number
+    long_without_summary: Array<{ id: number; content_length: number }>
+    low_helpful_rate: Array<{ id: number; rate: number; retrieval_count: number }>
+    aging_candidates: Array<{ id: number; last_retrieved_at: string | null }>
+  } {
+    const rows = this.db.prepare(
+      'SELECT fact_id, content, summary, retrieval_count, helpful_count, last_retrieved_at FROM facts'
+    ).all() as Array<{
+      fact_id: number; content: string; summary: string | null;
+      retrieval_count: number; helpful_count: number; last_retrieved_at: string | null
+    }>
+
+    const longWithoutSummary: Array<{ id: number; content_length: number }> = []
+    const lowHelpfulRate: Array<{ id: number; rate: number; retrieval_count: number }> = []
+    const agingCandidates: Array<{ id: number; last_retrieved_at: string | null }> = []
+
+    const now = Date.now()
+
+    for (const row of rows) {
+      // 超 500 字无 summary
+      if (row.content.length > 500 && !row.summary) {
+        longWithoutSummary.push({ id: row.fact_id, content_length: row.content.length })
+      }
+
+      // 低 helpful 率（>30 次检索，rate < 5%）
+      if (row.retrieval_count > 30) {
+        const rate = row.helpful_count / row.retrieval_count
+        if (rate < 0.05) {
+          lowHelpfulRate.push({ id: row.fact_id, rate: Math.round(rate * 1000) / 1000, retrieval_count: row.retrieval_count })
+        }
+      }
+
+      // 老化候选（>60 天未检索）
+      if (row.last_retrieved_at) {
+        const lastRetrieved = new Date(row.last_retrieved_at + 'Z').getTime()
+        const daysSince = (now - lastRetrieved) / 86_400_000
+        if (daysSince > 60) {
+          agingCandidates.push({ id: row.fact_id, last_retrieved_at: row.last_retrieved_at })
+        }
+      }
+    }
+
+    return {
+      total_facts: rows.length,
+      long_without_summary: longWithoutSummary,
+      low_helpful_rate: lowHelpfulRate,
+      aging_candidates: agingCandidates,
+    }
+  }
+
+  /** Dream 前备份数据库（使用 better-sqlite3 内置备份，安全处理 WAL 模式） */
+  async backupDatabase(): Promise<string> {
+    const dbDir = dirname(this.db.name)
+    const backupDir = join(dbDir, 'backup')
+    mkdirSync(backupDir, { recursive: true })
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+    const backupPath = join(backupDir, `dream-${timestamp}.db`)
+    await this.db.backup(backupPath)
+    return backupPath
+  }
+
+  /** 合并同 category 内 Jaccard > 0.6 的重叠 fact */
+  mergeOverlappingFacts(): { merged: number; details: Array<{ kept: number; removed: number; similarity: number }> } {
+    return this.db.transaction(() => {
+      const categories: FactCategory[] = ['identity', 'coding_style', 'tool_pref', 'workflow', 'general']
+      let merged = 0
+      const details: Array<{ kept: number; removed: number; similarity: number }> = []
+
+      for (const cat of categories) {
+        const rows = this.db.prepare(
+          'SELECT fact_id, content, retrieval_count FROM facts WHERE category = ? ORDER BY trust_score DESC'
+        ).all(cat) as Array<{ fact_id: number; content: string; retrieval_count: number }>
+
+        const removed = new Set<number>()
+
+        for (let i = 0; i < rows.length; i++) {
+          if (removed.has(rows[i].fact_id)) continue
+          const tokensA = this.tokenizeForDedup(rows[i].content)
+
+          for (let j = i + 1; j < rows.length; j++) {
+            if (removed.has(rows[j].fact_id)) continue
+            const tokensB = this.tokenizeForDedup(rows[j].content)
+            const sim = this.jaccardSimilarity(tokensA, tokensB)
+
+            if (sim > 0.6) {
+              const aHighFreq = rows[i].retrieval_count > 100
+              const bHighFreq = rows[j].retrieval_count > 100
+
+              if (aHighFreq && bHighFreq) continue
+
+              let keptId: number, removedId: number
+              if (bHighFreq) {
+                keptId = rows[j].fact_id
+                removedId = rows[i].fact_id
+              } else {
+                keptId = rows[i].fact_id
+                removedId = rows[j].fact_id
+              }
+
+              this.removeFact(removedId)
+              removed.add(removedId)
+              details.push({ kept: keptId, removed: removedId, similarity: Math.round(sim * 100) / 100 })
+              merged++
+              // 外层 fact 被删除时停止内层循环，避免幽灵操作
+              if (removedId === rows[i].fact_id) break
+            }
+          }
+        }
+      }
+      return { merged, details }
+    })()
+  }
+
+  /** 分类修正：按关键词规则表将误分类的 fact 挪到正确 category */
+  reclassifyFacts(): number {
+    return this.db.transaction(() => {
+      const rules: Array<{ keywords: string[]; target: FactCategory }> = [
+        { keywords: ['角色设定', '暖暖', '身份', '编程女朋友', '暖宝宝'], target: 'identity' },
+        { keywords: ['编码规范', '代码风格', 'pytest', '文件不超过', '方法不超过'], target: 'coding_style' },
+        { keywords: ['工作流', 'OpenSpec', 'writing-plans', 'subagent'], target: 'workflow' },
+        { keywords: ['偏好', 'VS Code', '编辑器', 'IDE', '快捷键'], target: 'tool_pref' },
+      ]
+
+      const rows = this.db.prepare(
+        'SELECT fact_id, content, category FROM facts'
+      ).all() as Array<{ fact_id: number; content: string; category: string }>
+
+      let reclassified = 0
+      for (const row of rows) {
+        for (const rule of rules) {
+          if (rule.target === row.category) continue
+          if (rule.keywords.some(kw => row.content.includes(kw))) {
+            this.db.prepare("UPDATE facts SET category = ?, updated_at = datetime('now', 'localtime') WHERE fact_id = ?").run(rule.target, row.fact_id)
+            reclassified++
+            break
+          }
+        }
+      }
+      return reclassified
+    })()
+  }
+
+  /** 执行完整 dream cycle：备份 → 压缩 → 合并 → 重分类 → 报告 */
+  async runDream(options?: { skipBackup?: boolean }): Promise<DreamReport> {
+    if (!options?.skipBackup) {
+      await this.backupDatabase()
+    }
+
+    const compressed = this.compressLongFacts()
+    const mergeResult = this.mergeOverlappingFacts()
+    const reclassified = this.reclassifyFacts()
+
+    const stats = this.db.prepare(`
+      SELECT COUNT(*) as total,
+             AVG(trust_score) as avg_trust,
+             AVG(length(content)) as avg_length
+      FROM facts
+    `).get() as { total: number; avg_trust: number; avg_length: number }
+
+    const categories: FactCategory[] = ['identity', 'coding_style', 'tool_pref', 'workflow', 'general']
+    const coverage: Record<string, number> = {}
+    for (const cat of categories) {
+      const row = this.db.prepare('SELECT COUNT(*) as c FROM facts WHERE category = ?').get(cat) as { c: number }
+      coverage[cat] = row.c
+    }
+
+    return {
+      merged: mergeResult.merged,
+      compressed,
+      reclassified,
+      deleted: mergeResult.merged,
+      mergeDetails: mergeResult.details,
+      health: {
+        total: stats.total,
+        avg_trust: Math.round((stats.avg_trust ?? 0) * 100) / 100,
+        avg_length: Math.round(stats.avg_length ?? 0),
+        coverage: coverage as Record<FactCategory, number>,
+      },
+    }
+  }
+
+  /** 压缩长 fact：content > 200 字且无 summary 的，自动提取前 2 句作为 summary */
+  compressLongFacts(): number {
+    const rows = this.db.prepare(
+      "SELECT fact_id, content FROM facts WHERE length(content) > 200 AND (summary IS NULL OR summary = '')"
+    ).all() as Array<{ fact_id: number; content: string }>
+
+    let compressed = 0
+    for (const row of rows) {
+      const summary = this.extractSummary(row.content)
+      if (summary) {
+        this.db.prepare('UPDATE facts SET summary = ? WHERE fact_id = ?').run(summary, row.fact_id)
+        compressed++
+      }
+    }
+    return compressed
+  }
+
+  /** 从 content 提取前 2 个完整句子（总长 ≤ 150 字） */
+  private extractSummary(content: string): string | null {
+    const sentences = content.split(/[。\n.]/).map(s => s.trim()).filter(s => s.length > 0)
+    if (sentences.length === 0) return null
+    let summary = sentences[0]
+    if (sentences.length > 1 && summary.length + sentences[1].length <= 148) {
+      summary += '。' + sentences[1]
+    }
+    return summary.length <= 150 ? summary : summary.slice(0, 147) + '...'
+  }
+
   /** 获取数据库连接（供 FactRetriever 直接使用） */
   get connection(): Database.Database {
     return this.db
@@ -795,9 +1160,11 @@ export class MemoryStore {
       category: row.category as FactCategory,
       tags: row.tags,
       keywords: row.keywords,
+      summary: (row as any).summary ?? null,
       trustScore: row.trust_score,
       retrievalCount: row.retrieval_count,
       helpfulCount: row.helpful_count,
+      lastRetrievedAt: (row as any).last_retrieved_at ?? null,
       createdAt: row.created_at,
       updatedAt: row.updated_at,
     }

package/src/types.ts

@@ -8,9 +8,11 @@ export interface Fact {
   category: FactCategory
   tags: string
   keywords: string
+  summary: string | null
   trustScore: number
   retrievalCount: number
   helpfulCount: number
+  lastRetrievedAt: string | null
   createdAt: string
   updatedAt: string
 }
@@ -53,7 +55,7 @@ export interface RetrieverOptions {
 
 /** fact_store 工具调用参数 */
 export interface FactStoreArgs {
-  action: 'add' | 'search' | 'probe' | 'related' | 'reason' | 'contradict' | 'update' | 'remove' | 'list'
+  action: 'add' | 'search' | 'probe' | 'related' | 'reason' | 'contradict' | 'update' | 'remove' | 'list' | 'learn' | 'audit' | 'dream'
   content?: string | string[]
   query?: string
   entity?: string
@@ -61,6 +63,7 @@ export interface FactStoreArgs {
   fact_id?: number | number[]
   category?: string
   tags?: string
+  summary?: string
   trust_delta?: number
   min_trust?: number
   limit?: number
@@ -79,3 +82,27 @@ export interface SecurityScanResult {
   hasPii: boolean
   injectionAttempts: string[]
 }
+
+/** Dream 整理报告 */
+export interface DreamReport {
+  merged: number
+  compressed: number
+  reclassified: number
+  deleted: number
+  mergeDetails: Array<{ kept: number; removed: number; similarity: number }>
+  health: {
+    total: number
+    avg_trust: number
+    avg_length: number
+    coverage: Record<FactCategory, number>
+  }
+}
+
+/** 精简搜索结果 */
+export interface CompactFactResult {
+  factId: number
+  display: string
+  category: FactCategory
+  trustScore: number
+  score: number
+}