@ppagent/memory 0.1.2 → 0.3.1

package/dist/index.js

@@ -2,6 +2,7 @@
 import { v4 as uuidv44 } from "uuid";
 
 // src/config.ts
+import * as path from "node:path";
 function resolveConfig(config) {
   let embeddingBaseUrl = config.embeddingBaseUrl;
   let embeddingApiKey = config.embeddingApiKey;
@@ -19,6 +20,8 @@ function resolveConfig(config) {
     ...config,
     embeddingBaseUrl,
     embeddingApiKey,
+    provider: config.provider ?? "auto",
+    sqlitePath: config.sqlitePath ?? path.join(path.dirname(config.lancedbPath), "memory.sqlite3"),
     sessionTokenLimit: config.sessionTokenLimit ?? 16386,
     historyWindowTokenLimit: config.historyWindowTokenLimit ?? 10240,
     topicRatio: config.topicRatio ?? [1, 5, 20],
@@ -47,6 +50,7 @@ function resolveConfig(config) {
     graphExtractConcurrency: config.graphExtractConcurrency ?? 2,
     graphBuildTimeoutMs: config.graphBuildTimeoutMs ?? 12e4,
     autoOptimizeOnInit: config.autoOptimizeOnInit ?? true,
+    autoOptimizeIntervalMs: config.autoOptimizeIntervalMs ?? 6 * 36e5,
     optimizeVersionRetentionMs: config.optimizeVersionRetentionMs ?? 0,
     restoreConcurrency: config.restoreConcurrency ?? 8
   };
@@ -710,120 +714,149 @@ var GrafeoService = class _GrafeoService {
   }
 };
 
-// src/db/lance.service.ts
-import * as lancedb from "@lancedb/lancedb";
-import { Field, FixedSizeList, Float32, Int32, Int64, Schema, Utf8 } from "apache-arrow";
-
-// src/db/sql.util.ts
-function escLance(value) {
-  return String(value).replace(/'/g, "''");
-}
-function eqFilter(field, value) {
-  return `${field} = '${escLance(value)}'`;
+// src/db/store.types.ts
+function eq(field, value) {
+  return { op: "eq", field, value };
 }
 
-// src/db/lance.service.ts
+// src/db/memory.store.ts
 var MESSAGES_TABLE = "messages";
 var TOPICS_TABLE = "topics";
 var FACTS_TABLE = "facts";
 var SESSIONS_TABLE = "sessions";
 var DOCUMENTS_TABLE = "documents";
 var CHUNKS_TABLE = "chunks";
-function messagesSchema(dim) {
-  return new Schema([
-    new Field("message_id", new Utf8(), false),
-    new Field("talker_id", new Utf8(), false),
-    new Field("chat_id", new Utf8(), false),
-    new Field("user_id", new Utf8(), false),
-    new Field("session_id", new Utf8(), false),
-    new Field("type", new Utf8(), false),
-    new Field("content", new Utf8(), false),
-    new Field("parts", new Utf8(), true),
-    // nullable，兼容存量数据
-    new Field("vector", new FixedSizeList(dim, new Field("item", new Float32(), false)), false),
-    new Field("usage", new Int32(), false),
-    new Field("metadata", new Utf8(), false),
-    new Field("created_at", new Int64(), false)
-  ]);
-}
-function topicsSchema(dim) {
-  return new Schema([
-    new Field("summary_id", new Utf8(), false),
-    new Field("session_id", new Utf8(), false),
-    new Field("user_id", new Utf8(), false),
-    new Field("chat_id", new Utf8(), false),
-    new Field("title", new Utf8(), true),
-    // nullable，兼容存量数据
-    new Field("detail", new Utf8(), false),
-    new Field("summary", new Utf8(), false),
-    new Field("concise", new Utf8(), false),
-    new Field("vector", new FixedSizeList(dim, new Field("item", new Float32(), false)), false),
-    new Field("start_time", new Int64(), false),
-    new Field("end_time", new Int64(), false),
-    new Field("created_at", new Int64(), false),
-    new Field("updated_at", new Int64(), false),
-    new Field("recall_count", new Int32(), false)
-  ]);
-}
-function factsSchema() {
-  return new Schema([
-    new Field("fact_id", new Utf8(), false),
-    new Field("level", new Utf8(), false),
-    new Field("chat_id", new Utf8(), false),
-    new Field("session_id", new Utf8(), false),
-    new Field("user_id", new Utf8(), false),
-    new Field("content", new Utf8(), false),
-    new Field("created_at", new Int64(), false)
-  ]);
-}
-function sessionsSchema() {
-  return new Schema([
-    new Field("session_id", new Utf8(), false),
-    new Field("chat_id", new Utf8(), false),
-    new Field("user_id", new Utf8(), false),
-    new Field("title", new Utf8(), false),
-    new Field("metadata", new Utf8(), false),
-    new Field("created_at", new Int64(), false),
-    new Field("updated_at", new Int64(), false)
-  ]);
-}
-function documentsSchema(dim) {
-  return new Schema([
-    new Field("doc_id", new Utf8(), false),
-    new Field("user_id", new Utf8(), false),
-    new Field("chat_id", new Utf8(), false),
-    new Field("session_id", new Utf8(), false),
-    new Field("title", new Utf8(), false),
-    new Field("source_name", new Utf8(), false),
-    new Field("full_content", new Utf8(), false),
-    new Field("content_hash", new Utf8(), false),
-    new Field("summary", new Utf8(), false),
-    // vector 列存储文档摘要向量（summaryVector），用于文档级粗召回
-    new Field("vector", new FixedSizeList(dim, new Field("item", new Float32(), false)), false),
-    new Field("chunk_count", new Int32(), false),
-    new Field("has_graph", new Int32(), false),
-    // 0/1 充当布尔
-    new Field("metadata", new Utf8(), false),
-    new Field("created_at", new Int64(), false),
-    new Field("updated_at", new Int64(), false)
-  ]);
+var RRF_K = 60;
+var HYBRID_OVERFETCH = 2;
+function tableDefs(dim) {
+  return [
+    {
+      name: MESSAGES_TABLE,
+      vectorDimension: dim,
+      columns: [
+        { name: "message_id", type: "text" },
+        { name: "talker_id", type: "text" },
+        { name: "chat_id", type: "text" },
+        { name: "user_id", type: "text" },
+        { name: "session_id", type: "text" },
+        { name: "type", type: "text" },
+        { name: "content", type: "text" },
+        { name: "parts", type: "text", nullable: true },
+        // 兼容存量数据
+        { name: "vector", type: "vector" },
+        { name: "usage", type: "int" },
+        { name: "metadata", type: "text" },
+        { name: "created_at", type: "long" }
+      ],
+      indexes: [
+        { column: "message_id", kind: "scalar" },
+        { column: "session_id", kind: "scalar" },
+        { column: "content", kind: "fts" },
+        { column: "metadata", kind: "fts" }
+      ]
+    },
+    {
+      name: TOPICS_TABLE,
+      vectorDimension: dim,
+      columns: [
+        { name: "summary_id", type: "text" },
+        { name: "session_id", type: "text" },
+        { name: "user_id", type: "text" },
+        { name: "chat_id", type: "text" },
+        { name: "title", type: "text", nullable: true },
+        // 兼容存量数据
+        { name: "detail", type: "text" },
+        { name: "summary", type: "text" },
+        { name: "concise", type: "text" },
+        { name: "vector", type: "vector" },
+        { name: "start_time", type: "long" },
+        { name: "end_time", type: "long" },
+        { name: "created_at", type: "long" },
+        { name: "updated_at", type: "long" },
+        { name: "recall_count", type: "int" }
+      ],
+      indexes: [
+        { column: "chat_id", kind: "scalar" },
+        { column: "detail", kind: "fts" }
+      ]
+    },
+    {
+      name: FACTS_TABLE,
+      columns: [
+        { name: "fact_id", type: "text" },
+        { name: "level", type: "text" },
+        { name: "chat_id", type: "text" },
+        { name: "session_id", type: "text" },
+        { name: "user_id", type: "text" },
+        { name: "content", type: "text" },
+        { name: "created_at", type: "long" }
+      ],
+      indexes: []
+    },
+    {
+      name: SESSIONS_TABLE,
+      columns: [
+        { name: "session_id", type: "text" },
+        { name: "chat_id", type: "text" },
+        { name: "user_id", type: "text" },
+        { name: "title", type: "text" },
+        { name: "metadata", type: "text" },
+        { name: "created_at", type: "long" },
+        { name: "updated_at", type: "long" }
+      ],
+      indexes: [{ column: "session_id", kind: "scalar" }]
+    },
+    {
+      name: DOCUMENTS_TABLE,
+      vectorDimension: dim,
+      columns: [
+        { name: "doc_id", type: "text" },
+        { name: "user_id", type: "text" },
+        { name: "chat_id", type: "text" },
+        { name: "session_id", type: "text" },
+        { name: "title", type: "text" },
+        { name: "source_name", type: "text" },
+        { name: "full_content", type: "text" },
+        { name: "content_hash", type: "text" },
+        { name: "summary", type: "text" },
+        // vector 列存储文档摘要向量（summaryVector），用于文档级粗召回
+        { name: "vector", type: "vector" },
+        { name: "chunk_count", type: "int" },
+        { name: "has_graph", type: "int" },
+        // 0/1 充当布尔
+        { name: "metadata", type: "text" },
+        { name: "created_at", type: "long" },
+        { name: "updated_at", type: "long" }
+      ],
+      indexes: [{ column: "doc_id", kind: "scalar" }]
+    },
+    {
+      name: CHUNKS_TABLE,
+      vectorDimension: dim,
+      columns: [
+        { name: "chunk_id", type: "text" },
+        { name: "doc_id", type: "text" },
+        // user_id/chat_id/session_id：chunkRedundantIds=false 时存空串，仅经 documents join 过滤
+        { name: "user_id", type: "text" },
+        { name: "chat_id", type: "text" },
+        { name: "session_id", type: "text" },
+        { name: "content", type: "text" },
+        { name: "vector", type: "vector" },
+        { name: "heading_path", type: "text" },
+        { name: "ordinal", type: "int" },
+        { name: "tokens", type: "int" },
+        { name: "metadata", type: "text" },
+        { name: "created_at", type: "long" }
+      ],
+      indexes: [
+        { column: "doc_id", kind: "scalar" },
+        { column: "content", kind: "fts" }
+      ]
+    }
+  ];
 }
-function chunksSchema(dim) {
-  return new Schema([
-    new Field("chunk_id", new Utf8(), false),
-    new Field("doc_id", new Utf8(), false),
-    // user_id/chat_id/session_id：chunkRedundantIds=false 时存空串，仅经 documents join 过滤
-    new Field("user_id", new Utf8(), false),
-    new Field("chat_id", new Utf8(), false),
-    new Field("session_id", new Utf8(), false),
-    new Field("content", new Utf8(), false),
-    new Field("vector", new FixedSizeList(dim, new Field("item", new Float32(), false)), false),
-    new Field("heading_path", new Utf8(), false),
-    new Field("ordinal", new Int32(), false),
-    new Field("tokens", new Int32(), false),
-    new Field("metadata", new Utf8(), false),
-    new Field("created_at", new Int64(), false)
-  ]);
+function toVector(v) {
+  return Array.isArray(v) ? v : Array.from(v);
 }
 function messageToRow(m) {
   return {
@@ -852,7 +885,7 @@ function rowToMessage(r) {
     content: r.content,
     parts: r.parts ?? "[]",
     // 旧数据无此列时安全降级
-    vector: Array.from(r.vector),
+    vector: toVector(r.vector),
     usage: Number(r.usage),
     metadata: r.metadata,
     createdAt: Number(r.created_at)
@@ -886,7 +919,7 @@ function rowToTopic(r) {
     detail: r.detail,
     summary: r.summary,
     concise: r.concise,
-    vector: Array.from(r.vector),
+    vector: toVector(r.vector),
     startTime: Number(r.start_time),
     endTime: Number(r.end_time),
     createdAt: Number(r.created_at),
@@ -968,7 +1001,7 @@ function rowToDocument(r) {
     fullContent: r.full_content,
     contentHash: r.content_hash,
     summary: r.summary,
-    summaryVector: Array.from(r.vector),
+    summaryVector: toVector(r.vector),
     chunkCount: Number(r.chunk_count),
     hasGraph: Number(r.has_graph) === 1,
     metadata: safeParseObject(r.metadata),
@@ -1000,7 +1033,7 @@ function rowToChunk(r) {
     chatId: r.chat_id,
     sessionId: r.session_id,
     content: r.content,
-    vector: Array.from(r.vector),
+    vector: toVector(r.vector),
     headingPath: r.heading_path,
     ordinal: Number(r.ordinal),
     tokens: Number(r.tokens),
@@ -1015,245 +1048,80 @@ function safeParseObject(s) {
     return {};
   }
 }
-var MESSAGES_INDEXES = [
-  { column: "message_id" },
-  { column: "session_id" },
-  { column: "content", fts: true },
-  { column: "metadata", fts: true }
-  // 支持 metadata 内容全文检索
-];
-var TOPICS_INDEXES = [
-  { column: "chat_id" },
-  { column: "detail", fts: true }
-];
-var SESSIONS_INDEXES = [{ column: "session_id" }];
-var DOCUMENTS_INDEXES = [{ column: "doc_id" }];
-var CHUNKS_INDEXES = [
-  { column: "doc_id" },
-  { column: "content", fts: true }
-  // 知识片段混合检索
-];
-var LanceService = class {
+function rrfFuse(lists, keyOf) {
+  const acc = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    list.forEach((row, idx) => {
+      const id = keyOf(row);
+      const inc = 1 / (RRF_K + idx + 1);
+      const entry = acc.get(id);
+      if (entry) entry.score += inc;
+      else acc.set(id, { row, score: inc });
+    });
+  }
+  return [...acc.values()].sort((a, b) => b.score - a.score).map((e) => e.row);
+}
+var MemoryStore = class {
   config;
-  conn;
-  messagesTable;
-  topicsTable;
-  factsTable;
-  sessionsTable;
-  documentsTable;
-  chunksTable;
-  // Scalar indexes cannot be created on empty tables (LanceDB btree limitation).
-  // These flags defer creation to the first insert.
-  isNewMessagesTable = false;
-  isNewTopicsTable = false;
-  isNewSessionsTable = false;
-  isNewDocumentsTable = false;
-  isNewChunksTable = false;
-  constructor(config) {
+  provider;
+  providerOverride;
+  /** provider 省略时在 init() 阶段经 provider.resolver 自动探测创建（测试可显式注入） */
+  constructor(config, provider) {
     this.config = config;
+    this.providerOverride = provider;
+  }
+  /** 当前后端 provider 标识（日志/诊断用） */
+  get providerKind() {
+    return this.provider?.kind ?? "uninitialized";
   }
   async init() {
-    this.conn = await lancedb.connect(this.config.lancedbPath);
-    const dim = this.config.embeddingDimension;
-    const existingTables = await this.conn.tableNames();
-    if (existingTables.includes(MESSAGES_TABLE)) {
-      this.messagesTable = await this.conn.openTable(MESSAGES_TABLE);
-      await this._ensurePartsColumn();
-    } else {
-      this.messagesTable = await this.conn.createEmptyTable(
-        MESSAGES_TABLE,
-        messagesSchema(dim)
-      );
-      this.isNewMessagesTable = true;
-    }
-    if (existingTables.includes(TOPICS_TABLE)) {
-      this.topicsTable = await this.conn.openTable(TOPICS_TABLE);
-      await this._ensureTopicTitleColumn();
-    } else {
-      this.topicsTable = await this.conn.createEmptyTable(
-        TOPICS_TABLE,
-        topicsSchema(dim)
-      );
-      this.isNewTopicsTable = true;
-    }
-    if (existingTables.includes(FACTS_TABLE)) {
-      this.factsTable = await this.conn.openTable(FACTS_TABLE);
+    if (this.providerOverride) {
+      this.provider = this.providerOverride;
     } else {
-      this.factsTable = await this.conn.createEmptyTable(FACTS_TABLE, factsSchema());
+      const { createProvider } = await import("./provider.resolver-ZLQ766IO.js");
+      this.provider = await createProvider(this.config);
+      console.info(`[memory] \u5411\u91CF\u5B58\u50A8\u540E\u7AEF\uFF1A${this.provider.kind}`);
     }
-    if (existingTables.includes(SESSIONS_TABLE)) {
-      this.sessionsTable = await this.conn.openTable(SESSIONS_TABLE);
-    } else {
-      this.sessionsTable = await this.conn.createEmptyTable(SESSIONS_TABLE, sessionsSchema());
-      this.isNewSessionsTable = true;
-    }
-    if (existingTables.includes(DOCUMENTS_TABLE)) {
-      this.documentsTable = await this.conn.openTable(DOCUMENTS_TABLE);
-    } else {
-      this.documentsTable = await this.conn.createEmptyTable(DOCUMENTS_TABLE, documentsSchema(dim));
-      this.isNewDocumentsTable = true;
-    }
-    if (existingTables.includes(CHUNKS_TABLE)) {
-      this.chunksTable = await this.conn.openTable(CHUNKS_TABLE);
-    } else {
-      this.chunksTable = await this.conn.createEmptyTable(CHUNKS_TABLE, chunksSchema(dim));
-      this.isNewChunksTable = true;
-    }
-    await this.ensureIndexes(this.messagesTable, MESSAGES_INDEXES);
-    await this.ensureIndexes(this.topicsTable, TOPICS_INDEXES);
-    await this.ensureIndexes(this.sessionsTable, SESSIONS_INDEXES);
-    await this.ensureIndexes(this.documentsTable, DOCUMENTS_INDEXES);
-    await this.ensureIndexes(this.chunksTable, CHUNKS_INDEXES);
+    await this.provider.init(tableDefs(this.config.embeddingDimension));
   }
-  /**
-   * 按需补齐索引：先经 listIndices 判存在，缺失的列才 createIndex（且 replace:false）。
-   * createIndex 默认 replace:true 会在每次启动时全量重建索引并提交新表版本——
-   * 这正是历史上「启动越来越慢 + _versions 目录膨胀」的根源，绝不可回退到无条件 createIndex。
-   */
-  async ensureIndexes(table, specs) {
-    let indexed;
-    try {
-      indexed = new Set((await table.listIndices()).flatMap((i) => i.columns));
-    } catch {
-      indexed = /* @__PURE__ */ new Set();
-    }
-    for (const { column, fts } of specs) {
-      if (indexed.has(column)) continue;
-      try {
-        await table.createIndex(
-          column,
-          fts ? { config: lancedb.Index.fts(), replace: false } : { replace: false }
-        );
-      } catch {
-      }
-    }
+  async close() {
+    await this.provider.close();
   }
   /**
-   * 存储压实：逐表执行碎片合并 + 清理 retentionMs 之前的历史版本。
-   * 嵌入式场景下 LanceDB 不会自动做这件事，长期运行后版本/碎片无限累积会显著拖慢启动与查询。
+   * 存储压实（碎片合并 + 历史版本清理）。
+   * LanceDB 后端长期运行必须定期执行；SQLite 后端为可选的空间回收。
    */
   async optimizeStorage(retentionMs = 0) {
-    const cutoff = new Date(Date.now() - Math.max(0, retentionMs));
-    const targets = [
-      [MESSAGES_TABLE, this.messagesTable],
-      [TOPICS_TABLE, this.topicsTable],
-      [FACTS_TABLE, this.factsTable],
-      [SESSIONS_TABLE, this.sessionsTable],
-      [DOCUMENTS_TABLE, this.documentsTable],
-      [CHUNKS_TABLE, this.chunksTable]
-    ];
-    const results = [];
-    for (const [name, table] of targets) {
-      try {
-        const stats = await table.optimize({ cleanupOlderThan: cutoff });
-        results.push({
-          table: name,
-          fragmentsRemoved: stats.compaction.fragmentsRemoved,
-          fragmentsAdded: stats.compaction.fragmentsAdded,
-          filesRemoved: stats.compaction.filesRemoved,
-          oldVersionsRemoved: stats.prune.oldVersionsRemoved,
-          bytesRemoved: Number(stats.prune.bytesRemoved)
-        });
-      } catch (err) {
-        console.warn(`[LanceService] optimize table "${name}" failed:`, err);
-      }
-    }
-    return results;
-  }
-  /**
-   * 为存量 messages 表添加 parts 列（如果缺失）。
-   * LanceDB 0.14+ 支持 addColumns；旧版本会 throw，此时 rowToMessage 的 ?? "[]" 兜底。
-   */
-  async _ensurePartsColumn() {
-    try {
-      const schema = await this.messagesTable.schema();
-      const hasPartsCol = schema.fields?.some(
-        (f) => f.name === "parts"
-      );
-      if (!hasPartsCol) {
-        await this.messagesTable.addColumns([
-          { name: "parts", valueSql: "CAST(NULL AS STRING)" }
-        ]);
-      }
-    } catch {
-    }
-  }
-  /**
-   * 为存量 topics 表添加 title 列（如果缺失）。
-   * 旧版本不支持 addColumns 时忽略，读取时 rowToTopic 的 ?? "" 兜底。
-   */
-  async _ensureTopicTitleColumn() {
-    try {
-      const schema = await this.topicsTable.schema();
-      const hasTitleCol = schema.fields?.some(
-        (f) => f.name === "title"
-      );
-      if (!hasTitleCol) {
-        await this.topicsTable.addColumns([
-          { name: "title", valueSql: "CAST(NULL AS STRING)" }
-        ]);
-      }
-    } catch {
-    }
+    return this.provider.optimize(retentionMs);
   }
+  // ── messages ───────────────────────────────────────────────────────────────
   async addMessages(messages) {
     if (messages.length === 0) return;
-    await this.messagesTable.add(messages.map(messageToRow));
-    if (this.isNewMessagesTable) {
-      await this.ensureIndexes(this.messagesTable, MESSAGES_INDEXES);
-      this.isNewMessagesTable = false;
-    }
-  }
-  async addTopic(topic) {
-    await this.topicsTable.add([topicToRow(topic)]);
-    if (this.isNewTopicsTable) {
-      await this.ensureIndexes(this.topicsTable, TOPICS_INDEXES);
-      this.isNewTopicsTable = false;
-    }
-  }
-  async updateTopicRecallCount(summaryId, count) {
-    await this.topicsTable.update({
-      values: { recall_count: count, updated_at: Date.now() },
-      where: eqFilter("summary_id", summaryId)
-    });
-  }
-  async getRecentTopics(chatId, userId, n1, n2, n3) {
-    const filter = `${eqFilter("chat_id", chatId)} AND ${eqFilter("user_id", userId)}`;
-    const recallBoostMs = this.config.recallBoostMs;
-    const fetchTopics = async (count) => {
-      if (count <= 0) return [];
-      try {
-        const rows = await this.topicsTable.query().where(filter).limit(count * 5).toArray();
-        return rows.sort((a, b) => {
-          const scoreA = Number(a.end_time) + Number(a.recall_count) * recallBoostMs;
-          const scoreB = Number(b.end_time) + Number(b.recall_count) * recallBoostMs;
-          return scoreB - scoreA;
-        }).slice(0, count).map(rowToTopic);
-      } catch {
-        return [];
-      }
-    };
-    const allTopics = await fetchTopics(n1 + n2 + n3);
-    return {
-      detail: allTopics.slice(0, n1),
-      summary: allTopics.slice(n1, n1 + n2),
-      concise: allTopics.slice(n1 + n2, n1 + n2 + n3)
-    };
+    await this.provider.add(MESSAGES_TABLE, messages.map(messageToRow));
   }
   async getMessagesSince(sessionId, since, limit) {
     try {
-      const q = this.messagesTable.query().where(`${eqFilter("session_id", sessionId)} AND created_at > ${since}`);
-      if (limit) q.limit(limit);
-      const rows = await q.toArray();
+      const rows = await this.provider.query(MESSAGES_TABLE, {
+        filter: [eq("session_id", sessionId), { op: "gt", field: "created_at", value: since }],
+        limit
+      });
       return rows.sort((a, b) => Number(a.created_at) - Number(b.created_at)).map(rowToMessage);
     } catch {
       return [];
     }
   }
   async getLatestMessages(sessionId, limit) {
+    if (limit <= 0) return [];
     try {
-      const rows = await this.messagesTable.query().where(eqFilter("session_id", sessionId)).limit(limit * 3).toArray();
-      return rows.sort((a, b) => Number(b.created_at) - Number(a.created_at)).slice(0, limit).reverse().map(rowToMessage);
+      const rows = await this.provider.query(MESSAGES_TABLE, {
+        filter: [eq("session_id", sessionId)],
+        orderBy: [
+          { column: "created_at", ascending: false },
+          { column: "message_id", ascending: false }
+        ],
+        limit
+      });
+      return rows.reverse().map(rowToMessage);
     } catch {
       return [];
     }
@@ -1261,54 +1129,51 @@ var LanceService = class {
   /** 取某会话的全部消息（按 createdAt 升序），供管理面板分页切片使用 */
   async getAllMessagesBySession(sessionId) {
     try {
-      const rows = await this.messagesTable.query().where(eqFilter("session_id", sessionId)).toArray();
-      return rows.sort((a, b) => Number(a.created_at) - Number(b.created_at) || cmpStr(a.message_id, b.message_id)).map(rowToMessage);
+      const rows = await this.provider.query(MESSAGES_TABLE, {
+        filter: [eq("session_id", sessionId)]
+      });
+      return rows.sort(
+        (a, b) => Number(a.created_at) - Number(b.created_at) || cmpStr(a.message_id, b.message_id)
+      ).map(rowToMessage);
     } catch {
       return [];
     }
   }
   async searchMessages(vector, filter, limit = 10) {
-    const q = this.messagesTable.vectorSearch(vector).limit(limit);
-    if (filter) q.where(filter);
-    const rows = await q.toArray();
-    return rows.map((r) => ({
-      ...rowToMessage(r),
-      _distance: r._distance
-    }));
+    const rows = await this.provider.vectorSearch(MESSAGES_TABLE, vector, { filter, limit });
+    return rows.map((r) => ({ ...rowToMessage(r), _distance: r._distance }));
   }
   // 对 messages 表执行混合搜索（BM25 + 向量），用于 topics 搜索无结果时的回退
   async hybridSearchMessages(query, vector, filter, limit = 10) {
-    try {
-      const q = this.messagesTable.query().fullTextSearch(query).nearestTo(vector).limit(limit);
-      if (filter) q.where(filter);
-      const rows = await q.toArray();
-      return rows.map(rowToMessage);
-    } catch {
-      const rows = await this.searchMessages(vector, filter, limit);
-      return rows.map(({ _distance: _d, ...r }) => r);
-    }
+    const fused = await this.hybridSearch(
+      MESSAGES_TABLE,
+      ["content", "metadata"],
+      query,
+      vector,
+      filter,
+      limit
+    );
+    return fused.slice(0, limit).map(rowToMessage);
   }
   async hybridSearchTopics(query, vector, filter, limit = 10) {
-    const recallBoostMs = this.config.recallBoostMs;
     try {
-      const q = this.topicsTable.query().fullTextSearch(query).nearestTo(vector).limit(limit);
-      if (filter) q.where(filter);
-      const rows = await q.toArray();
-      if (rows.length > 0) {
-        const total = rows.length;
-        return rows.map((r, idx) => ({
+      const fused = (await this.hybridSearch(TOPICS_TABLE, ["detail"], query, vector, filter, limit)).slice(0, limit);
+      if (fused.length > 0) {
+        const total = fused.length;
+        return fused.map((r, idx) => ({
           row: r,
           score: total - idx + Math.log1p(Number(r.recall_count))
         })).sort((a, b) => b.score - a.score).map((x) => rowToTopic(x.row));
       }
     } catch {
     }
-    const msgRows = await this.hybridSearchMessages(query, vector, filter, limit);
-    return msgRows.map((r) => ({
+    const msgs = await this.hybridSearchMessages(query, vector, filter, limit);
+    return msgs.map((r) => ({
       summaryId: r.messageId,
       sessionId: r.sessionId,
       userId: r.userId,
       chatId: r.chatId,
+      title: "",
       detail: r.content,
       summary: r.content,
       concise: r.content,
@@ -1320,83 +1185,154 @@ var LanceService = class {
       vector: r.vector
     }));
   }
+  /**
+   * 通用混合检索：FTS（BM25）与向量两路各取 limit*HYBRID_OVERFETCH 候选，RRF 融合。
+   * FTS 不可用（后端不支持或查询失败）时降级为纯向量。返回融合后的完整候选序列（未截断）。
+   */
+  async hybridSearch(table, ftsColumns, query, vector, filter, limit) {
+    const fetchN = limit * HYBRID_OVERFETCH;
+    const supportsFts = this.provider.capabilities().fts;
+    const [ftsRows, vecRows] = await Promise.all([
+      supportsFts ? this.provider.ftsSearch(table, query, { columns: ftsColumns, filter, limit: fetchN }).catch(() => []) : Promise.resolve([]),
+      this.provider.vectorSearch(table, vector, { filter, limit: fetchN }).catch(() => [])
+    ]);
+    const keyColumn = this.keyColumnOf(table);
+    return rrfFuse([ftsRows, vecRows], (r) => String(r[keyColumn]));
+  }
+  keyColumnOf(table) {
+    switch (table) {
+      case MESSAGES_TABLE:
+        return "message_id";
+      case TOPICS_TABLE:
+        return "summary_id";
+      case DOCUMENTS_TABLE:
+        return "doc_id";
+      case CHUNKS_TABLE:
+        return "chunk_id";
+      case SESSIONS_TABLE:
+        return "session_id";
+      case FACTS_TABLE:
+        return "fact_id";
+      default:
+        throw new Error(`Unknown table: ${table}`);
+    }
+  }
+  // ── topics ─────────────────────────────────────────────────────────────────
+  async addTopic(topic) {
+    await this.provider.add(TOPICS_TABLE, [topicToRow(topic)]);
+  }
+  async updateTopicRecallCount(summaryId, count) {
+    await this.provider.update(
+      TOPICS_TABLE,
+      { recall_count: count, updated_at: Date.now() },
+      [eq("summary_id", summaryId)]
+    );
+  }
+  async getRecentTopics(chatId, userId, n1, n2, n3) {
+    const filter = [eq("chat_id", chatId), eq("user_id", userId)];
+    const recallBoostMs = this.config.recallBoostMs;
+    const fetchTopics = async (count) => {
+      if (count <= 0) return [];
+      try {
+        const rows = await this.provider.query(TOPICS_TABLE, {
+          filter,
+          limit: count * 5
+        });
+        return rows.sort((a, b) => {
+          const scoreA = Number(a.end_time) + Number(a.recall_count) * recallBoostMs;
+          const scoreB = Number(b.end_time) + Number(b.recall_count) * recallBoostMs;
+          return scoreB - scoreA;
+        }).slice(0, count).map(rowToTopic);
+      } catch {
+        return [];
+      }
+    };
+    const allTopics = await fetchTopics(n1 + n2 + n3);
+    return {
+      detail: allTopics.slice(0, n1),
+      summary: allTopics.slice(n1, n1 + n2),
+      concise: allTopics.slice(n1 + n2, n1 + n2 + n3)
+    };
+  }
+  /** 全量读取 topics（管理面板列表用，不做 recall 加权排序，按 endTime 倒序）*/
+  async getAllTopics() {
+    try {
+      const rows = await this.provider.query(TOPICS_TABLE);
+      return rows.sort(
+        (a, b) => Number(b.end_time) - Number(a.end_time) || cmpStr(a.summary_id, b.summary_id)
+      ).map(rowToTopic);
+    } catch {
+      return [];
+    }
+  }
+  async deleteTopicsBySession(sessionId) {
+    await this.provider.deleteWhere(TOPICS_TABLE, [eq("session_id", sessionId)]);
+  }
+  // ── facts ──────────────────────────────────────────────────────────────────
   async saveFact(fact) {
-    await this.factsTable.add([factToRow(fact)]);
+    await this.provider.add(FACTS_TABLE, [factToRow(fact)]);
   }
   async getAllFacts() {
     try {
-      const rows = await this.factsTable.query().toArray();
+      const rows = await this.provider.query(FACTS_TABLE);
       return rows.map(rowToFact);
     } catch {
       return [];
     }
   }
+  /** 删除单条 fact */
+  async deleteFact(factId) {
+    await this.provider.deleteWhere(FACTS_TABLE, [eq("fact_id", factId)]);
+  }
+  // ── sessions ───────────────────────────────────────────────────────────────
   async getAllSessionIds() {
     try {
-      const rows = await this.messagesTable.query().select(["session_id"]).limit(1e4).toArray();
+      const rows = await this.provider.query(MESSAGES_TABLE, {
+        select: ["session_id"],
+        limit: 1e4
+      });
       return [...new Set(rows.map((r) => r.session_id))];
     } catch {
       return [];
     }
   }
   async insertSession(session) {
-    await this.sessionsTable.add([sessionToRow(session)]);
-    if (this.isNewSessionsTable) {
-      await this.ensureIndexes(this.sessionsTable, SESSIONS_INDEXES);
-      this.isNewSessionsTable = false;
-    }
+    await this.provider.add(SESSIONS_TABLE, [sessionToRow(session)]);
   }
   async upsertSession(session) {
-    await this.sessionsTable.delete(eqFilter("session_id", session.sessionId));
-    await this.sessionsTable.add([sessionToRow(session)]);
+    await this.provider.deleteWhere(SESSIONS_TABLE, [eq("session_id", session.sessionId)]);
+    await this.provider.add(SESSIONS_TABLE, [sessionToRow(session)]);
   }
   async getAllSessions() {
     try {
-      const rows = await this.sessionsTable.query().toArray();
+      const rows = await this.provider.query(SESSIONS_TABLE);
       return rows.map(rowToSession);
     } catch {
       return [];
     }
   }
   async deleteSession(sessionId) {
-    await this.sessionsTable.delete(eqFilter("session_id", sessionId));
-  }
-  // ── 管理面板用：全量读取 / 删除 / 计数 ──────────────────────────────────────────────
-  /** 全量读取 topics（管理面板列表用，不做 recall 加权排序，按 endTime 倒序）*/
-  async getAllTopics() {
-    try {
-      const rows = await this.topicsTable.query().toArray();
-      return rows.sort((a, b) => Number(b.end_time) - Number(a.end_time) || cmpStr(a.summary_id, b.summary_id)).map(rowToTopic);
-    } catch {
-      return [];
-    }
-  }
-  /** 删除单条 fact */
-  async deleteFact(factId) {
-    await this.factsTable.delete(eqFilter("fact_id", factId));
+    await this.provider.deleteWhere(SESSIONS_TABLE, [eq("session_id", sessionId)]);
   }
   /** 删除某会话下的全部消息（级联删除会话时使用）*/
   async deleteMessagesBySession(sessionId) {
-    await this.messagesTable.delete(eqFilter("session_id", sessionId));
-  }
-  /** 删除某会话下的全部 topics（级联删除会话时使用）*/
-  async deleteTopicsBySession(sessionId) {
-    await this.topicsTable.delete(eqFilter("session_id", sessionId));
+    await this.provider.deleteWhere(MESSAGES_TABLE, [eq("session_id", sessionId)]);
   }
+  // ── 统计 ───────────────────────────────────────────────────────────────────
   /** 各表行数统计（概览卡片用）*/
   async countAll() {
     const safeCount = async (table) => {
       try {
-        return await table.countRows();
+        return await this.provider.count(table);
       } catch {
         return 0;
       }
     };
     const [sessions, messages, topics, facts] = await Promise.all([
-      safeCount(this.sessionsTable),
-      safeCount(this.messagesTable),
-      safeCount(this.topicsTable),
-      safeCount(this.factsTable)
+      safeCount(SESSIONS_TABLE),
+      safeCount(MESSAGES_TABLE),
+      safeCount(TOPICS_TABLE),
+      safeCount(FACTS_TABLE)
     ]);
     return { sessions, messages, topics, facts };
   }
@@ -1417,16 +1353,20 @@ var LanceService = class {
     };
     const readCreatedAt = async (table) => {
       try {
-        const rows = await table.query().select(["created_at"]).where(`created_at >= ${startMs}`).limit(1e6).toArray();
+        const rows = await this.provider.query(table, {
+          select: ["created_at"],
+          filter: [{ op: "gte", field: "created_at", value: startMs }],
+          limit: 1e6
+        });
         return rows.map((r) => Number(r.created_at)).filter((n) => Number.isFinite(n));
       } catch {
         return [];
       }
     };
     const [sessionTs, messageTs, factTs] = await Promise.all([
-      readCreatedAt(this.sessionsTable),
-      readCreatedAt(this.messagesTable),
-      readCreatedAt(this.factsTable)
+      readCreatedAt(SESSIONS_TABLE),
+      readCreatedAt(MESSAGES_TABLE),
+      readCreatedAt(FACTS_TABLE)
     ]);
     const buckets = /* @__PURE__ */ new Map();
     for (let i = 0; i < days; i++) {
@@ -1446,29 +1386,25 @@ var LanceService = class {
   }
   // ── 知识库：documents / chunks ─────────────────────────────────────────────
   async addDocument(doc) {
-    await this.documentsTable.add([documentToRow(doc)]);
-    if (this.isNewDocumentsTable) {
-      await this.ensureIndexes(this.documentsTable, DOCUMENTS_INDEXES);
-      this.isNewDocumentsTable = false;
-    }
+    await this.provider.add(DOCUMENTS_TABLE, [documentToRow(doc)]);
   }
   async addChunks(chunks) {
     if (chunks.length === 0) return;
-    await this.chunksTable.add(chunks.map(chunkToRow));
-    if (this.isNewChunksTable) {
-      await this.ensureIndexes(this.chunksTable, CHUNKS_INDEXES);
-      this.isNewChunksTable = false;
-    }
+    await this.provider.add(CHUNKS_TABLE, chunks.map(chunkToRow));
   }
   async updateDocumentGraphFlag(docId, hasGraph) {
-    await this.documentsTable.update({
-      values: { has_graph: hasGraph ? 1 : 0, updated_at: Date.now() },
-      where: eqFilter("doc_id", docId)
-    });
+    await this.provider.update(
+      DOCUMENTS_TABLE,
+      { has_graph: hasGraph ? 1 : 0, updated_at: Date.now() },
+      [eq("doc_id", docId)]
+    );
   }
   async getDocument(docId) {
     try {
-      const rows = await this.documentsTable.query().where(eqFilter("doc_id", docId)).limit(1).toArray();
+      const rows = await this.provider.query(DOCUMENTS_TABLE, {
+        filter: [eq("doc_id", docId)],
+        limit: 1
+      });
       if (rows.length === 0) return null;
       return rowToDocument(rows[0]);
     } catch {
@@ -1478,8 +1414,10 @@ var LanceService = class {
   /** 查找同域同 hash 的文档（去重用）*/
   async findDocumentByHash(contentHash, filter) {
     try {
-      const where = filter ? `${eqFilter("content_hash", contentHash)} AND ${filter}` : eqFilter("content_hash", contentHash);
-      const rows = await this.documentsTable.query().where(where).limit(1).toArray();
+      const rows = await this.provider.query(DOCUMENTS_TABLE, {
+        filter: [eq("content_hash", contentHash), ...filter ?? []],
+        limit: 1
+      });
       if (rows.length === 0) return null;
       return rowToDocument(rows[0]);
     } catch {
@@ -1489,9 +1427,11 @@ var LanceService = class {
   /** 按域过滤返回 docId 列表（chunkRedundantIds=false 时用于 chunk 过滤）*/
   async getDocIdsByDomain(filter) {
     try {
-      const q = this.documentsTable.query().select(["doc_id"]).limit(1e5);
-      if (filter) q.where(filter);
-      const rows = await q.toArray();
+      const rows = await this.provider.query(DOCUMENTS_TABLE, {
+        select: ["doc_id"],
+        filter,
+        limit: 1e5
+      });
       return [...new Set(rows.map((r) => r.doc_id))];
     } catch {
       return [];
@@ -1500,13 +1440,8 @@ var LanceService = class {
   /** 文档级粗召回：对摘要向量做向量搜索，定位候选文档 */
   async searchDocuments(vector, filter, limit = 5) {
     try {
-      const q = this.documentsTable.vectorSearch(vector).limit(limit);
-      if (filter) q.where(filter);
-      const rows = await q.toArray();
-      return rows.map((r) => ({
-        ...rowToDocument(r),
-        _distance: r._distance
-      }));
+      const rows = await this.provider.vectorSearch(DOCUMENTS_TABLE, vector, { filter, limit });
+      return rows.map((r) => ({ ...rowToDocument(r), _distance: r._distance }));
     } catch {
       return [];
     }
@@ -1514,32 +1449,30 @@ var LanceService = class {
   /** 知识片段混合检索（BM25 + 向量），失败回退纯向量 */
   async searchChunks(query, vector, filter, limit = 8) {
     try {
-      const q = this.chunksTable.query().fullTextSearch(query).nearestTo(vector).limit(limit);
-      if (filter) q.where(filter);
-      const rows = await q.toArray();
+      const fused = await this.hybridSearch(CHUNKS_TABLE, ["content"], query, vector, filter, limit);
+      if (fused.length > 0) return fused.slice(0, limit).map(rowToChunk);
+    } catch {
+    }
+    try {
+      const rows = await this.provider.vectorSearch(CHUNKS_TABLE, vector, { filter, limit });
       return rows.map(rowToChunk);
     } catch {
-      try {
-        const q = this.chunksTable.vectorSearch(vector).limit(limit);
-        if (filter) q.where(filter);
-        const rows = await q.toArray();
-        return rows.map(rowToChunk);
-      } catch {
-        return [];
-      }
+      return [];
     }
   }
   async deleteDocument(docId) {
-    await this.documentsTable.delete(eqFilter("doc_id", docId));
+    await this.provider.deleteWhere(DOCUMENTS_TABLE, [eq("doc_id", docId)]);
   }
   async deleteChunksByDoc(docId) {
-    await this.chunksTable.delete(eqFilter("doc_id", docId));
+    await this.provider.deleteWhere(CHUNKS_TABLE, [eq("doc_id", docId)]);
   }
   /** 全量读取文档（管理面板用），按更新时间倒序 */
   async getAllDocuments() {
     try {
-      const rows = await this.documentsTable.query().toArray();
-      return rows.sort((a, b) => Number(b.updated_at) - Number(a.updated_at) || cmpStr(a.doc_id, b.doc_id)).map(rowToDocument);
+      const rows = await this.provider.query(DOCUMENTS_TABLE);
+      return rows.sort(
+        (a, b) => Number(b.updated_at) - Number(a.updated_at) || cmpStr(a.doc_id, b.doc_id)
+      ).map(rowToDocument);
     } catch {
       return [];
     }
@@ -1548,34 +1481,33 @@ var LanceService = class {
   async countKnowledge() {
     const safeCount = async (table) => {
       try {
-        return await table.countRows();
+        return await this.provider.count(table);
       } catch {
         return 0;
       }
     };
     const [documents, chunks] = await Promise.all([
-      safeCount(this.documentsTable),
-      safeCount(this.chunksTable)
+      safeCount(DOCUMENTS_TABLE),
+      safeCount(CHUNKS_TABLE)
     ]);
     return { documents, chunks };
   }
   /**
-   * 根据 metadata 字段内容构建 SQL LIKE 过滤条件。
+   * 根据 metadata 字段内容构建结构化过滤条件。
    *
-   * metadata 以 JSON 字符串存储，此方法将键值对转换为 SQL LIKE 表达式，
+   * metadata 以 JSON 字符串存储，此方法将键值对转换为 jsonContains 条件，
    * 可直接传给 searchMessages / hybridSearchTopics 的 filter 参数。
    *
-   * 示例：buildMetadataFilter({ env: "prod", version: 2 })
-   *   → `metadata LIKE '%"env":"prod"%' AND metadata LIKE '%"version":2%'`
-   *
    * 注意：仅适合简单标量值（字符串、数字、布尔）的精确匹配。
    * 复杂嵌套对象或含空格的 JSON 值可能无法可靠匹配。
    */
   static buildMetadataFilter(conditions) {
-    return Object.entries(conditions).map(([key, value]) => {
-      const jsonValue = typeof value === "string" ? `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : String(value);
-      return `metadata LIKE '%"${key}":${jsonValue}%'`;
-    }).join(" AND ");
+    return Object.entries(conditions).map(([key, value]) => ({
+      op: "jsonContains",
+      field: "metadata",
+      key,
+      value
+    }));
   }
 };
 
@@ -1885,16 +1817,16 @@ ${context}`, false);
 import { v4 as uuidv4 } from "uuid";
 var CompressManager = class {
   config;
-  lance;
+  store;
   grafeo;
   llm;
   embed;
   sessionCache;
   semaphore;
   sessionChain = /* @__PURE__ */ new Map();
-  constructor(config, lance, grafeo, llm, embed, sessionCache) {
+  constructor(config, store, grafeo, llm, embed, sessionCache) {
     this.config = config;
-    this.lance = lance;
+    this.store = store;
     this.grafeo = grafeo;
     this.llm = llm;
     this.embed = embed;
@@ -1951,14 +1883,14 @@ var CompressManager = class {
       vector: topicVector
     };
     try {
-      await this.lance.addTopic(topic);
+      await this.store.addTopic(topic);
     } catch (err) {
       console.error(`[CompressManager] Save topic failed:`, err);
     }
     this.sessionCache.clearMessages(sessionId, endTime);
     const [n1, n2, n3] = this.config.topicRatio;
     try {
-      const topicGroups = await this.lance.getRecentTopics(chatId, userId, n1, n2, n3);
+      const topicGroups = await this.store.getRecentTopics(chatId, userId, n1, n2, n3);
       this.sessionCache.buildHistoryWindow(sessionId, topicGroups);
     } catch (err) {
       console.error(`[CompressManager] Rebuild history window failed:`, err);
@@ -2032,13 +1964,13 @@ function withTimeout(promise, timeoutMs, label) {
 // src/manager/fact.cache.ts
 import { v4 as uuidv42 } from "uuid";
 var FactCache = class {
-  lance;
+  store;
   cache = /* @__PURE__ */ new Map();
-  constructor(lance) {
-    this.lance = lance;
+  constructor(store) {
+    this.store = store;
   }
   async init() {
-    const facts = await this.lance.getAllFacts();
+    const facts = await this.store.getAllFacts();
     for (const fact of facts) {
       const key = this.key(fact.level, fact.level === "user" ? fact.userId : fact.chatId);
       const existing = this.cache.get(key) ?? [];
@@ -2059,7 +1991,7 @@ var FactCache = class {
       content,
       createdAt: Date.now()
     };
-    await this.lance.saveFact(fact);
+    await this.store.saveFact(fact);
     const id = level === "user" ? userId : chatId;
     const k = this.key(level, id);
     const existing = this.cache.get(k) ?? [];
@@ -2073,7 +2005,7 @@ var FactCache = class {
   all() {
     return [...this.cache.values()].flat();
   }
-  /** 删除单条 fact：同步从 LanceDB 与内存缓存中移除。返回是否命中。*/
+  /** 删除单条 fact：同步从存储与内存缓存中移除。返回是否命中。*/
   async remove(factId) {
     let hit = false;
     for (const [k, facts] of this.cache) {
@@ -2086,7 +2018,7 @@ var FactCache = class {
         break;
       }
     }
-    await this.lance.deleteFact(factId);
+    await this.store.deleteFact(factId);
     return hit;
   }
   toString(level, id) {
@@ -2230,14 +2162,14 @@ function takeTailTokens(text, overlapTokens) {
 // src/manager/knowledge.manager.ts
 var KnowledgeManager = class {
   config;
-  lance;
+  store;
   grafeo;
   llm;
   embed;
   semaphore;
-  constructor(config, lance, grafeo, llm, embed) {
+  constructor(config, store, grafeo, llm, embed) {
     this.config = config;
-    this.lance = lance;
+    this.store = store;
     this.grafeo = grafeo;
     this.llm = llm;
     this.embed = embed;
@@ -2252,8 +2184,12 @@ var KnowledgeManager = class {
     const now = Date.now();
     const content = opts.content;
     const contentHash = createHash("sha256").update(content).digest("hex");
-    const domainFilter = `user_id = '${esc(userId)}' AND chat_id = '${esc(chatId)}' AND session_id = '${esc(sessionId)}'`;
-    const existing = await this.lance.findDocumentByHash(contentHash, domainFilter);
+    const domainFilter = [
+      eq("user_id", userId),
+      eq("chat_id", chatId),
+      eq("session_id", sessionId)
+    ];
+    const existing = await this.store.findDocumentByHash(contentHash, domainFilter);
     if (existing) return { docId: existing.docId };
     const pieces = chunkMarkdown(content, {
       maxTokens: this.config.chunkMaxTokens,
@@ -2286,7 +2222,7 @@ var KnowledgeManager = class {
       createdAt: now,
       updatedAt: now
     };
-    await this.lance.addDocument(doc);
+    await this.store.addDocument(doc);
     const chunkIngest = this.semaphore.run(() => this.ingestChunks(doc, pieces));
     const graphBuild = chunkIngest.then((chunks) => {
       if (!shouldBuildGraph) return;
@@ -2336,7 +2272,7 @@ ${p.content}` : p.content
       metadata: {},
       createdAt: doc.createdAt
     }));
-    await this.lance.addChunks(chunks);
+    await this.store.addChunks(chunks);
     return chunks;
   }
   async buildDocumentGraph(doc, chunks) {
@@ -2389,7 +2325,7 @@ ${p.content}` : p.content
       embeddings,
       KIND_KNOWLEDGE
     );
-    await this.lance.updateDocumentGraphFlag(doc.docId, true).catch((err) => {
+    await this.store.updateDocumentGraphFlag(doc.docId, true).catch((err) => {
       console.error(`[KnowledgeManager] Failed to update graph flag for doc ${doc.docId}:`, err);
     });
   }
@@ -2402,11 +2338,11 @@ ${p.content}` : p.content
     const mode = opts.mode ?? "auto";
     const limit = opts.limit ?? this.config.knowledgeTopK;
     const vector = await this.embed.embedOne(opts.query);
-    const docFilter = buildDomainSql(scope, scopeId);
+    const docFilter = buildDomainFilter(scope, scopeId);
     let candidateDocIds;
     const docTitleMap = /* @__PURE__ */ new Map();
     if (this.config.docCoarseTopK > 0) {
-      const coarse = await this.lance.searchDocuments(vector, docFilter, this.config.docCoarseTopK);
+      const coarse = await this.store.searchDocuments(vector, docFilter, this.config.docCoarseTopK);
       if (coarse.length > 0) {
         candidateDocIds = coarse.map((d) => d.docId);
         for (const d of coarse) docTitleMap.set(d.docId, d.title);
@@ -2414,7 +2350,7 @@ ${p.content}` : p.content
     }
     const chunkFilter = await this.buildChunkFilter(scope, scopeId, candidateDocIds);
     if (chunkFilter === NO_MATCH) return empty;
-    const rawChunks = await this.lance.searchChunks(opts.query, vector, chunkFilter, limit);
+    const rawChunks = await this.store.searchChunks(opts.query, vector, chunkFilter, limit);
     const scored = rawChunks.map((c) => ({
       chunkId: c.chunkId,
       docId: c.docId,
@@ -2428,7 +2364,7 @@ ${p.content}` : p.content
       [...docCount.entries()].map(async ([docId, matchedChunkCount]) => {
         let title = docTitleMap.get(docId);
         if (title === void 0) {
-          const d = await this.lance.getDocument(docId);
+          const d = await this.store.getDocument(docId);
           title = d?.title ?? "";
         }
         return { docId, title, matchedChunkCount };
@@ -2476,32 +2412,32 @@ ${p.content}` : p.content
   async buildChunkFilter(scope, scopeId, candidateDocIds) {
     const parts = [];
     if (this.config.chunkRedundantIds) {
-      const domainSql = buildDomainSql(scope, scopeId);
-      if (domainSql) parts.push(domainSql);
-      if (candidateDocIds) parts.push(inSql("doc_id", candidateDocIds));
+      const domain = buildDomainFilter(scope, scopeId);
+      if (domain) parts.push(...domain);
+      if (candidateDocIds) parts.push({ op: "in", field: "doc_id", values: candidateDocIds });
     } else {
       let docIds = candidateDocIds;
       if (scope !== "all") {
-        const domainSql = buildDomainSql(scope, scopeId);
-        const domainDocIds = await this.lance.getDocIdsByDomain(domainSql);
+        const domain = buildDomainFilter(scope, scopeId);
+        const domainDocIds = await this.store.getDocIdsByDomain(domain);
         docIds = docIds ? domainDocIds.filter((id) => docIds.includes(id)) : domainDocIds;
       }
       if (docIds) {
         if (docIds.length === 0) return NO_MATCH;
-        parts.push(inSql("doc_id", docIds));
+        parts.push({ op: "in", field: "doc_id", values: docIds });
       }
     }
-    return parts.length > 0 ? parts.join(" AND ") : void 0;
+    return parts.length > 0 ? parts : void 0;
   }
   // ── 读取 / 删除 ─────────────────────────────────────────────────────────────────
   async getDocument(docId) {
-    return this.lance.getDocument(docId);
+    return this.store.getDocument(docId);
   }
   async deleteDocument(docId) {
-    const existing = await this.lance.getDocument(docId);
+    const existing = await this.store.getDocument(docId);
     if (!existing) return false;
-    await this.lance.deleteDocument(docId);
-    await this.lance.deleteChunksByDoc(docId).catch((err) => {
+    await this.store.deleteDocument(docId);
+    await this.store.deleteChunksByDoc(docId).catch((err) => {
       console.error(`[KnowledgeManager] Failed to delete chunks for doc ${docId}:`, err);
     });
     await this.grafeo.deleteKnowledgeByDoc(docId).catch((err) => {
@@ -2510,7 +2446,7 @@ ${p.content}` : p.content
     return true;
   }
   async listDocuments(filter, page) {
-    let docs = await this.lance.getAllDocuments();
+    let docs = await this.store.getAllDocuments();
     if (filter?.userId) docs = docs.filter((d) => d.userId === filter.userId);
     if (filter?.chatId) docs = docs.filter((d) => d.chatId === filter.chatId);
     if (filter?.sessionId) docs = docs.filter((d) => d.sessionId === filter.sessionId);
@@ -2528,19 +2464,12 @@ function dedupByContent(items) {
   }
   return out;
 }
-function esc(value) {
-  return value.replace(/'/g, "''");
-}
-function buildDomainSql(scope, scopeId) {
-  if (scope === "session" && scopeId) return `session_id = '${esc(scopeId)}'`;
-  if (scope === "chat" && scopeId) return `chat_id = '${esc(scopeId)}'`;
-  if (scope === "user" && scopeId) return `user_id = '${esc(scopeId)}'`;
+function buildDomainFilter(scope, scopeId) {
+  if (scope === "session" && scopeId) return [eq("session_id", scopeId)];
+  if (scope === "chat" && scopeId) return [eq("chat_id", scopeId)];
+  if (scope === "user" && scopeId) return [eq("user_id", scopeId)];
   return void 0;
 }
-function inSql(column, values) {
-  const list = values.map((v) => `'${esc(v)}'`).join(", ");
-  return `${column} IN (${list})`;
-}
 function inferTitle(markdown) {
   const lines = markdown.split(/\r?\n/);
   for (const line of lines) {
@@ -2649,7 +2578,7 @@ var SessionCache = class {
 // src/memory.manager.ts
 var MemoryManager = class {
   config;
-  lance;
+  store;
   grafeo;
   embed;
   llm;
@@ -2658,17 +2587,19 @@ var MemoryManager = class {
   compressManager;
   knowledgeManager;
   sessionMap = /* @__PURE__ */ new Map();
+  optimizeTimer;
+  optimizeRunning = false;
   constructor(config) {
     this.config = resolveConfig(config);
-    this.lance = new LanceService(this.config);
+    this.store = new MemoryStore(this.config);
     this.grafeo = new GrafeoService(this.config);
     this.embed = new EmbedService(this.config);
     this.llm = new LlmService(this.config);
     this.sessionCache = new SessionCache(this.config);
-    this.factCache = new FactCache(this.lance);
+    this.factCache = new FactCache(this.store);
     this.compressManager = new CompressManager(
       this.config,
-      this.lance,
+      this.store,
       this.grafeo,
       this.llm,
       this.embed,
@@ -2676,7 +2607,7 @@ var MemoryManager = class {
     );
     this.knowledgeManager = new KnowledgeManager(
       this.config,
-      this.lance,
+      this.store,
       this.grafeo,
       this.llm,
       this.embed
@@ -2684,26 +2615,42 @@ var MemoryManager = class {
   }
   async init() {
     initEncoder();
-    await this.lance.init();
+    await this.store.init();
     await this.grafeo.init();
     await this.factCache.init();
-    const allSessions = await this.lance.getAllSessions();
+    const allSessions = await this.store.getAllSessions();
     for (const s of allSessions) {
       this.sessionMap.set(s.sessionId, this.deserializeSession(s));
     }
     await this.restoreFromStorage();
     if (this.config.autoOptimizeOnInit) {
-      void this.optimizeStorage().then((results) => {
-        const versions = results.reduce((s, r) => s + r.oldVersionsRemoved, 0);
-        const fragments = results.reduce((s, r) => s + r.fragmentsRemoved, 0);
-        if (versions > 0 || fragments > 0) {
-          console.info(
-            `[MemoryManager] \u540E\u53F0\u5B58\u50A8\u538B\u5B9E\u5B8C\u6210\uFF1A\u6E05\u7406\u5386\u53F2\u7248\u672C ${versions} \u4E2A\uFF0C\u5408\u5E76\u788E\u7247 ${fragments} \u4E2A`
-          );
-        }
-      }).catch((err) => {
-        console.warn("[MemoryManager] \u540E\u53F0\u5B58\u50A8\u538B\u5B9E\u5931\u8D25\uFF08\u4E0D\u5F71\u54CD\u670D\u52A1\uFF09:", err);
-      });
+      void this.runBackgroundOptimize(this.config.optimizeVersionRetentionMs);
+    }
+    if (this.config.autoOptimizeIntervalMs > 0) {
+      const retention = Math.max(this.config.optimizeVersionRetentionMs, 6e4);
+      this.optimizeTimer = setInterval(() => {
+        void this.runBackgroundOptimize(retention);
+      }, this.config.autoOptimizeIntervalMs);
+      this.optimizeTimer.unref?.();
+    }
+  }
+  /** 后台压实的统一入口：防重入（上一轮未结束则跳过），失败仅告警不影响服务。*/
+  async runBackgroundOptimize(retentionMs) {
+    if (this.optimizeRunning) return;
+    this.optimizeRunning = true;
+    try {
+      const results = await this.optimizeStorage(retentionMs);
+      const versions = results.reduce((s, r) => s + r.oldVersionsRemoved, 0);
+      const fragments = results.reduce((s, r) => s + r.fragmentsRemoved, 0);
+      if (versions > 0 || fragments > 0) {
+        console.info(
+          `[MemoryManager] \u540E\u53F0\u5B58\u50A8\u538B\u5B9E\u5B8C\u6210\uFF1A\u6E05\u7406\u5386\u53F2\u7248\u672C ${versions} \u4E2A\uFF0C\u5408\u5E76\u788E\u7247 ${fragments} \u4E2A`
+        );
+      }
+    } catch (err) {
+      console.warn("[MemoryManager] \u540E\u53F0\u5B58\u50A8\u538B\u5B9E\u5931\u8D25\uFF08\u4E0D\u5F71\u54CD\u670D\u52A1\uFF09:", err);
+    } finally {
+      this.optimizeRunning = false;
     }
   }
   /**
@@ -2711,18 +2658,18 @@ var MemoryManager = class {
    * @param retentionMs 保留多久内的历史版本，默认取配置 optimizeVersionRetentionMs
    */
   async optimizeStorage(retentionMs) {
-    return this.lance.optimizeStorage(retentionMs ?? this.config.optimizeVersionRetentionMs);
+    return this.store.optimizeStorage(retentionMs ?? this.config.optimizeVersionRetentionMs);
   }
   async restoreFromStorage() {
     const [n1, n2, n3] = this.config.topicRatio;
-    const sessionIds = await this.lance.getAllSessionIds();
+    const sessionIds = await this.store.getAllSessionIds();
     if (sessionIds.length === 0) return;
     const topicsCache = /* @__PURE__ */ new Map();
     const getTopics = (chatId, userId) => {
       const key = `${chatId}\0${userId}`;
       let cached = topicsCache.get(key);
       if (!cached) {
-        cached = this.lance.getRecentTopics(chatId, userId, n1, n2, n3);
+        cached = this.store.getRecentTopics(chatId, userId, n1, n2, n3);
         topicsCache.set(key, cached);
       }
       return cached;
@@ -2731,12 +2678,12 @@ var MemoryManager = class {
     await Promise.all(
       sessionIds.map(
         (sessionId) => sem.run(async () => {
-          const recentMessages = await this.lance.getLatestMessages(sessionId, 1);
+          const recentMessages = await this.store.getLatestMessages(sessionId, 1);
           if (recentMessages.length === 0) return;
           const { chatId, userId } = recentMessages[0];
           const topicGroups = await getTopics(chatId, userId);
           const n1EndTime = topicGroups.detail.length > 0 ? topicGroups.detail[topicGroups.detail.length - 1].endTime : 0;
-          const rawMessages = n1EndTime > 0 ? await this.lance.getMessagesSince(sessionId, n1EndTime) : await this.lance.getLatestMessages(sessionId, 100);
+          const rawMessages = n1EndTime > 0 ? await this.store.getMessagesSince(sessionId, n1EndTime) : await this.store.getLatestMessages(sessionId, 100);
           if (rawMessages.length > 0) {
             this.sessionCache.addMessages(sessionId, rawMessages, chatId, userId);
           }
@@ -2789,7 +2736,7 @@ var MemoryManager = class {
       vector: vectors[i],
       createdAt: m.createdAt
     }));
-    await this.lance.addMessages(stored);
+    await this.store.addMessages(stored);
     if (!this.sessionMap.has(sessionId)) {
       const session = {
         sessionId,
@@ -2801,13 +2748,13 @@ var MemoryManager = class {
         updatedAt: now
       };
       this.sessionMap.set(sessionId, this.deserializeSession(session));
-      this.lance.insertSession(session).catch((err) => {
+      this.store.insertSession(session).catch((err) => {
         console.error("[MemoryManager] Failed to insert session:", err);
       });
     } else {
       const view = this.sessionMap.get(sessionId);
       view.updatedAt = now;
-      this.lance.upsertSession(this.serializeSession(view)).catch((err) => {
+      this.store.upsertSession(this.serializeSession(view)).catch((err) => {
         console.error(`[MemoryManager] Failed to upsert session ${sessionId}:`, err);
       });
     }
@@ -2862,7 +2809,7 @@ var MemoryManager = class {
     } = opts;
     if (!query.trim()) return [];
     const vector = await this.embed.embedOne(query);
-    const filter = this.buildLanceFilter(scope, scopeId);
+    const filter = this.buildScopeFilter(scope, scopeId);
     let useGraph = false;
     if (mode === "all") {
       useGraph = true;
@@ -2870,7 +2817,7 @@ var MemoryManager = class {
       useGraph = await this.llm.judgeNeedsGraphSearch(query).catch(() => false);
     }
     const tasks = [
-      this.lance.hybridSearchTopics(query, vector, filter, limit).then(
+      this.store.hybridSearchTopics(query, vector, filter, limit).then(
         (topics) => topics.map((t) => ({
           type: "topic",
           content: t.detail,
@@ -2943,10 +2890,10 @@ var MemoryManager = class {
   getHistoryWindow(sessionId) {
     return this.sessionCache.getHistoryWindow(sessionId);
   }
-  buildLanceFilter(scope, scopeId) {
-    if (scope === "session" && scopeId) return `session_id = '${scopeId}'`;
-    if (scope === "chat" && scopeId) return `chat_id = '${scopeId}'`;
-    if (scope === "user" && scopeId) return `user_id = '${scopeId}'`;
+  buildScopeFilter(scope, scopeId) {
+    if (scope === "session" && scopeId) return [eq("session_id", scopeId)];
+    if (scope === "chat" && scopeId) return [eq("chat_id", scopeId)];
+    if (scope === "user" && scopeId) return [eq("user_id", scopeId)];
     return void 0;
   }
   deserializeSession(s) {
@@ -2957,7 +2904,7 @@ var MemoryManager = class {
   }
   // ── Message queries ──────────────────────────────────────────────────────────
   async getRecentMessages(sessionId, limit) {
-    return this.lance.getLatestMessages(sessionId, limit);
+    return this.store.getLatestMessages(sessionId, limit);
   }
   // ── Session queries (in-memory) ──────────────────────────────────────────────
   getSession(sessionId) {
@@ -2993,17 +2940,17 @@ var MemoryManager = class {
       updatedAt: Date.now()
     };
     this.sessionMap.set(sessionId, updated);
-    await this.lance.upsertSession(this.serializeSession(updated));
+    await this.store.upsertSession(this.serializeSession(updated));
     return updated;
   }
   async deleteSession(sessionId) {
     if (!this.sessionMap.has(sessionId)) return false;
     this.sessionMap.delete(sessionId);
-    await this.lance.deleteSession(sessionId);
-    await this.lance.deleteMessagesBySession(sessionId).catch((err) => {
+    await this.store.deleteSession(sessionId);
+    await this.store.deleteMessagesBySession(sessionId).catch((err) => {
       console.error(`[MemoryManager] Failed to delete messages for session ${sessionId}:`, err);
     });
-    await this.lance.deleteTopicsBySession(sessionId).catch((err) => {
+    await this.store.deleteTopicsBySession(sessionId).catch((err) => {
       console.error(`[MemoryManager] Failed to delete topics for session ${sessionId}:`, err);
     });
     return true;
@@ -3012,8 +2959,8 @@ var MemoryManager = class {
   /** 概览统计：各类记忆数据的总量 */
   async stats() {
     const [counts, knowledge, entities, relations] = await Promise.all([
-      this.lance.countAll(),
-      this.lance.countKnowledge(),
+      this.store.countAll(),
+      this.store.countKnowledge(),
       this.grafeo.getAllEntities(),
       this.grafeo.getAllRelations()
     ]);
@@ -3027,7 +2974,7 @@ var MemoryManager = class {
   /** 按天聚合最近 days 天的活跃趋势（概览图表用，含零值天）。days 默认 30，范围 1~365。 */
   async trend(days = 30) {
     const n = Math.min(365, Math.max(1, Math.floor(days)));
-    return this.lance.trendDaily(n);
+    return this.store.trendDaily(n);
   }
   listSessions(filter, page) {
     let results = [...this.sessionMap.values()];
@@ -3038,13 +2985,13 @@ var MemoryManager = class {
   }
   async listMessages(sessionId, limitOrPage) {
     if (typeof limitOrPage === "object") {
-      const all = await this.lance.getAllMessagesBySession(sessionId);
+      const all = await this.store.getAllMessagesBySession(sessionId);
       return paginate(all, limitOrPage);
     }
-    return this.lance.getLatestMessages(sessionId, limitOrPage ?? 100);
+    return this.store.getLatestMessages(sessionId, limitOrPage ?? 100);
   }
   async listTopics(filter, page) {
-    let topics = await this.lance.getAllTopics();
+    let topics = await this.store.getAllTopics();
     if (filter?.sessionId) topics = topics.filter((t) => t.sessionId === filter.sessionId);
     if (filter?.userId) topics = topics.filter((t) => t.userId === filter.userId);
     if (filter?.chatId) topics = topics.filter((t) => t.chatId === filter.chatId);
@@ -3113,7 +3060,13 @@ var MemoryManager = class {
     return page ? this.knowledgeManager.listDocuments(filter, page) : this.knowledgeManager.listDocuments(filter);
   }
   destroy() {
+    if (this.optimizeTimer) {
+      clearInterval(this.optimizeTimer);
+      this.optimizeTimer = void 0;
+    }
     this.grafeo.close();
+    void this.store.close().catch(() => {
+    });
   }
 };
 export {
@@ -3121,6 +3074,6 @@ export {
   DEFAULT_RELATION_TYPES,
   KIND_CONVERSATION,
   KIND_KNOWLEDGE,
-  LanceService,
-  MemoryManager
+  MemoryManager,
+  MemoryStore
 };