morpheus-cli 0.2.6 → 0.2.8

package/dist/runtime/memory/sati/repository.js

@@ -2,13 +2,18 @@ import Database from 'better-sqlite3';
 import path from 'path';
 import { homedir } from 'os';
 import fs from 'fs-extra';
-import { randomUUID } from 'crypto'; // Available in recent Node versions
+import { randomUUID } from 'crypto';
+import loadVecExtension from '../sqlite-vec.js';
+import { DisplayManager } from '../../display.js';
+const EMBEDDING_DIM = 384;
 export class SatiRepository {
     db = null;
     dbPath;
     static instance;
+    display = DisplayManager.getInstance();
     constructor(dbPath) {
-        this.dbPath = dbPath || path.join(homedir(), '.morpheus', 'memory', 'santi-memory.db');
+        this.dbPath =
+            dbPath || path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db');
     }
     static getInstance(dbPath) {
         if (!SatiRepository.instance) {
@@ -17,59 +22,248 @@ export class SatiRepository {
         return SatiRepository.instance;
     }
     initialize() {
-        try {
-            // Ensure directory exists
-            fs.ensureDirSync(path.dirname(this.dbPath));
-            // Connect to database
-            this.db = new Database(this.dbPath, { timeout: 5000 });
-            this.db.pragma('journal_mode = WAL');
-            // Create schema
-            this.createSchema();
-        }
-        catch (error) {
-            console.error(`[SatiRepository] Failed to initialize database: ${error}`);
-            throw error;
-        }
+        fs.ensureDirSync(path.dirname(this.dbPath));
+        this.db = new Database(this.dbPath, { timeout: 5000 });
+        this.db.pragma('journal_mode = WAL');
+        loadVecExtension(this.db);
+        this.createSchema();
     }
     createSchema() {
         if (!this.db)
-            throw new Error("DB not initialized");
+            throw new Error('DB not initialized');
         this.db.exec(`
-      CREATE TABLE IF NOT EXISTS long_term_memory (
-        id TEXT PRIMARY KEY,
-        category TEXT NOT NULL,
-        importance TEXT NOT NULL,
-        summary TEXT NOT NULL,
-        details TEXT,
-        hash TEXT NOT NULL UNIQUE,
-        source TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL,
-        last_accessed_at TEXT,
-        access_count INTEGER DEFAULT 0,
-        version INTEGER DEFAULT 1,
-        archived INTEGER DEFAULT 0
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_memory_category ON long_term_memory(category);
-      CREATE INDEX IF NOT EXISTS idx_memory_importance ON long_term_memory(importance);
-      CREATE INDEX IF NOT EXISTS idx_memory_archived ON long_term_memory(archived);
-
-      -- FTS5 Virtual Table for semantic-like keyword search
-      CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(summary, content='long_term_memory', content_rowid='rowid');
-
-      -- Triggers to sync FTS
-      CREATE TRIGGER IF NOT EXISTS memory_ai AFTER INSERT ON long_term_memory BEGIN
-        INSERT INTO memory_fts(rowid, summary) VALUES (new.rowid, new.summary);
-      END;
-      CREATE TRIGGER IF NOT EXISTS memory_ad AFTER DELETE ON long_term_memory BEGIN
-        INSERT INTO memory_fts(memory_fts, rowid, summary) VALUES('delete', old.rowid, old.summary);
-      END;
-      CREATE TRIGGER IF NOT EXISTS memory_au AFTER UPDATE ON long_term_memory BEGIN
-        INSERT INTO memory_fts(memory_fts, rowid, summary) VALUES('delete', old.rowid, old.summary);
-        INSERT INTO memory_fts(rowid, summary) VALUES (new.rowid, new.summary);
-      END;
-    `);
+    -- ===============================
+    -- 1️⃣ TABELA PRINCIPAL
+    -- ===============================
+    CREATE TABLE IF NOT EXISTS long_term_memory (
+      id TEXT PRIMARY KEY,
+      category TEXT NOT NULL,
+      importance TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      details TEXT,
+      hash TEXT NOT NULL UNIQUE,
+      source TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      last_accessed_at TEXT,
+      access_count INTEGER DEFAULT 0,
+      version INTEGER DEFAULT 1,
+      archived INTEGER DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_category 
+      ON long_term_memory(category);
+
+    CREATE INDEX IF NOT EXISTS idx_memory_importance 
+      ON long_term_memory(importance);
+
+    CREATE INDEX IF NOT EXISTS idx_memory_archived 
+      ON long_term_memory(archived);
+
+    -- ===============================
+    -- 2️⃣ FTS5
+    -- ===============================
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+      summary,
+      details,
+      content='long_term_memory',
+      content_rowid='rowid',
+      tokenize = 'unicode61 remove_diacritics 2'
+    );
+
+    -- ===============================
+    -- 3️⃣ VECTOR TABLE (vec0)
+    -- ===============================
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_vec USING vec0(
+      embedding float[${EMBEDDING_DIM}]
+    );
+
+    CREATE TABLE IF NOT EXISTS memory_embedding_map (
+      memory_id TEXT PRIMARY KEY,
+      vec_rowid INTEGER NOT NULL
+    );
+
+    -- ===============================
+    -- 4️⃣ TRIGGERS FTS
+    -- ===============================
+    CREATE TRIGGER IF NOT EXISTS memory_ai 
+    AFTER INSERT ON long_term_memory BEGIN
+      INSERT INTO memory_fts(rowid, summary, details)
+      VALUES (new.rowid, new.summary, new.details);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memory_ad 
+    AFTER DELETE ON long_term_memory BEGIN
+      INSERT INTO memory_fts(memory_fts, rowid, summary, details)
+      VALUES('delete', old.rowid, old.summary, old.details);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memory_au 
+    AFTER UPDATE ON long_term_memory BEGIN
+      INSERT INTO memory_fts(memory_fts, rowid, summary, details)
+      VALUES('delete', old.rowid, old.summary, old.details);
+
+      INSERT INTO memory_fts(rowid, summary, details)
+      VALUES (new.rowid, new.summary, new.details);
+    END;
+
+    -- ===============================
+    -- 3️⃣ VECTOR TABLE SESSIONS (vec0)
+    -- ===============================
+
+    CREATE TABLE IF NOT EXISTS session_chunks (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      chunk_index INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS session_vec USING vec0(
+      embedding float[384]
+    );
+
+    CREATE TABLE IF NOT EXISTS session_embedding_map (
+      session_chunk_id TEXT PRIMARY KEY,
+      vec_rowid INTEGER NOT NULL
+    );
+
+  `);
+    }
+    // 🔥 NOVO — Salvar embedding
+    upsertEmbedding(memoryId, embedding) {
+        if (!this.db)
+            this.initialize();
+        const getExisting = this.db.prepare(`
+    SELECT vec_rowid FROM memory_embedding_map
+    WHERE memory_id = ?
+  `);
+        const insertVec = this.db.prepare(`
+    INSERT INTO memory_vec (embedding)
+    VALUES (?)
+  `);
+        const deleteVec = this.db.prepare(`
+    DELETE FROM memory_vec WHERE rowid = ?
+  `);
+        const upsertMap = this.db.prepare(`
+    INSERT OR REPLACE INTO memory_embedding_map (memory_id, vec_rowid)
+    VALUES (?, ?)
+  `);
+        const transaction = this.db.transaction(() => {
+            const existing = getExisting.get(memoryId);
+            if (existing?.vec_rowid) {
+                deleteVec.run(existing.vec_rowid);
+            }
+            const result = insertVec.run(new Float32Array(embedding));
+            const newVecRowId = result.lastInsertRowid;
+            upsertMap.run(memoryId, newVecRowId);
+        });
+        transaction();
+    }
+    // 🔥 NOVO — Busca vetorial
+    searchByVector(embedding, limit) {
+        if (!this.db)
+            return [];
+        const SIMILARITY_THRESHOLD = 0.5; // ajuste fino depois
+        const stmt = this.db.prepare(`
+    SELECT 
+      m.*,
+      vec_distance_cosine(v.embedding, ?) as distance
+    FROM memory_vec v
+    JOIN memory_embedding_map map ON map.vec_rowid = v.rowid
+    JOIN long_term_memory m ON m.id = map.memory_id
+    WHERE m.archived = 0
+    ORDER BY distance ASC
+    LIMIT ?
+  `);
+        const rows = stmt.all(new Float32Array(embedding), limit);
+        // 🔥 Filtrar por similaridade real
+        const ranked = rows
+            .map(r => ({
+            ...r,
+            similarity: 1 - r.distance
+        }))
+            .sort((a, b) => b.distance - a.distance);
+        const filtered = ranked
+            .filter(r => r.distance >= SIMILARITY_THRESHOLD)
+            .sort((a, b) => b.distance - a.distance);
+        if (filtered.length > 0) {
+            console.log(`[SatiRepository] Vector hit (${filtered.length})`);
+        }
+        return filtered.map(this.mapRowToRecord);
+    }
+    searchUnifiedVector(embedding, limit) {
+        if (!this.db)
+            return [];
+        const SIMILARITY_THRESHOLD = 0.75;
+        const stmt = this.db.prepare(`
+    SELECT *
+    FROM (
+      -- LONG TERM MEMORY
+      SELECT 
+        m.id as id,
+        m.summary as summary,
+        m.details as details,
+        m.category as category,
+        m.importance as importance,
+        'long_term' as source_type,
+        (1 - vec_distance_cosine(v.embedding, ?)) * 0.7 as distance
+      FROM memory_vec v
+      JOIN memory_embedding_map map ON map.vec_rowid = v.rowid
+      JOIN long_term_memory m ON m.id = map.memory_id
+      WHERE m.archived = 0
+
+      UNION ALL
+
+      -- SESSION CHUNKS
+      SELECT 
+        sc.id as id,
+        sc.content as summary,
+        sc.content as details,
+        'session' as category,
+        'medium' as importance,
+        'session_chunk' as source_type,
+        (1 - vec_distance_cosine(v.embedding, ?)) * 0.3 as distance
+      FROM session_vec v
+      JOIN session_embedding_map map ON map.vec_rowid = v.rowid
+      JOIN session_chunks sc ON sc.id = map.session_chunk_id
+    )
+    ORDER BY distance ASC
+    LIMIT ?
+  `);
+        const rows = stmt.all(new Float32Array(embedding), new Float32Array(embedding), limit);
+        // console.log(
+        //   `[SatiRepository] Unified vector search returned ${rows.length} raw results`
+        // );
+        // console each row
+        // rows.forEach((row, index) => {
+        //   console.log(`[SatiRepository] Row ${index + 1}:`, row);
+        // });
+        const ranked = rows
+            .map(r => ({
+            ...r,
+            similarity: 1 - r.distance
+        }))
+            .sort((a, b) => b.similarity - a.similarity);
+        const filtered = ranked
+            .filter(r => r.similarity >= SIMILARITY_THRESHOLD)
+            .sort((a, b) => b.similarity - a.similarity);
+        this.display.log(`🧠 Unified vector search retornou ${filtered.length} resultados`, { source: 'Sati', level: 'debug' });
+        return filtered.map(r => ({
+            id: r.id,
+            summary: r.summary,
+            details: r.details,
+            category: r.category,
+            importance: r.importance,
+            hash: '',
+            source: r.source_type,
+            created_at: new Date(),
+            updated_at: new Date(),
+            access_count: 0,
+            version: 1,
+            archived: false
+        }));
     }
     async save(record) {
         if (!this.db)
@@ -118,73 +312,81 @@ export class SatiRepository {
         const row = this.db.prepare('SELECT * FROM long_term_memory WHERE hash = ?').get(hash);
         return row ? this.mapRowToRecord(row) : null;
     }
-    search(query, limit = 5) {
+    search(query, limit = 5, embedding) {
         if (!this.db)
             this.initialize();
-        // Sanitize query for FTS5: remove characters that break FTS5 syntax
-        // Keep only alphanumeric, spaces, and safe punctuation (comma, period, hyphen)
-        // const safeQuery = query.replace(/[^a-zA-Z0-9\s,.\-]/g, "").trim();
-        // if (!safeQuery) {
-        //     console.warn('[SatiRepository] Empty query after sanitization');
-        //     return this.getFallbackMemories(limit);
-        // }
-        // try {
-        //     // Try FTS5 search first
-        //     const stmt = this.db!.prepare(`
-        //         SELECT m.* 
-        //         FROM long_term_memory m
-        //         JOIN memory_fts f ON m.rowid = f.rowid
-        //         WHERE memory_fts MATCH ? AND m.archived = 0
-        //         ORDER BY rank
-        //         LIMIT ?
-        //     `);
-        //     const rows = stmt.all(safeQuery, limit) as any[];
-        //     if (rows.length > 0) {
-        //         console.log(`[SatiRepository] FTS5 found ${rows.length} memories for: "${safeQuery}"`);
-        //         return rows.map(this.mapRowToRecord);
-        //     }
-        //     // Fallback: try LIKE search
-        //     console.log(`[SatiRepository] FTS5 returned no results, trying LIKE search for: "${safeQuery}"`);
-        //     const likeStmt = this.db!.prepare(`
-        //         SELECT * FROM long_term_memory
-        //         WHERE (summary LIKE ? OR details LIKE ?) 
-        //         AND archived = 0
-        //         ORDER BY importance DESC, access_count DESC
-        //         LIMIT ?
-        //     `);
-        //     const likePattern = `%${safeQuery}%`;
-        //     const likeRows = likeStmt.all(likePattern, likePattern, limit) as any[];
-        //     if (likeRows.length > 0) {
-        //         console.log(`[SatiRepository] LIKE search found ${likeRows.length} memories`);
-        //         return likeRows.map(this.mapRowToRecord);
-        //     }
-        //     // Final fallback: return most important/accessed memories
-        //     console.log('[SatiRepository] No search results, returning most important memories');
-        //     return this.getFallbackMemories(limit);
-        // } catch (e) {
-        //     console.warn(`[SatiRepository] Search failed for query "${query}": ${e}`);
-        //     return this.getFallbackMemories(limit);
-        // }
-        return this.getFallbackMemories(limit);
+        try {
+            this.display.log(`🔍 Iniciando busca de memória | Query: "${query}"`, { source: 'Sati', level: 'debug' });
+            // 1️⃣ Vetorial
+            if (embedding) {
+                this.display.log('🧠 Tentando busca vetorial...', { source: 'Sati', level: 'debug' });
+                const vectorResults = this.searchUnifiedVector(embedding, limit);
+                if (vectorResults.length > 0) {
+                    this.display.log(`✅ Vetorial retornou ${vectorResults.length} resultado(s)`, { source: 'Sati', level: 'success' });
+                    return vectorResults.slice(0, limit);
+                }
+                this.display.log('⚠️ Vetorial não encontrou resultados relevantes', { source: 'Sati', level: 'debug' });
+            }
+            // 2️⃣ BM25 (FTS)
+            // Sanitize query: remove characters that could break FTS5 syntax (like ?, *, OR, etc)
+            // keeping only letters, numbers and spaces.
+            const safeQuery = query
+                .replace(/[^\p{L}\p{N}\s]/gu, ' ')
+                .replace(/\s+/g, ' ')
+                .trim();
+            if (safeQuery) {
+                this.display.log('📚 Tentando busca BM25 (FTS5)...', { source: 'Sati', level: 'debug' });
+                const stmt = this.db.prepare(`
+        SELECT m.*, bm25(memory_fts) as rank
+        FROM long_term_memory m
+        JOIN memory_fts ON m.rowid = memory_fts.rowid
+        WHERE memory_fts MATCH ?
+        AND m.archived = 0
+        ORDER BY rank
+        LIMIT ?
+      `);
+                const rows = stmt.all(safeQuery, limit);
+                if (rows.length > 0) {
+                    this.display.log(`✅ BM25 retornou ${rows.length} resultado(s)`, { source: 'Sati', level: 'success' });
+                    return rows.map(this.mapRowToRecord);
+                }
+                this.display.log('⚠️ BM25 não encontrou resultados', { source: 'Sati', level: 'debug' });
+            }
+            // 3️⃣ LIKE fallback
+            this.display.log('🧵 Tentando fallback LIKE...', { source: 'Sati', level: 'debug' });
+            const likeStmt = this.db.prepare(`
+      SELECT * FROM long_term_memory
+      WHERE (summary LIKE ? OR details LIKE ?) 
+      AND archived = 0
+      ORDER BY importance DESC, access_count DESC
+      LIMIT ?
+    `);
+            const pattern = `%${query}%`;
+            const likeRows = likeStmt.all(pattern, pattern, limit);
+            if (likeRows.length > 0) {
+                this.display.log(`✅ LIKE retornou ${likeRows.length} resultado(s)`, { source: 'Sati', level: 'success' });
+                return likeRows.map(this.mapRowToRecord);
+            }
+            // 4️⃣ Final fallback
+            this.display.log('🛟 Nenhum mecanismo encontrou resultados. Usando fallback estratégico.', { source: 'Sati', level: 'warning' });
+            return this.getFallbackMemories(limit);
+        }
+        catch (e) {
+            this.display.log(`❌ Erro durante busca: ${e}`, { source: 'Sati', level: 'error' });
+            return this.getFallbackMemories(limit);
+        }
     }
     getFallbackMemories(limit) {
         if (!this.db)
             return [];
-        const stmt = this.db.prepare(`
+        const rows = this.db
+            .prepare(`
         SELECT * FROM long_term_memory
         WHERE archived = 0
-        ORDER BY 
-            CASE importance
-                WHEN 'critical' THEN 1
-                WHEN 'high' THEN 2
-                WHEN 'medium' THEN 3
-                WHEN 'low' THEN 4
-            END,
-            access_count DESC,
-            created_at DESC
+        ORDER BY access_count DESC, created_at DESC
         LIMIT ?
-    `);
-        const rows = stmt.all(limit);
+      `)
+            .all(limit);
         return rows.map(this.mapRowToRecord);
     }
     getAllMemories() {
@@ -204,18 +406,14 @@ export class SatiRepository {
             source: row.source,
             created_at: new Date(row.created_at),
             updated_at: new Date(row.updated_at),
-            last_accessed_at: row.last_accessed_at ? new Date(row.last_accessed_at) : undefined,
+            last_accessed_at: row.last_accessed_at
+                ? new Date(row.last_accessed_at)
+                : undefined,
             access_count: row.access_count,
             version: row.version,
             archived: Boolean(row.archived)
         };
     }
-    close() {
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-        }
-    }
     archiveMemory(id) {
         if (!this.db)
             this.initialize();
@@ -223,4 +421,10 @@ export class SatiRepository {
         const result = stmt.run(id);
         return result.changes > 0;
     }
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
 }

package/dist/runtime/memory/sati/service.js

@@ -6,6 +6,7 @@ import { SATI_EVALUATION_PROMPT } from './system-prompts.js';
 import { createHash } from 'crypto';
 import { DisplayManager } from '../../display.js';
 import { SQLiteChatMessageHistory } from '../sqlite.js';
+import { EmbeddingService } from '../embedding.service.js';
 const display = DisplayManager.getInstance();
 export class SatiService {
     repository;
@@ -24,11 +25,21 @@ export class SatiService {
     }
     async recover(currentMessage, recentMessages) {
         const santiConfig = ConfigManager.getInstance().getSatiConfig();
-        const memoryLimit = santiConfig.memory_limit || 1000;
-        // Use the current message as the primary search query
-        // We could enhance this by extracting keywords from the last few messages
-        // but for FR-004 we start with user input.
-        const memories = this.repository.search(currentMessage, memoryLimit);
+        const memoryLimit = santiConfig.memory_limit || 10;
+        let queryEmbedding;
+        try {
+            const embeddingService = await EmbeddingService.getInstance();
+            const queryText = [
+                ...recentMessages.slice(-3),
+                currentMessage
+            ].join(' ');
+            queryEmbedding = await embeddingService.generate(queryText);
+        }
+        catch (err) {
+            console.warn('[Sati] Failed to generate embedding:', err);
+        }
+        const memories = this.repository.search(currentMessage, memoryLimit, queryEmbedding // 🔥 agora vai usar vector search
+        );
         return {
             relevant_memories: memories.map(m => ({
                 summary: m.summary,
@@ -100,7 +111,7 @@ export class SatiService {
             }
             // Safe JSON parsing (handle markdown blocks if LLM wraps output)
             content = content.replace(/```json/g, '').replace(/```/g, '').trim();
-            let result;
+            let result = [];
             try {
                 result = JSON.parse(content);
             }
@@ -108,26 +119,38 @@ export class SatiService {
                 console.warn('[SatiService] Failed to parse JSON response:', content);
                 return;
             }
-            if (result.should_store && result.summary && result.category && result.importance) {
-                display.log(`Persisting new memory: [${result.category.toUpperCase()}] ${result.summary}`, { source: 'Sati' });
-                try {
-                    await this.repository.save({
-                        summary: result.summary,
-                        category: result.category,
-                        importance: result.importance,
-                        details: result.reason,
-                        hash: this.generateHash(result.summary),
-                        source: 'conversation' // Could track actual session ID here if available
-                    });
-                    // Quiet success - logging handled by repository/middleware if needed, or verbose debug
-                }
-                catch (saveError) {
-                    if (saveError.message && saveError.message.includes('UNIQUE constraint failed')) {
-                        // Duplicate detected by DB (Hash collision)
-                        // This is expected given T012 logic
+            for (const item of result) {
+                if (item.should_store && item.summary && item.category && item.importance) {
+                    display.log(`Persisting new memory: [${item.category.toUpperCase()}] ${item.summary}`, { source: 'Sati' });
+                    try {
+                        const savedMemory = await this.repository.save({
+                            summary: item.summary,
+                            category: item.category,
+                            importance: item.importance,
+                            details: item.reason,
+                            hash: this.generateHash(item.summary),
+                            source: 'conversation'
+                        });
+                        // 🔥 GERAR EMBEDDING
+                        const embeddingService = await EmbeddingService.getInstance();
+                        const textForEmbedding = [
+                            savedMemory.summary,
+                            savedMemory.details ?? ''
+                        ].join(' ');
+                        const embedding = await embeddingService.generate(textForEmbedding);
+                        display.log(`Generated embedding for memory ID ${savedMemory.id}`, { source: 'Sati', level: 'debug' });
+                        // 🔥 SALVAR EMBEDDING NO SQLITE_VEC
+                        this.repository.upsertEmbedding(savedMemory.id, embedding);
+                        // Quiet success - logging handled by repository/middleware if needed, or verbose debug
                     }
-                    else {
-                        throw saveError;
+                    catch (saveError) {
+                        if (saveError.message && saveError.message.includes('UNIQUE constraint failed')) {
+                            // Duplicate detected by DB (Hash collision)
+                            // This is expected given T012 logic
+                        }
+                        else {
+                            throw saveError;
+                        }
                     }
                 }
             }

package/dist/runtime/memory/sati/system-prompts.js

@@ -22,6 +22,7 @@ Classify any new memory into one of these types:
 - **professional_profile**: Job title, industry, skills.
 
 ### CRITICAL RULES
+0. **SAVE ON SUMMARY and REASONING IN ENGLISH AND NATIVE LANGUAGE**: Always generate a concise summary in English and, if the original information is in another language, also provide a summary in the original language. This ensures the memory is accessible and useful for future interactions, regardless of the language used.
 1. **NO SECRETS**: NEVER store API keys, passwords, credit cards, or private tokens. If found, ignore them explicitly.
 2. **NO DUPLICATES**: If the information is already covered by the \`existing_memory_summaries\`, DO NOT store it again.
 3. **NO CHIT-CHAT**: Do not store trivial conversation like "Hello", "Thanks", "How are you?".
@@ -31,12 +32,22 @@ Classify any new memory into one of these types:
 5. **OBEY THE USER**: If the user explicitly states something should be remembered, it must be stored with at least 'medium' importance.
 
 ### OUTPUT FORMAT
-You MUST respond with a valid JSON object matching the \`ISatiEvaluationOutput\` interface:
-{
-  "should_store": boolean,
-  "category": "category_name" | null,
-  "importance": "low" | "medium" | "high" | null,
-  "summary": "Concise factual statement" | null,
-  "reason": "Why you decided to store or not store"
-}
+You MUST respond with a valid JSON object ARRAY matching the \`ISatiEvaluationOutputArray\` interface:
+[
+  {
+    "should_store": boolean,
+    "category": "category_name" | null,
+    "importance": "low" | "medium" | "high" | null,
+    "summary": "Concise factual statement | Summary in native language" | null,
+    "reason": "Why you decided to store or not store | Reason in native language"
+  },
+  {
+    "should_store": boolean,
+    "category": "category_name" | null,
+    "importance": "low" | "medium" | "high" | null,
+    "summary": "Concise factual statement | Summary in native language" | null,
+    "reason": "Why you decided to store or not store | Reason in native language"
+  },
+]
+
 `;