memories-lite 0.10.1 → 0.99.1

package/src/memory/index.ts

@@ -16,10 +16,8 @@ import {
   HistoryManagerFactory,
 } from "../utils/factory";
 import {
-  FactRetrievalSchema_extended,
-  getFactRetrievalMessages,
-  getUpdateMemoryMessages,
-  MemoryUpdateSchema,
+  DiscussionSynthesisSchema,
+  getDiscussionSynthesisMessages,
   removeCodeBlocks,
 } from "../prompts";
 import { DummyHistoryManager } from "../storage/DummyHistoryManager";
@@ -152,180 +150,98 @@ export class MemoriesLite {
   }
 
 
+  /**
+   * Capture une discussion et génère une synthèse (title + summary)
+   * Utilise getDiscussionSynthesisMessages pour produire la synthèse
+   */
   private async addToVectorStore(
     messages: Message[],
     metadata: Record<string, any>,
     userId: string,
     filters: SearchFilters,
-    customFacts?: string,
+    capturePrompt?: string,
   ): Promise<MemoryItem[]> {
 
     const $t = this.$t;
     const vectorStore = await this.getVectorStore(userId);
-    const parsedMessages = messages.filter((m) => typeof m.content === 'string' && m.role=='user').map((m) => `${m.role=='user' ? '**USER**: ' : '**ASSISTANT**: '}${$t(m.content as string)}\n`).join("\n");
-
-    // Disinterest handling is delegated to the LLM via prompt guidelines
+    
+    //
+    // Formater les messages pour la synthèse
+    const parsedMessages = messages
+      .filter((m) => typeof m.content === 'string')
+      .map((m) => `**${m.role.toUpperCase()}**: ${$t(m.content as string)}`)
+      .join("\n\n");
 
-    const [systemPrompt, userPrompt] = getFactRetrievalMessages(parsedMessages, customFacts||this.customPrompt);
+    //
+    // Générer la synthèse via LLM
+    const [systemPrompt, userPrompt] = getDiscussionSynthesisMessages(
+      parsedMessages, 
+      capturePrompt || this.customPrompt
+    );
 
     const response = await this.llm.generateResponse(
       [
         { role: "system", content: systemPrompt },
         { role: "user", content: userPrompt },
       ],
-      {...zodResponseFormat(FactRetrievalSchema_extended,"FactRetrieval")},[],false
+      { ...zodResponseFormat(DiscussionSynthesisSchema, "DiscussionSynthesis") },
+      [],
+      false
     );
-    const parsedResponse = (response:any) => {
+
+    //
+    // Parser la réponse
+    const parsedResponse = (res: any) => {
       try {
-        // structured output
-        if(typeof response === 'object') {
-          return response;
+        if (typeof res === 'object') {
+          return res;
         }
-        const cleanResponse = removeCodeBlocks(response as string);
+        const cleanResponse = removeCodeBlocks(res as string);
         return JSON.parse(cleanResponse);
       } catch (e) {
-        console.error(
-          "Failed to parse facts from LLM response:",
-          response,
-          e,
-          response
-        );
-        return [];
+        console.error("Failed to parse synthesis from LLM response:", res, e);
+        return { title: "Sans titre", summary: "" };
       }
-    }
-    // 
-    // can use native structured output
-    // Drop factual facts at capture level (do not store factual memories)
-    // FIXME Drop factual should be done at prompt level
-    const facts = parsedResponse(response).facts?.filter((f:any) => !f.existing )||[];
+    };
 
-    // console.log("-- DBG extract:", userPrompt);
-    // console.log("-- DBG facts:", facts);
+    const { title, summary } = parsedResponse(response);
 
-    // Get embeddings for new facts
-    const newMessageEmbeddings: Record<string, number[]> = {};
-    const retrievedOldMemory: Array<{ id: string; text: string; type: string }> = [];
+    if (!summary) {
+      console.warn("-- ⚠️ Empty summary from LLM, skipping memory creation");
+      return [];
+    }
 
     //
-    // add the userId to the filters
-    filters.userId = userId;
-    // Create embeddings and search for similar memories
-    for (const elem of facts) {
-      const fact = elem.fact;
-      const embedding = await this.embedder.embed(fact);
-      newMessageEmbeddings[fact] = embedding;
-
-      const existingMemories = await vectorStore.search(
-        embedding,
-        5,
-        filters,
-      );
-      for (const mem of existingMemories) {
-        retrievedOldMemory.push({ id: mem.id, text: mem.payload.data,type: mem.payload.type });
-      }
-    }
+    // Créer l'embedding sur le summary (pour recherche sémantique)
+    const embedding = await this.embedder.embed(summary);
 
-    // console.log("-- DBG old memories:", retrievedOldMemory);
-    // Remove duplicates from old memories
-    const uniqueOldMemories = retrievedOldMemory.filter(
-      (mem, index) =>
-        retrievedOldMemory.findIndex((m) => m.id === mem.id) === index,
-    );
+    //
+    // Préparer les métadonnées
+    const memoryType: MemoryType = metadata.type || 'discussion';
+    const memoryMetadata = {
+      ...metadata,
+      title,
+      type: memoryType,
+      userId,
+    };
 
-    // Create UUID mapping for handling UUID hallucinations
-    const tempUuidMapping: Record<string, string> = {};
-    uniqueOldMemories.forEach((item, idx) => {
-      tempUuidMapping[String(idx)] = item.id;
-      uniqueOldMemories[idx].id = String(idx);
-    });
-
-    // Get memory update decisions
-    const lastUserMessage = [...messages].reverse().find(m => m.role === 'user');
-    const userInstruction = typeof lastUserMessage?.content === 'string' ? lastUserMessage?.content as string : '';
-    const updatePrompt = getUpdateMemoryMessages(uniqueOldMemories, facts, 'French', userInstruction);
-
-    // console.log("-- DBG updatePrompt:", updatePrompt);
-    const updateResponse = await this.llm.generateResponse(
-      [{ role: "user", content: updatePrompt }],
-      {...zodResponseFormat(MemoryUpdateSchema,"Memory")},[],false,
+    //
+    // Stocker la mémoire
+    const memoryId = await this.createMemory(
+      summary,
+      { [summary]: embedding },
+      memoryMetadata,
+      userId,
     );
-    // console.log("-- DBG merge:", updatePrompt);
 
-    const memoryActions: any[] = parsedResponse(updateResponse).memory || [];
+    console.log(`-- 🧠 Memory created: "${title}" (${memoryType})`);
 
-    // Process memory actions
-    const results: MemoryItem[] = [];
-    for (const action of memoryActions) {
-      // Ignore any factual memory actions (ADD/UPDATE/DELETE) → void
-      if(action.type === 'factual') {
-        continue;
-      }
-      if(action.reason === "undefined") {
-        console.log(`-- ⛔ LLM Error: ${action.event}, ${action.type}, "${action.text}"`);
-        continue;
-      }
-      console.log(`-- DBG memory "${userId}": ${action.event}, ${action.type}, "${action.text}", why: "${action.reason}"`);
-      try {
-        switch (action.event) {
-          case "ADD": {
-            if(!action.type) {
-              // log error
-              console.error("Type is mandatory to manage memories:", action);
-              continue;
-            }
-            metadata.type = action.type;
-            const memoryId = await this.createMemory(
-              action.text,
-              newMessageEmbeddings,
-              metadata,
-              userId,
-            );
-            results.push({
-              id: memoryId,
-              memory: action.text,
-              type: action.type,
-              metadata: { event: action.event },
-            });
-            break;
-          }
-          case "UPDATE": {
-            const realMemoryId = tempUuidMapping[action.id];
-            const type = metadata.type = uniqueOldMemories[action.id].type || action.type;
-            await this.updateMemory(
-              realMemoryId,
-              action.text,
-              newMessageEmbeddings,
-              metadata,
-              userId,
-            );
-            results.push({
-              id: realMemoryId,
-              memory: action.text,
-              type,
-              metadata: {
-                event: action.event,
-                previousMemory: action.old_memory,
-              },
-            });
-            break;
-          }
-          case "DELETE": {
-            const realMemoryId = tempUuidMapping[action.id];
-            await this.deleteMemory(realMemoryId, userId);
-            results.push({
-              id: realMemoryId,
-              memory: action.text,
-              type: action.type,
-              metadata: { event: action.event },
-            });
-            break;
-          }
-        }
-      } catch (error) {
-        console.error(`Error processing memory action: ${error}`);
-      }
-    }
-    return results;
+    return [{
+      id: memoryId,
+      memory: summary,
+      type: memoryType,
+      metadata: { title, event: "ADD" },
+    }];
   }  
 
   static fromConfig(configDict: Record<string, any>): MemoriesLite {
@@ -342,24 +258,24 @@ export class MemoriesLite {
     return LiteVectorStore.from(userId, this.vectorStoreConfig);
   }
 
+  /**
+   * Capture une discussion et génère une mémoire (title + summary)
+   * 
+   * @param messages - Messages de la discussion ou texte brut
+   * @param userId - ID utilisateur
+   * @param config - Options incluant capturePrompt pour personnaliser la synthèse
+   */
   async capture(
     messages: string | Message[],
     userId: string,
     config: AddMemoryOptions,
   ): Promise<SearchResult> {
-    // await this._captureEvent("add", {
-    //   message_count: Array.isArray(messages) ? messages.length : 1,
-    //   has_metadata: !!config.metadata,
-    //   has_filters: !!config.filters,
-    //   infer: config.infer,
-    // });
     const {
       agentId,
       runId,
       metadata = {},
       filters = {},
-      infer = true,
-      customFacts
+      capturePrompt
     } = config;
 
     if (agentId) filters.agentId = metadata.agentId = agentId;
@@ -377,16 +293,18 @@ export class MemoriesLite {
 
     const final_parsedMessages = await parse_vision_messages(parsedMessages);
 
-    // Add to vector store
+    //
+    // Générer synthèse et stocker
     const vectorStoreResult = await this.addToVectorStore(
       final_parsedMessages,
       metadata,
       userId,
       filters,
-      customFacts,
+      capturePrompt,
     );
 
-    // Add to graph store if available
+    //
+    // Graph store (si configuré)
     let graphResult;
     if (this.graphMemory) {
       try {

package/src/memory/memory.types.ts

@@ -10,8 +10,7 @@ export interface Entity {
 export interface AddMemoryOptions extends Entity {
   metadata?: Record<string, any>;
   filters?: SearchFilters;
-  customFacts?: string;
-  infer?: boolean;
+  capturePrompt?: string;
 }
 
 export interface SearchMemoryOptions extends Entity {

package/src/prompts/index.ts

@@ -1,36 +1,83 @@
 import { z } from "zod";
 import { MemoryItem } from "../types";
 
-// Define Zod schema for fact retrieval output
+// ══════════════════════════════════════════════════════════════════════════════
+// DISCUSSION SYNTHESIS - Nouveau système de mémoire
+// ══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Schema pour la synthèse de discussion
+ * Produit un titre court et une synthèse opérationnelle
+ */
+export const DiscussionSynthesisSchema = z.object({
+  title: z.string().describe("Titre court et descriptif (6-10 mots)"),
+  summary: z.string().describe("Synthèse opérationnelle des points clés (50-100 mots)")
+});
+
+/**
+ * Prompt par défaut pour la synthèse de discussion
+ * Peut être remplacé via capturePrompt dans AddMemoryOptions
+ */
+export const DEFAULT_DISCUSSION_PROMPT = `Tu es un expert en synthèse opérationnelle.
+
+À partir de cette discussion, génère :
+1. TITRE: Un titre court et descriptif (6-10 mots) qui capture l'essence de la demande
+2. SUMMARY: Les points clés du chemin de résolution (50-100 mots)
+
+Cette synthèse servira à retrouver et réappliquer ce pattern de résolution similaire.
+Utilise la même langue que la discussion.
+
+Discussion à synthétiser:
+`;
+
+/**
+ * Génère les messages pour la synthèse de discussion
+ * @param discussion - Contenu de la discussion formatée
+ * @param capturePrompt - Prompt custom optionnel (remplace DEFAULT_DISCUSSION_PROMPT)
+ * @returns [systemPrompt, userPrompt]
+ */
+export function getDiscussionSynthesisMessages(
+  discussion: string,
+  capturePrompt?: string
+): [string, string] {
+  const systemPrompt = capturePrompt || DEFAULT_DISCUSSION_PROMPT;
+  return [systemPrompt, discussion];
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// @deprecated - Ancien système de capture (todo, factual)
+// Ces exports sont conservés pour compatibilité mais ne doivent plus être utilisés
+// ══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @deprecated Use DiscussionSynthesisSchema instead
+ */
 export const FactRetrievalSchema_simple = z.object({
   facts: z
     .array(z.string())
     .describe("An array of distinct facts extracted from the conversation."),
 });
 
-
-//1. **Factual memory** – stable facts & preferences about the user
-//2. **Todo memory** – explicit user tasks to remember
-//3. **Assistant preference memory** – how the user wants the AI to behave
-//
+/**
+ * @deprecated Use DiscussionSynthesisSchema instead
+ * Types todo et factual supprimés - seul assistant_preference reste pour compatibilité
+ */
 export const FactRetrievalSchema_extended = z.object({
   facts: z
   .array(
     z.object({
       fact: z.string().describe("The fact extracted from the conversation."),
       existing: z.boolean().describe("Whether the fact is already present"),
-      type: z.enum(["assistant_preference","factual","todo"])
-      .describe(`The type of the fact.
-        Use 'assistant_preference' for Assistant behavior preferences (style/language/constraints/commands).
-        Use 'factual' for stable user facts (identity, preferences, beliefs, work context).
-        Use 'todo' ONLY if the user explicitly asks to save/keep as a todo (e.g., « garde/enregistre en todo », « ajoute un todo »). Do not infer todos.
-        `),
+      type: z.enum(["assistant_preference"])
+      .describe(`The type of the fact. Only 'assistant_preference' is supported.`),
     })
   )
 });
 
 
-// Define Zod schema for memory update output
+/**
+ * @deprecated Memory updates are disabled - use capture() for new memories
+ */
 export const MemoryUpdateSchema = z.object({
   memory: z
     .array(
@@ -54,21 +101,14 @@ export const MemoryUpdateSchema = z.object({
             "The reason why you selected this event.",
           ),
         type: z
-          .enum(["factual", "todo", "assistant_preference"])
-          .describe("Type of the memory. Use 'assistant_preference' for Assistant behavior preferences, 'factual' for user facts, 'todo' for explicit tasks."),
+          .enum(["assistant_preference"])
+          .describe("Type of the memory. Only 'assistant_preference' is supported."),
       }),
     )
     .describe(
       "An array representing the state of memory items after processing new facts.",
     ),
 });
-/**
- * Practical Application:
- * 
- * If the task is "factual" (e.g., "Where do I live?", "What's my job?") → retrieve factual memory.
- * If the task is about assistant behavior (e.g., "How should I respond?") → retrieve assistant_preference memory.
- * If the task is a user task/reminder (e.g., "Add a reminder to call the bank tomorrow") → retrieve todo memory.
- */
 export const MEMORY_STRING_SYSTEM = `# DIRECTIVES FOR MEMORIES
 - Information stored in memory is always enclosed within the <memories> tag.
 - Prioritize the latest user message over memories (the user's current question is authoritative).
@@ -80,10 +120,10 @@ export const MEMORY_STRING_SYSTEM = `# DIRECTIVES FOR MEMORIES
 
 export const MEMORY_STRING_PREFIX = "Use these contextual memories to guide your response. Prioritize the user's question. Ignore irrelevant memories."
 
-
-// Deprecated: getFactRetrievalMessages_O removed in favor of getFactRetrievalMessages
-
-
+/**
+ * @deprecated Use getDiscussionSynthesisMessages instead
+ * Cette fonction est conservée pour compatibilité avec l'ancien système
+ */
 export function getFactRetrievalMessages(
   parsedMessages: string, 
   customRules: string = "",
@@ -132,6 +172,9 @@ Remember the following:
   return [systemPrompt, userPrompt];
 }
 
+/**
+ * @deprecated Memory updates are disabled by config
+ */
 export function getUpdateMemoryMessages(
   retrievedOldMemory: Array<{ id: string; text: string }>,
   newRetrievedFacts: any[],

package/src/types/index.ts

@@ -72,9 +72,8 @@ export interface MemoryTypeConfig {
 }
 
 export interface MemoryScoringConfig {
-  todo: MemoryTypeConfig;
-  factual: MemoryTypeConfig;
   assistant_preference: MemoryTypeConfig;
+  discussion: MemoryTypeConfig;
   default: MemoryTypeConfig; // Fallback if type is missing or unknown
 }
 
@@ -101,7 +100,7 @@ export interface MemoryConfig {
   enableGraph?: boolean;
 }
 
-export type MemoryType = 'todo' | 'factual' | 'assistant_preference';
+export type MemoryType = 'assistant_preference' | 'discussion';
 
 export interface MemoryItem {
   id: string;
@@ -162,19 +161,13 @@ export const MemoryConfigSchema = z.object({
         dimension: z.number().optional(),
         client: z.any().optional(),
         scoring: z.object({
-          todo: z.object({
-            alpha: z.number(),
-            beta: z.number(),
-            gamma: z.number(),
-            halfLifeDays: z.number(),
-          }),
-          factual: z.object({
+          assistant_preference: z.object({
             alpha: z.number(),
             beta: z.number(),
             gamma: z.number(),
             halfLifeDays: z.number(),
           }),
-          assistant_preference: z.object({
+          discussion: z.object({
             alpha: z.number(),
             beta: z.number(),
             gamma: z.number(),

package/tests/lite.spec.ts

@@ -25,6 +25,10 @@ jest.mock('sqlite3', () => {
 });
 
 
+/**
+ * Tests for LiteVectorStore private methods
+ * Updated to use new memory types: assistant_preference and discussion
+ */
 describe('LiteVectorStore Private Methods', () => {
   let store: LiteVectorStore;
   const userId = 'test-user';
@@ -98,59 +102,65 @@ describe('LiteVectorStore Private Methods', () => {
     const veryOldDate = new Date(now.getTime() - 400 * 24 * 60 * 60 * 1000).toISOString();
     const scoring = DEFAULT_MEMORY_CONFIG.vectorStore.config.scoring!;
 
-    it('should prioritize cosine similarity for factual memory (high alpha)', () => {
-      const payload: MemoryPayload = { memoryId: 'mem-f1', userId: userId, type: 'factual', createdAt: twoDaysAgo };
+    it('should prioritize cosine similarity for assistant_preference (high alpha)', () => {
+      //
+      // assistant_preference: { alpha: 0.60, beta: 0.05, gamma: 0.35, halfLifeDays: Infinity }
+      const payload: MemoryPayload = { memoryId: 'mem-ap1', userId: userId, type: 'assistant_preference', createdAt: twoDaysAgo };
       const cosineScore = 0.9;
-      const expectedRecency = (store as any).calculateRecencyScore(twoDaysAgo, scoring.factual.halfLifeDays);
-      const expectedScore = scoring.factual.alpha * cosineScore + scoring.factual.beta * expectedRecency + scoring.factual.gamma;
+      const expectedRecency = 1.0; // Infinity halfLife → recency = 1
+      const expectedScore = scoring.assistant_preference.alpha * cosineScore + scoring.assistant_preference.beta * expectedRecency + scoring.assistant_preference.gamma;
       const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
       expect(hybridScore).toBeCloseTo(expectedScore, 5);
-      expect(scoring.factual.alpha * cosineScore).toBeGreaterThan(scoring.factual.beta * expectedRecency);
+      // alpha * cosine (0.54) > beta * recency (0.05)
+      expect(scoring.assistant_preference.alpha * cosineScore).toBeGreaterThan(scoring.assistant_preference.beta * expectedRecency);
     });
 
-    it('should prioritize recency for episodic memory (high beta, short half-life)', () => {
-      const payload: MemoryPayload = { memoryId: 'mem-e1', userId: userId, type: 'episodic', createdAt: twoDaysAgo };
+    it('should return constant score for discussion (beta=1, alpha=0, gamma=0)', () => {
+      //
+      // discussion: { alpha: 0, beta: 1, gamma: 0, halfLifeDays: Infinity }
+      // Score = 0 * cosine + 1 * recency + 0 = 1 (constant)
+      const payload: MemoryPayload = { memoryId: 'mem-d1', userId: userId, type: 'discussion', createdAt: twoDaysAgo };
       const cosineScore = 0.5;
-      const expectedRecency = (store as any).calculateRecencyScore(twoDaysAgo, scoring.episodic.halfLifeDays);
-      const expectedScore = scoring.episodic.alpha * cosineScore + scoring.episodic.beta * expectedRecency + scoring.episodic.gamma;
+      const expectedRecency = 1.0; // Infinity halfLife → recency = 1
+      const expectedScore = scoring.discussion.alpha * cosineScore + scoring.discussion.beta * expectedRecency + scoring.discussion.gamma;
       const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
       expect(hybridScore).toBeCloseTo(expectedScore, 5);
-      expect(scoring.episodic.beta * expectedRecency).toBeGreaterThan(0.2);
+      expect(hybridScore).toBe(1); // Score constant = 1
     });
 
-    it('should have low score for old episodic memory', () => {
-        const payload: MemoryPayload = { memoryId: 'mem-e2', userId: userId, type: 'episodic', createdAt: veryOldDate };
-        const cosineScore = 0.9;
-        const expectedRecency = (store as any).calculateRecencyScore(veryOldDate, scoring.episodic.halfLifeDays);
-        const expectedScore = scoring.episodic.alpha * cosineScore + scoring.episodic.beta * expectedRecency + scoring.episodic.gamma;
-        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-        expect(expectedRecency).toBeLessThan(0.01);
-        expect(hybridScore).toBeCloseTo(scoring.episodic.alpha * cosineScore + scoring.episodic.gamma, 5);
+    it('should have constant score for old discussion memory (no decay)', () => {
+      //
+      // discussion with Infinity halfLife → old memories have same score as new
+      const payload: MemoryPayload = { memoryId: 'mem-d2', userId: userId, type: 'discussion', createdAt: veryOldDate };
+      const cosineScore = 0.9;
+      const expectedRecency = 1.0; // Infinity halfLife → recency = 1 even for old dates
+      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+      expect(hybridScore).toBe(1); // Score constant = 1
     });
 
     it('should handle assistant_preference with no decay (Infinity half-life)', () => {
-        const payload: MemoryPayload = { memoryId: 'mem-a1', userId: userId, type: 'assistant_preference', createdAt: veryOldDate };
-        const cosineScore = 0.7;
-        const expectedRecency = 1.0;
-        const expectedScore = scoring.assistant_preference.alpha * cosineScore + scoring.assistant_preference.beta * expectedRecency + scoring.assistant_preference.gamma;
-        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-        expect(hybridScore).toBeCloseTo(expectedScore, 5);
+      const payload: MemoryPayload = { memoryId: 'mem-a1', userId: userId, type: 'assistant_preference', createdAt: veryOldDate };
+      const cosineScore = 0.7;
+      const expectedRecency = 1.0;
+      const expectedScore = scoring.assistant_preference.alpha * cosineScore + scoring.assistant_preference.beta * expectedRecency + scoring.assistant_preference.gamma;
+      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+      expect(hybridScore).toBeCloseTo(expectedScore, 5);
     });
 
     it('should use default scoring if type is missing', () => {
-        const payload: MemoryPayload = { memoryId: 'mem-d1', userId: userId, createdAt: sevenDaysAgo }; // No type specified
-        const cosineScore = 0.8;
-        const expectedRecency = (store as any).calculateRecencyScore(sevenDaysAgo, scoring.default.halfLifeDays);
-        const expectedScore = scoring.default.alpha * cosineScore + scoring.default.beta * expectedRecency + scoring.default.gamma;
-        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-        expect(hybridScore).toBeCloseTo(expectedScore, 5);
+      const payload: MemoryPayload = { memoryId: 'mem-def1', userId: userId, createdAt: sevenDaysAgo }; // No type specified
+      const cosineScore = 0.8;
+      const expectedRecency = (store as any).calculateRecencyScore(sevenDaysAgo, scoring.default.halfLifeDays);
+      const expectedScore = scoring.default.alpha * cosineScore + scoring.default.beta * expectedRecency + scoring.default.gamma;
+      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+      expect(hybridScore).toBeCloseTo(expectedScore, 5);
     });
 
     it('should return score >= 0 even with negative cosine similarity', () => {
-        const payload: MemoryPayload = { memoryId: 'mem-s1', userId: userId, type: 'factual', createdAt: twoDaysAgo };
-        const cosineScore = -0.5;
-        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-        expect(hybridScore).toBeGreaterThanOrEqual(0);
+      const payload: MemoryPayload = { memoryId: 'mem-neg1', userId: userId, type: 'assistant_preference', createdAt: twoDaysAgo };
+      const cosineScore = -0.5;
+      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+      expect(hybridScore).toBeGreaterThanOrEqual(0);
     });
 
   });