memories-lite 0.99.2 → 0.99.5

package/dist/memory/index.d.ts

@@ -33,7 +33,14 @@ export declare class MemoriesLite {
     capture(messages: string | Message[], userId: string, config: AddMemoryOptions): Promise<SearchResult>;
     get(memoryId: string, userId: string): Promise<MemoryItem | null>;
     retrieve(query: string, userId: string, config: SearchMemoryOptions): Promise<SearchResult>;
-    update(memoryId: string, data: string, userId: string): Promise<{
+    /**
+     * Met à jour une mémoire existante
+     * @param memoryId - ID de la mémoire
+     * @param data - Nouveau contenu
+     * @param userId - ID utilisateur
+     * @param metadata - Métadonnées optionnelles (peut inclure applyMode pour changer le mode)
+     */
+    update(memoryId: string, data: string, userId: string, metadata?: Record<string, any>): Promise<{
         message: string;
     }>;
     delete(memoryId: string, userId: string): Promise<{

package/dist/memory/index.js

@@ -132,11 +132,14 @@ class MemoriesLite {
         const embedding = await this.embedder.embed(title);
         //
         // Préparer les métadonnées
+        // applyMode par défaut = MEM_SMART (recherche sémantique)
         const memoryType = metadata.type || 'discussion';
+        const applyMode = metadata.applyMode || types_1.DEFAULT_MEMORY_APPLY_MODE;
         const memoryMetadata = {
             ...metadata,
             title,
             type: memoryType,
+            applyMode,
             userId,
         };
         //
@@ -203,6 +206,7 @@ class MemoriesLite {
             id: memory.id,
             memory: memory.payload.data,
             type: memory.payload.type,
+            applyMode: memory.payload.applyMode || types_1.DEFAULT_MEMORY_APPLY_MODE,
             hash: memory.payload.hash,
             createdAt: memory.payload.createdAt,
             updatedAt: memory.payload.updatedAt,
@@ -252,12 +256,21 @@ class MemoriesLite {
             "data",
             "createdAt",
             "updatedAt",
+            "applyMode",
         ]);
-        const results = memories.map((mem) => ({
+        //
+        // Filtrer uniquement les mémoires avec applyMode = MEM_SMART (recherche sémantique)
+        // Les MEM_ALWAYS et MEM_MANUAL ne sont pas retournées par retrieve()
+        const filteredMemories = memories.filter((mem) => {
+            const mode = mem.payload.applyMode || types_1.DEFAULT_MEMORY_APPLY_MODE;
+            return mode === 'MEM_SMART';
+        });
+        const results = filteredMemories.map((mem) => ({
             id: mem.id,
             memory: mem.payload.data,
             hash: mem.payload.hash,
             type: mem.payload.type,
+            applyMode: mem.payload.applyMode || types_1.DEFAULT_MEMORY_APPLY_MODE,
             createdAt: mem.payload.createdAt,
             updatedAt: mem.payload.updatedAt,
             score: mem.score,
@@ -271,10 +284,17 @@ class MemoriesLite {
             results,
         };
     }
-    async update(memoryId, data, userId) {
+    /**
+     * Met à jour une mémoire existante
+     * @param memoryId - ID de la mémoire
+     * @param data - Nouveau contenu
+     * @param userId - ID utilisateur
+     * @param metadata - Métadonnées optionnelles (peut inclure applyMode pour changer le mode)
+     */
+    async update(memoryId, data, userId, metadata = {}) {
         // await this._captureEvent("update", { memory_id: memoryId });
         const embedding = await this.embedder.embed(data);
-        await this.updateMemory(memoryId, data, { [data]: embedding }, {}, userId);
+        await this.updateMemory(memoryId, data, { [data]: embedding }, metadata, userId);
         return { message: "Memory updated successfully!" };
     }
     async delete(memoryId, userId) {
@@ -350,12 +370,14 @@ class MemoriesLite {
             "data",
             "createdAt",
             "updatedAt",
+            "applyMode",
         ]);
         const results = memories.map((mem) => ({
             id: mem.id,
             memory: mem.payload.data,
             hash: mem.payload.hash,
             type: mem.payload.type,
+            applyMode: mem.payload.applyMode || types_1.DEFAULT_MEMORY_APPLY_MODE,
             createdAt: mem.payload.createdAt,
             updatedAt: mem.payload.updatedAt,
             metadata: Object.entries(mem.payload)
@@ -388,20 +410,28 @@ class MemoriesLite {
             throw new Error(`Memory with ID ${memoryId} not found`);
         }
         const prevValue = existingMemory.payload.data;
+        const originalPayload = (existingMemory.payload ?? {});
         const embedding = existingEmbeddings[data] || (await this.embedder.embed(data));
+        //
+        // Preserve origin fields to avoid corrupting ownership/linkage (discussionId/userId/agentId).
+        // - title: keep original unless explicitly changed
+        // - applyMode: keep original unless explicitly changed
+        // - discussionId, userId, agentId/runId: always keep original
+        const title = (typeof metadata.title === "string" && metadata.title.trim())
+            ? metadata.title.trim()
+            : originalPayload.title;
+        //
+        // applyMode: si fourni dans metadata, on le prend, sinon on garde l'original ou le défaut
+        const applyMode = (metadata.applyMode && ['MEM_ALWAYS', 'MEM_SMART', 'MEM_MANUAL'].includes(metadata.applyMode))
+            ? metadata.applyMode
+            : (originalPayload.applyMode || types_1.DEFAULT_MEMORY_APPLY_MODE);
         const newMetadata = {
-            ...metadata,
+            ...originalPayload,
             data,
             hash: (0, crypto_1.createHash)("md5").update(data).digest("hex"),
-            type: existingMemory.payload.type,
-            createdAt: existingMemory.payload.createdAt,
             updatedAt: new Date().toISOString(),
-            ...(existingMemory.payload.agentId && {
-                agentId: existingMemory.payload.agentId,
-            }),
-            ...(existingMemory.payload.runId && {
-                runId: existingMemory.payload.runId,
-            }),
+            title: title,
+            applyMode,
         };
         await vectorStore.update(memoryId, embedding, newMetadata);
         await this.db.addHistory(memoryId, prevValue, data, "UPDATE", newMetadata.createdAt, newMetadata.updatedAt);

package/dist/types/index.d.ts

@@ -77,10 +77,24 @@ export interface MemoryConfig {
     capturePrompt?: string;
 }
 export type MemoryType = 'assistant_preference' | 'discussion';
+/**
+ * Mode d'application de la mémoire (inspiré de Cursor AI)
+ * Stocké dans metadata.applyMode avec préfixe MEM_* pour migration soft
+ *
+ * - MEM_ALWAYS: Toujours appliquer - la mémoire est toujours injectée dans le contexte
+ * - MEM_SMART: Appliquer intelligemment - utilisé pour la recherche sémantique (défaut)
+ * - MEM_MANUAL: Appliquer manuellement - la mémoire n'est jamais injectée automatiquement
+ */
+export type MemoryApplyMode = 'MEM_ALWAYS' | 'MEM_SMART' | 'MEM_MANUAL';
+/**
+ * Mode par défaut pour la capture
+ */
+export declare const DEFAULT_MEMORY_APPLY_MODE: MemoryApplyMode;
 export interface MemoryItem {
     id: string;
     memory: string;
     type: MemoryType;
+    applyMode?: MemoryApplyMode;
     event?: "ADD" | "UPDATE" | "DELETE" | "NONE";
     hash?: string;
     createdAt?: string;

package/dist/types/index.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryConfigSchema = void 0;
+exports.MemoryConfigSchema = exports.DEFAULT_MEMORY_APPLY_MODE = void 0;
 const zod_1 = require("zod");
+/**
+ * Mode par défaut pour la capture
+ */
+exports.DEFAULT_MEMORY_APPLY_MODE = 'MEM_SMART';
 exports.MemoryConfigSchema = zod_1.z.object({
     version: zod_1.z.string().optional(),
     embedder: zod_1.z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memories-lite",
-  "version": "0.99.2",
+  "version": "0.99.5",
   "description": "A lightweight memory system for LLM agents",
   "author": "olivier@evaletolab.ch",
   "main": "dist/index.js",

package/src/memory/index.ts

@@ -5,6 +5,8 @@ import {
   MemoryConfigSchema,
   MemoryItem,
   MemoryType,
+  MemoryApplyMode,
+  DEFAULT_MEMORY_APPLY_MODE,
   Message,
   SearchFilters,
   SearchResult,
@@ -208,11 +210,14 @@ export class MemoriesLite {
 
     //
     // Préparer les métadonnées
+    // applyMode par défaut = MEM_SMART (recherche sémantique)
     const memoryType: MemoryType = metadata.type || 'discussion';
+    const applyMode: MemoryApplyMode = metadata.applyMode || DEFAULT_MEMORY_APPLY_MODE;
     const memoryMetadata = {
       ...metadata,
       title,
       type: memoryType,
+      applyMode,
       userId,
     };
 
@@ -228,7 +233,7 @@ export class MemoriesLite {
     console.log(`-- 🧠 Memory created: "${title}" (${memoryType})`);
 
     return [{
-      id: memoryId,
+              id: memoryId,
       memory: summary,
       type: memoryType,
       metadata: { title, event: "ADD" },
@@ -292,7 +297,7 @@ export class MemoriesLite {
       userId,
       filters,
       capturePrompt,
-    );
+        );
 
     return {
       results: vectorStoreResult,
@@ -315,6 +320,7 @@ export class MemoriesLite {
       id: memory.id,
       memory: memory.payload.data,
       type: memory.payload.type,
+      applyMode: memory.payload.applyMode || DEFAULT_MEMORY_APPLY_MODE,
       hash: memory.payload.hash,
       createdAt: memory.payload.createdAt,
       updatedAt: memory.payload.updatedAt,
@@ -382,12 +388,23 @@ export class MemoriesLite {
       "data",
       "createdAt",
       "updatedAt",
+      "applyMode",
     ]);
-    const results = memories.map((mem) => ({
+
+    //
+    // Filtrer uniquement les mémoires avec applyMode = MEM_SMART (recherche sémantique)
+    // Les MEM_ALWAYS et MEM_MANUAL ne sont pas retournées par retrieve()
+    const filteredMemories = memories.filter((mem) => {
+      const mode = mem.payload.applyMode || DEFAULT_MEMORY_APPLY_MODE;
+      return mode === 'MEM_SMART';
+    });
+
+    const results = filteredMemories.map((mem) => ({
       id: mem.id,
       memory: mem.payload.data,
       hash: mem.payload.hash,
       type: mem.payload.type,
+      applyMode: mem.payload.applyMode || DEFAULT_MEMORY_APPLY_MODE,
       createdAt: mem.payload.createdAt,
       updatedAt: mem.payload.updatedAt,
       score: mem.score,
@@ -403,10 +420,22 @@ export class MemoriesLite {
     };
   }
 
-  async update(memoryId: string, data: string, userId: string): Promise<{ message: string }> {
+  /**
+   * Met à jour une mémoire existante
+   * @param memoryId - ID de la mémoire
+   * @param data - Nouveau contenu
+   * @param userId - ID utilisateur
+   * @param metadata - Métadonnées optionnelles (peut inclure applyMode pour changer le mode)
+   */
+  async update(
+    memoryId: string,
+    data: string,
+    userId: string,
+    metadata: Record<string, any> = {},
+  ): Promise<{ message: string }> {
     // await this._captureEvent("update", { memory_id: memoryId });
     const embedding = await this.embedder.embed(data);
-    await this.updateMemory(memoryId, data, { [data]: embedding }, {}, userId);
+    await this.updateMemory(memoryId, data, { [data]: embedding }, metadata, userId);
     return { message: "Memory updated successfully!" };
   }
 
@@ -501,12 +530,14 @@ export class MemoriesLite {
       "data",
       "createdAt",
       "updatedAt",
+      "applyMode",
     ]);
     const results = memories.map((mem) => ({
       id: mem.id,
       memory: mem.payload.data,
       hash: mem.payload.hash,
       type: mem.payload.type,
+      applyMode: mem.payload.applyMode || DEFAULT_MEMORY_APPLY_MODE,
       createdAt: mem.payload.createdAt,
       updatedAt: mem.payload.updatedAt,
       metadata: Object.entries(mem.payload)
@@ -564,22 +595,34 @@ export class MemoriesLite {
     }
 
     const prevValue = existingMemory.payload.data;
+    const originalPayload: Record<string, any> = (existingMemory.payload ?? {}) as Record<string, any>;
     const embedding =
       existingEmbeddings[data] || (await this.embedder.embed(data));
 
-    const newMetadata = {
-      ...metadata,
+    //
+    // Preserve origin fields to avoid corrupting ownership/linkage (discussionId/userId/agentId).
+    // - title: keep original unless explicitly changed
+    // - applyMode: keep original unless explicitly changed
+    // - discussionId, userId, agentId/runId: always keep original
+    const title =
+      (typeof metadata.title === "string" && metadata.title.trim())
+        ? metadata.title.trim()
+        : originalPayload.title;
+
+    //
+    // applyMode: si fourni dans metadata, on le prend, sinon on garde l'original ou le défaut
+    const applyMode: MemoryApplyMode =
+      (metadata.applyMode && ['MEM_ALWAYS', 'MEM_SMART', 'MEM_MANUAL'].includes(metadata.applyMode))
+        ? metadata.applyMode
+        : (originalPayload.applyMode || DEFAULT_MEMORY_APPLY_MODE);
+
+    const newMetadata: Record<string, any> = {
+      ...originalPayload,
       data,
       hash: createHash("md5").update(data).digest("hex"),
-      type: existingMemory.payload.type,
-      createdAt: existingMemory.payload.createdAt,
       updatedAt: new Date().toISOString(),
-      ...(existingMemory.payload.agentId && {
-        agentId: existingMemory.payload.agentId,
-      }),
-      ...(existingMemory.payload.runId && {
-        runId: existingMemory.payload.runId,
-      }),
+      title: title,
+      applyMode,
     };
 
     await vectorStore.update(memoryId, embedding, newMetadata);

package/src/types/index.ts

@@ -88,10 +88,26 @@ export interface MemoryConfig {
 
 export type MemoryType = 'assistant_preference' | 'discussion';
 
+/**
+ * Mode d'application de la mémoire (inspiré de Cursor AI)
+ * Stocké dans metadata.applyMode avec préfixe MEM_* pour migration soft
+ * 
+ * - MEM_ALWAYS: Toujours appliquer - la mémoire est toujours injectée dans le contexte
+ * - MEM_SMART: Appliquer intelligemment - utilisé pour la recherche sémantique (défaut)
+ * - MEM_MANUAL: Appliquer manuellement - la mémoire n'est jamais injectée automatiquement
+ */
+export type MemoryApplyMode = 'MEM_ALWAYS' | 'MEM_SMART' | 'MEM_MANUAL';
+
+/**
+ * Mode par défaut pour la capture
+ */
+export const DEFAULT_MEMORY_APPLY_MODE: MemoryApplyMode = 'MEM_SMART';
+
 export interface MemoryItem {
   id: string;
   memory: string;
   type: MemoryType;
+  applyMode?: MemoryApplyMode;
   event?: "ADD" | "UPDATE" | "DELETE" | "NONE";
   hash?: string;
   createdAt?: string;

package/tests/lite.spec.ts

@@ -132,35 +132,35 @@ describe('LiteVectorStore Private Methods', () => {
       //
       // 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 cosineScore = 0.9;
       const expectedRecency = 1.0; // Infinity halfLife → recency = 1 even for old dates
-      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+        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-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);
+        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-neg1', userId: userId, type: 'assistant_preference', createdAt: twoDaysAgo };
-      const cosineScore = -0.5;
-      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-      expect(hybridScore).toBeGreaterThanOrEqual(0);
+        const cosineScore = -0.5;
+        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+        expect(hybridScore).toBeGreaterThanOrEqual(0);
     });
 
   });

package/tests/memory.applymode.test.ts

@@ -0,0 +1,228 @@
+/// <reference types="jest" />
+import { MemoriesLite, DEFAULT_MEMORY_APPLY_MODE, MemoryApplyMode } from "../src";
+import { SearchResult } from "../src/types";
+import dotenv from "dotenv";
+import { createTestMemory } from "./init.mem";
+
+dotenv.config();
+
+jest.setTimeout(30000);
+
+/**
+ * Tests pour le MemoryApplyMode (type d'application de mémoire)
+ * - MEM_ALWAYS: Toujours appliquer
+ * - MEM_SMART: Appliquer intelligemment (défaut, recherche sémantique)
+ * - MEM_MANUAL: Appliquer manuellement
+ */
+describe("Memory ApplyMode", () => {
+  let memory: MemoriesLite;
+  let userId: string;
+
+  beforeEach(async () => {
+    ({ memory, userId } = createTestMemory({}));
+    await memory.reset(userId);
+  });
+
+  afterEach(async () => {
+    await memory.reset(userId);
+  });
+
+  describe("Default ApplyMode", () => {
+    it("should set applyMode to MEM_SMART by default on capture", async () => {
+      //
+      // Capture une discussion avec le mode par défaut
+      const messages = [
+        { role: "user", content: "Bonjour, comment gérer les congés ?" },
+        { role: "assistant", content: "Pour gérer les congés, vous devez..." }
+      ];
+
+      const result = await memory.capture(messages, userId, {
+        metadata: { type: "discussion" }
+      });
+
+      expect(result.results.length).toBeGreaterThan(0);
+      const createdMemory = result.results[0];
+      
+      //
+      // Vérifier que le mode par défaut est MEM_SMART
+      expect(createdMemory.metadata?.applyMode || DEFAULT_MEMORY_APPLY_MODE).toBe("MEM_SMART");
+    });
+
+    it("should return DEFAULT_MEMORY_APPLY_MODE as MEM_SMART", () => {
+      expect(DEFAULT_MEMORY_APPLY_MODE).toBe("MEM_SMART");
+    });
+  });
+
+  describe("ApplyMode Update", () => {
+    it("should update applyMode when specified in metadata", async () => {
+      //
+      // Créer une mémoire avec le mode par défaut
+      const messages = [
+        { role: "user", content: "Comment faire une facture ?" },
+        { role: "assistant", content: "Pour créer une facture..." }
+      ];
+
+      const result = await memory.capture(messages, userId, {
+        metadata: { type: "discussion" }
+      });
+
+      expect(result.results.length).toBeGreaterThan(0);
+      const memoryId = result.results[0].id;
+
+      //
+      // Mettre à jour avec un nouveau mode
+      await memory.update(
+        memoryId,
+        "Procédure de facturation mise à jour",
+        userId,
+        { applyMode: "MEM_ALWAYS" as MemoryApplyMode }
+      );
+
+      //
+      // Vérifier que le mode a été mis à jour
+      const updatedMemory = await memory.get(memoryId, userId);
+      expect(updatedMemory).not.toBeNull();
+      expect(updatedMemory?.applyMode).toBe("MEM_ALWAYS");
+    });
+
+    it("should preserve applyMode when not specified in update metadata", async () => {
+      //
+      // Créer une mémoire avec un mode spécifique
+      const messages = [
+        { role: "user", content: "Règles de sécurité" },
+        { role: "assistant", content: "Les règles de sécurité sont..." }
+      ];
+
+      const result = await memory.capture(messages, userId, {
+        metadata: { type: "discussion", applyMode: "MEM_MANUAL" }
+      });
+
+      expect(result.results.length).toBeGreaterThan(0);
+      const memoryId = result.results[0].id;
+
+      //
+      // Mettre à jour le contenu sans changer le mode
+      await memory.update(
+        memoryId,
+        "Règles de sécurité mises à jour",
+        userId,
+        {} // Pas de applyMode dans les metadata
+      );
+
+      //
+      // Vérifier que le mode est préservé
+      const updatedMemory = await memory.get(memoryId, userId);
+      expect(updatedMemory).not.toBeNull();
+      expect(updatedMemory?.applyMode).toBe("MEM_MANUAL");
+    });
+
+    it("should change applyMode from MEM_SMART to MEM_MANUAL", async () => {
+      //
+      // Créer une mémoire avec le mode par défaut
+      const messages = [
+        { role: "user", content: "Comment utiliser l'API ?" },
+        { role: "assistant", content: "L'API s'utilise de la manière suivante..." }
+      ];
+
+      const result = await memory.capture(messages, userId, {
+        metadata: { type: "discussion" }
+      });
+
+      const memoryId = result.results[0].id;
+
+      //
+      // Changer de MEM_SMART vers MEM_MANUAL
+      await memory.update(
+        memoryId,
+        "Documentation API mise à jour",
+        userId,
+        { applyMode: "MEM_MANUAL" as MemoryApplyMode }
+      );
+
+      const updatedMemory = await memory.get(memoryId, userId);
+      expect(updatedMemory?.applyMode).toBe("MEM_MANUAL");
+    });
+  });
+
+  describe("Retrieve Filtering by ApplyMode", () => {
+    it("should only return MEM_SMART memories in retrieve()", async () => {
+      //
+      // Créer 3 mémoires avec différents modes
+      const messagesBase = [
+        { role: "user", content: "Question sur les procédures" },
+        { role: "assistant", content: "Les procédures sont..." }
+      ];
+
+      //
+      // Mémoire 1: MEM_SMART (par défaut)
+      await memory.capture(messagesBase, userId, {
+        metadata: { type: "discussion", customTag: "smart" }
+      });
+
+      //
+      // Mémoire 2: MEM_ALWAYS
+      await memory.capture([
+        { role: "user", content: "Règle toujours appliquée" },
+        { role: "assistant", content: "Cette règle est toujours appliquée..." }
+      ], userId, {
+        metadata: { type: "discussion", applyMode: "MEM_ALWAYS", customTag: "always" }
+      });
+
+      //
+      // Mémoire 3: MEM_MANUAL
+      await memory.capture([
+        { role: "user", content: "Note manuelle" },
+        { role: "assistant", content: "Ceci est une note manuelle..." }
+      ], userId, {
+        metadata: { type: "discussion", applyMode: "MEM_MANUAL", customTag: "manual" }
+      });
+
+      //
+      // Vérifier que getAll retourne les 3 mémoires
+      const allMemories = await memory.getAll(userId, { type: "discussion" });
+      expect(allMemories.results.length).toBe(3);
+
+      //
+      // Vérifier que retrieve() ne retourne que MEM_SMART
+      const searchResult = await memory.retrieve("procédures", userId, { limit: 10 });
+      
+      //
+      // Seule la mémoire MEM_SMART devrait être retournée
+      const smartMemories = searchResult.results.filter(m => m.applyMode === "MEM_SMART");
+      const nonSmartMemories = searchResult.results.filter(m => m.applyMode !== "MEM_SMART");
+      
+      expect(smartMemories.length).toBeGreaterThanOrEqual(0);
+      expect(nonSmartMemories.length).toBe(0);
+    });
+  });
+
+  describe("GetAll returns all ApplyModes", () => {
+    it("should return memories of all applyModes in getAll()", async () => {
+      //
+      // Créer des mémoires avec différents modes
+      await memory.capture([
+        { role: "user", content: "Mémoire intelligente" },
+        { role: "assistant", content: "Réponse intelligente" }
+      ], userId, {
+        metadata: { type: "discussion" } // MEM_SMART par défaut
+      });
+
+      await memory.capture([
+        { role: "user", content: "Mémoire toujours" },
+        { role: "assistant", content: "Réponse toujours" }
+      ], userId, {
+        metadata: { type: "discussion", applyMode: "MEM_ALWAYS" }
+      });
+
+      //
+      // getAll doit retourner les deux
+      const allMemories = await memory.getAll(userId, { type: "discussion" });
+      expect(allMemories.results.length).toBe(2);
+
+      const modes = allMemories.results.map(m => m.applyMode);
+      expect(modes).toContain("MEM_SMART");
+      expect(modes).toContain("MEM_ALWAYS");
+    });
+  });
+});
+