@morningljn/mnemo 0.2.1 → 0.3.0

package/docs/superpowers/plans/2026-05-16-llm-dream.md

@@ -0,0 +1,973 @@
+# LLM Dream Engine Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** 用 LLM 替代硬编码规则做语义级记忆整理（合并/摘要/分类），Ollama 不可用时降级到规则引擎。
+
+**Architecture:** 新增 `llm-client.ts`（统一 OpenAI 兼容 `/v1/chat/completions` 客户端）+ `dream-engine.ts`（LLM 驱动的三个整理任务 + 安全校验 + 降级）。修改 `store.ts` 的 `runDream()` 集成 dream engine。配置从 `~/.mnemo/config.json` 加载，无配置时默认 Ollama localhost。
+
+**Tech Stack:** TypeScript, Node.js 原生 fetch, better-sqlite3, vitest
+
+---
+
+## File Structure
+
+| File | Action | Responsibility |
+|------|--------|---------------|
+| `src/types.ts` | Modify | 新增 LLMConfig、LLMMessage、DreamReport 新增 fallback 字段 |
+| `src/config.ts` | Create | 加载 `~/.mnemo/config.json`，返回 LLM 配置 |
+| `src/llm-client.ts` | Create | OpenAI 兼容 `/v1/chat/completions` 客户端 |
+| `src/dream-engine.ts` | Create | LLM 语义合并/摘要/分类 + 安全校验 + 降级到规则引擎 |
+| `src/store.ts` | Modify | `runDream()` 集成 DreamEngine |
+| `src/dream.ts` | Modify | CLI 使用新 dream engine |
+| `tests/llm-client.test.ts` | Create | LLM 客户端测试（mock fetch） |
+| `tests/dream-engine.test.ts` | Create | Dream engine 测试（mock LLM） |
+
+---
+
+### Task 1: 类型定义
+
+**Files:**
+- Modify: `src/types.ts`
+
+- [ ] **Step 1: 新增 LLM 相关类型到 types.ts**
+
+在 `src/types.ts` 文件末尾追加：
+
+```typescript
+/** LLM 配置 */
+export interface LLMConfig {
+  baseUrl: string
+  model: string
+  apiKey?: string
+  temperature: number
+}
+
+/** LLM 聊天消息 */
+export interface LLMMessage {
+  role: 'system' | 'user' | 'assistant'
+  content: string
+}
+```
+
+修改 `DreamReport` 接口，新增两个字段：
+
+```typescript
+export interface DreamReport {
+  merged: number
+  compressed: number
+  reclassified: number
+  deleted: number
+  mergeDetails: Array<{ kept: number; removed: number; similarity: number }>
+  fallback?: boolean
+  fallbackReason?: string
+  health: {
+    total: number
+    avg_trust: number
+    avg_length: number
+    coverage: Record<FactCategory, number>
+  }
+}
+```
+
+- [ ] **Step 2: 验证构建通过**
+
+Run: `npm run build 2>&1 | tail -5`
+Expected: 无错误
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/types.ts
+git commit -m "feat(types): add LLMConfig, LLMMessage types and DreamReport fallback fields"
+```
+
+---
+
+### Task 2: 配置加载
+
+**Files:**
+- Create: `src/config.ts`
+
+- [ ] **Step 1: 创建 config.ts**
+
+```typescript
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import type { LLMConfig } from './types.js'
+
+const DEFAULT_CONFIG: LLMConfig = {
+  baseUrl: 'http://localhost:11434/v1',
+  model: 'qwen3:8b',
+  temperature: 0.1,
+}
+
+export function loadConfig(): LLMConfig {
+  const configPath = join(homedir(), '.mnemo', 'config.json')
+  if (!existsSync(configPath)) return { ...DEFAULT_CONFIG }
+
+  try {
+    const raw = readFileSync(configPath, 'utf-8')
+    const parsed = JSON.parse(raw)
+    const llm = parsed.llm ?? {}
+    return {
+      baseUrl: llm.baseUrl ?? DEFAULT_CONFIG.baseUrl,
+      model: llm.model ?? DEFAULT_CONFIG.model,
+      apiKey: llm.apiKey,
+      temperature: llm.temperature ?? DEFAULT_CONFIG.temperature,
+    }
+  } catch {
+    return { ...DEFAULT_CONFIG }
+  }
+}
+```
+
+- [ ] **Step 2: 验证构建通过**
+
+Run: `npm run build 2>&1 | tail -3`
+Expected: 无错误
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/config.ts
+git commit -m "feat(config): add loadConfig for ~/.mnemo/config.json with Ollama defaults"
+```
+
+---
+
+### Task 3: LLM 客户端
+
+**Files:**
+- Create: `src/llm-client.ts`
+- Create: `tests/llm-client.test.ts`
+
+- [ ] **Step 1: 写失败测试 `tests/llm-client.test.ts`**
+
+```typescript
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { LLMClient } from '../src/llm-client.js'
+import type { LLMConfig, LLMMessage } from '../src/types.js'
+
+const mockConfig: LLMConfig = {
+  baseUrl: 'http://localhost:11434/v1',
+  model: 'test-model',
+  temperature: 0.1,
+}
+
+function mockFetchResponse(body: unknown, ok = true, status = 200) {
+  return vi.fn().mockResolvedValue({
+    ok,
+    status,
+    json: () => Promise.resolve(body),
+    text: () => Promise.resolve(JSON.stringify(body)),
+  })
+}
+
+describe('LLMClient', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('chat', () => {
+    it('sends request and returns text content', async () => {
+      const mockResp = {
+        choices: [{ message: { content: 'Hello from LLM' } }],
+      }
+      globalThis.fetch = mockFetchResponse(mockResp)
+
+      const client = new LLMClient(mockConfig)
+      const messages: LLMMessage[] = [{ role: 'user', content: 'Hi' }]
+      const result = await client.chat(messages)
+
+      expect(result).toBe('Hello from LLM')
+      expect(globalThis.fetch).toHaveBeenCalledWith(
+        'http://localhost:11434/v1/chat/completions',
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({ 'Content-Type': 'application/json' }),
+        }),
+      )
+    })
+
+    it('includes Authorization header when apiKey is set', async () => {
+      const configWithKey = { ...mockConfig, apiKey: 'sk-test-key' }
+      globalThis.fetch = mockFetchResponse({
+        choices: [{ message: { content: 'ok' } }],
+      })
+
+      const client = new LLMClient(configWithKey)
+      await client.chat([{ role: 'user', content: 'test' }])
+
+      const callArgs = (globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0][1] as RequestInit
+      expect(callArgs.headers).toHaveProperty('Authorization', 'Bearer sk-test-key')
+    })
+
+    it('throws on connection failure', async () => {
+      globalThis.fetch = vi.fn().mockRejectedValue(new Error('ECONNREFUSED'))
+      const client = new LLMClient(mockConfig)
+      await expect(client.chat([{ role: 'user', content: 'test' }])).rejects.toThrow('ECONNREFUSED')
+    })
+
+    it('throws on non-ok HTTP status', async () => {
+      globalThis.fetch = mockFetchResponse({ error: 'bad request' }, false, 400)
+      const client = new LLMClient(mockConfig)
+      await expect(client.chat([{ role: 'user', content: 'test' }])).rejects.toThrow('400')
+    })
+
+    it('extracts JSON from markdown code fence', async () => {
+      const jsonBody = { result: [1, 2] }
+      const fenced = '```json\n' + JSON.stringify(jsonBody) + '\n```'
+      globalThis.fetch = mockFetchResponse({
+        choices: [{ message: { content: fenced } }],
+      })
+
+      const client = new LLMClient(mockConfig)
+      const result = await client.chatJSON([{ role: 'user', content: 'test' }])
+      expect(result).toEqual(jsonBody)
+    })
+
+    it('throws on invalid JSON response in chatJSON', async () => {
+      globalThis.fetch = mockFetchResponse({
+        choices: [{ message: { content: 'not json at all' } }],
+      })
+      const client = new LLMClient(mockConfig)
+      await expect(client.chatJSON([{ role: 'user', content: 'test' }])).rejects.toThrow()
+    })
+  })
+
+  describe('isAvailable', () => {
+    it('returns true when service is reachable', async () => {
+      globalThis.fetch = mockFetchResponse({ data: [] })
+      const client = new LLMClient(mockConfig)
+      expect(await client.isAvailable()).toBe(true)
+    })
+
+    it('returns false when service is unreachable', async () => {
+      globalThis.fetch = vi.fn().mockRejectedValue(new Error('fail'))
+      const client = new LLMClient(mockConfig)
+      expect(await client.isAvailable()).toBe(false)
+    })
+  })
+})
+```
+
+- [ ] **Step 2: 运行测试确认失败**
+
+Run: `npx vitest run tests/llm-client.test.ts 2>&1 | tail -10`
+Expected: FAIL — `Cannot find module '../src/llm-client.js'`
+
+- [ ] **Step 3: 实现 `src/llm-client.ts`**
+
+```typescript
+import type { LLMConfig, LLMMessage } from './types.js'
+
+export class LLMClient {
+  constructor(private config: LLMConfig) {}
+
+  async chat(messages: LLMMessage[], options?: { temperature?: number }): Promise<string> {
+    const url = `${this.config.baseUrl}/chat/completions`
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+    if (this.config.apiKey) {
+      headers['Authorization'] = `Bearer ${this.config.apiKey}`
+    }
+
+    const resp = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        model: this.config.model,
+        messages,
+        temperature: options?.temperature ?? this.config.temperature,
+        stream: false,
+      }),
+    })
+
+    if (!resp.ok) {
+      throw new Error(`LLM request failed: ${resp.status} ${await resp.text()}`)
+    }
+
+    const data = await resp.json() as { choices: Array<{ message: { content: string } }> }
+    return data.choices[0]?.message?.content ?? ''
+  }
+
+  async chatJSON<T = unknown>(messages: LLMMessage[]): Promise<T> {
+    const text = await this.chat(messages)
+    // 尝试直接解析
+    try {
+      return JSON.parse(text)
+    } catch {
+      // 尝试从 markdown code fence 中提取
+      const match = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/)
+      if (match) {
+        return JSON.parse(match[1].trim())
+      }
+      throw new Error(`LLM response is not valid JSON: ${text.slice(0, 200)}`)
+    }
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      const url = `${this.config.baseUrl}/models`
+      const resp = await fetch(url, { method: 'GET', signal: AbortSignal.timeout(3000) })
+      return resp.ok
+    } catch {
+      return false
+    }
+  }
+}
+```
+
+- [ ] **Step 4: 运行测试确认通过**
+
+Run: `npx vitest run tests/llm-client.test.ts 2>&1 | tail -8`
+Expected: 6 tests passed
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/llm-client.ts tests/llm-client.test.ts
+git commit -m "feat(llm-client): OpenAI-compatible /v1/chat/completions client with health check"
+```
+
+---
+
+### Task 4: Dream Engine — 语义合并
+
+**Files:**
+- Create: `src/dream-engine.ts`
+- Create: `tests/dream-engine.test.ts`（部分）
+
+- [ ] **Step 1: 写语义合并的失败测试**
+
+在 `tests/dream-engine.test.ts` 中：
+
+```typescript
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { DreamEngine } from '../src/dream-engine.js'
+import { LLMClient } from '../src/llm-client.js'
+import { MemoryStore } from '../src/store.js'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import type { LLMConfig } from '../src/types.js'
+
+let store: MemoryStore
+let tmpDir: string
+let mockChatJSON: ReturnType<typeof vi.fn>
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), 'mnemo-dream-'))
+  store = new MemoryStore(join(tmpDir, 'test.db'))
+})
+
+afterEach(() => {
+  store.close()
+  rmSync(tmpDir, { recursive: true, force: true })
+})
+
+function createEngine(llmResponses: unknown[]): DreamEngine {
+  mockChatJSON = vi.fn()
+  for (const resp of llmResponses) {
+    mockChatJSON.mockResolvedValueOnce(resp)
+  }
+  const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+  return new DreamEngine(mockClient, store)
+}
+
+describe('DreamEngine - semanticMerge', () => {
+  it('merges semantically duplicate facts in same category', async () => {
+    store.addFact('用户喜欢使用 VS Code 编辑器写代码', 'tool_pref')
+    store.addFact('用户偏好 Visual Studio Code 作为开发工具', 'tool_pref')
+
+    mockChatJSON.mockResolvedValueOnce({
+      merges: [{ kept: 1, removed: 2, reason: '都描述偏好VS Code编辑器' }],
+    })
+
+    const engine = createEngine([])
+    // override mockChatJSON for this test
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.semanticMerge()
+
+    expect(result.merged).toBe(1)
+    expect(result.details.length).toBe(1)
+    expect(result.details[0].reason).toBe('都描述偏好VS Code编辑器')
+  })
+
+  it('skips batch when LLM returns invalid JSON', async () => {
+    store.addFact('一些事实内容', 'general')
+
+    const mockClient = {
+      chatJSON: vi.fn().mockRejectedValue(new Error('invalid json')),
+      isAvailable: vi.fn().mockResolvedValue(true),
+    } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.semanticMerge()
+
+    expect(result.merged).toBe(0)
+  })
+
+  it('protects high-trust facts from deletion', async () => {
+    const id1 = store.addFact('高信任事实内容', 'general')
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    // trust now ~0.75, need more pushes
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    store.recordFeedback(id1, true)
+    // trust now ~1.0
+
+    const id2 = store.addFact('另一个事实内容', 'general')
+
+    mockChatJSON.mockResolvedValueOnce({
+      merges: [{ kept: id2, removed: id1, reason: '重复' }],
+    })
+
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.semanticMerge()
+
+    // id1 trust > 0.8, should be protected
+    expect(result.merged).toBe(0)
+  })
+})
+```
+
+- [ ] **Step 2: 运行测试确认失败**
+
+Run: `npx vitest run tests/dream-engine.test.ts 2>&1 | tail -10`
+Expected: FAIL — module not found
+
+- [ ] **Step 3: 创建 `src/dream-engine.ts` 骨架，实现 semanticMerge**
+
+```typescript
+import type { LLMConfig, LLMMessage, FactCategory } from './types.js'
+import type { LLMClient } from './llm-client.js'
+import type { MemoryStore } from './store.js'
+import type { Fact } from './types.js'
+
+const BATCH_SIZE = 20
+const MAX_DELETE_RATIO = 0.1
+const TRUST_DELETE_LIMIT = 0.8
+const RETRIEVAL_DELETE_LIMIT = 100
+
+export class DreamEngine {
+  constructor(private llm: LLMClient, private store: MemoryStore) {}
+
+  async semanticMerge(): Promise<{
+    merged: number
+    details: Array<{ kept: number; removed: number; reason: string }>
+  }> {
+    const categories: FactCategory[] = ['identity', 'coding_style', 'tool_pref', 'workflow', 'general']
+    let merged = 0
+    const details: Array<{ kept: number; removed: number; reason: string }> = []
+
+    const totalFacts = this.store.getTotalCount()
+    const maxDeletes = Math.max(1, Math.floor(totalFacts * MAX_DELETE_RATIO))
+
+    for (const cat of categories) {
+      const facts = this.store.listFacts(cat, 0, 200)
+      if (facts.length < 2) continue
+
+      // 分批处理
+      for (let i = 0; i < facts.length; i += BATCH_SIZE) {
+        const batch = facts.slice(i, i + BATCH_SIZE)
+        const factList = batch.map(f => `[${f.factId}] ${f.content}`).join('\n')
+
+        const messages: LLMMessage[] = [
+          {
+            role: 'system',
+            content: `你是一个记忆整理助手。分析以下同一分类(${cat})的记忆条目，找出语义重复的条目对。
+只输出JSON，格式：{"merges": [{"kept": 保留的fact_id, "removed": 删除的fact_id, "reason": "原因"}]}
+如果没有语义重复的条目，输出：{"merges": []}
+规则：
+- 保留内容更完整、信息量更大的条目
+- 用词不同但意思相同的条目应合并（如"喜欢VS Code"和"偏好Visual Studio Code"）
+- 不要合并只是主题相关但内容不同的条目`,
+          },
+          { role: 'user', content: factList },
+        ]
+
+        try {
+          const result = await this.llm.chatJSON<{ merges: Array<{ kept: number; removed: number; reason: string }> }>(messages)
+          if (!result?.merges || !Array.isArray(result.merges)) continue
+
+          for (const merge of result.merges) {
+            if (merged >= maxDeletes) break
+            if (!merge.kept || !merge.removed) continue
+
+            // 安全校验
+            const toRemove = this.store.listFacts(cat, 0, 200).find(f => f.factId === merge.removed)
+            if (!toRemove) continue
+            if (toRemove.trustScore > TRUST_DELETE_LIMIT) continue
+            if (toRemove.retrievalCount > RETRIEVAL_DELETE_LIMIT) continue
+
+            const toKeep = this.store.listFacts(cat, 0, 200).find(f => f.factId === merge.kept)
+            if (!toKeep) continue
+
+            this.store.removeFact(merge.removed)
+            details.push({ kept: merge.kept, removed: merge.removed, reason: merge.reason })
+            merged++
+          }
+        } catch {
+          // LLM 输出格式错误，跳过该批
+          continue
+        }
+      }
+    }
+
+    return { merged, details }
+  }
+
+  async smartCompress(): Promise<number> {
+    // Task 5 实现
+    return 0
+  }
+
+  async smartReclassify(): Promise<number> {
+    // Task 6 实现
+    return 0
+  }
+}
+```
+
+- [ ] **Step 4: 运行测试**
+
+Run: `npx vitest run tests/dream-engine.test.ts 2>&1 | tail -10`
+Expected: 3 tests passed
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/dream-engine.ts tests/dream-engine.test.ts
+git commit -m "feat(dream-engine): add semanticMerge with LLM batch analysis and safety validation"
+```
+
+---
+
+### Task 5: Dream Engine — 智能摘要
+
+**Files:**
+- Modify: `src/dream-engine.ts`
+- Modify: `tests/dream-engine.test.ts`
+
+- [ ] **Step 1: 在 test 文件中追加智能摘要测试**
+
+```typescript
+describe('DreamEngine - smartCompress', () => {
+  it('generates summary for long facts without summary', async () => {
+    const longContent = '这是一段很长的记忆内容。'.repeat(15) // >200 chars
+    store.addFact(longContent, 'general')
+
+    const summary = '这是一段关于长内容的简洁摘要'
+    mockChatJSON.mockResolvedValueOnce({ summaries: [{ fact_id: 1, summary }] })
+
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.smartCompress()
+
+    expect(result).toBe(1)
+  })
+
+  it('skips facts that already have summary', async () => {
+    const longContent = '这是一段很长的记忆内容。'.repeat(15)
+    const id = store.addFact(longContent, 'general')
+    store.connection.prepare('UPDATE facts SET summary = ? WHERE fact_id = ?').run('已有摘要', id)
+
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.smartCompress()
+
+    expect(result).toBe(0)
+    expect(mockChatJSON).not.toHaveBeenCalled()
+  })
+
+  it('truncates summary longer than 150 chars', async () => {
+    const longContent = '这是一段很长的记忆内容。'.repeat(15)
+    store.addFact(longContent, 'general')
+
+    const tooLongSummary = 'a'.repeat(200)
+    mockChatJSON.mockResolvedValueOnce({ summaries: [{ fact_id: 1, summary: tooLongSummary }] })
+
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    await eng.smartCompress()
+
+    const fact = store.listFacts('general', 0, 10)[0]
+    expect(fact.summary!.length).toBeLessThanOrEqual(150)
+  })
+})
+```
+
+- [ ] **Step 2: 运行测试确认失败**
+
+Run: `npx vitest run tests/dream-engine.test.ts 2>&1 | grep -A5 "smartCompress"`
+Expected: smartCompress 测试失败（方法返回 0）
+
+- [ ] **Step 3: 在 `dream-engine.ts` 中实现 smartCompress**
+
+替换 `smartCompress` 方法：
+
+```typescript
+async smartCompress(): Promise<number> {
+  const rows = this.store.connection.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 }>
+
+  if (rows.length === 0) return 0
+
+  let compressed = 0
+
+  for (let i = 0; i < rows.length; i += BATCH_SIZE) {
+    const batch = rows.slice(i, i + BATCH_SIZE)
+    const factList = batch.map(f => `[${f.fact_id}] ${f.content}`).join('\n\n---\n\n')
+
+    const messages: LLMMessage[] = [
+      {
+        role: 'system',
+        content: `你是一个记忆摘要助手。为每条记忆生成简洁的摘要（≤150字）。
+摘要应保留核心信息：谁/什么/关键决策/关键数据。去除示例、过程描述、冗余细节。
+输出JSON：{"summaries": [{"fact_id": 数字, "summary": "摘要内容"}]}`,
+      },
+      { role: 'user', content: factList },
+    ]
+
+    try {
+      const result = await this.llm.chatJSON<{ summaries: Array<{ fact_id: number; summary: string }> }>(messages)
+      if (!result?.summaries || !Array.isArray(result.summaries)) continue
+
+      for (const item of result.summaries) {
+        if (!item.fact_id || !item.summary) continue
+        const truncated = item.summary.length > 150 ? item.summary.slice(0, 147) + '...' : item.summary
+        this.store.connection.prepare('UPDATE facts SET summary = ? WHERE fact_id = ?').run(truncated, item.fact_id)
+        compressed++
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return compressed
+}
+```
+
+注意：需要添加 import `LLMMessage`（已在 Task 4 中导入）。
+
+- [ ] **Step 4: 运行测试确认通过**
+
+Run: `npx vitest run tests/dream-engine.test.ts 2>&1 | tail -8`
+Expected: 所有 smartCompress 测试通过
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/dream-engine.ts tests/dream-engine.test.ts
+git commit -m "feat(dream-engine): add smartCompress with LLM-generated summaries"
+```
+
+---
+
+### Task 6: Dream Engine — 智能分类
+
+**Files:**
+- Modify: `src/dream-engine.ts`
+- Modify: `tests/dream-engine.test.ts`
+
+- [ ] **Step 1: 追加智能分类测试**
+
+```typescript
+describe('DreamEngine - smartReclassify', () => {
+  it('moves general facts to correct category via LLM', async () => {
+    store.addFact('用户编码规范要求文件不超过500行', 'general')
+
+    mockChatJSON.mockResolvedValueOnce({
+      reclassify: [{ fact_id: 1, to: 'coding_style' }],
+    })
+
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.smartReclassify()
+
+    expect(result).toBe(1)
+    const fact = store.listFacts('coding_style', 0, 10)[0]
+    expect(fact).toBeDefined()
+    expect(fact.content).toContain('编码规范')
+  })
+
+  it('ignores invalid category from LLM', async () => {
+    store.addFact('一些内容', 'general')
+
+    mockChatJSON.mockResolvedValueOnce({
+      reclassify: [{ fact_id: 1, to: 'invalid_category' }],
+    })
+
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.smartReclassify()
+
+    expect(result).toBe(0)
+  })
+
+  it('skips when LLM says keep general', async () => {
+    store.addFact('一些杂项内容', 'general')
+
+    mockChatJSON.mockResolvedValueOnce({
+      reclassify: [{ fact_id: 1, to: 'general' }],
+    })
+
+    const mockClient = { chatJSON: mockChatJSON, isAvailable: vi.fn().mockResolvedValue(true) } as unknown as LLMClient
+    const eng = new DreamEngine(mockClient, store)
+    const result = await eng.smartReclassify()
+
+    expect(result).toBe(0)
+  })
+})
+```
+
+- [ ] **Step 2: 运行测试确认失败**
+
+Run: `npx vitest run tests/dream-engine.test.ts 2>&1 | grep "smartReclassify"`
+Expected: smartReclassify 测试失败
+
+- [ ] **Step 3: 实现 smartReclassify**
+
+替换 `smartReclassify` 方法：
+
+```typescript
+async smartReclassify(): Promise<number> {
+  const rows = this.store.connection.prepare(
+    "SELECT fact_id, content FROM facts WHERE category = 'general'"
+  ).all() as Array<{ fact_id: number; content: string }>
+
+  if (rows.length === 0) return 0
+
+  const validCategories = ['identity', 'coding_style', 'tool_pref', 'workflow']
+  let reclassified = 0
+
+  for (let i = 0; i < rows.length; i += BATCH_SIZE) {
+    const batch = rows.slice(i, i + BATCH_SIZE)
+    const factList = batch.map(f => `[${f.fact_id}] ${f.content}`).join('\n')
+
+    const messages: LLMMessage[] = [
+      {
+        role: 'system',
+        content: `你是一个记忆分类助手。分析以下记忆条目，判断它们应该属于哪个分类。
+可选分类：identity（身份/角色）、coding_style（编码规范）、tool_pref（工具偏好）、workflow（工作流）
+如果记忆不属于以上任何分类，保持 general。
+输出JSON：{"reclassify": [{"fact_id": 数字, "to": "分类名"}]}
+不需要重新分类的条目不要输出。`,
+      },
+      { role: 'user', content: factList },
+    ]
+
+    try {
+      const result = await this.llm.chatJSON<{ reclassify: Array<{ fact_id: number; to: string }> }>(messages)
+      if (!result?.reclassify || !Array.isArray(result.reclassify)) continue
+
+      for (const item of result.reclassify) {
+        if (!item.fact_id || !item.to) continue
+        if (!validCategories.includes(item.to)) continue
+
+        this.store.connection.prepare(
+          "UPDATE facts SET category = ?, updated_at = datetime('now', 'localtime') WHERE fact_id = ?"
+        ).run(item.to, item.fact_id)
+        reclassified++
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return reclassified
+}
+```
+
+- [ ] **Step 4: 运行测试**
+
+Run: `npx vitest run tests/dream-engine.test.ts 2>&1 | tail -8`
+Expected: 所有测试通过
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/dream-engine.ts tests/dream-engine.test.ts
+git commit -m "feat(dream-engine): add smartReclassify with LLM-driven category assignment"
+```
+
+---
+
+### Task 7: 集成到 runDream — 降级策略
+
+**Files:**
+- Modify: `src/store.ts`
+- Modify: `src/dream.ts`
+- Modify: `src/server.ts`
+- Modify: `tests/store.test.ts`
+
+- [ ] **Step 1: 更新 store.ts 的 runDream 集成 DreamEngine**
+
+在 `src/store.ts` 顶部添加 import：
+
+```typescript
+import { loadConfig } from './config.js'
+import { LLMClient } from './llm-client.js'
+import { DreamEngine } from './dream-engine.js'
+```
+
+替换 `runDream` 方法：
+
+```typescript
+async runDream(options?: { skipBackup?: boolean }): Promise<DreamReport> {
+  if (!options?.skipBackup) {
+    await this.backupDatabase()
+  }
+
+  // 尝试 LLM 驱动的 dream
+  const config = loadConfig()
+  const llmClient = new LLMClient(config)
+
+  const available = await llmClient.isAvailable()
+  if (available) {
+    try {
+      const engine = new DreamEngine(llmClient, this)
+      const mergeResult = await engine.semanticMerge()
+      const compressed = await engine.smartCompress()
+      const reclassified = await engine.smartReclassify()
+
+      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.map(d => ({ kept: d.kept, removed: d.removed, similarity: 0 })),
+        fallback: false,
+        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>,
+        },
+      }
+    } catch (err) {
+      // LLM 执行失败，降级到规则引擎
+    }
+  }
+
+  // 降级到规则引擎
+  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,
+    fallback: true,
+    fallbackReason: 'LLM unavailable',
+    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>,
+    },
+  }
+}
+```
+
+- [ ] **Step 2: 更新 store.test.ts 中 dream 测试**
+
+现有 `dream - runDream` 测试用例需要适配 — 因为 `loadConfig` 和 `LLMClient` 需要 mock。最简单的方式是 `skipBackup` 测试时 Ollama 不可用会降级：
+
+测试不需要改动逻辑，但需要确认 dream 报告新增的 `fallback` 字段不影响现有断言。在 `tests/store.test.ts` 的 `dream - runDream` 测试中，在 expect 后追加：
+
+```typescript
+expect(report.fallback).toBe(true) // 测试环境无 Ollama，应降级
+```
+
+- [ ] **Step 3: 运行全量测试**
+
+Run: `npx vitest run 2>&1 | tail -15`
+Expected: 所有测试通过
+
+- [ ] **Step 4: 构建**
+
+Run: `npm run build 2>&1 | tail -3`
+Expected: 无错误
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/store.ts src/dream.ts tests/store.test.ts
+git commit -m "feat(store): integrate DreamEngine into runDream with fallback to rule engine"
+```
+
+---
+
+### Task 8: 最终验证
+
+**Files:**
+- 无新增
+
+- [ ] **Step 1: 运行全量测试**
+
+Run: `npx vitest run 2>&1 | tail -10`
+Expected: 所有测试通过
+
+- [ ] **Step 2: 构建**
+
+Run: `npm run build 2>&1`
+Expected: 无错误
+
+- [ ] **Step 3: CLI 测试（无 Ollama 时降级）**
+
+Run: `node dist/dream.js 2>&1`
+Expected: 输出包含 `"fallback": true`，报告结构正确
+
+- [ ] **Step 4: MCP 测试（在 Claude Code 中调用）**
+
+Run: `fact_store(action="dream")`
+Expected: 返回带有 `fallback` 字段的 DreamReport
+
+- [ ] **Step 5: Commit 所有未提交的改动（如有）**
+
+```bash
+git add -A
+git commit -m "chore: llm-dream integration complete"
+```