memories-lite 0.9.5 → 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,179 +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 && f.type !== 'factual')||[];
+    };
 
-    // 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);
-
-    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 {
@@ -341,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;
@@ -376,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,38 +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  
-//2. **Episodic memory** – time‑stamped events / interactions  
-//3. **Procedural memory** – step‑by‑step know‑how  
-//4. **Todo memory** – explicit user tasks to remember
-//
+/**
+ * @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","episodic","procedural","todo"])
-      .describe(`The type of the fact.
-        Use 'assistant_preference' for Assistant behavior preferences (style/language/constraints/commands).
-        Use 'episodic' always for time-based events.
-        Use 'procedural' for how-to/business questions (e.g., « je veux résilier un bail, comment faire ? »).
-        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(
@@ -56,21 +101,14 @@ export const MemoryUpdateSchema = z.object({
             "The reason why you selected this event.",
           ),
         type: z
-          .enum(["factual", "episodic", "todo", "procedural","assistant_preference"])
-          .describe("Type of the memory. Use 'assistant_preference' for Assistant behavior preferences, 'procedural' for all business processes."),
+          .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?") → retrieve factual memory.
- * If the task is temporal or event-based ("What was I doing yesterday?") → retrieve episodic 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).
@@ -82,15 +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."
 
-export const MEMORY_STRING_SYSTEM_OLD = `# USER AND MEMORIES PREFERENCES:
-- Utilize the provided memories to guide your responses.
-- Disregard any memories that are not relevant.
-- By default, do not reference this section or the memories in your response.
-`;
- 
-// 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 = "",
@@ -98,36 +131,31 @@ export function getFactRetrievalMessages(
 ): [string, string] {
 
   const injectCustomRules = (customRules:string) => customRules ?`\n# PRE-EXISTING FACTS\n${customRules}` : "";
-  const systemPrompt = `You are a Personal Information Organizer, specialized in accurately storing facts, user memories, and preferences. You are also an expert in job tasks extraction.
+  const systemPrompt = `You are a Personal Information Organizer, specialized in extracting and structuring user facts and preferences for AI personalization. You also handle explicit task extraction (todos only).
 
 Filter content before extracting triplets:
-  - Relevance: keep only statements directly about the user (preferences, identity, actions, experiences) or explicit tasks; drop weather/small talk.
+  - Relevance: keep only statements directly about the user (preferences with the AI, identity relevant to personalization, actions/experiences that affect responses) or explicit todos; drop weather/small talk.
   - Disinterest: if the user rejects the topic (e.g., "cette information ne m'intéresse pas", "not interested"), return {"facts":[]}.
-  - Business/procedures: if the user asks about processes, regulations, or third-party policies (company workflows, public steps, legal actions), classify as "procedural". This applies even if personal pronouns are used.
-  - Action requests to the assistant (find/search/locate/call/email/book/reserve) are NOT preferences. Unless the user explicitly asks to save as a todo, do not create a memory for such requests (return {"facts":[]}).
-  
-You must strictly extract {Subject, Predicate, Object} triplets by following these rules (max 12 triplets):
+  - Ignore business/process/regulation/company-policy content entirely (no extraction, no memory).
+  - Action requests to the assistant (find/search/locate/call/email/book/reserve) are NOT preferences. Unless the user explicitly asks to save as a todo, return {"facts":[]}.
+
+You must strictly extract {Subject, Predicate, Object} triplets (max 12):
 1. Identify named entities, preferences, and meaningful user-related concepts:
-  - Extract triplets that describe facts *about the user* based on their statements, covering areas like preferences, beliefs, actions, experiences, learning, identity, work, or relationships (e.g., "I love working").
-  - Apply explicit, precise, and unambiguous predicates (e.g., "owns", "is located at", "is a", "has function", "causes", etc.).
-  - Determine the triplet type ("assistant_preference", "procedural", "episodic", "factual", "todo"):
-    - "assistant_preference": ONLY when the user specifies response style/language/format or interaction constraints.
-    - "procedural": for how-to/business questions (e.g., « je veux résilier un bail, comment faire ? »).
-    - "todo": ONLY if the user explicitly requests to save/keep as todo (e.g., « garde/enregistre en todo », « ajoute un todo »). Never infer todo from intent alone.
-    - If multiple types apply (excluding assistant_preference and todo rules above), priority: procedural > episodic > factual.
-    - "episodic" If a fact depends on a temporal, situational, or immediate personal context, then that fact AND ALL OF ITS sub-facts MUST be classified as episodic.
-    - "procedural" for business processes (e.g., "Looking for customer John Doe address", "How to create a new contract").
-    - "factual" for stable user data (except procedural that prevails).
-    
-  - Eliminate introductions, sub-facts, detailed repetitive elements, stylistic fillers, or vague statements. General facts always takes precedence over multiple sub-facts (signal vs noise).
-  - The query intention can include specific preferences about how the Assistant should respond (e.g., "answer concisely", "explain in detail").   
-  - Compress each OUTPUT (fact and reason) ≤ 10 words.
-  - Do not include type labels or annotations inside the fact text (e.g., avoid "(todo)", "(procedural)"). Use the separate 'type' field only.
-  - DO NOT infer personal facts from third-party informations.
-  - Treat "**ASSISTANT**:" as responses to enrich context of your reasoning process about the USER query.
-2. Use pronoun "I" instead of "The user" in the subject of the triplet.
-3. Do not output any facts already present in section # PRE-EXISTING FACTS.
-  - If you find facts already present in section # PRE-EXISTING FACTS, use field "existing" to store them.
+  - Extract triplets *about the user* that help AI personalization (preferences, stable facts, explicit todos).
+  - Use explicit, precise, unambiguous predicates (e.g., "prefers", "speaks", "is a", "uses").
+  - Triplet type ∈ {"assistant_preference","factual","todo"} only:
+    - "assistant_preference": response style/language/format or interaction constraints.
+    - "factual": stable user data relevant to personalization (e.g., language, timezone, tools used).
+    - "todo": ONLY if the user explicitly asks to save/keep as todo. Never infer from intent alone.
+  - Remove introductions, sub-facts, repetitions, fillers, vague statements; prefer the general fact over details.
+  - Each triplet (S,P,O) ≤ 10 words total.
+  - Do not include type labels inside fact text; use the 'type' field only.
+  - Do not infer personal facts from third-party information.
+  - Treat "**ASSISTANT**:" as context only; never as a fact source.
+
+2. Use pronoun "I" as the Subject (not "The user").
+3. Do not output facts already in # PRE-EXISTING FACTS.
+  - If found, put them in "existing" (list of matched facts or IDs).
 
 ${injectCustomRules(customRules)}
 
@@ -144,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[],
@@ -153,46 +184,66 @@ export function getUpdateMemoryMessages(
 const serializeFacts = (facts: any[]) => {
   if(facts.length === 0) return "";
   if(facts[0].fact) {
-    return facts.map((elem) => `* ${elem.fact} (${elem.type})`).join("\n");
+    return facts.map((elem) => `- "${elem.fact}" (type:${elem.type})`).join("\n");
   } else {
     return facts.join("\n");
   }
 }
 const serializeMemory = (memory: any[]) => {
-  return memory.map((elem) => `* ${elem.id} - ${elem.text}`).join("\n");
+  return memory.map((elem) => `- "${elem.text}" (id:${elem.id})`).join("\n");
 }
   return `ROLE:
-You are a smart memory manager dedicated on users. You are expert in semantic comparison, RDF inference and boolean logic.
+You are the Memory Manager module of an AI assistant. You are specialized in semantic reasoning, fact consistency, and memory lifecycle operations.  
+Your job is to maintain a coherent, contradiction-free knowledge base (long-term memory) of user facts.
 
 MISSION:
-For each new user fact from "# New Retrieved Facts", you MUSTmerge it into "# Current Memory" by assigning exactly ONE of: ADD, DELETE, UPDATE, or NONE:
-
-1. Semantic compare each new facts to memory, for each fact:
-  - If the new fact **contradicts**, **negates**, **reverses**, **retracts**, or **cancels** the meaning of a memory entry THEN DELETE.
-    ⛔ You MUST NOT treat this as an UPDATE. Contradictions invalidate the original fact.
-  - Else If the new fact **specializes** the previous fact (adds precision, extends the detail without changing the core meaning) THEN UPDATE.
-  - Else If it is **equivalent** → NONE.
-  - Else If it is **completely new** → ADD.
-  - Else (default) → NONE.
-2. Event mapping from user intent (imperatives prevail):
-  - DELETE if user asks to remove.
-  - UPDATE if user asks to change: "mets à jour", "modifie", "corrige", "update", "change", "replace".
-  - ADD if user asks to add: "ajoute", "add" (including explicit todo adds).
-3. If no match is found:
-   - Generate a new ID for ADD
-5. Assign the action (IF you can't find a match, restart the process)
+Given:
+  1. A set of **Current Memory** facts (each with unique ID and textual content).
+  2. A set of **New Retrieved Facts** from the user or external sources.
+  3. (Optional) A **User Instruction** indicating explicit intent (add, modify, delete).
+
+You must process each new fact individually and decide **exactly one** action: **ADD**, **DELETE**, **UPDATE**, or **NONE**, following these rules, in this order:
+
+1. **User intent override**  
+   If the User Instruction clearly requests adding, updating, or removal (e.g. “ajoute X”, “mets à jour Y”, “supprime Z”), you **must** respect that and assign the corresponding action for the matching fact, superseding semantic rules.
+
+2. **Semantic consistency check**  
+   For each new fact:
+   - If it **contradicts**, **negates**, or **cancels** an existing memory item, you **DELETE** the memory item.  
+   - Else, if the new fact is a **specialization** (i.e. same core meaning + additional detail) of an existing one, **UPDATE** that memory (keeping the same ID).  
+   - Else, if it is **semantically equivalent** (i.e. redundant or paraphrased), assign **NONE** (no change).  
+   - Else, if it is entirely **new** (no overlap or relation), **ADD** it (generate a new ID).  
+   - Otherwise (if ambiguous or borderline), assign **NONE** (do not delete).  
+
+3. **ID reuse and consistency**  
+   - For **UPDATE**, reuse the existing memory item’s ID.  
+   - For **DELETE**, simply remove the item from the final memory output.  
+   - For **ADD**, generate a new unique ID (e.g. UUID).  
+   - If memory is initially empty, treat all new facts as **ADD**.
+
+4. **Output formatting**  
+   Return the updated memory state in strict JSON format. Each memory entry must include:
+   - \`id\` (string)  
+   - \`text\` (string, the pure factual content)  
+   - Optionally for updates: \`old_text\` (the prior version)  
+   - *(No extra annotation or type markup in \`text\`)*  
+
+If there are no facts at all, return \`{"memory": []}\`.
+
+*You must not output any other text besides the valid JSON result.*
 
 # Output Instructions
-- Default user language is ${defaultLanguage}.
+- Default user language is "${defaultLanguage}".
 - Each memory item must follow this strict format:
-  - UPDATE also include the previous text: \`old_memory\`.
-  - ⚠️ Reuse correct IDs for UPDATE and DELETE.
-  - Generate random IDs for ADDs.
+  - UPDATE must also include the previous text: \`old_text\`.
+  - Reuse correct IDs for UPDATE.  
+  - For DELETE, exclude the removed item from the final memory list.  
+  - Generate random IDs for ADDs (format: UUID).
   - If memory is empty, treat all facts as ADD.
   - Without facts, return an empty memory: \`{"memory": []}\`
 - Memory must strictly reflect valid facts.  
-- Contradictions, cancellations, negations, or ambiguities must be handled by DELETE.  
- - The field 'text' must be the pure memory content only: do not add any type markers or parentheses like "(todo)".
+- Contradictions, cancellations, or negations must be handled by DELETE. Ambiguities must be handled by NONE.  
+- The field 'text' must be the pure memory content only: do not add any type markers or parentheses.
 
 # Current Memory (extract and reuse their IDs for UPDATE or DELETE events):
 ${serializeMemory(retrievedOldMemory)}
@@ -200,8 +251,7 @@ ${serializeMemory(retrievedOldMemory)}
 # New Retrieved Facts:
 ${serializeFacts(newRetrievedFacts)}
 
-# User Instruction:
-${userInstruction || ""}
+# User Instruction: "${userInstruction || ''}"
 
 Return the updated memory in JSON format only. Do not output anything else.`;
 }
@@ -229,8 +279,9 @@ export const getMemoriesAsPrefix = (memories: MemoryItem[]) => {
 };
 
 export const getMemoriesAsSystem = (memories: MemoryItem[], facts?: string[]) => {
+  if(!memories || memories.length === 0) return "";
   const memoryString = memories.map((mem) => `- ${mem.memory}`).concat(facts||[]).join("\n");
-  return `${MEMORY_STRING_SYSTEM}\n<memories>${memoryString}\n</memories>`;
+  return `${MEMORY_STRING_SYSTEM}\n<memories>\n${memoryString}\n</memories>`;
 }
 
 export function parseMessages(messages: string[]): string {