@morningljn/mnemo 0.2.1 → 0.3.0

package/openspec/changes/llm-dream/.openspec.yaml

@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-05-16

package/openspec/changes/llm-dream/design.md

@@ -0,0 +1,84 @@
+## Context
+
+mnemo-mcp 是一个 SQLite 驱动的记忆管理 MCP 服务器，当前 dream cycle 通过硬编码规则（Jaccard 词频、关键词匹配、截断压缩）整理记忆。用户有 71 条事实，规则引擎几乎不产生效果（merge=0, compress=0, reclassified=反复震荡）。
+
+用户本地有 Ollama（HomeUbuntu 上运行 qwen3:8b 等），也有云端 API（智谱/DeepSeek/Kimi）。触发方式保持手动（CLI `mnemo-dream` 或 MCP `dream` action）。
+
+## Goals / Non-Goals
+
+**Goals:**
+- LLM 理解语义后做合并、摘要、分类，产生实际可感知的整理效果
+- 本地优先：默认 Ollama，零成本
+- 云端可插拔：支持 OpenAI 兼容 API（智谱/DeepSeek/Kimi 等）
+- 安全：硬编码安全层保护高信任/高频 fact
+- 降级：LLM 不可用时回退到规则引擎
+
+**Non-Goals:**
+- 自动定时触发（保持手动触发）
+- 流式输出 / 进度回调
+- 多轮对话式确认（全自动，触发即执行）
+- 训练/微调模型
+
+## Decisions
+
+### Decision 1: 统一使用 OpenAI 兼容 `/v1/chat/completions` 接口
+
+**选择**: 只实现一个 OpenAI 兼容客户端。Ollama 本地（localhost:11434/v1）和 Ollama 云端（ollama.com/v1）以及所有国产模型 API（智谱/DeepSeek/Kimi）都走 `/v1/chat/completions`
+
+**备选**: 分别实现 Ollama 原生 API（/api/chat）和 OpenAI API 两个客户端
+
+**理由**:
+- Ollama 已原生支持 OpenAI 兼容接口（`/v1/chat/completions`）
+- 用户可配置 baseUrl 指向：本地 Ollama / ollama.com / 智谱 / DeepSeek / 任意 OpenAI 兼容 API
+- 只需一个客户端实现，零 SDK 依赖，用 Node.js 原生 `fetch()`
+- 配置示例：`{ baseUrl: "http://localhost:11434/v1" }` 或 `{ baseUrl: "https://ollama.com/v1", apiKey: "..." }`
+
+### Decision 2: 批量处理，每批 20 条 fact 送 LLM
+
+**选择**: 同 category 的 facts 按每批 20 条分组，一次性送 LLM 分析
+
+**备选**: 逐条送 LLM / 全部一次性送
+
+**理由**:
+- 逐条：token 浪费（每次都传 system prompt），延迟高
+- 全部一次：71 条 fact 的 content 总长约 40K 字，超出小模型上下文
+- 每批 20 条：约 5-10K 字 input，适合 8B 模型（如 qwen3:8b 的 32K 上下文）
+
+### Decision 3: 配置文件可选，无配置时用默认值
+
+**选择**: `~/.mnemo/config.json` 为可选文件。不存在时默认 `ollama/localhost:11434/qwen3:8b`
+
+**备选**: 必须配置才能使用 LLM dream
+
+**理由**:
+- 用户 HomeUbuntu 上已有 Ollama 运行，开箱即用
+- 零配置降低使用门槛
+- macOS 本地无 Ollama 时自动降级到规则引擎
+
+### Decision 4: 安全层在 LLM 输出之后、数据库操作之前执行
+
+**选择**: LLM 返回操作建议 → 安全层校验（信任度/数量/格式） → 执行数据库操作
+
+**备选**: 在 LLM prompt 中加入安全约束
+
+**理由**:
+- LLM 可能不遵守 prompt 约束（尤其是小模型）
+- 安全长用硬编码 TypeScript 保证不会误删
+- 职责分离：LLM 负责理解语义，代码负责安全边界
+
+### Decision 5: Prompt 用中文，适配中文记忆内容
+
+**选择**: 所有 LLM prompt 使用中文指令
+
+**理由**:
+- mnemo 的 fact 内容主要是中文
+- 中文 prompt 对中文内容的理解更准确
+- qwen3 对中文支持好
+
+## Risks / Trade-offs
+
+- **[小模型幻觉风险]** qwen3:8b 可能输出格式错误的 JSON → 用 try-catch 解析，解析失败丢弃该批结果，降级到规则引擎处理该批
+- **[Ollama 连接失败]** 用户本地未启动 Ollama → 自动降级到规则引擎，dream report 中标记 `fallback: true`
+- **[Token 成本]** 使用云端 API 时每次 dream 消耗 token → 配置中可设 provider，默认 Ollama 零成本
+- **[删除误伤]** LLM 可能错误判断"语义重复" → 安全层限制：单次最多删除 10% fact，信任度 > 0.8 禁止删除
+- **[处理速度]** 71 条 fact 批量送 LLM，每批 20 条约 3 批，总耗时 10-30 秒（取决于模型速度） → 可接受，dream 本就不频繁

package/openspec/changes/llm-dream/proposal.md

@@ -0,0 +1,36 @@
+## Why
+
+当前 dream cycle 使用硬编码规则（Jaccard 词频合并、关键词重分类、截断压缩），无法理解语义。导致：
+- 两条用词不同但语义相同的 fact（如"喜欢VS Code" vs "偏好Visual Studio Code"）永远无法合并
+- 分类只靠关键词匹配，容易震荡（同一条 fact 反复换分类）
+- 摘要只是截取前两句，不是真正的信息提炼
+
+需要引入 LLM 做语义级别的记忆整理，让 dream 产生实际效果。
+
+## What Changes
+
+- 新增 LLM 客户端抽象层，支持 Ollama（默认）和 OpenAI 兼容 API
+- 新增配置系统（`~/.mnemo/config.json`），支持 LLM provider/model/参数配置
+- 改造 dream cycle 三个核心任务为 LLM 驱动：
+  - **语义合并**：LLM 判断同 category facts 是否语义重复，输出合并建议
+  - **智能摘要**：LLM 提取长 fact 的核心信息作为 summary
+  - **智能分类**：LLM 判断 general 分类的 fact 应归属哪个 category
+- 新增安全验证层（硬编码规则，不经过 LLM）：信任度保护、删除数量上限、备份
+- Ollama 不可用时自动降级到当前规则引擎
+
+## Capabilities
+
+### New Capabilities
+- `llm-client`: LLM 客户端抽象层，支持 Ollama 和 OpenAI 兼容 API，包含配置加载和健康检查
+- `llm-dream-engine`: LLM 驱动的 dream engine，包含语义合并、智能摘要、智能分类三个任务，安全验证层，降级策略
+
+### Modified Capabilities
+- `dream-cycle`: runDream() 从纯规则引擎改为调用 LLM dream engine，保留规则引擎作为降级方案
+
+## Impact
+
+- **新增文件**：`src/llm-client.ts`（LLM 客户端）、`src/dream-engine.ts`（LLM dream engine）
+- **修改文件**：`src/store.ts`（runDream 集成 dream engine）、`src/types.ts`（新增配置类型）、`src/server.ts`（dream action 传递配置）
+- **新增依赖**：无（使用 Node.js 原生 fetch 调用 Ollama/OpenAI API）
+- **配置文件**：新增 `~/.mnemo/config.json` 支持可选配置
+- **向后兼容**：Ollama 不可用时自动降级到规则引擎，不影响现有用户

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

@@ -0,0 +1,42 @@
+## MODIFIED Requirements
+
+### Requirement: Dream action 整理记忆库
+系统 SHALL 提供 `fact_store(action="dream")` 操作，优先使用 LLM 做语义级整理（合并、摘要、分类），LLM 不可用时降级到规则引擎。整理前自动备份数据库。
+
+#### Scenario: LLM 驱动的语义合并
+- **WHEN** 同 category 内存在语义重复的 fact（由 LLM 判断）
+- **THEN** 系统合并重复 fact，保留内容更完整的，在 dream report 中记录合并对和原因
+
+#### Scenario: LLM 驱动的智能摘要
+- **WHEN** fact 的 content 长度 > 200 字且 summary 为 NULL
+- **THEN** 系统由 LLM 生成精准摘要（≤ 150 字）写入 summary 字段
+
+#### Scenario: LLM 驱动的智能分类
+- **WHEN** fact 的 category 为 "general" 但内容属于其他 category
+- **THEN** 系统由 LLM 判断正确分类并更新
+
+#### Scenario: 降级到规则引擎
+- **WHEN** LLM 服务不可用（连接失败/超时）
+- **THEN** 系统自动降级到规则引擎（Jaccard 合并、截取摘要、关键词分类），report 中标记 fallback: true
+
+#### Scenario: Dream 前备份
+- **WHEN** dream action 被触发
+- **THEN** 系统在执行任何修改前，自动将数据库备份到备份目录
+
+#### Scenario: 输出 dream report
+- **WHEN** dream 整理完成
+- **THEN** 系统返回 JSON 报告，包含 merged、compressed、reclassified、deleted 计数、health 统计、fallback 标记
+
+### Requirement: CLI dream 命令
+系统 SHALL 提供 `mnemo-dream` CLI 命令，手动触发 LLM 驱动的 dream 整理。
+
+#### Scenario: 手动执行 dream
+- **WHEN** 用户运行 `mnemo-dream`
+- **THEN** 系统执行 LLM 驱动的 dream cycle 并输出 report 到 stdout
+
+### Requirement: 高频 fact 保护
+Dream 整理 SHALL 保护检索次数 > 100 或信任度 > 0.8 的 fact 不被删除，无论 LLM 是否建议删除。
+
+#### Scenario: 高频/高信任 fact 不被合并删除
+- **WHEN** LLM 建议删除 retrieval_count > 100 或 trust_score > 0.8 的 fact
+- **THEN** 系统拒绝该删除操作

package/openspec/changes/llm-dream/specs/llm-client/spec.md

@@ -0,0 +1,57 @@
+## ADDED Requirements
+
+### Requirement: OpenAI 兼容 LLM 客户端
+系统 SHALL 提供统一 LLM 客户端，使用 OpenAI 兼容的 `/v1/chat/completions` 接口。通过配置 baseUrl 支持 Ollama 本地、Ollama 云端（ollama.com/v1）、智谱、DeepSeek 等任何 OpenAI 兼容 API。
+
+#### Scenario: 连接 Ollama 本地
+- **WHEN** config.baseUrl 为 "http://localhost:11434/v1"
+- **THEN** 系统向 `localhost:11434/v1/chat/completions` 发送请求，无需 apiKey
+
+#### Scenario: 连接 Ollama 云端
+- **WHEN** config.baseUrl 为 "https://ollama.com/v1" 且提供 apiKey
+- **THEN** 系统向 `ollama.com/v1/chat/completions` 发送请求，附带 Authorization header
+
+#### Scenario: 连接第三方 OpenAI 兼容 API
+- **WHEN** config.baseUrl 为 "https://open.bigmodel.cn/api/paas/v4" 且提供 apiKey
+- **THEN** 系统向对应 `/chat/completions` 端点发送请求
+
+### Requirement: LLM 聊天接口
+系统 SHALL 提供 `chat(messages, options)` 方法，返回 LLM 文本响应。
+
+#### Scenario: 成功调用返回文本
+- **WHEN** 调用 chat([{ role: "user", content: "..." }], { temperature: 0.1 })
+- **THEN** 系统返回 LLM 生成的文本内容
+
+#### Scenario: 连接失败抛出错误
+- **WHEN** LLM 服务不可用（连接拒绝/超时）
+- **THEN** 系统抛出 LLMConnectionError，包含原始错误信息
+
+#### Scenario: JSON 响应解析
+- **WHEN** LLM 响应内容可解析为 JSON
+- **THEN** 系统返回解析后的 JSON 对象
+
+#### Scenario: JSON 解析失败
+- **WHEN** LLM 响应不是有效 JSON
+- **THEN** 系统抛出 LLMResponseError，包含原始响应文本
+
+### Requirement: LLM 健康检查
+系统 SHALL 提供 `isAvailable()` 方法，检测 LLM 服务是否可达。
+
+#### Scenario: 服务可用
+- **WHEN** 调用 isAvailable()
+- **THEN** 系统向 baseUrl/models 端点发送 GET 请求，成功返回 true
+
+#### Scenario: 服务不可用
+- **WHEN** 调用 isAvailable()
+- **THEN** 连接失败返回 false，不抛出错误
+
+### Requirement: 配置加载
+系统 SHALL 从 `~/.mnemo/config.json` 加载 LLM 配置。文件不存在时使用默认配置。
+
+#### Scenario: 配置文件存在
+- **WHEN** `~/.mnemo/config.json` 存在且包含 llm 字段
+- **THEN** 系统使用配置文件中的 baseUrl/model/apiKey/temperature
+
+#### Scenario: 配置文件不存在
+- **WHEN** `~/.mnemo/config.json` 不存在
+- **THEN** 系统使用默认配置：`{ baseUrl: "http://localhost:11434/v1", model: "qwen3:8b", temperature: 0.1 }`

package/openspec/changes/llm-dream/specs/llm-dream-engine/spec.md

@@ -0,0 +1,72 @@
+## ADDED Requirements
+
+### Requirement: LLM 语义合并
+系统 SHALL 将同 category 的 facts 按每批 20 条送 LLM，由 LLM 判断语义重复并输出合并建议。
+
+#### Scenario: LLM 识别语义重复
+- **WHEN** 同 category 内存在两条用词不同但语义相同的 fact（如"喜欢VS Code"和"偏好Visual Studio Code"）
+- **THEN** LLM 返回 merge 建议 `{"kept": factId, "removed": factId, "reason": "..."}`，系统执行合并
+
+#### Scenario: LLM 判断不重复
+- **WHEN** 同 category 内两条 fact 语义不同
+- **THEN** LLM 不输出合并建议，系统不操作
+
+#### Scenario: LLM 输出格式错误
+- **WHEN** LLM 返回的 JSON 无法解析或缺少必需字段（kept/removed）
+- **THEN** 系统丢弃该批合并建议，不执行任何操作
+
+### Requirement: LLM 智能摘要
+系统 SHALL 将 content > 200 字且 summary 为 NULL 的 fact 送 LLM 生成精准摘要。
+
+#### Scenario: LLM 生成摘要
+- **WHEN** fact 的 content 长度 > 200 且 summary 为空
+- **THEN** LLM 返回 `{"summary": "核心信息..."}`，系统写入 summary 字段，摘要长度 SHALL ≤ 150 字
+
+#### Scenario: 已有摘要跳过
+- **WHEN** fact 已有 summary
+- **THEN** 系统不发送给 LLM，跳过该 fact
+
+#### Scenario: LLM 摘要超长
+- **WHEN** LLM 返回的 summary 长度 > 150 字
+- **THEN** 系统截断到 150 字
+
+### Requirement: LLM 智能分类
+系统 SHALL 将 category 为 "general" 的 facts 送 LLM 判断正确分类。
+
+#### Scenario: LLM 正确分类
+- **WHEN** general 分类中的 fact 内容属于 identity/coding_style/tool_pref/workflow
+- **THEN** LLM 返回 `{"fact_id": id, "to": "target_category"}`，系统更新 category
+
+#### Scenario: LLM 判断应保持 general
+- **WHEN** fact 内容不属于其他四个 category
+- **THEN** LLM 返回 `{"fact_id": id, "to": "general"}`，系统不操作
+
+#### Scenario: LLM 返回无效 category
+- **WHEN** LLM 返回的 target 不在 [identity, coding_style, tool_pref, workflow, general] 中
+- **THEN** 系统丢弃该分类建议
+
+### Requirement: 安全验证层
+系统 SHALL 在执行 LLM 建议的数据库操作前，进行硬编码安全校验。
+
+#### Scenario: 高信任 fact 禁止删除
+- **WHEN** LLM 建议删除 trust_score > 0.8 的 fact
+- **THEN** 系统拒绝该删除操作
+
+#### Scenario: 单次删除数量限制
+- **WHEN** LLM 建议删除的 fact 数量超过总量的 10%
+- **THEN** 系统只执行前 10% 的删除，丢弃多余建议
+
+#### Scenario: 高频 fact 保护
+- **WHEN** LLM 建议删除 retrieval_count > 100 的 fact
+- **THEN** 系统拒绝该删除操作
+
+### Requirement: 降级策略
+系统 SHALL 在 LLM 不可用时自动降级到规则引擎。
+
+#### Scenario: Ollama 不可用自动降级
+- **WHEN** Ollama 连接失败或超时
+- **THEN** 系统自动使用当前硬编码规则引擎执行 dream，report 中标记 `fallback: true`
+
+#### Scenario: 降级后 report 包含 fallback 标记
+- **WHEN** dream 执行了降级路径
+- **THEN** DreamReport 中 `fallback` 字段为 true，`fallbackReason` 字段记录原因

package/openspec/changes/llm-dream/tasks.md

@@ -0,0 +1,32 @@
+## 1. 类型定义与配置
+
+- [ ] 1.1 在 `src/types.ts` 新增 LLM 相关类型：LLMConfig（baseUrl/model/apiKey/temperature）、LLMMessage（role/content）、DreamReport 新增 fallback/fallbackReason 字段
+- [ ] 1.2 新增 `src/config.ts`：loadConfig() 函数，从 `~/.mnemo/config.json` 读取配置，文件不存在时返回默认值（localhost:11434/v1, qwen3:8b, temperature 0.1）
+
+## 2. LLM 客户端
+
+- [ ] 2.1 新增 `src/llm-client.ts`：实现 OpenAI 兼容 `/v1/chat/completions` 客户端，包含 chat(messages, options) 和 isAvailable() 方法
+- [ ] 2.2 chat() 方法：POST 请求到 baseUrl/chat/completions，解析 choices[0].message.content，支持 JSON 响应提取
+- [ ] 2.3 isAvailable() 方法：GET baseUrl/models，成功返回 true，失败返回 false（不抛错）
+- [ ] 2.4 错误处理：LLMConnectionError（连接失败）、LLMResponseError（响应解析失败）
+
+## 3. LLM Dream Engine
+
+- [ ] 3.1 新增 `src/dream-engine.ts`：DreamEngine 类，接收 LLMClient 和 MemoryStore 实例
+- [ ] 3.2 实现 llmSemanticMerge(category, facts)：将同 category 的 facts 按每批 20 条送 LLM，prompt 要求输出 JSON 格式的合并建议，解析后返回操作列表
+- [ ] 3.3 实现 llmSmartCompress(facts)：将长 fact（content > 200, summary 为空）送 LLM 生成摘要，返回摘要操作列表
+- [ ] 3.4 实现 llmSmartReclassify(facts)：将 general 分类的 facts 送 LLM 判断正确分类，返回分类操作列表
+- [ ] 3.5 实现安全验证层 validateOperations(operations, totalFacts)：过滤掉 trust_score > 0.8、retrieval_count > 100 的删除操作，限制删除总数 ≤ 10%
+- [ ] 3.6 实现降级逻辑：LLM 不可用时（isAvailable() 返回 false 或 chat 抛错），调用现有规则引擎方法
+
+## 4. 集成到 Dream Cycle
+
+- [ ] 4.1 修改 `src/store.ts` 的 runDream()：加载配置 → 创建 LLMClient → 创建 DreamEngine → 优先 LLM 整理 → 降级规则引擎
+- [ ] 4.2 修改 `src/server.ts` 的 dream action：传递配置，处理 fallback 标记
+- [ ] 4.3 修改 `src/dream.ts` CLI：确保 CLI 也使用新的 dream engine
+
+## 5. 测试
+
+- [ ] 5.1 新增 `tests/llm-client.test.ts`：测试 chat() 成功/失败/JSON 解析、isAvailable() 可用/不可用
+- [ ] 5.2 新增 `tests/dream-engine.test.ts`：测试语义合并/智能摘要/智能分类（mock LLM 响应）、安全验证层、降级策略
+- [ ] 5.3 更新 `tests/store.test.ts`：dream 测试用例适配新的 DreamReport 字段（fallback/fallbackReason）

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morningljn/mnemo",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Structured fact memory MCP server — SQLite + FTS5, trust scoring, entity graph, bilingual retrieval for Claude Code & Codex",
   "type": "module",
   "main": "dist/server.js",

package/src/config.ts

@@ -0,0 +1,29 @@
+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 }
+  }
+}

package/src/dream-engine.ts

@@ -0,0 +1,162 @@
+import type { FactCategory, LLMMessage } from './types.js'
+import type { LLMClient } from './llm-client.js'
+import type { MemoryStore } from './store.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 {
+          continue
+        }
+      }
+    }
+
+    return { merged, details }
+  }
+
+  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
+  }
+
+  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
+  }
+}

package/src/llm-client.ts

@@ -0,0 +1,59 @@
+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 {
+      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
+    }
+  }
+}

package/src/resources.ts

@@ -78,7 +78,7 @@ export class ResourceManager {
       f.content.includes('角色设定') ||
       f.content.includes('你是') ||
       f.content.includes('身份是') ||
-      f.content.includes('女朋友')
+      f.content.includes('你扮演')
     )
     const otherFacts = facts.filter(f => !roleFacts.includes(f))