@morningljn/mnemo 0.2.0 → 0.2.1

package/openspec/changes/archive/2026-05-16-memory-dreaming/proposal.md

@@ -0,0 +1,32 @@
+## Why
+
+mnemo 的记忆库随着长期使用会积累大量冗余、重叠、过长的 fact，导致检索精度下降、token 浪费。当前 `runLearning()` 只调 trust 分，不整理内容。需要一套后台自动整理机制（类似 OpenClaw Dreaming），定期合并去重、压缩摘要、分类修正，保持数据库精炼。
+
+## What Changes
+
+- 新增 `dream` action（`fact_store(action="dream")`），执行三阶段整理：Collect → Consolidate → Evaluate
+- 新增 `mnemo dream` CLI 命令，支持 cron 定时触发
+- 合并 Jaccard > 0.6 的重叠 fact（保留最完整的，其余删除）
+- 长 fact（content > 200 字且无 summary）自动提取关键句生成 summary
+- 分类自动修正：按关键词规则将误分类的 fact 挪到正确 category
+- 输出 dream report：合并/删除/压缩了什么，健康评分多少
+- 搜索结果精简格式：返回 summary（优先）或 content 前 100 字，减少 token 消耗
+
+## Capabilities
+
+### New Capabilities
+- `dream-cycle`: 后台定期整理记忆库（合并去重、摘要压缩、分类修正、健康评分）
+- `compact-search`: 搜索结果精简格式（summary 优先、content 截断、限制条数）
+
+### Modified Capabilities
+
+（无已有 spec 需要修改）
+
+## Impact
+
+- `src/store.ts` — 新增 `runDream()` 方法（合并、压缩、分类修正、报告）
+- `src/retriever.ts` — 搜索结果格式精简（返回 summary 而非完整 content）
+- `src/server.ts` — `fact_store` 新增 `dream` action
+- `src/init.ts` — `mnemo init` 可选配置 cron 定时 dream
+- `tests/store.test.ts` — dream 相关测试
+- 数据库 — dream 可能删除/合并 fact，不可逆操作需谨慎

package/openspec/changes/archive/2026-05-16-memory-dreaming/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/changes/archive/2026-05-16-memory-dreaming/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/openspec/changes/archive/2026-05-16-memory-dreaming/tasks.md

@@ -0,0 +1,27 @@
+## 1. 搜索结果精简
+
+- [ ] 1.1 修改 `ScoredFact` 类型定义，新增 `display` 字段（精简内容）
+- [ ] 1.2 修改 `retriever.ts` search 方法：有 summary 用 summary，无 summary 截取 content 前 100 字
+- [ ] 1.3 修改 `server.ts` search/probe/related/reason 响应格式：返回 display 而非完整 content
+- [ ] 1.4 更新 `tests/retriever.test.ts` 验证精简格式
+
+## 2. Dream Cycle - Store 层
+
+- [ ] 2.1 实现 `mergeOverlappingFacts()` — 同 category 内 Jaccard > 0.6 的 fact 合并，高频（retrieval > 100）保护
+- [ ] 2.2 实现 `compressLongFacts()` — content > 200 字且无 summary 的 fact 自动提取前 2 句
+- [ ] 2.3 实现 `reclassifyFacts()` — 按关键词规则表修正 category
+- [ ] 2.4 实现 `backupDatabase()` — dream 前备份到 `~/.mnemo/backup/dream-<timestamp>.db`
+- [ ] 2.5 实现 `runDream()` — 编排以上步骤，生成 dream report（merged/compressed/reclassified/deleted + health）
+- [ ] 2.6 新增 `dream` action 到 `server.ts` 的 fact_store handler
+
+## 3. CLI 命令
+
+- [ ] 3.1 新增 `src/dream.ts` CLI 入口，执行 `store.runDream()` 并输出 report
+- [ ] 3.2 在 `package.json` 添加 `mnemo dream` bin 入口
+
+## 4. 测试
+
+- [ ] 4.1 `tests/store.test.ts` — mergeOverlappingFacts 合并 + 高频保护测试
+- [ ] 4.2 `tests/store.test.ts` — compressLongFacts 提取 summary 测试
+- [ ] 4.3 `tests/store.test.ts` — reclassifyFacts 分类修正测试
+- [ ] 4.4 `tests/store.test.ts` — runDream 端到端测试（备份数据库 + 整理 + report）

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.2.0",
+  "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

@@ -437,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}"`)
       }
     }
 

package/src/schema.ts

@@ -46,9 +46,9 @@ 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 全文索引（含 summary 列）
+-- FTS5 全文索引（trigram tokenizer 支持中文子串匹配）
 CREATE VIRTUAL TABLE IF NOT EXISTS facts_fts
-  USING fts5(content, tags, summary, 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

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,7 +27,7 @@ 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', 'learn', 'audit']),
+  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' 必需）"),
@@ -52,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 --
@@ -76,7 +86,25 @@ process.nextTick(() => {
 })
 
 // -- 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)
@@ -136,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': {
@@ -194,6 +226,13 @@ server.tool(
           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 }) }] }