@memrosetta/core 0.2.20 → 0.2.22

package/dist/index.d.ts

@@ -44,6 +44,8 @@ interface MemoryRow {
     readonly access_count: number | null;
     readonly last_accessed_at: string | null;
     readonly compressed_from: string | null;
+    readonly use_count: number | null;
+    readonly success_count: number | null;
 }
 declare function rowToMemory(row: MemoryRow): Memory;
 declare function serializeEmbedding(embedding: readonly number[] | Float32Array): Buffer;
@@ -167,6 +169,17 @@ declare function rrfMergeWeighted(ftsResults: readonly {
     readonly memory: Memory;
     readonly rank: number;
 }[], k?: number, limit?: number, ftsWeight?: number, vecWeight?: number): readonly SearchResult[];
+/**
+ * Score-level fusion: alpha * normalizedVecSim + (1 - alpha) * normalizedFtsSim.
+ *
+ * Unlike RRF (which discards score magnitude), this preserves score information.
+ * Both FTS and vector scores are min-max normalized within the result set so
+ * neither modality dominates due to scale differences.
+ *
+ * Items found by both sources get the combined score (strongest signal).
+ * Items found by only one source get at most alpha or (1-alpha) of max.
+ */
+declare function convexCombinationMerge(ftsResults: readonly SearchResult[], vecResults: readonly VectorSearchResult[], alpha?: number, limit?: number): readonly SearchResult[];
 /**
  * Generative Agents-inspired 3-factor reranking.
  * final_score = w_recency * recency + w_importance * importance + w_relevance * relevance
@@ -207,7 +220,7 @@ declare function updateAccessTracking(db: Database.Database, memoryIds: readonly
  *
  * When queryVec is not provided, performs FTS-only search (backward compatible).
  * When queryVec is provided, performs hybrid search combining FTS + vector
- * results via Reciprocal Rank Fusion.
+ * results via convex combination score fusion.
  *
  * Results are weighted by activation score and access tracking is updated.
  */
@@ -242,6 +255,7 @@ declare class SqliteMemoryEngine implements IMemoryEngine {
     compress(userId: string): Promise<CompressResult>;
     maintain(userId: string): Promise<MaintenanceResult>;
     setTier(memoryId: string, tier: MemoryTier): Promise<void>;
+    feedback(memoryId: string, helpful: boolean): Promise<void>;
     quality(userId: string): Promise<MemoryQuality>;
     /**
      * Check the newly stored memory against existing similar memories
@@ -328,4 +342,4 @@ declare function determineTier(memory: {
  */
 declare function estimateTokens(content: string): number;
 
-export { DEFAULT_TIER_CONFIG, type MemoryRow, type PreparedStatements, type RelationStatements, type SchemaOptions, type SearchSqlResult, type SqliteEngineOptions, SqliteMemoryEngine, type VectorSearchResult, applyKeywordBoost, applyThreeFactorReranking, bruteForceVectorSearch, buildFtsQuery, buildSearchSql, computeActivation, computeEbbinghaus, createEngine, createPreparedStatements, createRelation, createRelationStatements, deduplicateResults, deriveMemoryState, determineTier, ensureSchema, estimateTokens, extractQueryTokens, ftsSearch, generateMemoryId, getRelationsByMemory, keywordsToString, normalizeScores, nowIso, rowToMemory, rrfMerge, rrfMergeWeighted, searchMemories, serializeEmbedding, storeBatchAsync, storeBatchInTransaction, storeMemory, storeMemoryAsync, stringToKeywords, updateAccessTracking, vectorSearch };
+export { DEFAULT_TIER_CONFIG, type MemoryRow, type PreparedStatements, type RelationStatements, type SchemaOptions, type SearchSqlResult, type SqliteEngineOptions, SqliteMemoryEngine, type VectorSearchResult, applyKeywordBoost, applyThreeFactorReranking, bruteForceVectorSearch, buildFtsQuery, buildSearchSql, computeActivation, computeEbbinghaus, convexCombinationMerge, createEngine, createPreparedStatements, createRelation, createRelationStatements, deduplicateResults, deriveMemoryState, determineTier, ensureSchema, estimateTokens, extractQueryTokens, ftsSearch, generateMemoryId, getRelationsByMemory, keywordsToString, normalizeScores, nowIso, rowToMemory, rrfMerge, rrfMergeWeighted, searchMemories, serializeEmbedding, storeBatchAsync, storeBatchInTransaction, storeMemory, storeMemoryAsync, stringToKeywords, updateAccessTracking, vectorSearch };

package/dist/index.js

@@ -24,7 +24,9 @@ CREATE TABLE memories (
   activation_score REAL DEFAULT 1.0,
   access_count     INTEGER DEFAULT 0,
   last_accessed_at TEXT,
-  compressed_from  TEXT
+  compressed_from  TEXT,
+  use_count        INTEGER DEFAULT 0,
+  success_count    INTEGER DEFAULT 0
 );
 
 CREATE INDEX idx_memories_user_id ON memories(user_id);
@@ -72,6 +74,10 @@ CREATE TRIGGER memories_au AFTER UPDATE ON memories BEGIN
   INSERT INTO memories_fts(rowid, content, keywords) VALUES (new.id, new.content, new.keywords);
 END;
 `;
+var SCHEMA_V5 = `
+ALTER TABLE memories ADD COLUMN use_count INTEGER DEFAULT 0;
+ALTER TABLE memories ADD COLUMN success_count INTEGER DEFAULT 0;
+`;
 function schemaV2(dim) {
   return `CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0(embedding float[${dim}]);`;
 }
@@ -106,7 +112,7 @@ function ensureSchema(db, options) {
       db.exec(schemaV2(dim));
       version = 2;
     }
-    version = 4;
+    version = 5;
     db.prepare("INSERT INTO schema_version (version, embedding_dimension) VALUES (?, ?)").run(version, dim);
     return;
   }
@@ -132,6 +138,12 @@ function ensureSchema(db, options) {
     }
     db.prepare("UPDATE schema_version SET version = ?").run(4);
   }
+  if (currentVersion < 5) {
+    if (currentVersion >= 1) {
+      db.exec(SCHEMA_V5);
+    }
+    db.prepare("UPDATE schema_version SET version = ?").run(5);
+  }
   if (options?.vectorEnabled) {
     const hasVecTable = db.prepare(
       "SELECT name FROM sqlite_master WHERE type='table' AND name='vec_memories'"
@@ -213,7 +225,9 @@ function rowToMemory(row) {
     activationScore: row.activation_score ?? 1,
     accessCount: row.access_count ?? 0,
     ...row.last_accessed_at != null ? { lastAccessedAt: row.last_accessed_at } : {},
-    ...row.compressed_from != null ? { compressedFrom: row.compressed_from } : {}
+    ...row.compressed_from != null ? { compressedFrom: row.compressed_from } : {},
+    useCount: row.use_count ?? 0,
+    successCount: row.success_count ?? 0
   };
 }
 function deserializeEmbedding(buf) {
@@ -229,8 +243,8 @@ function serializeEmbedding(embedding) {
 function createPreparedStatements(db) {
   return {
     insertMemory: db.prepare(`
-      INSERT INTO memories (memory_id, user_id, namespace, memory_type, content, raw_text, document_date, learned_at, source_id, confidence, salience, is_latest, embedding, keywords, event_date_start, event_date_end, invalidated_at, tier, activation_score, access_count, last_accessed_at, compressed_from)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO memories (memory_id, user_id, namespace, memory_type, content, raw_text, document_date, learned_at, source_id, confidence, salience, is_latest, embedding, keywords, event_date_start, event_date_end, invalidated_at, tier, activation_score, access_count, last_accessed_at, compressed_from, use_count, success_count)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `),
     getById: db.prepare("SELECT * FROM memories WHERE id = ?"),
     getByMemoryId: db.prepare("SELECT * FROM memories WHERE memory_id = ?"),
@@ -269,8 +283,12 @@ function storeMemory(db, stmts, input) {
     // access_count
     null,
     // last_accessed_at
-    null
+    null,
     // compressed_from
+    0,
+    // use_count
+    0
+    // success_count
   );
   const row = stmts.getByMemoryId.get(memoryId);
   return rowToMemory(row);
@@ -312,8 +330,12 @@ async function storeMemoryAsync(db, stmts, input, embedder) {
     // access_count
     null,
     // last_accessed_at
-    null
+    null,
     // compressed_from
+    0,
+    // use_count
+    0
+    // success_count
   );
   if (embeddingVec && info.lastInsertRowid) {
     const rowid = Number(info.lastInsertRowid);
@@ -379,8 +401,12 @@ async function storeBatchAsync(db, stmts, inputs, embedder) {
         // access_count
         null,
         // last_accessed_at
-        null
+        null,
         // compressed_from
+        0,
+        // use_count
+        0
+        // success_count
       );
       if (info.lastInsertRowid) {
         db.prepare("INSERT INTO vec_memories(rowid, embedding) VALUES (CAST(? AS INTEGER), ?)").run(
@@ -619,7 +645,7 @@ function buildSearchSql(query) {
       stateConditions.push("(m.is_latest = 1 AND m.invalidated_at IS NULL)");
     }
     if (filters.states.includes("superseded")) {
-      stateConditions.push("(m.is_latest = 0)");
+      stateConditions.push("(m.is_latest = 0 AND m.invalidated_at IS NULL)");
     }
     if (filters.states.includes("invalidated")) {
       stateConditions.push("(m.invalidated_at IS NOT NULL)");
@@ -703,7 +729,7 @@ function bruteForceVectorSearch(db, queryVec, userId, limit, filters) {
       stateConditions.push("(is_latest = 1 AND invalidated_at IS NULL)");
     }
     if (filters.states.includes("superseded")) {
-      stateConditions.push("(is_latest = 0)");
+      stateConditions.push("(is_latest = 0 AND invalidated_at IS NULL)");
     }
     if (filters.states.includes("invalidated")) {
       stateConditions.push("(invalidated_at IS NOT NULL)");
@@ -791,7 +817,7 @@ function vectorSearch(db, queryVec, userId, limit, filters, useVecTable = true)
       stateConditions.push("(is_latest = 1 AND invalidated_at IS NULL)");
     }
     if (filters.states.includes("superseded")) {
-      stateConditions.push("(is_latest = 0)");
+      stateConditions.push("(is_latest = 0 AND invalidated_at IS NULL)");
     }
     if (filters.states.includes("invalidated")) {
       stateConditions.push("(invalidated_at IS NOT NULL)");
@@ -908,6 +934,42 @@ function rrfMergeWeighted(ftsResults, vecResults, k = 20, limit = 10, ftsWeight
     matchType: "hybrid"
   }));
 }
+function convexCombinationMerge(ftsResults, vecResults, alpha = 0.5, limit = 10) {
+  const vecSims = /* @__PURE__ */ new Map();
+  for (const vr of vecResults) {
+    vecSims.set(vr.memory.memoryId, {
+      sim: 1 - vr.distance,
+      memory: vr.memory
+    });
+  }
+  const vecValues = [...vecSims.values()].map((v) => v.sim);
+  const vecMin = vecValues.length > 0 ? Math.min(...vecValues) : 0;
+  const vecMax = vecValues.length > 0 ? Math.max(...vecValues) : 1;
+  const vecRange = vecMax - vecMin || 1;
+  const ftsValues = ftsResults.map((r) => r.score);
+  const ftsMin = ftsValues.length > 0 ? Math.min(...ftsValues) : 0;
+  const ftsMax = ftsValues.length > 0 ? Math.max(...ftsValues) : 1;
+  const ftsRange = ftsMax - ftsMin || 1;
+  const merged = /* @__PURE__ */ new Map();
+  for (const fr of ftsResults) {
+    const normFts = (fr.score - ftsMin) / ftsRange;
+    const vecEntry = vecSims.get(fr.memory.memoryId);
+    const normVec = vecEntry ? (vecEntry.sim - vecMin) / vecRange : 0;
+    const score = alpha * normVec + (1 - alpha) * normFts;
+    merged.set(fr.memory.memoryId, { score, memory: fr.memory });
+  }
+  for (const [id, entry] of vecSims) {
+    if (merged.has(id)) continue;
+    const normVec = (entry.sim - vecMin) / vecRange;
+    const score = alpha * normVec;
+    merged.set(id, { score, memory: entry.memory });
+  }
+  return [...merged.values()].sort((a, b) => b.score - a.score).slice(0, limit).map(({ score, memory }) => ({
+    memory,
+    score,
+    matchType: "hybrid"
+  }));
+}
 function cosineSimilarity(a, b) {
   let dot = 0;
   let normA = 0;
@@ -1046,34 +1108,10 @@ function searchMemories(db, query, queryVec, useVecTable = true, skipAccessTrack
     finalResults = deduplicateResults(boosted);
   } else {
     const limit = query.limit ?? DEFAULT_LIMIT;
-    const ftsHasEnough = ftsResults.length >= limit;
-    if (ftsHasEnough) {
-      const vecIds = new Set(vecResults.map((r) => r.memory.memoryId));
-      const reranked = ftsResults.map((r) => ({
-        ...r,
-        score: r.score * (vecIds.has(r.memory.memoryId) ? 1.3 : 1)
-      }));
-      reranked.sort((a, b) => b.score - a.score);
-      const weighted = applyThreeFactorReranking(reranked);
-      const boosted = applyKeywordBoost(weighted, queryTokens);
-      finalResults = deduplicateResults(boosted);
-    } else {
-      const ftsIds = new Set(ftsResults.map((r) => r.memory.memoryId));
-      const ftsItems = [...ftsResults];
-      for (const vr of vecResults) {
-        if (ftsItems.length >= limit) break;
-        if (ftsIds.has(vr.memory.memoryId)) continue;
-        ftsItems.push({
-          memory: vr.memory,
-          score: (1 - vr.distance) * 0.5,
-          // Lower score than FTS items
-          matchType: "hybrid"
-        });
-      }
-      const weighted = applyThreeFactorReranking(ftsItems);
-      const boosted = applyKeywordBoost(weighted, queryTokens);
-      finalResults = deduplicateResults(boosted);
-    }
+    const merged = convexCombinationMerge(ftsResults, vecResults, 0.3, limit);
+    const weighted = applyThreeFactorReranking(merged);
+    const boosted = applyKeywordBoost(weighted, queryTokens);
+    finalResults = deduplicateResults(boosted);
   }
   updateAccessTracking(db, finalResults.map((r) => r.memory.memoryId));
   return {
@@ -1209,10 +1247,22 @@ var SqliteMemoryEngine = class {
     } else {
       memories = storeBatchInTransaction(this.db, this.stmts, inputs);
     }
-    if (this.options.contradictionDetector && this.options.embedder && memories.length <= 50) {
+    if (memories.length <= 50) {
       for (const memory of memories) {
+        if (this.options.embedder && this.options.contradictionDetector) {
+          try {
+            await this.checkContradictions(memory);
+          } catch {
+          }
+        }
+        if (this.options.embedder) {
+          try {
+            await this.checkDuplicates(memory);
+          } catch {
+          }
+        }
         try {
-          await this.checkContradictions(memory);
+          await this.autoRelate(memory);
         } catch {
         }
       }
@@ -1338,6 +1388,7 @@ var SqliteMemoryEngine = class {
     const coldMemories = db.prepare(`
       SELECT * FROM memories
       WHERE user_id = ? AND tier = 'cold' AND activation_score < 0.1 AND is_latest = 1
+      AND invalidated_at IS NULL
       ORDER BY namespace, learned_at
     `).all(userId);
     if (coldMemories.length === 0) return { compressed: 0, removed: 0 };
@@ -1398,8 +1449,12 @@ var SqliteMemoryEngine = class {
           // access_count
           null,
           // last_accessed_at
-          rows[0].memory_id
+          rows[0].memory_id,
           // compressed_from
+          0,
+          // use_count
+          0
+          // success_count
         );
         compressed++;
         for (const row of rows) {
@@ -1467,6 +1522,29 @@ var SqliteMemoryEngine = class {
     this.ensureInitialized();
     this.db.prepare("UPDATE memories SET tier = ? WHERE memory_id = ?").run(tier, memoryId);
   }
+  async feedback(memoryId, helpful) {
+    this.ensureInitialized();
+    const db = this.db;
+    db.transaction(() => {
+      if (helpful) {
+        db.prepare(
+          "UPDATE memories SET use_count = use_count + 1, success_count = success_count + 1 WHERE memory_id = ?"
+        ).run(memoryId);
+      } else {
+        db.prepare(
+          "UPDATE memories SET use_count = use_count + 1 WHERE memory_id = ?"
+        ).run(memoryId);
+      }
+      const row = db.prepare(
+        "SELECT salience, use_count, success_count FROM memories WHERE memory_id = ?"
+      ).get(memoryId);
+      if (row && row.use_count > 0) {
+        const successRate = row.success_count / row.use_count;
+        const newSalience = Math.min(1, Math.max(0.1, 0.5 + 0.5 * successRate));
+        db.prepare("UPDATE memories SET salience = ? WHERE memory_id = ?").run(newSalience, memoryId);
+      }
+    })();
+  }
   async quality(userId) {
     this.ensureInitialized();
     const db = this.db;
@@ -1656,6 +1734,7 @@ export {
   buildSearchSql,
   computeActivation,
   computeEbbinghaus,
+  convexCombinationMerge,
   createEngine,
   createPreparedStatements,
   createRelation,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memrosetta/core",
-  "version": "0.2.20",
+  "version": "0.2.22",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,10 +20,10 @@
     "better-sqlite3": "^11.0.0",
     "nanoid": "^5.0.0",
     "sqlite-vec": "^0.1.7",
-    "@memrosetta/types": "0.2.20"
+    "@memrosetta/types": "0.2.21"
   },
   "optionalDependencies": {
-    "@memrosetta/embeddings": "0.2.20"
+    "@memrosetta/embeddings": "0.2.21"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.0",