@melandlabs/memory-store 0.1.6 → 0.2.0

package/dist/server/cli-http.js

@@ -247,7 +247,14 @@ function clampUnifiedMemorySearchThreshold(threshold) {
   }
   return Math.min(1, Math.max(-1, parsed));
 }
-function mergeUnifiedMemorySearchResults(results, limit) {
+function mergeUnifiedMemorySearchResults(results, limit, options = {}) {
+  const strategy = normalizeUnifiedMemoryMergeStrategy(options.strategy);
+  if (strategy === "rrf") {
+    const lists = options.rankedLists ?? [
+      { name: "memory-semantic", hits: results }
+    ];
+    return mergeUnifiedMemorySearchResultsRrf(lists, limit);
+  }
   return [...results].sort((a, b) => {
     const scoreDelta = b.similarity - a.similarity;
     if (scoreDelta !== 0) {
@@ -256,6 +263,42 @@ function mergeUnifiedMemorySearchResults(results, limit) {
     return a.type.localeCompare(b.type) || a.id.localeCompare(b.id);
   }).slice(0, limit);
 }
+function normalizeUnifiedMemoryMergeStrategy(value) {
+  return value === "rrf" ? "rrf" : "similarity";
+}
+var DEFAULT_RRF_K = 60;
+function mergeUnifiedMemorySearchResultsRrf(lists, limit, k = DEFAULT_RRF_K) {
+  if (!Array.isArray(lists) || lists.length === 0) {
+    return [];
+  }
+  const safeK = Number.isFinite(k) && k > 0 ? k : DEFAULT_RRF_K;
+  const scores = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const list of lists) {
+    for (let index = 0; index < list.hits.length; index += 1) {
+      const hit = list.hits[index];
+      const key = `${hit.type}::${hit.id}`;
+      const contribution = 1 / (safeK + index + 1);
+      const existing = scores.get(key);
+      if (existing) {
+        existing.rrf += contribution;
+      } else {
+        scores.set(key, { hit, rrf: contribution });
+        order.push(key);
+      }
+    }
+  }
+  const ranked = order.map((key) => scores.get(key)).sort((a, b) => {
+    if (b.rrf !== a.rrf) {
+      return b.rrf - a.rrf;
+    }
+    return a.hit.type.localeCompare(b.hit.type) || a.hit.id.localeCompare(b.hit.id);
+  }).slice(0, limit);
+  return ranked.map(({ hit, rrf }) => ({
+    ...hit,
+    metadata: { ...hit.metadata, rrfScore: rrf }
+  }));
+}
 function toKnowledgeResult(result) {
   return {
     type: "knowledge",
@@ -287,6 +330,9 @@ function isRawMemorySemanticResult(result) {
 }
 
 // src/search/unified-search.ts
+function deriveLexicalKeywords(query) {
+  return query.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((token) => token.length >= 2).slice(0, 16);
+}
 function createUnifiedSearch(deps = {}) {
   const logger = deps.logger ?? console;
   async function searchUnifiedMemory(input) {
@@ -294,8 +340,8 @@ function createUnifiedSearch(deps = {}) {
     const sources = normalizeUnifiedMemorySearchSources(input.sources);
     const limit = clampUnifiedMemorySearchLimit(input.limit);
     const threshold = clampUnifiedMemorySearchThreshold(input.threshold);
+    const mergeStrategy = normalizeUnifiedMemoryMergeStrategy(input.mergeStrategy);
     const warnings = [];
-    const results = [];
     if (!query) {
       return {
         query,
@@ -305,11 +351,11 @@ function createUnifiedSearch(deps = {}) {
         warnings
       };
     }
+    let memorySubs;
     if (sources.includes("memory")) {
       if (isRawMessageStorageAvailable()) {
         try {
-          const memoryHits = await runMemorySource(input, limit, threshold);
-          results.push(...memoryHits);
+          memorySubs = await runMemorySource(input, limit, threshold, warnings);
         } catch (error) {
           logger.warn?.("[memory-store] memory source failed:", error);
           warnings.push({
@@ -326,9 +372,10 @@ function createUnifiedSearch(deps = {}) {
         });
       }
     }
+    const insightHits = [];
     if (sources.includes("insights") && typeof deps.searchInsights === "function") {
       try {
-        const insightHits = await deps.searchInsights({
+        const hits = await deps.searchInsights({
           userId: input.userId,
           query: input.query,
           limit,
@@ -337,8 +384,8 @@ function createUnifiedSearch(deps = {}) {
           includeArchived: input.includeArchivedInsights,
           authToken: input.authToken
         });
-        for (const hit of insightHits) {
-          results.push({
+        for (const hit of hits) {
+          insightHits.push({
             type: "insight",
             id: hit.id,
             content: hit.content,
@@ -361,9 +408,10 @@ function createUnifiedSearch(deps = {}) {
         message: "Insights search is not configured for this host."
       });
     }
+    const knowledgeHits = [];
     if (sources.includes("knowledge") && typeof deps.searchKnowledge === "function") {
       try {
-        const knowledgeHits = await deps.searchKnowledge({
+        const hits = await deps.searchKnowledge({
           userId: input.userId,
           query: input.query,
           options: {
@@ -373,8 +421,8 @@ function createUnifiedSearch(deps = {}) {
           },
           authToken: input.authToken
         });
-        for (const hit of knowledgeHits) {
-          results.push(toKnowledgeResult(hit));
+        for (const hit of hits) {
+          knowledgeHits.push(toKnowledgeResult(hit));
         }
       } catch (error) {
         logger.warn?.("[memory-store] knowledge source failed:", error);
@@ -391,7 +439,13 @@ function createUnifiedSearch(deps = {}) {
         message: "Knowledge search is not configured for this host."
       });
     }
-    const merged = mergeUnifiedMemorySearchResults(results, limit);
+    const merged = mergeAcrossSources({
+      memorySubs,
+      insightHits,
+      knowledgeHits,
+      limit,
+      strategy: mergeStrategy
+    });
     return {
       query: input.query,
       sources,
@@ -400,7 +454,7 @@ function createUnifiedSearch(deps = {}) {
       warnings
     };
   }
-  async function runMemorySource(input, limit, threshold) {
+  async function runMemorySource(input, limit, threshold, warnings) {
     if (typeof deps.embedQuery !== "function") {
       throw new Error("embedQuery is not configured");
     }
@@ -410,9 +464,10 @@ function createUnifiedSearch(deps = {}) {
       authToken: input.authToken
     });
     const filters = input.botIds && input.botIds.length > 0 ? input.botIds.map((botId) => ({ botId })) : [{}];
+    let semantic = [];
     if (isRawMessageChromaEnabled()) {
       try {
-        const chromaHits = (await Promise.all(
+        semantic = (await Promise.all(
           filters.map((filter) => {
             const botId = "botId" in filter ? filter.botId : void 0;
             return searchRawMessagesWithChroma({
@@ -427,18 +482,16 @@ function createUnifiedSearch(deps = {}) {
         logger.log?.("[memory-store] Raw message semantic search completed", {
           backend: "chroma",
           dimensions: queryEmbedding.length,
-          count: chromaHits.length
+          count: semantic.length
         });
-        return chromaHits;
       } catch (error) {
         logger.warn?.(
           "[memory-store] Chroma raw message search failed; falling back to database search:",
           error
         );
       }
-    }
-    if (typeof deps.searchRawMessagesAnn === "function") {
-      const rows = (await Promise.all(
+    } else if (typeof deps.searchRawMessagesAnn === "function") {
+      semantic = (await Promise.all(
         filters.map(
           (filter) => deps.searchRawMessagesAnn({
             userId: input.userId,
@@ -449,17 +502,87 @@ function createUnifiedSearch(deps = {}) {
           })
         )
       )).flat().filter(isRawMemorySemanticResult).map(toMemoryResult);
-      return rows;
     }
-    return [];
+    let lexical = [];
+    if (typeof deps.searchRawMessagesLexical === "function") {
+      const keywords = deriveLexicalKeywords(input.query);
+      if (keywords.length > 0) {
+        try {
+          const lexFilters = input.botIds && input.botIds.length > 0 ? input.botIds : [void 0];
+          lexical = (await Promise.all(
+            lexFilters.map(
+              (botId) => deps.searchRawMessagesLexical({
+                userId: input.userId,
+                keywords,
+                limit,
+                botId
+              })
+            )
+          )).flat().filter(isRawMemorySemanticResult).map((hit) => ({
+            ...toMemoryResult(hit),
+            metadata: { ...hit.metadata, scoring: "bm25" }
+          }));
+        } catch (error) {
+          logger.warn?.("[memory-store] lexical memory search failed:", error);
+          warnings.push({
+            source: "memory",
+            code: "memory_lexical_search_failed",
+            message: error.message ?? "memory_lexical_search_failed"
+          });
+        }
+      }
+    } else if (input.mergeStrategy === "rrf") {
+      warnings.push({
+        source: "memory",
+        code: "memory_lexical_search_not_configured",
+        message: "RRF merge requested but lexical search is not configured; falling back to semantic-only RRF."
+      });
+    }
+    return { semantic, lexical };
   }
   async function searchRawMemorySemantically(input) {
     const limit = clampUnifiedMemorySearchLimit(input.limit);
     const threshold = clampUnifiedMemorySearchThreshold(input.threshold);
-    return runMemorySource(input, limit, threshold);
+    const sub = await runMemorySource(input, limit, threshold, []);
+    return mergeAcrossSources({
+      memorySubs: sub,
+      insightHits: [],
+      knowledgeHits: [],
+      limit,
+      strategy: normalizeUnifiedMemoryMergeStrategy(input.mergeStrategy)
+    });
   }
   return { searchUnifiedMemory, searchRawMemorySemantically };
 }
+function mergeAcrossSources(input) {
+  const memorySubs = input.memorySubs ?? { semantic: [], lexical: [] };
+  const all = [
+    ...memorySubs.semantic,
+    ...memorySubs.lexical,
+    ...input.insightHits,
+    ...input.knowledgeHits
+  ];
+  if (input.strategy !== "rrf") {
+    return mergeUnifiedMemorySearchResults(all, input.limit);
+  }
+  const lists = [];
+  if (memorySubs.semantic.length > 0) {
+    lists.push({ name: "memory-semantic", hits: memorySubs.semantic });
+  }
+  if (memorySubs.lexical.length > 0) {
+    lists.push({ name: "memory-bm25", hits: memorySubs.lexical });
+  }
+  if (input.insightHits.length > 0) {
+    lists.push({ name: "insights", hits: input.insightHits });
+  }
+  if (input.knowledgeHits.length > 0) {
+    lists.push({ name: "knowledge", hits: input.knowledgeHits });
+  }
+  if (lists.length <= 1) {
+    return mergeUnifiedMemorySearchResults(all, input.limit);
+  }
+  return mergeUnifiedMemorySearchResultsRrf(lists, input.limit);
+}
 
 // src/http.ts
 async function embedMissingMessages(messages, deps) {
@@ -934,5 +1057,3 @@ main().catch((error) => {
   console.error("[memory-store/http] fatal:", error);
   process.exit(1);
 });
-//# sourceMappingURL=cli-http.js.map
-//# sourceMappingURL=cli-http.js.map

package/dist/server/cli-mcp.js

@@ -248,7 +248,14 @@ function clampUnifiedMemorySearchThreshold(threshold) {
   }
   return Math.min(1, Math.max(-1, parsed));
 }
-function mergeUnifiedMemorySearchResults(results, limit) {
+function mergeUnifiedMemorySearchResults(results, limit, options = {}) {
+  const strategy = normalizeUnifiedMemoryMergeStrategy(options.strategy);
+  if (strategy === "rrf") {
+    const lists = options.rankedLists ?? [
+      { name: "memory-semantic", hits: results }
+    ];
+    return mergeUnifiedMemorySearchResultsRrf(lists, limit);
+  }
   return [...results].sort((a, b) => {
     const scoreDelta = b.similarity - a.similarity;
     if (scoreDelta !== 0) {
@@ -257,6 +264,42 @@ function mergeUnifiedMemorySearchResults(results, limit) {
     return a.type.localeCompare(b.type) || a.id.localeCompare(b.id);
   }).slice(0, limit);
 }
+function normalizeUnifiedMemoryMergeStrategy(value) {
+  return value === "rrf" ? "rrf" : "similarity";
+}
+var DEFAULT_RRF_K = 60;
+function mergeUnifiedMemorySearchResultsRrf(lists, limit, k = DEFAULT_RRF_K) {
+  if (!Array.isArray(lists) || lists.length === 0) {
+    return [];
+  }
+  const safeK = Number.isFinite(k) && k > 0 ? k : DEFAULT_RRF_K;
+  const scores = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const list of lists) {
+    for (let index = 0; index < list.hits.length; index += 1) {
+      const hit = list.hits[index];
+      const key = `${hit.type}::${hit.id}`;
+      const contribution = 1 / (safeK + index + 1);
+      const existing = scores.get(key);
+      if (existing) {
+        existing.rrf += contribution;
+      } else {
+        scores.set(key, { hit, rrf: contribution });
+        order.push(key);
+      }
+    }
+  }
+  const ranked = order.map((key) => scores.get(key)).sort((a, b) => {
+    if (b.rrf !== a.rrf) {
+      return b.rrf - a.rrf;
+    }
+    return a.hit.type.localeCompare(b.hit.type) || a.hit.id.localeCompare(b.hit.id);
+  }).slice(0, limit);
+  return ranked.map(({ hit, rrf }) => ({
+    ...hit,
+    metadata: { ...hit.metadata, rrfScore: rrf }
+  }));
+}
 function toKnowledgeResult(result) {
   return {
     type: "knowledge",
@@ -288,6 +331,9 @@ function isRawMemorySemanticResult(result) {
 }
 
 // src/search/unified-search.ts
+function deriveLexicalKeywords(query) {
+  return query.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((token) => token.length >= 2).slice(0, 16);
+}
 function createUnifiedSearch(deps = {}) {
   const logger = deps.logger ?? console;
   async function searchUnifiedMemory(input) {
@@ -295,8 +341,8 @@ function createUnifiedSearch(deps = {}) {
     const sources = normalizeUnifiedMemorySearchSources(input.sources);
     const limit = clampUnifiedMemorySearchLimit(input.limit);
     const threshold = clampUnifiedMemorySearchThreshold(input.threshold);
+    const mergeStrategy = normalizeUnifiedMemoryMergeStrategy(input.mergeStrategy);
     const warnings = [];
-    const results = [];
     if (!query) {
       return {
         query,
@@ -306,11 +352,11 @@ function createUnifiedSearch(deps = {}) {
         warnings
       };
     }
+    let memorySubs;
     if (sources.includes("memory")) {
       if (isRawMessageStorageAvailable()) {
         try {
-          const memoryHits = await runMemorySource(input, limit, threshold);
-          results.push(...memoryHits);
+          memorySubs = await runMemorySource(input, limit, threshold, warnings);
         } catch (error) {
           logger.warn?.("[memory-store] memory source failed:", error);
           warnings.push({
@@ -327,9 +373,10 @@ function createUnifiedSearch(deps = {}) {
         });
       }
     }
+    const insightHits = [];
     if (sources.includes("insights") && typeof deps.searchInsights === "function") {
       try {
-        const insightHits = await deps.searchInsights({
+        const hits = await deps.searchInsights({
           userId: input.userId,
           query: input.query,
           limit,
@@ -338,8 +385,8 @@ function createUnifiedSearch(deps = {}) {
           includeArchived: input.includeArchivedInsights,
           authToken: input.authToken
         });
-        for (const hit of insightHits) {
-          results.push({
+        for (const hit of hits) {
+          insightHits.push({
             type: "insight",
             id: hit.id,
             content: hit.content,
@@ -362,9 +409,10 @@ function createUnifiedSearch(deps = {}) {
         message: "Insights search is not configured for this host."
       });
     }
+    const knowledgeHits = [];
     if (sources.includes("knowledge") && typeof deps.searchKnowledge === "function") {
       try {
-        const knowledgeHits = await deps.searchKnowledge({
+        const hits = await deps.searchKnowledge({
           userId: input.userId,
           query: input.query,
           options: {
@@ -374,8 +422,8 @@ function createUnifiedSearch(deps = {}) {
           },
           authToken: input.authToken
         });
-        for (const hit of knowledgeHits) {
-          results.push(toKnowledgeResult(hit));
+        for (const hit of hits) {
+          knowledgeHits.push(toKnowledgeResult(hit));
         }
       } catch (error) {
         logger.warn?.("[memory-store] knowledge source failed:", error);
@@ -392,7 +440,13 @@ function createUnifiedSearch(deps = {}) {
         message: "Knowledge search is not configured for this host."
       });
     }
-    const merged = mergeUnifiedMemorySearchResults(results, limit);
+    const merged = mergeAcrossSources({
+      memorySubs,
+      insightHits,
+      knowledgeHits,
+      limit,
+      strategy: mergeStrategy
+    });
     return {
       query: input.query,
       sources,
@@ -401,7 +455,7 @@ function createUnifiedSearch(deps = {}) {
       warnings
     };
   }
-  async function runMemorySource(input, limit, threshold) {
+  async function runMemorySource(input, limit, threshold, warnings) {
     if (typeof deps.embedQuery !== "function") {
       throw new Error("embedQuery is not configured");
     }
@@ -411,9 +465,10 @@ function createUnifiedSearch(deps = {}) {
       authToken: input.authToken
     });
     const filters = input.botIds && input.botIds.length > 0 ? input.botIds.map((botId) => ({ botId })) : [{}];
+    let semantic = [];
     if (isRawMessageChromaEnabled()) {
       try {
-        const chromaHits = (await Promise.all(
+        semantic = (await Promise.all(
           filters.map((filter) => {
             const botId = "botId" in filter ? filter.botId : void 0;
             return searchRawMessagesWithChroma({
@@ -428,18 +483,16 @@ function createUnifiedSearch(deps = {}) {
         logger.log?.("[memory-store] Raw message semantic search completed", {
           backend: "chroma",
           dimensions: queryEmbedding.length,
-          count: chromaHits.length
+          count: semantic.length
         });
-        return chromaHits;
       } catch (error) {
         logger.warn?.(
           "[memory-store] Chroma raw message search failed; falling back to database search:",
           error
         );
       }
-    }
-    if (typeof deps.searchRawMessagesAnn === "function") {
-      const rows = (await Promise.all(
+    } else if (typeof deps.searchRawMessagesAnn === "function") {
+      semantic = (await Promise.all(
         filters.map(
           (filter) => deps.searchRawMessagesAnn({
             userId: input.userId,
@@ -450,17 +503,87 @@ function createUnifiedSearch(deps = {}) {
           })
         )
       )).flat().filter(isRawMemorySemanticResult).map(toMemoryResult);
-      return rows;
     }
-    return [];
+    let lexical = [];
+    if (typeof deps.searchRawMessagesLexical === "function") {
+      const keywords = deriveLexicalKeywords(input.query);
+      if (keywords.length > 0) {
+        try {
+          const lexFilters = input.botIds && input.botIds.length > 0 ? input.botIds : [void 0];
+          lexical = (await Promise.all(
+            lexFilters.map(
+              (botId) => deps.searchRawMessagesLexical({
+                userId: input.userId,
+                keywords,
+                limit,
+                botId
+              })
+            )
+          )).flat().filter(isRawMemorySemanticResult).map((hit) => ({
+            ...toMemoryResult(hit),
+            metadata: { ...hit.metadata, scoring: "bm25" }
+          }));
+        } catch (error) {
+          logger.warn?.("[memory-store] lexical memory search failed:", error);
+          warnings.push({
+            source: "memory",
+            code: "memory_lexical_search_failed",
+            message: error.message ?? "memory_lexical_search_failed"
+          });
+        }
+      }
+    } else if (input.mergeStrategy === "rrf") {
+      warnings.push({
+        source: "memory",
+        code: "memory_lexical_search_not_configured",
+        message: "RRF merge requested but lexical search is not configured; falling back to semantic-only RRF."
+      });
+    }
+    return { semantic, lexical };
   }
   async function searchRawMemorySemantically(input) {
     const limit = clampUnifiedMemorySearchLimit(input.limit);
     const threshold = clampUnifiedMemorySearchThreshold(input.threshold);
-    return runMemorySource(input, limit, threshold);
+    const sub = await runMemorySource(input, limit, threshold, []);
+    return mergeAcrossSources({
+      memorySubs: sub,
+      insightHits: [],
+      knowledgeHits: [],
+      limit,
+      strategy: normalizeUnifiedMemoryMergeStrategy(input.mergeStrategy)
+    });
   }
   return { searchUnifiedMemory, searchRawMemorySemantically };
 }
+function mergeAcrossSources(input) {
+  const memorySubs = input.memorySubs ?? { semantic: [], lexical: [] };
+  const all = [
+    ...memorySubs.semantic,
+    ...memorySubs.lexical,
+    ...input.insightHits,
+    ...input.knowledgeHits
+  ];
+  if (input.strategy !== "rrf") {
+    return mergeUnifiedMemorySearchResults(all, input.limit);
+  }
+  const lists = [];
+  if (memorySubs.semantic.length > 0) {
+    lists.push({ name: "memory-semantic", hits: memorySubs.semantic });
+  }
+  if (memorySubs.lexical.length > 0) {
+    lists.push({ name: "memory-bm25", hits: memorySubs.lexical });
+  }
+  if (input.insightHits.length > 0) {
+    lists.push({ name: "insights", hits: input.insightHits });
+  }
+  if (input.knowledgeHits.length > 0) {
+    lists.push({ name: "knowledge", hits: input.knowledgeHits });
+  }
+  if (lists.length <= 1) {
+    return mergeUnifiedMemorySearchResults(all, input.limit);
+  }
+  return mergeUnifiedMemorySearchResultsRrf(lists, input.limit);
+}
 
 // src/mcp.ts
 var DEFAULT_NAME = "@melandlabs/memory-store";
@@ -976,5 +1099,3 @@ main().catch((error) => {
   console.error("[memory-store/mcp] fatal:", error);
   process.exit(1);
 });
-//# sourceMappingURL=cli-mcp.js.map
-//# sourceMappingURL=cli-mcp.js.map

package/dist/server/cli-shared.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { d as UnifiedSearchDeps } from '../config-D6MzksfT.js';
+import { d as UnifiedSearchDeps } from '../config-BYfTzG3h.js';
 
 /**
  * Shared argv parsing + `unified.*` wiring for the memory-store CLI bins.

package/dist/server/cli-shared.js

@@ -369,5 +369,3 @@ Cross-source search (wires unified.searchKnowledge / searchInsights / searchRawM
 }
 
 export { buildUnified, parseUnifiedArgs, printUnifiedHelp };
-//# sourceMappingURL=cli-shared.js.map
-//# sourceMappingURL=cli-shared.js.map

package/dist/storage/chroma-memory-index.js

@@ -245,5 +245,3 @@ async function searchInsightsWithChroma(input) {
 }
 
 export { isInsightChromaEnabled, isRawMessageChromaEnabled, searchInsightsWithChroma, searchRawMessagesWithChroma, upsertInsightsToChroma, upsertRawMessagesToChroma };
-//# sourceMappingURL=chroma-memory-index.js.map
-//# sourceMappingURL=chroma-memory-index.js.map

package/dist/storage/postgres-raw-message-factory.d.ts

@@ -1,4 +1,4 @@
-import { b as MemoryStoreEnv } from '../config-D6MzksfT.js';
+import { b as MemoryStoreEnv } from '../config-BYfTzG3h.js';
 
 /**
  * Lazy registration slot for the host's Postgres-backed raw message

package/dist/storage/postgres-raw-message-factory.js

@@ -15,5 +15,3 @@ function hasPostgresFactory() {
 }
 
 export { clearPostgresFactory, hasPostgresFactory, registerPostgresFactory, resolvePostgresFactory };
-//# sourceMappingURL=postgres-raw-message-factory.js.map
-//# sourceMappingURL=postgres-raw-message-factory.js.map

package/dist/storage/raw-message-store.d.ts

@@ -1,5 +1,5 @@
 import { RawMessageStorageManager } from '@melandlabs/indexeddb/storage';
-import { b as MemoryStoreEnv, M as MemoryStoreConfig } from '../config-D6MzksfT.js';
+import { b as MemoryStoreEnv, M as MemoryStoreConfig } from '../config-BYfTzG3h.js';
 
 /**
  * Top-level raw-message store facade.
@@ -34,6 +34,14 @@ type RawMessageStorageManagerWithSearch = RawMessageStorageManager & {
         startTime?: number;
         endTime?: number;
     }) => Promise<unknown[]>;
+    lexicalSearchMessages?: (input: {
+        userId: string;
+        keywords: string[];
+        limit?: number;
+        includeArchived?: boolean;
+        platform?: string;
+        botId?: string;
+    }) => Promise<unknown[]>;
 };
 interface CreateRawMessageStoreOptions {
     env?: MemoryStoreEnv;

package/dist/storage/raw-message-store.js

@@ -125,5 +125,3 @@ async function closeRawMessageStore() {
 }
 
 export { closeRawMessageStore, configureRawMessageStore, createRawMessageStore, getRawMessageManager, getRawMessageStorageBackend, isRawMessageStorageAvailable };
-//# sourceMappingURL=raw-message-store.js.map
-//# sourceMappingURL=raw-message-store.js.map

package/dist/storage/sqlite-raw-message-store.d.ts

@@ -1,5 +1,5 @@
 import { SQLiteRawMessageManager } from '@melandlabs/sqlite';
-import { b as MemoryStoreEnv } from '../config-D6MzksfT.js';
+import { b as MemoryStoreEnv } from '../config-BYfTzG3h.js';
 
 /**
  * SQLite-backed raw message store.
@@ -30,5 +30,18 @@ declare function closeSQLiteRawMessageManager(): Promise<void>;
  * Test-only: reset the singleton. Used by vitest between test cases.
  */
 declare function __resetSQLiteRawMessageManagerForTests(): void;
+/**
+ * BM25 lexical proxy over the SQLite FTS5 index. Mirrors
+ * `SQLiteRawMessageManager.lexicalSearchMessages` so callers downstream of the
+ * raw-message facade can opt in to a second ranking signal.
+ */
+declare function lexicalSearchRawMessages(input: {
+    userId: string;
+    keywords: string[];
+    limit?: number;
+    includeArchived?: boolean;
+    platform?: string;
+    botId?: string;
+}): Promise<unknown[]>;
 
-export { __resetSQLiteRawMessageManagerForTests, closeSQLiteRawMessageManager, getSQLiteRawMessageManager, isSQLiteRawMessageStorageAvailable, resolveSQLiteRawMessageDbPath };
+export { __resetSQLiteRawMessageManagerForTests, closeSQLiteRawMessageManager, getSQLiteRawMessageManager, isSQLiteRawMessageStorageAvailable, lexicalSearchRawMessages, resolveSQLiteRawMessageDbPath };

package/dist/storage/sqlite-raw-message-store.js

@@ -56,7 +56,12 @@ async function closeSQLiteRawMessageManager() {
 function __resetSQLiteRawMessageManagerForTests() {
   manager = null;
 }
+async function lexicalSearchRawMessages(input) {
+  const mgr = await getSQLiteRawMessageManager();
+  if (typeof mgr.lexicalSearchMessages !== "function") {
+    return [];
+  }
+  return mgr.lexicalSearchMessages(input);
+}
 
-export { __resetSQLiteRawMessageManagerForTests, closeSQLiteRawMessageManager, getSQLiteRawMessageManager, isSQLiteRawMessageStorageAvailable, resolveSQLiteRawMessageDbPath };
-//# sourceMappingURL=sqlite-raw-message-store.js.map
-//# sourceMappingURL=sqlite-raw-message-store.js.map
+export { __resetSQLiteRawMessageManagerForTests, closeSQLiteRawMessageManager, getSQLiteRawMessageManager, isSQLiteRawMessageStorageAvailable, lexicalSearchRawMessages, resolveSQLiteRawMessageDbPath };